Discussion :

[Bakouz]

Re-bonjour, j'ai dans mon application, un objet A composé d'objet B, qui lui meme est composé d'objet C ( et compose donc A), composé de D qui lui est composé de E, pour cela j'utilise les LinkedList.

Code :

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

1
2
3
4
public class Compose<T> {
    protected T c; // C l'objet composé
(..)
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
public class ComposéDe<T extends Compose> {
    protected LinkedList<T> cde;

ComposéDe()
    {
        cde=new LinkedList<T>();
    }
(...)
    public void effacer()
    {
         // Cf. plus bas
    }
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
public class ComposéDeCompose<T1 extends Compose,T2> extends Compose<T2> implements IntComposéDe<T1> {
    protected ComposéDe C;
 
    ComposéDeCompose()
    {
        super();
        C=new ComposéDe();
    }
(...)
 
}

A hérite de ComposéDe<B>, E de Compose<D>, le reste du type :

Code :

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

1
2
3
4
public class B extends ComposéDeCompose<C,A>
{
..
}

Je cherche a faire une suppression en cascade, supprimer A reviendrais a supprimer tous ses Objet B, pour lesquels on supprimerais tous leurs Objet C etc
La méthode que je cherche a écrire est la suivante :

Je teste si ma liste est composé d'objet composé d'autres objets, si oui, suppression en cascade, sinon, je supprime les éléments de la liste.

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
public void effacer()
    {
        ListIterator iter=this.cde.listIterator();
        Class cls=this.cde.getClass().getComponentType();
        if(cls instanceof ComposéDeCompose)
        {
           // Suppression 
        }
        else
        {
             while(iter.hasNext())
             {
                 iter.next();
                 iter.remove();
             }
        }
    }

C'est ce qui est en gras qui pose problème, lorsque je fais un essai avec un document par exemple, cette ligne

return this.cde.getClass().getComponentType();

me renvoie null au lieu de page, je comprend pas.
Cette ligne aussi pose problème

Code :

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

if(cls instanceof ComposéDeCompose)

Cela me dit

inconvertible types
required: document.ComposéDeCompose
found: java.lang.Class

Really need help, ne serait-ce qu'une indication

Merci d'avance

[thelvin]

getComponentType() ne s'applique qu'aux tableaux.

Les génériques n'existent que compile-time, ils disparaissent à la compilation et n'existent pas au runtime. Par conséquent, on ne peut pas faire d'introspection sur le type véritable d'un paramètre générique.

[Bakouz]

Pour supprimer en cascade je dois vérifier si la liste est composé d'objet qui eux meme sont composé, cela doit forcément passer par une comparaison pour qu'une fois arriver au dernier objet composé cela ne pose pas de problème.

Comment je pourrais récuperer le type d'une Liste et le comparer avec la classe "ComposéDeCompose" ?

[thelvin]

Comment je pourrais récuperer le type d'une Liste et le comparer avec la classe "ComposéDeCompose" ?

Tu ne peux pas, tu dois te débrouiller autrement.

Une idée serait d'avoir une classe dédiée à contenir des ComposéDeCompose, et que cette classe-là, dans sa méthode effacer(), fasse la suppression en chaîne. Les autres, étant de classe différente, ne sont pas censées contenir des ComposéDeCompose, et donc n'ont pas de suppression en chaîne à faire.

Ah, au fait : pour vider une collection c'est pas la peine de la parcourir : clear() c'est très bien.
Et je rappelle que Java est garbage-collecté : la suppression en chaîne, elle se fait toute seule.

[Bakouz]

Je serais toujours bloqué au moment ou j'arriverais au dernier objet composé non ?

Edit : Je crois avoir trouvé, avec la comparaison d'instance sur les Iteration et non sur la LinkedList elle meme

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public void effacer()
    {
        ListIterator iter=this.cde.listIterator();
        while(iter.hasNext())
        {
          T t=(T)iter.next();
          if(t instanceof ComposéDeCompose)
          {
              ComposéDeCompose t2=(ComposéDeCompose)t;
              t2.effacer();
          }
          iter.remove();
        }
    }

Je sais pas pourquoi j'y ai pas pensé avant, ca oblige a comparer tous les derniers objets mais s'il y a pas d'autre moyens.

[thelvin]

Il y a au moins deux moyens plus courts, dont celui que je t'ai donné, mais bon, tu y reviendras quand tu auras un peu l'habitude des design patterns et du polymorphisme.

Si je te donne un truc tout cuit ça servira à rien, et j'aurai perdu pas mal de mon temps.