Discussion :

[Metafire18]

Bonjour à tous,

Je travaille actuellement sur un parser XSD avec une visualisation sous forme de JTree en sortie. J'obtient le résultat ci-dessous:


Je souhaiterais supprimer les noeuds (type complexe) sans supprimer leurs descendances.

Par exemple pour l'élément ShipTo : Je souhaite supprimer l'élément complexe USAdress et raccorder les sous élément country, name, zip .... à l'élément ShipTo.

Avez vous une idée?

[choko83]

Tout simplement, tu parcours tous les fils de USAdress et tu les ajoute à ShipTo, puis tu supprime le noeud USAdress avec l'instruction remove().

[Metafire18]

Oui jusque là je suis d'accord avec toi Mais j'ai du mal à structurer ma fonction récursive.

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
void EnleverComplexe(Object r)
    {
        TreeNode root = (TreeNode)r;
        if(root.toString().contains("type complexe"))
        {
            System.out.println(root.toString()+" est un élément complexe");
        }
 
        for (int i = 0; i < root.getChildCount(); i++)
        {
            TreeNode enfant=root.getChildAt(i);
            if (!(enfant.isLeaf()))
            {
                EnleverComplexe(root.getChildAt(i));
            }
        }
    }

Je n'arrive pas à voir à quel moment je dois transférer les noeuds enfants de l'élément complexe vers le niveau supérieur et à quel moment je dois supprimer l'élément complexe...

[Metafire18]

J'avais pensé faire quelque chose de ce genre :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
Si ( NoeudVisité est un élément Complexe)
{
         listeElement <= récupération des enfants de NoeudVisité
         Pour chaque element de listeElement
         {
                 je raccord l'element enfant à l'élément supérieur de NoeudVisité
         }
         Je supprime NoeudVisité
         .
         .
         .
}

Seulement je ne sais pas comment reprendre le parcours après cela.

[Metafire18]

J'ai trouvé une solution, je gère ça en deux temps. J'appelle d'abord la méthode ParcourirDeplacer puis la méthode SupprimerComplexe :

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
/**
    * Fonction utilisée pour déplacer les éléments contenus dans un élément complexe.
    * Ainsi les éléments complexes deviennent des feuilles de l'arbre.
    * @param r: le noeud sur lequel s'applique la méthode
    */
    void ParcourirDeplacer(DefaultMutableTreeNode r)
    {
        //Pour chaque enfant du noeud r
        for (int i = 0; i < r.getChildCount(); i++)
        {
            //Si l'enfant n'est pas une feuille
            if (!(r.getChildAt(i).isLeaf()))
            {
                //Récupération de l'enfant
                DefaultMutableTreeNode temp=(DefaultMutableTreeNode) r.getChildAt(i);
                //On appelle recursivement la méthode
                ParcourirDeplacer(temp);
                //Si l'enfant est de type complexe
                if(temp.toString().contains("type complexe"))
                {
                    //Pour chacun de ses enfants
                    for(int j=0;j<temp.getChildCount();j++)
                    {
                        //On récupère l'enfant
                        DefaultMutableTreeNode tempEnf=((DefaultMutableTreeNode)temp.getChildAt(j));
                        //Et on le confie à l'élément hierarchique de niveau supérieur
                        model.insertNodeInto(tempEnf,(MutableTreeNode)temp.getParent(),0);
                    }
                }               
            }
        }	
    }
 
 
    /**
    * Fonction utilisée supprimer les feuilles de l'arbre qui sont de type complexe
    * @param r: le noeud sur lequel s'applique la méthode
    */
    void SupprimerComplexe(DefaultMutableTreeNode r)
    {
        //Pour chaque enfant de r
        for (int i = 0; i < r.getChildCount(); i++)
        {
            //On récupère l'enfant
            DefaultMutableTreeNode temp=(DefaultMutableTreeNode) r.getChildAt(i);
            //Si l'enfant est une feuille de l'arbre
            if((r.getChildAt(i).isLeaf()))
            {
                //Si la feuille examiné est de type complexe
                if(temp.toString().contains("type complexe"))
                {
                    //On supprime la feuille
                    r.remove(i);
                    //On décrémente le compteur pour éviter un dépassement de boucle
                    i--;
                }
            }
            //Si l'enfant n'est pas une feuille
            if ((!r.getChildAt(i).isLeaf()))
            {
                //On appelle recursivement la méthode
                SupprimerComplexe(temp);                
            }
        }
    }