xml - tipos - xsd atributos

Restricción de co-ocurrencia de atributo/elemento en el Esquema XML

Question

¿Es posible crear un Esquema XML que impone una restricción de co-ocurrencia a un par de atributo / elemento?

<primitive-list>
    <primitive name="P1">
        <definition><!-- primitive specification --></definition>
    </primitive>
    <primitive name="P2">
        <definition><!-- primitive specification --></definition>
    </primitive>

    <!-- other common primitives are specified here-->

<primitive-list>

<composite-list>
    <composite name="C1">
        <primitive ref="P1" />
        <primitive ref="P2" />
        <primitive>
            <definition><!-- inline primitive specification --></definition>
        </primitive>        
    </composite>

    <!-- Other compisites are specified here-->

</composite-list>

El esquema debe implicar que:

• Si se especifica un elemento primitivo dentro de un elemento de lista primitiva , entonces debe contener el atributo de nombre y el elemento de definición incrustado, pero no el atributo ref .
• Si se especifica un elemento primitivo en el elemento compuesto , entonces debe contener el atributo ref o el elemento de definición . El nombre está permitido en ninguno de los casos.

Estoy bastante seguro de que es posible ya que el elemento elemento en el Esquema XML mismo se comporta así. Entonces, cualquiera que esté en posesión de ese conocimiento sagrado, por favor comparte :-)

Gracias de antemano.

Answer 1

Sí, esto es posible Al crear su esquema XML, creará un tipo complejo para cada escenario, en función de dónde se define el elemento en el árbol XML.

Si recibo un momento más tarde puedo tratar de obtener un ejemplo aquí para ti, simplemente no tengo el tiempo para obtener todo el formato perfectamente para publicar aquí.

Personalmente, recomiendo consultar este tutorial de w3schools , ya que debe obtener lo que necesita.

Answer 2

Ok, aquí hay una muestra, esto te acerca, lo único que no se maneja es el atributo primitivo y ref en el compuesto. Viendo lo que puedo encontrar, parece casi imposible hacerlo a través de un esquema. Aunque no estoy 100% seguro, pero en todos los casos donde he visto esto hecho, un esquema como este se usa para la validación de alto nivel y el código de proceso se usa para validar los elementos individuales.

<?xml version="1.0" encoding="utf-8"?>
<xs:schema targetNamespace="http://www.iowacomputergurus.com//samples/xsdexample"
    elementFormDefault="qualified"
    xmlns="http://www.iowacomputergurus.com//samples/xsdexample"
    xmlns:xs="http://www.w3.org/2001/XMLSchema"
>

  <xs:complexType name="PrimitiveType">
    <xs:sequence>
      <xs:element name="definition" type="xs:string" minOccurs="1" maxOccurs="1" />
    </xs:sequence>
    <xs:attribute name ="name" use="required" type="xs:string" />
  </xs:complexType>

  <xs:element name="root">
    <xs:complexType>
      <xs:sequence>
          <xs:element name="primitive-list" minOccurs="1" maxOccurs="1">
            <xs:complexType>
              <xs:sequence>
                <xs:element name="primitive" type="PrimitiveType" minOccurs="1" maxOccurs="unbounded" />
              </xs:sequence>
            </xs:complexType>
          </xs:element>
          <xs:element name="composite-list" minOccurs="1" maxOccurs="1">
            <xs:complexType>
              <xs:sequence>
                <xs:element name="composite">
                  <xs:complexType>
                    <xs:sequence>
                      <xs:element name="primitive" minOccurs="1" maxOccurs="unbounded">
                        <xs:complexType>
                          <xs:sequence>
                            <xs:element name="definition" minOccurs="0" maxOccurs="1" />
                          </xs:sequence>
                          <xs:attribute name="ref" use="optional" type="xs:string" />
                        </xs:complexType>
                      </xs:element>
                    </xs:sequence>
                    <xs:attribute name="name" type="xs:string" use="required" />
                  </xs:complexType>
                </xs:element>
              </xs:sequence>
            </xs:complexType>
          </xs:element>
      </xs:sequence>
    </xs:complexType>
  </xs:element>  
</xs:schema>

Answer 3

Después de buscar en Internet y buscar algunos libros, descubrí cómo implementarlo.

Antes que nada, necesitamos definir un tipo genérico que acomode todos los atributos y elementos de ambos tipos del elemento primitivo . Se supone que el elemento de definición se define en otro lugar.

<xs:complexType name="primitive" abstract="true">
    <xs:sequence>
        <xs:element ref="definition" minOccurs="0" maxOccurs="unbounded" />
    </xs:sequence>
    <xs:attribute name="name" type="xs:Name" />
    <xs:attribute name="ref" type="xs:Name" />
</xs:complexType>

Luego definimos dos subtipos primitivos que se utilizarán en la lista primitiva y el compuesto, respectivamente.

<xs:complexType name="public-primitive">
    <xs:complexContent>
        <xs:restriction base="primitive">
            <xs:sequence>
                <xs:element ref="definition" minOccurs="1" maxOccurs="unbounded" />
            </xs:sequence>
            <xs:attribute name="name" type="xs:Name" use="required" />
            <xs:attribute name="ref" use="prohibited" />
        </xs:restriction>
    </xs:complexContent>
</xs:complexType>

<xs:complexType name="private-primitive">
    <xs:complexContent>
        <xs:restriction base="primitive">
            <xs:sequence>
                <xs:element ref="definition" minOccurs="0" maxOccurs="unbounded" />
            </xs:sequence>
            <xs:attribute name="name" use="prohibited" />
        </xs:restriction>
    </xs:complexContent>
</xs:complexType>

Ahora podemos definir la lista primitiva y los elementos compuestos en términos de estos tipos complejos de la siguiente manera:

<xs:element name="primitive-list">
    <xs:complexType>
        <xs:sequence>
            <xs:element name="primitive" type="public-primitive" maxOccurs="unbounded" />
        </xs:sequence>
    </xs:complexType>
</xs:element>

<xs:element name="composite">
    <xs:complexType>
        <xs:sequence>
            <xs:element name="primitive" type="private-primitive" maxOccurs="unbounded">
                <xs:key name="definition-ref--co-occurrence--constraint">
                    <xs:selector xpath="." />
                    <xs:field xpath="definition|@ref" />
                </xs:key>
            </xs:element>
        </xs:sequence>
    </xs:complexType>
</xs:element>

Echemos un vistazo a los requisitos del esquema original y veamos cómo se aplican:

• Si se especifica un elemento primitivo dentro de un elemento de lista primitiva , entonces debe contener el atributo de nombre y el elemento de definición incrustado, pero no el atributo ref .

Este requisito se aplica por la definición del tipo primitivo público solo.

• Si se especifica un elemento primitivo en el elemento compuesto , entonces debe contener el atributo ref o el elemento de definición . El nombre está permitido en ninguno de los casos.

Este requerimiento es impuesto por la definición del tipo primitivo privado y por el elemento clave xs: especificado en el elemento primitivo definido dentro del elemento compuesto . La clave xs: garantiza que está presente la ref o la definición, pero no ambas.