- ` par un simple `M` par exemple.
J'ai obtenu quelque chose comme :
subgraph cluster_x {
node [label="C"] C_x ;
node [label="E"] E_x ;
node [label="a1"] tag1_x ;
node [label="a2"] tag2_x ;
node [label="R", color="#880000", fillcolor="#880000", fontcolor="white"] R_x ;
R_x -> C_x;
C_x -> tag1_x ;
C_x -> tag2_x ;
R_x -> E_x ;
}
subgraph cluster_y {
node [label="C"] C_y ;
node [label="E"] E_y ;
node [label="a1"] tag1_y ;
node [label="a2"] tag2_y ;
node [label="R", color="#880000", fillcolor="#880000", fontcolor="white"] R_y ;
R_y -> C_y;
C_y -> tag1_y ;
C_y -> tag2_y ;
R_y -> E_y ;
}
subgraph cluster_z {
node [label="C"] C_z ;
node [label="E"] E_z ;
node [label="a1"] tag1_z ;
node [label="a2"] tag2_z ;
node [label="R", color="#880000", style="filled", fillcolor="#880000", fontcolor="white"] R_z ;
R_z -> C_z;
C_z -> tag1_z ;
C_z -> tag2_z ;
R_z -> E_z ;
}
E_x -> R_y ;
E_x -> R_z ;
et
subgraph cluster_x {
node [label="M"] E_x ;
node [label="a1"] tag1_x ;
node [label="V"] value_tag1_x ;
node [label="a2"] tag2_x ;
node [label="V"] value_tag2_x ;
node [label="V", color="#880000", fillcolor="#880000", fontcolor="white"] R_x ;
R_x -> value_tag1_x -> tag1_x ;
R_x -> value_tag2_x -> tag2_x ;
R_x -> E_x ;
}
subgraph cluster_y {
node [label="M"] E_y ;
node [label="a1"] tag1_y ;
node [label="V"] value_tag1_y ;
node [label="a2"] tag2_y ;
node [label="V"] value_tag2_y ;
node [label="V", color="#880000", fillcolor="#880000", fontcolor="white"] R_y ;
R_y -> value_tag1_y -> tag1_y ;
R_y -> value_tag2_y -> tag2_y ;
R_y -> E_y ;
}
subgraph cluster_z {
node [label="M"] E_z ;
node [label="a1"] tag1_z ;
node [label="V"] value_tag1_z ;
node [label="a2"] tag2_z ;
node [label="V"] value_tag2_z ;
node [label="V", color="#880000", fillcolor="#880000", fontcolor="white"] R_z ;
R_z -> value_tag1_z -> tag1_z ;
R_z -> value_tag2_z -> tag2_z ;
R_z -> E_z ;
}
E_x -> R_y ;
E_x -> R_z ;
Puis, je me suis fait la réflexion suivante :
Dans les distances d'éditions sur les arbres, chaque opération atomique correspond à un simple *search and replace* sur mon fichier xml source[^nb].
On considère trois opérations atomiques sur les arbres :
- *substitution*: renommer un nœud
- *insertion*: ajouter un nœud
- *délétion*: supprimer un nœud
[^nb]: J'ai programmé un outil qui calcule automatiquement le poids de chaque élément des matrices d'édition à partir de données.
Une des particularité avec les transformations sur les arbres est celle-ci :
supprimer un nœud et tous ses enfants deviendront les enfants du père de ce nœud.
Un exemple:
r - x - a
\ \
\ b
y - c
Si vous supprimez le nœud `x`, vous obtenez
a
/
r - b
\
y - c
And look at what it implies when you write it in xml:
value for a
value for b
value for c
Alors supprimer tous les nœuds `x` revient à faire passer le xml à travers le filtre suivant :
s/<\/?x>//g
Par conséquent, s'il existe un transducteur déterministe à un état qui permet de transformer mes arbres ;
je suis capable de transformer le xml d'un format à l'autre en utilisant une simple liste de *search and replace*.
# Solution
Transformer cet arbre :
R - C - tag1
\ \
\ tag2
E -- R - C - tag1
\ \ \
\ \ tag2
\ E ...
R - C - tag1
\ \
\ tag2
E ...
en celui-ci :
tag1
/
M - V - M - V - tag2 tag1
\ /
M --- V - tag2
\ \
\ M
\ tag1
\ /
V - tag2
\
M
peut-être fait en utilisant le transducteur déterministe à un état suivant:
> C -> ε
> E -> M
> R -> V
Ce qui peut-être traduit par les simples directives Perl suivantes :
s/C//g
s/E/M/g
s/R/V/g
Une fois adapté au xml cela devient :
s%?contenu>%%g
s%%- %g
s%
%
%g
s%?rubrique>%