Quel est le XSD le plus simple/le plus clair pour ce XML?

Question

Quel est le style le plus simple/le plus clair de XSD pour ce type de XML? (Il est de this answer)

<object name="contact"> 
    <object name="home"> 
    <object name="tel"> 
     <string name="area" value="910"/> 
     <string name="num" value="1234 5678"/> 
    </object> 
    </object> 
    <object name="work"> 
    <object name="tel"> 
     <string name="area" value="701"/> 
     <string name="num" value="8888 8888"/> 
    </object> 
    <object name="fax"> 
     <string name="area" value="701"/> 
     <string name="num" value="9999 9999"/> 
    </object> 
    </object> 
</object> 

EDIT Je déplacé mon exemple XSD et des éclaircissements dans une réponse.

Answer 1

Si vos données sont pas de format totalement gratuit, je fais le XML spécifique à votre modèle de données:

<contact> 
    <home> 
    <tel> 
     <area>910</area> 
     <num>1234 5678</num> 
    </tel> 
    </home> 
    <work> 
    <tel> 
     <area>701</area> 
     <num>8888 8888</num> 
    </tel> 
    <fax> 
     <area>701</area> 
     <num>9999 9999</num> 
    </fax> 
    </work> 
</contact> 

Cependant, en supposant que vous avez une raison pour ce faire de la façon que vous le faites (par exemple, en supposant que vos données vraiment sont des données totalement gratuit format structuré), vous pouvez faire le XSD un peu plus clair en faisant quelque chose comme ceci:

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"> 
    <xs:element name="object"> 
    <xs:complexType> 
     <xs:choice minOccurs="0" maxOccurs="unbounded"> 
     <xs:element ref="string"/> 
     <xs:element ref="object"/> 
     </xs:choice> 
     <xs:attribute name="name" type="xs:string"/> 
    </xs:complexType> 
    </xs:element> 

    <xs:element name="string"> 
    <xs:complexType> 
     <xs:attribute name="name" type="xs:string"/> 
     <xs:attribute name="value" type="xs:string"/> 
    </xs:complexType> 
    </xs:element> 
</xs:schema> 

Je préfère des schémas où chaque element est défini dans un manière autonome - autant que possibl e - et tout type utilisé à plusieurs endroits est également défini séparément. Dans votre cas, il n'y a pas de type réutilisé.

Lorsqu'un XSD est profondément imbriqué, il devient plus difficile à lire et plus difficile à supporter et à modifier.

Note: Vous pouvez faire le nom d'objet en option en faisant ce changement:

<xs:element name="object"> 
    <xs:complexType> 
     <xs:choice minOccurs="0" maxOccurs="unbounded"> 
     <xs:element ref="string"/> 
     <xs:element ref="object"/> 
     </xs:choice> 
     <xs:attribute name="name" type="xs:string" use="optional"/> 
    </xs:complexType> 
    </xs:element> 

Mais ne font pas aussi le nom du type de chaîne en option! (Au moins de ce que vous nous avez montré, cela n'a aucun sens de le faire.)

Answer 2

Voici une XSD - est-ce que sa grammaire est la plus claire?

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"> 
    <xs:element name="object"> 
    <xs:complexType> 
     <xs:choice minOccurs="0" maxOccurs="unbounded"> 

     <xs:element name="string"> 
      <xs:complexType> 
      <xs:attribute name="name" type="xs:string"/> 
      <xs:attribute name="value" type="xs:string"/> 
      </xs:complexType> 
     </xs:element> 

     <xs:element ref="object"/> 

     </xs:choice> 
     <xs:attribute name="name" type="xs:string"/> 
    </xs:complexType> 
    </xs:element> 

</xs:schema> 

L'idée de base du XML est des objets imbriqués:

V --> string | O  // a Value is a string or an Object 
O --> (K V)*   // an Object is list of named values (Key-Value pairs) 

Mais il est un peu différent, en ce que la racine est toujours un objet (pas une chaîne), et il est lui-même nommé (même qu'il ne soit pas dans un autre objet):

O ==> (string K | O)* K 

Je suis ouvert à changer le format lui-même légèrement, pour donner XML différent, si cela fera une XSD plus simple/plus claire. Si un objet a toujours un nom, cela supprime les cas spéciaux, ce qui rend la grammaire et le XSD plus réguliers - et plus simples. Par conséquent, il semble plus simple pour un objet d'avoir toujours un nom.

Clarification: le cas particulier serait que lorsque l'objet est la racine, il n'est pas nommé, mais dans tous les autres cas, il est nommé. Cela nécessite une section d'en-tête supplémentaire, comme ceci:

O'==> (string K | O)* 
O ==> (string K | O)* K 

La manipulation de ce cas particulier est plus complexe que l'original, même si refactorisé pour minimiser cette complexité:

F ==> (string K | O)* 
O ==> F K