Discussion :

[themadmax]

Bonjour,

Je suis face a un problème, j'ai des classes Module qui sont générique:

Code :

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

1
2
3
4
5
class Module
{
    Module _parent ;
    void FunctionGeneric() {}
}

Puis j'ai de multiple classes qui dérivent de ces modules, et ces objets sont connecté en eux comme un graphe. Dans un module j'aimerai avoir accès à une fonction spécifique d'un parent en parcourant le graphe récursivement, voila mon choix d’implémentation:

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
class ModuleA : Module
{
    void FunctionSpec();
}
class ModuleB : Module
{
    void Recherche()
    {
        Module parent = _parent ;
        for(;;) {
            ModuleA parentA = (ModuleA)parent;
            if ( parentA != NULL ) {
                parentA.FunctionSpec();
                break;
            } else parent = parent._parent ;
        }
    }
}

Je trouve se code pas très propre de devoir "caster", une autre solution est de remonté la fonction FunctionSpec() dans la classe Module. J'aimerai bien avoir votre avis sur la meilleure implémentation.
Merci d'avance

[bruno_pages]

Bonjour,

si l'attribut _parent suit bien l'héritage (ce qui ne semble pas être le cas ici) alors définissez FunctionSpec sur Module et lorsque cela est nécessaire sur les sous classes, le code généré appellera automatiquement la FunctionSpec de la classe la plus 'proche', de plus il semble que votre code soit en Java, dans ce cas vous n'avez pas besoin de l'attribut _parent car vous avez super()

si l'attribut _parent ne suit pas l'héritage alors il faut définir Recherche au niveau Module et appeler Recherche et non FunctionSpec sur le _parent, ainsi pas de cast et ModuleB n'a pas à savoir que sont _parent est un ModuleA et donc l'arbre n'est pas figé au niveau code (ce qui à priori est incompatible avec votre besoin). Bien évidemment Recherche doit être défini dans toutes les sous classes de Module, et au niveau de chaque classe Recherche appelle FunctionSpec si celle-ci existe pour la classe (connu statiquement) sinon appelle Recherche sur _parent. A noter que votre algo déréférence NULL dés que _parent est NULL

[Desboys]

Bonjour,

Vous semblez exploiter un pattern Composite pour décrire une relation hiérarchique entre module. La classe mère du niveau le plus haut est potentiellement correcte ( l'attribut _parent est, à priori, de type "protected", et la méthode FunctionGeneric() virtuelle ).

Pour ce besoin spécifique, je pense que vous vous égarez dans votre raffinement de la notion Module.
Si votre ModuleB nécessite une méthode du ModuleA, vous exprimer alors un couplage plus spécialisé que celui exprimé par la classe mère Module.
Soit vous résolvez ce couplage avec un héritage ( avec ModuleB qui hérite de ModuleA, implémentant lui-même Module ), soit vous vous appuyez sur une composition ( à la construction de l'arborescence des implémentations de Module, vous fournissez à ModuleB une référence vers un ModuleA ).
Si l'une de ces solutions n'est pas acceptable, alors il vous faut inscrire la méthode FunctionSpecific() dans la classe Module, et implémenter ceci par une délégation sur le Module parent, s'il existe.

@bruno_pages: pour info, l'expression de l'héritage en Java exploite les mots-clefs extends ou implements :-)

Cordialement,
Sébastien

[bruno_pages]

@bruno_pages: pour info, l'expression de l'héritage en Java exploite les mots-clefs extends ou implements :-)

merci, je suis au courant, en fait j'ai pensé (peut être à tord) que c'était écrit en pseudo code et devant l'absence totale de pointeur opté pour un programmeur Java plutôt que C++, car avoir (entre autre) un attribut de type Module dans la classe Module ça va mal se passer

[themadmax]

Merci pour vos réponses

si l'attribut _parent suit bien l'héritage (ce qui ne semble pas être le cas ici) alors définissez FunctionSpec sur Module et lorsque cela est nécessaire sur les sous classes, le code généré appellera automatiquement la FunctionSpec de la classe la plus 'proche', de plus il semble que votre code soit en Java, dans ce cas vous n'avez pas besoin de l'attribut _parent car vous avez super()

Mon exemple est bien du pseudo-code, mon projet est en réalité en C++, mais l'attribut _parent, n'est pas la pour l'appel de la classe parent, mais de l'objet connecté, donc Java ou pas j'ai besoin de lui!

La classe mère du niveau le plus haut est potentiellement correcte ( l'attribut _parent est, à priori, de type "protected", et la méthode FunctionGeneric() virtuelle ).

Oui en effet... pour etre plus claire voici mon exemple en Java

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
class Program
{
	public static void main(String[] args)
	{
		// WebCam => Filter => Recorder 
		
		Module m1 = new WebCam(null);
		Module m2 = new Filter(m1);
		Module m3 = new Recorder(m2);
		
		m1.start(); m2.start(); m3.start(); 
	}
}

class Module
{
	Module _parent ;
	public Module(Module parent) { _parent = parent ; }	
	public void start() { }
}

class WebCam extends Module
{
	static int width = 320 ;
	static int height = 320 ;
	
	public WebCam(Module parent) { super(parent); }
	
	public int getWidth() { return width; }
	public int getHeight() { return height; }
}

class Filter extends Module
{
	public Filter(Module parent) { super(parent); }
}

class Recorder extends Module
{
	public Recorder(Module parent) { super(parent); }
	//@overide
	public void start()
	{
		int width = 0 ;
		//pour creer un avi on a besoin de la taille de la video !
		Module parent = _parent ;
        for(;parent!=null;) {
            if ( parent instanceof WebCam ) {
                width = ((WebCam)parent).getWidth();
				System.out.println("Width found : " + width );
                break;
            } else parent = parent._parent ;
        }
	}
}

Pour ce besoin spécifique, je pense que vous vous égarez dans votre raffinement de la notion Module.

Je me prend la tête pour rien ?

Si votre ModuleB nécessite une méthode du ModuleA, vous exprimer alors un couplage plus spécialisé que celui exprimé par la classe mère Module.
Soit vous résolvez ce couplage avec un héritage ( avec ModuleB qui hérite de ModuleA, implémentant lui-même Module ),

Je ne comprend pas hélas cette phrase mais je pense qu'elle correspond à mon choix implémentation...

soit vous vous appuyez sur une composition ( à la construction de l'arborescence des implémentations de Module, vous fournissez à ModuleB une référence vers un ModuleA ).

Donc sa je pense que sa s’implémente comme cela :

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
class Program
{
	public static void main(String[] args)
	{
		// WebCam => Filter => Recorder 
		
		Module m1 = new WebCam(null);
		Module m2 = new Filter(m1);
		Module m3 = new Recorder(m2,(Sizer)m1);
		
		m1.start(); m2.start(); m3.start(); 
	}
}

interface Sizer 
{
	public int getWidth();
	public int getHeight();
}

class WebCam extends Module implements Sizer
{
	static int width = 320 ;
	static int height = 320 ;
	
	public WebCam(Module parent) { super(parent); }
	
	public int getWidth() { return width; }
	public int getHeight() { return height; }
}

class Recorder extends Module
{
	Sizer _sizer ;
	
	public Recorder(Module parent,Sizer sizer) { super(parent); _sizer = sizer ;}
	//@overide
	public void start()
	{		
		//pour creer un avi on a besoin de la taille de la video !
		int width = _sizer.getWidth();
		System.out.println("Width found : " + width );
	}
}

Est-ce bien cela? Trouve tu cette méthode plus clean? J'ai regarder du coté du "pattern Composite" mais j'ai l'impression que ce parttern ne correspond pas exactement a mon besoin.

[Desboys]

Bonjour,

Je comprends mieux, enfin j'espère.
Est-ce que l'objectif de ta modélisation est de pouvoir intercaler des "filter" dynamiquement entre ta webcam et ton recorder? ou bien de composer une chaine d'acquisition un peu plus complexe?
Personnellement, je ne suis pas certain qu'une Webcam et un système d'enregistrement aient une notion commune.
Une WebCam capture des images de l'extérieur, et permet de les extraire. C'est un dispositif "producteur" d'information
Un "recorder" va plutôt recevoir des images, et les convertir dans un format de stockage spécialisé. C'est un dispositif "consommateur" d'information.
Je vois donc bien un lien d'assemblage entre ces éléments, mais je ne suis pas certain qu'ils aient une notion parente commune.
Je ne suis pas très au fait du monde de la vidéo, mais il me semble que, potentiellement, lorsqu'on veut faire une retouche, un effet, etc ... on place un dispositif intermédiaire ( qui pourraient alors fournir des filtres ).

J'aurai donc une classe pour chacun de ces 3 élements, qui n'ont pas de propriété commune ( et donc pas de classe parente ).
Tu pourrais alors composer ton système de capture d'une webcam, d'éventuels traitements ( sous forme de filtres ), et d'un recorder.

Cordialement,
Sébastien

[themadmax]

Personnellement, je ne suis pas certain qu'une Webcam et un système d'enregistrement aient une notion commune.

Ceci est bien est un choix de représentation, mais pour moi ce choix est évidant et d’ailleurs fortement inspiré du choix de Microsoft dans le DirectShow.
Cela permet d'avoir des traitements générique pour tous mes modules, comme le chargement, la gestion enfants<>parents, l’échange de données...