Discussion :

[poukill]

Bonjour à tous !

Soit une classe Camera qui récupère des données depuis une caméra physique.
Soit une classe Composant qui possède plusieurs Camera. (sous forme de std::vector<Camera> par exemple).

Au cours de l'exécution de mon programme, je peux avoir 4, voire 5 Camera associées au même Composant.
Je cherche à "lier" deux Camera entre elle, c'est à dire que toute modification (changer d'image, etc...) faite sur une caméra soit faite sur l'autre...

Le but est de faire défiler, si le besoin s'en fait sentir, les deux films issus des deux caméras en même temps. Ou bien d'appliquer les même traitements... Je dois pouvoir rompre le lien à tout moment pour que les caméras se retrouvent en position indépendantes.

Existe t-il un Pattern connu pour ça? J'ai d'abord pensé à une variable statique, mais ça ne m'a pas mené bien loin !
Ma première conception n'avait pas prévu ce cas là puisque il ne devait pas y avoir de synchronisation.
Bien entendu, suite à une réussite, le cahier des charges a changé

Merci beaucoup pour votre aide!

[r0d]

Peut-être qu'un proxy pourrait convenir.
En gros, le proxy est une classe que tu rajoutes entre deux classes pour modifier le comportement d'une classe sans avoir besoin de la modifier.
Je ne sais pas trop à quel point c'est applicable dans ton cas.

[poukill]

Le truc c'est que je veux lier deux instances d'une même classe Camera...

Tu parles d'un proxy entre la classe Composant et la classe Camera c'est bien ça?

[r0d]

Oui, c'est bien ce à quoi je pensais.
Mais en y réfléchissant, il doit y avoir plus simple. Le problème du proxy ici, c'est que tu va devoir implémenter tous les cas de liaison (camera1 avec camera2, camera1 avec camera3, etc..). On doit pouvoir trouver mieux.

[r0d]

Mhh, et si tu rajoutais, dans ta classe camera, un tableau de pointeur. Chaque élément de ce tableau est un pointeur vers la ou les caméras(s) avec laquelles (lesquelles) elle est liée...
mouais... bof.

[poukill]

Mhh, et si tu rajoutais, dans ta classe camera, un tableau de pointeur. Chaque élément de ce tableau est un pointeur vers la ou les caméras(s) avec laquelles (lesquelles) elle est liée...
mouais... bof.

Oui, c'est le premier truc qui m'est venu à l'esprit: un tableau de pointeurs static contenant toutes les instances. Sauf que toutes ne doivent pas être liées!
Un tableau de pointeurs vers les caméras liés seulement, comme tu me le propose, est ce qui m'est venu en deuxième.

Après réflexion, je n'ai qu'un seul attribut à partager (deux en fait mais ils sont liés), c'est le numéro de l'image en cours. Car toutes les fonctions membres imageSuivante() etc. n'utilise que mon "m_numero_image".
Le mettre en static n'est pas une solution, ça voudrait dire que toutes les instances de caméras seraient liées...

[r0d]

Dois-moi si j'ai bien compris:
La seule chose à modifier est le paramètre m_numero_image de chacune des caméras liées entre elles?

[poukill]

Hum... Oui

Enfin, un autre paramètre serait bien à modifier aussi, c'est le temps courant... Il est lié à m_numero_image...

Disons que pour faire bien, il faudrait modifier:

• m_numero_image
• m_temps_image

Car si une fontion membre est appelé avec la variable temps, ça va pas le faire tu vois? (l'utilisateur choisit le temps de l'image, moi je gère la film avec des numéros)

[smashy]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
class Camera;
 
class CameraGroup {
 
  typedef vector<Camera *> camera_set;
 
  void updateAll(Camera * except_this){
 
    camera_set::iterator it;
 
    for (it = cameras.begin(); it != cameras.end() ; ++it){
 
      if (*it != except_this){
 
        (*it)->update();
      }
 
    }
  }
 
  camera_set cameras;
};
 
class Camera {
 
  virtual void update() = 0;
 
  void updateAllLinked(){
 
    if (camera_group != NULL){
 
      camera_group->updateAll(this);
    }
  }
 
  CameraGroup * camera_group;
};

[Mat007]

Salut,

S'il n'existe pas déjà d'interface (que des virtuelles pures) pour une caméra c'est je pense le bon moment pour l'ajouter...

Ensuite tu crées un LinkedCamera qui aggrège 2 caméras et qui implémente la même interface et dont l'implémentation se contente d'appeler les mêmes traitements sur les 2 caméras à la fois.
Ensuite il n'y a plus qu'à réaliser l'opération pour lier/délier des caméras (dans composant par exemple), et tous les autres traitements sont inchangés car ils travaillent sur une interface.
Peut-être que la liaison des caméras pourrait être externe aucomposant éventuellement si cette classe expose déjà publiquement des méthodes pour enregistrer/désenregistrer une caméra et/ou qu'elle fait déjà plein de trucs, à voir...

J'espère que ce n'est pas trop incompréhensible

MAT.

[tristan_m]

Bonsoir,

Dépendant du nombre de type de modification, le pattern observateur pourrait être une solution.

Deux caméras seraient liées par le fait qu'elles soient des observateurs de la même chose.
Pour supprimer la liaison, il suffit de faire observer autrechose à l'une des caméras.

La limitation, comme je le dit au début, se situe sur le nombre d'objet à observer. Cela risque d'être difficilement gérable si ce nombre est important.

[poukill]

Dans le cahier des charges actuels, 3 ou 4 au maximums, couramment 2 ou 3...

Merci pour vos réponses à tous. Je continue ma réflexion en suivant vos orientations...

[koala01]

Salut,

Je suis tombé il y a quelques jours sur Ce site au gré de mes périgrinations...

L'un des patterns proposés devrait pouvoir faire l'affaire: il s'agit du pattern mediator

Tu trouveras, en bas de page, un exemple en C++

[poukill]

En vous écoutant tous, y'a 15 pattern qui font l'affaire !

OK merci Koala je vais regarder ça...

[r0d]

Peut-être que finalement, la solution la plus propre serait celle de Mat007, qui consiste, de fait, à un médiateur + un proxy (ou délégué) sur chaque caméra. En réfléchissant à ton problème, j'ai fais ce bout de code hier soir:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
#include <set>
 
class Camera
{
public:
	Camera():numeroImage(0),tempsImage(0),assignatedSlot(0){}
 
	int numeroImage;
	int tempsImage;
	int assignatedSlot;
};
 
class Slot
{
public:
	std::set<Camera*> cameras;
};
 
class Binder
{
public:
	Binder(unsigned int nbSlots = 5):m_nbSlots(nbSlots){m_slots = new Slot[nbSlots];}
	~Binder(){delete [] m_slots;}
 
	int AttachCamera(Camera &cameraRef, unsigned int slotNumber){
		if ( slotNumber>m_nbSlots ) return 1;
		m_slots[slotNumber].cameras.insert(&cameraRef);
		cameraRef.assignatedSlot = slotNumber;
		return 0;
	}
 
	bool DetachCamera(Camera& cameraRef){
		if ( cameraRef.assignatedSlot>m_nbSlots || cameraRef.assignatedSlot<0 )
			return false;
		std::set<Camera*> &pS = m_slots[cameraRef.assignatedSlot].cameras;
		std::set<Camera*>::iterator it = pS.find(&cameraRef);
		if ( it!=pS.end() ){
			pS.erase(it);
			return true;
		}
		else
			return false;
	}
 
	void SetNumeroImage(Camera& cameraRef, int numImage){
		std::set<Camera*> &pS = m_slots[cameraRef.assignatedSlot].cameras;
		for ( std::set<Camera*>::iterator it = pS.begin(); it!=pS.end(); it++)
			(*it)->numeroImage = numImage;
	}
 
	void SetTempsImage(Camera& cameraRef, int tpsImage){
		std::set<Camera*> &pS = m_slots[cameraRef.assignatedSlot].cameras;
		for ( std::set<Camera*>::iterator it = pS.begin(); it!=pS.end(); it++)
			(*it)->tempsImage = tpsImage;
	}
 
private:
	unsigned int	m_nbSlots;
	Slot*			m_slots;
};

C'est "brut de fonderie" et à améliorer bien évidemment, mais ça fonctionne. La classe Binder est un truc bizzare qui fais à la fois le boulot du médiateur et du proxy...
Un exemple d'utilisation:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
Camera cam1;
Camera cam2;
Camera cam3;
Camera cam4;
Camera cam5;
Binder binder;
binder.AttachCamera(cam1, 0);
binder.AttachCamera(cam2, 1);
binder.AttachCamera(cam3, 0);
binder.AttachCamera(cam4, 2);
binder.AttachCamera(cam5, 0);
binder.SetNumeroImage(cam1, 125);
binder.DetachCamera(cam1);

[poukill]

Franchement rOd, excellent...
C'est vraiment ce qui me convenait je crois...

J'ai pris le temps d'étudier ton pattern, et je prend tout!
Je rajoute juste un truc: t'as oublié de réinitialisé le assignatedSlot de la camera quand tu la détaches de son groupe!
Sinon un appel de setImage ferait mettre à jour tout le groupe sauf elle!
Eh puis il faut faire un test supplémentaire avant de faire un attachCamera(), sous peine de voir sa caméra copiée dans plusieurs groupes...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#include <set>
 
class Camera
{
public:
	Camera():numeroImage(0),tempsImage(0),assignatedSlot(-1){}
 
	int numeroImage;
	int tempsImage;
	int assignatedSlot;
};
 
class Slot
{
public:
	std::set<Camera*> cameras;
};
 
class Binder
{
public:
	Binder(unsigned int nbSlots = 5):m_nbSlots(nbSlots){m_slots = new Slot[nbSlots];}
	~Binder(){delete [] m_slots;}
 
	int AttachCamera(Camera &cameraRef, unsigned int slotNumber){
		if ( slotNumber>m_nbSlots ) return 1;
		DetachCamera(cameraRef);
		m_slots[slotNumber].cameras.insert(&cameraRef);
		cameraRef.assignatedSlot = slotNumber;
		return 0;
	}
 
	bool DetachCamera(Camera& cameraRef){
		if ( cameraRef.assignatedSlot>m_nbSlots || cameraRef.assignatedSlot<0 )
			return false;
		std::set<Camera*> &pS = m_slots[cameraRef.assignatedSlot].cameras;
		std::set<Camera*>::iterator it = pS.find(&cameraRef);
		cameraRef.assignatedSlot = -1;
		if ( it!=pS.end() ){
			pS.erase(it);
			return true;
		}
		else
			return false;
	}
 
	void SetNumeroImage(Camera& cameraRef, int numImage){
		std::set<Camera*> &pS = m_slots[cameraRef.assignatedSlot].cameras;
		for ( std::set<Camera*>::iterator it = pS.begin(); it!=pS.end(); it++)
			(*it)->numeroImage = numImage;
	}
 
	void SetTempsImage(Camera& cameraRef, int tpsImage){
		std::set<Camera*> &pS = m_slots[cameraRef.assignatedSlot].cameras;
		for ( std::set<Camera*>::iterator it = pS.begin(); it!=pS.end(); it++)
			(*it)->tempsImage = tpsImage;
	}
 
private:
	unsigned int	m_nbSlots;
	Slot*			m_slots;
};

Merci encore pour le temps que tu as passé pour moi...
Merci aussi aux autres (Koala, Mat007) qui comme d'habitude sont de bons conseils !

Bon week-end !

[poukill]

Pour celui ou celle qui chercherait à faire à peu près la même chose, voici mon code final du binder en template...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
#pragma once
 
#include <set>
#include <vector>
 
template <typename T>
class Slot
{
	public:
	Slot();
	Slot(T* obj1, T* obj2) {m_liste_objets.insert(obj1); m_liste_objets.insert(obj2);}
 
	std::set<T*> m_liste_objets;
 
	bool is_empty() const {return m_liste_objets.empty();	}
};
 
template <typename T>
class BaseBinder
{
public:
	BaseBinder() {}
	~BaseBinder(){}
 
	bool Attach(T* Tref1, T* Tref2);
 
private:
	int getFreeSlotNumber() const;
	bool Attach(T* TRef, unsigned int slotNumber);
	bool Detach(T* TRef);
 
	std::vector< Slot<T> >	m_vecteur_objets;
};
 
 
template <typename T>
bool BaseBinder<T>::Attach(T* Tref1, T* Tref2)
{
	Detach(Tref1); // On détache Tfref1 de son éventuel Slot
	if (Tref2->m_assignated_slot != -1) { // Si Tref2 est déjà sur un Slot, on lui ajouter Tref1
		Attach(Tref1, Tref2->m_assignated_slot);
		return true;
	}
	else {
		int slot = getFreeSlotNumber();
		if (slot != -1) {
			Attach(Tref1, slot);
		}
		else {
			m_vecteur_objets.push_back(Slot<T>(Tref1, Tref2) );
		}
	}
	return 0;
}
 
 
template <typename T>
bool BaseBinder<T>::Attach(T* TRef, unsigned int slotNumber)
{
	m_vecteur_objets[slotNumber].m_liste_objets.insert(TRef);
	TRef->m_assignated_slot = slotNumber;
	return 0;
}
 
 
template <typename T>
bool BaseBinder<T>::Detach(T* TRef)
{
	if (TRef->m_assignated_slot < 0 )
		return false;
	TRef->m_assignated_slot = -1; // On réinitialise le slot de l'objet
	std::set<T*> &pS = m_vecteur_objets[TRef->m_assignated_slot].m_liste_objets;
	std::set<T*>::iterator it = pS.find(TRef);
	if ( it!=pS.end() ){
		pS.erase(it);
		return true;
	}
}
 
template <typename T>
int BaseBinder<T>::getFreeSlotNumber() const
{
	std::vector< Slot<T> >::const_iterator iter;
	for(iter = m_vecteur_objets.begin(); iter != m_vecteur_objets.end(); iter++) {
		if (!iter->is_empty() )
			return std::distance(m_vecteur_objets.begin(), iter);
	}
	return -1;
}