<?xml version="1.0" encoding="UTF-8"?>
<!--
  ~ ModeShape (http://www.modeshape.org)
  ~
  ~ See the COPYRIGHT.txt file distributed with this work for information
  ~ regarding copyright ownership.  Some portions may be licensed
  ~ to Red Hat, Inc. under one or more contributor license agreements.
  ~ See the AUTHORS.txt file in the distribution for a full listing of 
  ~ individual contributors.
  ~
  ~ ModeShape is free software. Unless otherwise indicated, all code in ModeShape
  ~ is licensed to you under the terms of the GNU Lesser General Public License as
  ~ published by the Free Software Foundation; either version 2.1 of
  ~ the License, or (at your option) any later version.
  ~
  ~ ModeShape is distributed in the hope that it will be useful,
  ~ but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  ~ or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
  ~ for more details.
  ~
  ~ You should have received a copy of the GNU Lesser General Public License
  ~ along with this distribution; if not, write to:
  ~ Free Software Foundation, Inc.
  ~ 51 Franklin Street, Fifth Floor
  ~ Boston, MA  02110-1301  USA
  -->
<!DOCTYPE preface PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN" "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd"	[
<!ENTITY % CustomDTD SYSTEM "../../custom.dtd">
%CustomDTD;
]>
<chapter id="xsd-sequencer">
  <title>XML Schema Document (XSD) Sequencer</title>
    <para>
      The XSD sequencer included in ModeShape can parse XML Schema Documents that adhere to the W3C's XML Schema 
      <ulink url="http://www.w3.org/TR/xmlschema-1/">Part 1</ulink> and <ulink url="http://www.w3.org/TR/xmlschema-2/">Part 2</ulink> specifications, 
      and output a representation of the XSD's attribute declarations, element
      declarations, simple type definitions, complex type definitions, import statements, include statements, attribute group declarations,
      annotations, other components, and even attributes with a non-schema namespace. 
      This derived information is intended to accurately reflect the structure and semantics
      of the XSD files while also making it possible for ModeShape users to easily navigate, query and search over this derived information.
      This sequencer captures the namespace and names of all referenced components, and will resolve references to components appearing within 
      the same files.
    </para>
    <para>
      The design of this sequencer and it's output structure have been influenced by the SOA Repository Artifact Model and Protocol (S-RAMP)
      draft specification, which is currently under development as an OASIS Technology Committee. S-RAMP defines a model for a variety
      of file types, including WSDL and XSD. This sequencer's output was designed to mirror that model, and thus some of the properties
      and node types used are defined within the "sramp" namespace.
    </para>
    <para>
      The XML Schema specification is powerful, flexible, rich, and complicated. This means that many XML Schema Documents themselves are
      complicated. But it also means that there is a lot of variation in XSDs, and consequently there is a lot of variation in the
      output structure that this sequencer derives from XSD files.
    </para>
  <sect1 id="xsd-sequencer-example">
    <title>Example</title>
    <para>
      So before we get too far, let's look at an example XML Schema Document taken from the 
      <ulink url="http://www.w3.org/TR/xmlschema-0/">XML Schema Primer</ulink>:
	  </para>
	  <programlisting language="XML" role="XML"><![CDATA[
<?xml version="1.0" encoding="ISO-8859-1" ?>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">

  <xsd:annotation>
    <xsd:documentation xml:lang="en">
     Purchase order schema for Example.com.
     Copyright 2000 Example.com. All rights reserved.
    </xsd:documentation>
  </xsd:annotation>

  <xsd:element name="purchaseOrder" type="PurchaseOrderType"/>

  <xsd:element name="comment" type="xsd:string"/>

  <xsd:complexType name="PurchaseOrderType">
    <xsd:sequence>
      <xsd:element name="shipTo" type="USAddress"/>
      <xsd:element name="billTo" type="USAddress"/>
      <xsd:element ref="comment" minOccurs="0"/>
      <xsd:element name="items"  type="Items"/>
    </xsd:sequence>
    <xsd:attribute name="orderDate" type="xsd:date"/>
  </xsd:complexType>

  <xsd:complexType name="USAddress">
    <xsd:sequence>
      <xsd:element name="name"   type="xsd:string"/>
      <xsd:element name="street" type="xsd:string"/>
      <xsd:element name="city"   type="xsd:string"/>
      <xsd:element name="state"  type="xsd:string"/>
      <xsd:element name="zip"    type="xsd:decimal"/>
    </xsd:sequence>
    <xsd:attribute name="country" type="xsd:NMTOKEN"
                   fixed="US"/>
  </xsd:complexType>

  <xsd:complexType name="Items">
    <xsd:sequence>
      <xsd:element name="item" minOccurs="0" maxOccurs="unbounded">
        <xsd:complexType>
          <xsd:sequence>
            <xsd:element name="productName" type="xsd:string"/>
            <xsd:element name="quantity">
              <xsd:simpleType>
                <xsd:restriction base="xsd:positiveInteger">
                  <xsd:maxExclusive value="100"/>
                </xsd:restriction>
              </xsd:simpleType>
            </xsd:element>
            <xsd:element name="USPrice"  type="xsd:decimal"/>
            <xsd:element ref="comment"   minOccurs="0"/>
            <xsd:element name="shipDate" type="xsd:date" minOccurs="0"/>
          </xsd:sequence>
          <xsd:attribute name="partNum" type="SKU" use="required"/>
        </xsd:complexType>
      </xsd:element>
    </xsd:sequence>
  </xsd:complexType>

  <!-- Stock Keeping Unit, a code for identifying products -->
  <xsd:simpleType name="SKU">
    <xsd:restriction base="xsd:string">
      <xsd:pattern value="\d{3}-[A-Z]{2}"/>
    </xsd:restriction>
  </xsd:simpleType>

</xsd:schema>]]></programlisting>
    <para>
      This schema defines the structure of several XML elements used to represent purchase orders, and describes an XML document such as 
      the following:
    </para>
	  <programlisting language="XML" role="XML"><![CDATA[
<?xml version="1.0"?>
<purchaseOrder orderDate="1999-10-20">
   <shipTo country="US">
      <name>Alice Smith</name>
      <street>123 Maple Street</street>
      <city>Mill Valley</city>
      <state>CA</state>
      <zip>90952</zip>
   </shipTo>
   <billTo country="US">
      <name>Robert Smith</name>
      <street>8 Oak Avenue</street>
      <city>Old Town</city>
      <state>PA</state>
      <zip>95819</zip>
   </billTo>
   <comment>Hurry, my lawn is going wild<!/comment>
   <items>
      <item partNum="872-AA">
         <productName>Lawnmower</productName>
         <quantity>1</quantity>
         <USPrice>148.95</USPrice>
         <comment>Confirm this is electric</comment>
      </item>
      <item partNum="926-AA">
         <productName>Baby Monitor</productName>
         <quantity>1</quantity>
         <USPrice>39.98</USPrice>
         <shipDate>1999-05-21</shipDate>
      </item>
   </items>
</purchaseOrder>]]></programlisting>
    <para>
       The XSD sequencer will derive the following content from the above XSD:
    </para>
	    <programlisting language="XML" role="XML"><![CDATA[
 po.xsd jcr:primaryType=xs:schemaDocument jcr:mixinTypes=[mode:derived] 
   - jcr:uuid=ca46f972-6875-481d-b9e1-cfb64ae76f74
   - mode:derivedAt=2011-05-18T18:34:08.922Z
   - mode:derivedFrom=/files/po.xsd
   - sramp:contentEncoding="UTF-8"
   - sramp:contentSize=2353
   - sramp:contentType="application/xsd"
   - sramp:description="Purchase order schema for Example.com.
   Copyright 2000 Example.com. All rights reserved."
   purchaseOrder jcr:primaryType=xs:elementDeclaration 
     - jcr:uuid=eff3bcfb-42d1-4d55-805b-5133279e15eb
     - xs:abstract=false
     - xs:form="qualified"
     - xs:ncName="purchaseOrder"
     - xs:nillable=false
     - xs:type=5088dc05-ad30-4d7d-8d24-3edc548a777f
     - xs:typeName="PurchaseOrderType"
   comment jcr:primaryType=xs:elementDeclaration 
     - jcr:uuid=2daaa747-01f1-41f3-b5c2-ec218d8a7290
     - xs:abstract=false
     - xs:form="qualified"
     - xs:ncName="comment"
     - xs:nillable=false
     - xs:typeName="string"
     - xs:typeNamespace=http://www.w3.org/2001/XMLSchema
   PurchaseOrderType jcr:primaryType=xs:complexTypeDefinition 
     - jcr:uuid=5088dc05-ad30-4d7d-8d24-3edc548a777f
     - xs:abstract=false
     - xs:baseTypeName="anyType"
     - xs:baseTypeNamespace="http://www.w3.org/2001/XMLSchema"
     - xs:method="restriction"
     - xs:mixed=false
     - xs:ncName="PurchaseOrderType"
     xs:sequence jcr:primaryType=xs:sequence 
       - jcr:uuid=1b87d92d-4d59-44ac-859f-2a51c3a48eb2
       - xs:maxOccurs=1
       - xs:minOccurs=1
       shipTo jcr:primaryType=xs:elementDeclaration 
         - jcr:uuid=994ba18b-c389-4635-8ce3-27d3a81cf97d
         - xs:abstract=false
         - xs:form="qualified"
         - xs:maxOccurs=1
         - xs:minOccurs=1
         - xs:ncName="shipTo"
         - xs:nillable=false
         - xs:type=dd683707-83bb-4893-aa6e-f3ce81237e76
         - xs:typeName="USAddress"
       billTo jcr:primaryType=xs:elementDeclaration 
         - jcr:uuid=e260c1aa-5a5a-4db5-a962-b02576359ee7
         - xs:abstract=false
         - xs:form="qualified"
         - xs:maxOccurs=1
         - xs:minOccurs=1
         - xs:ncName="billTo"
         - xs:nillable=false
         - xs:type=dd683707-83bb-4893-aa6e-f3ce81237e76
         - xs:typeName="USAddress"
       comment jcr:primaryType=xs:elementDeclaration 
         - jcr:uuid=a7796d20-0e7b-4833-96b6-16e0ac6676ca
         - xs:abstract=false
         - xs:form="qualified"
         - xs:maxOccurs=1
         - xs:minOccurs=0
         - xs:nillable=false
         - xs:ref=2daaa747-01f1-41f3-b5c2-ec218d8a7290
         - xs:refName="comment"
       items jcr:primaryType=xs:elementDeclaration 
         - jcr:uuid=02ab83d1-ea1a-4a7b-b66d-a1974f13ca63
         - xs:abstract=false
         - xs:form="qualified"
         - xs:maxOccurs=1
         - xs:minOccurs=1
         - xs:ncName="items"
         - xs:nillable=false
         - xs:type=7543bf0f-1753-4813-9a31-f2bbed34fd11
         - xs:typeName="Items"
     orderDate jcr:primaryType=xs:attributeDeclaration 
       - jcr:uuid=8b23e048-c683-4d6d-8835-faf81df6912d
       - xs:ncName="orderDate"
       - xs:typeName="date"
       - xs:typeNamespace=http://www.w3.org/2001/XMLSchema
       - xs:use="optional"
   USAddress jcr:primaryType=xs:complexTypeDefinition 
     - jcr:uuid=dd683707-83bb-4893-aa6e-f3ce81237e76
     - xs:abstract=false
     - xs:baseTypeName="anyType"
     - xs:baseTypeNamespace="http://www.w3.org/2001/XMLSchema"
     - xs:method="restriction"
     - xs:mixed=false
     - xs:ncName="USAddress"
     xs:sequence jcr:primaryType=xs:sequence 
       - jcr:uuid=82411c47-7f1a-4b11-9778-acc310c9e51c
       - xs:maxOccurs=1
       - xs:minOccurs=1
       name jcr:primaryType=xs:elementDeclaration 
         - jcr:uuid=40dcb6fc-386c-4d3a-841b-dab478348d74
         - xs:abstract=false
         - xs:form="qualified"
         - xs:maxOccurs=1
         - xs:minOccurs=1
         - xs:ncName="name"
         - xs:nillable=false
         - xs:typeName="string"
         - xs:typeNamespace=http://www.w3.org/2001/XMLSchema
       street jcr:primaryType=xs:elementDeclaration 
         - jcr:uuid=a3ff1a2d-38e7-442a-a46b-141fa1ac4442
         - xs:abstract=false
         - xs:form="qualified"
         - xs:maxOccurs=1
         - xs:minOccurs=1
         - xs:ncName="street"
         - xs:nillable=false
         - xs:typeName="string"
         - xs:typeNamespace=http://www.w3.org/2001/XMLSchema
       city jcr:primaryType=xs:elementDeclaration 
         - jcr:uuid=30d4215f-cd44-4857-9589-3df127e42cf3
         - xs:abstract=false
         - xs:form="qualified"
         - xs:maxOccurs=1
         - xs:minOccurs=1
         - xs:ncName="city"
         - xs:nillable=false
         - xs:typeName="string"
         - xs:typeNamespace=http://www.w3.org/2001/XMLSchema
       state jcr:primaryType=xs:elementDeclaration 
         - jcr:uuid=061a58d9-94fd-4dca-84e2-6ced7fe523fe
         - xs:abstract=false
         - xs:form="qualified"
         - xs:maxOccurs=1
         - xs:minOccurs=1
         - xs:ncName="state"
         - xs:nillable=false
         - xs:typeName="string"
         - xs:typeNamespace=http://www.w3.org/2001/XMLSchema
       zip jcr:primaryType=xs:elementDeclaration 
         - jcr:uuid=100dc3cc-b59f-4835-b14e-243b9e7a2ecf
         - xs:abstract=false
         - xs:form="qualified"
         - xs:maxOccurs=1
         - xs:minOccurs=1
         - xs:ncName="zip"
         - xs:nillable=false
         - xs:typeName="decimal"
         - xs:typeNamespace=http://www.w3.org/2001/XMLSchema
     country jcr:primaryType=xs:attributeDeclaration 
       - jcr:uuid=f323219f-bea0-4d6f-9ad5-f51cf8409f13
       - xs:ncName="country"
       - xs:typeName="NMTOKEN"
       - xs:typeNamespace=http://www.w3.org/2001/XMLSchema
       - xs:use="optional"
   Items jcr:primaryType=xs:complexTypeDefinition 
     - jcr:uuid=7543bf0f-1753-4813-9a31-f2bbed34fd11
     - xs:abstract=false
     - xs:baseTypeName="anyType"
     - xs:baseTypeNamespace="http://www.w3.org/2001/XMLSchema"
     - xs:method="restriction"
     - xs:mixed=false
     - xs:ncName="Items"
     xs:sequence jcr:primaryType=xs:sequence 
       - jcr:uuid=d907da56-f370-40e3-b06e-e3a5ae957f4d
       - xs:maxOccurs=1
       - xs:minOccurs=1
       item jcr:primaryType=xs:elementDeclaration 
         - jcr:uuid=87cc1352-2f90-49f4-9f36-3db7b9ffcf26
         - xs:abstract=false
         - xs:form="qualified"
         - xs:minOccurs=0
         - xs:ncName="item"
         - xs:nillable=false
   SKU jcr:primaryType=xs:simpleTypeDefinition 
     - jcr:uuid=4127108d-a699-461e-8210-3bb40c923318
     - xs:baseTypeName="string"
     - xs:baseTypeNamespace=http://www.w3.org/2001/XMLSchema
     - xs:ncName="SKU"
     - xs:pattern="\d{3}-[A-Z]{2}"
]]></programlisting>
    
    <para>
      The first thing to note is that the sequencer produces a node of type <code>xs:schemaDocument</code> that includes
      the <code>mode:derived</code> information (e.g., the time of sequencing and the path to the file from which this information
      was derived), information about the XSD itself, plus an <code>sramp:description</code> property containing the documentation
      content from any annotations directly under the <code>schema</code> element in the XSD.
    </para>
    <para>
      Secondly, there is a node for each top-level element declaration, namely "<code>purchaseOrder</code>" and "<code>comment</code>",
      with properties capturing the element's name, namespace (not shown since there is no target namespace for the schema),
      and XSD type name, namespace and reference. The "<code>comment</code>" element declaration has a base type of "<code>xs:string</code>",
      whereas the "<code>purchaseOrder</code>" element declaration has a type of "<code>PurchaseOrderType</code>" (defined later
      in the XSD and in the derived content). Each node is "<code>mix:referenceable</code>" and has a <code>jcr:uuid</code> property,
      allowing the "<code>purchaseOrder</code>" element declaration to have a "<code>xs:type</code>" REFERENCE property pointing
      to the "<code>PurchaseOrderType</code>" complex type definition node.
    </para>
    <para>
      There are also nodes representing each of the global complex type definitions, including "<code>PurchaseOrderType</code>",
      "<code>USAddress</code>", "<code>Items</code>", and "<code>SKU</code>". Each of these nodes has properties 
      representing the complex type's features (such as <code>abstract</code>, <code>mixed</code>, <code>name</code>, etc.),
      as well as child nodes that represent the definition of the complex type's content (e.g., sequence, choice, all, simple content,
      complex content, etc.).
    </para>
    <para>
      This example shows some of the structure that this sequencer derives from the XML Schema Documents. Our goal for this
      sequencer was to output content that reflected as accurately as possible the structure of the XML Schema Documents while
      also making the content easy to navigate, search and query.
    </para>
  </sect1>
  <sect1 id="xsd-sequencer-nodetypes">
    <title>Node Types</title>
		<para>
			The XSD sequencer follows JCR best-practices by defining all nodes to have a primary type that allows any single or multi-valued
			property, meaning it's possible and valid for any node to have any property (with single or multiple values). In fact, this
			feature is used when XSD files contain attributes with non-schema namespaces, which are then mapped onto properties with the
			attributes name and possibly-empty namespace.
			However, it is still useful to capture the metadata about what that node represents, and so the sequencer use explicit node
			type definitions and mixins for this.
		</para>
			<para>
				The compact node definitions for the "xs" namespace are as follows:
			</para>
<programlisting><![CDATA[
<jcr='http://www.jcp.org/jcr/1.0'>
<nt='http://www.jcp.org/jcr/nt/1.0'>
<mix='http://www.jcp.org/jcr/mix/1.0'>
<sramp = "http://s-ramp.org/xmlns/2010/s-ramp">
<xs = "http://www.w3.org/2001/XMLSchema">

//------------------------------------------------------------------------------
// N O D E T Y P E S
//------------------------------------------------------------------------------

[xs:component] > sramp:derivedArtifactType abstract
- xs:id (string)
- * (undefined) multiple 
- * (undefined) 

[xs:namespaced] mixin
- xs:namespace (uri) mandatory

[xs:located] mixin
- xs:schemaLocation (string)

[xs:import] > xs:component, xs:located, xs:namespaced

[xs:include] > xs:component, xs:located

[xs:redefine] > xs:component, xs:located

[xs:named] > xs:namespaced mixin
- xs:ncName (string) mandatory

[xs:typeDefinition] > xs:component

// A mixin representing a reference to an 'xs:typeDefinition'
[xs:typed] mixin
- xs:typeName (string)
- xs:typeNamespace (uri)
- xs:type (weakreference) < 'xs:typeDefinition'

// Attribute wildcard
[xs:anyAttribute] > xs:component
- xs:minOccurs (long) < '[0,)'
- xs:maxOccurs (long) < '[0,)'
- xs:namespace (uri) multiple
- xs:processContents (string) = 'strict' < 'lax', 'strict', 'skip'

//
// The 'group', 'all', 'sequence' and 'choice' components
//
[xs:modelGroup] > xs:component abstract
- xs:minOccurs (long) < '[0,)'
- xs:maxOccurs (long) < '[0,)'
- xs:refName (string)
- xs:refNamespace (uri)
- xs:ref (weakReference) < 'xs:modelGroup'
+ * (xs:elementDeclaration)

[xs:group] > xs:modelGroup
+ 'xs:anyAttribute' (xs:anyAttribute)

[xs:all] > xs:modelGroup

[xs:sequence] > xs:modelGroup
+ 'xs:sequence' (xs:sequence)
+ 'xs:choice' (xs:choice)
+ 'xs:all' (xs:all)
+ 'xs:anyAttribute' (xs:anyAttribute)

[xs:choice] > xs:modelGroup
+ 'xs:sequence' (xs:sequence)
+ 'xs:choice' (xs:choice)
+ 'xs:all' (xs:all)
+ 'xs:anyAttribute' (xs:anyAttribute)

//
// The 'simpleContent' and 'complexContent' components
//
[xs:complexContent]  > xs:component
- xs:method (string) < 'restriction', 'extension'
+ * (xs:attributeDeclaration)
+ * (xs:attributeGroup)
+ * (xs:group)
+ 'xs:anyAttribute' (xs:anyAttribute)
+ 'xs:sequence' (xs:sequence)
+ 'xs:choice' (xs:choice)
+ 'xs:all' (xs:all)

[xs:simpleContent]  > xs:component
- xs:method (string) < 'restriction', 'extension'
- xs:minValueExclusive (*)
- xs:minValueInclusive (*)
- xs:maxValueExclusive (*)
- xs:maxValueInclusive (*)
- xs:totalDigits (long) < '[0,]'
- xs:fractionDigits (long) < '[0,]'
- xs:length (long)
- xs:maxLength (long) < '[0,]'
- xs:minLength (long) < '[0,]'
- xs:enumeratedValues (string) multiple
- xs:whitespace (string) < 'preserve','collapse','replace'
- xs:pattern (string)
+ * (xs:attributeDeclaration) sns
+ * (xs:attributeGroup) sns
+ * (xs:simpleTypeDefinition) sns
+ 'xs:anyAttribute' (xs:anyAttribute)

//
// Attribute Groups
//
[xs:attributeGroup] > xs:component
- xs:ncName (string)
- xs:namespace (uri)
- xs:refName (string)
- xs:refNamespace (uri)
- xs:ref (weakReference) < 'xs:attributeGroup'
+ * (xs:attributeDeclaration) sns
+ * (xs:attributeGroup) sns
+ 'xs:anyAttribute' (xs:anyAttribute)

//
// Complex and simple type definitions
//
[xs:complexTypeDefinition] > xs:typeDefinition, xs:named
- xs:abstract (boolean) = 'false'
- xs:mixed (boolean) = 'false'
- xs:block (string) multiple < 'restriction', 'extension', 'all'
- xs:final (string) multiple < 'restriction', 'extension', 'all'
+ * (xs:attributeDeclaration) sns
+ * (xs:attributeGroup) sns
+ * (xs:complexContent) sns
+ * (xs:simpleContent) sns
+ * (xs:group) sns
+ 'xs:anyAttribute' (xs:anyAttribute)
+ 'xs:sequence' (xs:sequence)
+ 'xs:choice' (xs:choice)
+ 'xs:all' (xs:all)

[xs:simpleTypeDefinition] > xs:typeDefinition, xs:named
- xs:baseTypeName (string)
- xs:baseTypeNamespace (uri)
- xs:baseType (weakreference) < 'xs:typeDefinition'
- xs:final (string) multiple < 'restriction', 'list', 'union', 'all'

//
// Attribute declaration
//
[xs:attributeDeclaration] > xs:component, xs:named, xs:typed
- xs:length (long)
- xs:maxLength (long)
- xs:minLength (long)
- xs:enumeratedValues (string) multiple
- xs:whitespace (string) < 'preserve','collapse','replace'
- xs:maxValueExclusive (*)
- xs:minValueExclusive (*)
- xs:maxValueInclusive (*)
- xs:minValueInclusive (*)
- xs:totalDigits (long)
- xs:fractionDigits (long)
- xs:pattern (string)
- xs:use (string)

//
// Identity constraint definition 
//
[xs:selector] > xs:component
- xs:xpath (string) mandatory

[xs:field] > xs:component
- xs:xpath (string) mandatory

[xs:identityConstraintDefinition] > xs:component abstract
- xs:ncName (string) mandatory
+ 'selector' (xs:selector)
+ 'field' (xs:field) sns

[xs:unique] > xs:identityConstraintDefinition

[xs:key] > xs:identityConstraintDefinition

[xs:keyref] > xs:identityConstraintDefinition
- xs:refer (string) mandatory

//
// Element declaration
//
[xs:elementDeclaration] > xs:component, xs:named, xs:typed
- xs:abstract (boolean) = 'false'
- xs:nillable (boolean) = 'false'
- xs:final (string) multiple < 'all', 'extension', 'restriction'
- xs:block (string) multiple < 'all', 'extension', 'restriction', 'substitution'
- xs:default (string)
- xs:fixed (string)
- xs:form (string) < 'qualified', 'unqualified'
- xs:minOccurs (long) < '[0,)'
- xs:maxOccurs (long) < '[0,)'
- xs:refName (string)
- xs:refNamespace (uri)
- xs:ref (weakReference) < 'xs:elementDeclaration'
- xs:substitutionGroupName (string)
- xs:substitutionGroup (weakReference) < 'xs:elementDeclaration'
+ * (xs:typeDefinition)
+ * (xs:identityConstraintDefinition)

//
// XML Schema Document
//
[xs:schemaDocument] > sramp:xmlDocument
- xs:id (string)
- xs:targetNamespace (uri)
- xs:version (string)
- xs:attributeFormDefault (string) = 'unqualified' < 'qualified', 'unqualified'
- xs:elementFormDefault (string) = 'unqualified' < 'qualified', 'unqualified'
- xs:finalDefault (string) multiple < 'all', 'extension', 'restriction', 'list', 'union'
- xs:blockDefault (string) multiple < 'all', 'extension', 'restriction', 'substitution'
- xs:importedXsds (weakreference) multiple < 'xs:xsdDocument'
- xs:includedXsds (weakreference) multiple < 'xs:xsdDocument'
- xs:redefinedXsds (weakreference) multiple < 'xs:xsdDocument'
- * (undefined) multiple 
- * (undefined) 
+ * (xs:import) sns
+ * (xs:include) sns
+ * (xs:redefine) sns
// Technically need 'sns' because the attributes, elements, simple types, complex types, attribute groups, 
// and groups don't share same name scopes
+ * (xs:attributeDeclaration) sns
+ * (xs:elementDeclaration) sns
+ * (xs:attributeGroup) sns
+ * (xs:group) sns
+ * (xs:simpleTypeDefinition) sns
+ * (xs:complexTypeDefinition) sns
]]></programlisting>
      <para>
        These types use some of the node types and mixins defined in the "sramp" namespace:
      </para>
<programlisting><![CDATA[
<jcr='http://www.jcp.org/jcr/1.0'>
<nt='http://www.jcp.org/jcr/nt/1.0'>
<mix='http://www.jcp.org/jcr/mix/1.0'>
<sramp = "http://s-ramp.org/xmlns/2010/s-ramp">

//------------------------------------------------------------------------------
// N O D E T Y P E S
//------------------------------------------------------------------------------

// -------------------------------------------------------
// S-RAMP Core Model Artifacts
// -------------------------------------------------------

[sramp:baseArtifactType] > mix:created, mix:lastModified, mix:referenceable, mix:versionable abstract mixin
- sramp:classifiedBy (reference) multiple < 'owl:class'
- sramp:description (string)
- * (string)
- * (string) multiple

[sramp:documentArtifactType] > sramp:baseArtifactType abstract mixin
- sramp:contentType (string)
- sramp:contentSize (long)

[sramp:xmlDocument] > sramp:documentArtifactType mixin
- sramp:contentEncoding (string) mandatory

[sramp:document] > sramp:documentArtifactType mixin

[sramp:derivedArtifactType] > sramp:baseArtifactType abstract mixin
- sramp:relatedDocuments (reference) < 'sramp:documentArtifactType'

[sramp:userDefinedArtifactType] > sramp:baseArtifactType mixin
- sramp:userType (string) mandatory

[sramp:storedQuery] > nt:query
- sramp:propertyList (string) multiple

[sramp:relatedTo] mixin
- * (weakreference) multiple
]]></programlisting>
	</sect1>
  <sect1 id="xsd-sequencer-using">
    <title>Configuration</title>
    <para>
        To use this sequencer, simply include the appropriate version of the Maven artifact with a "<code>org.modeshape</code>" group ID and
        "<code>modeshape-sequencer-xsd</code>" artifact ID. Or, if you're using JAR files and manually setting up the classpath for your
        application, use the "<code>modeshape-sequencer-xsd-&versionNumber;-jar-with-dependencies.jar</code>" file.
        Then, define a sequencing configuration in the ModeShape configuration, using something similar to:
    </para>
   	<programlisting language="XML" role="XML"><![CDATA[
<configuration xmlns:mode="http://www.modeshape.org/1.0" 
               xmlns:jcr="http://www.jcp.org/jcr/1.0">
    <mode:sequencers>
	      ...
        <mode:sequencer jcr:name="XSD Sequencer" 
                        mode:classname="org.modeshape.sequencer.xsd.XsdSequencer">
            <mode:description>Sequences XML Schema Documents (e.g., *.xsd) loaded 
                 into the repository under '/files', extracting the XSD attribute
                 and element declarations, simple and complex type definitions, 
                 attribute and element groups, annotations, imports, includes and 
                 any other component of XSDs.</mode:description>        
            <!-- Note this path expression captures the path below '/files' but 
                 excludes the filename, and places the sequenced content under the
                 same relative path below '/sequenced/xsd'. For example, if an XSD
                 file is uploaded to '/files/my/favorites/Customers.xsd', then the
                 sequenced output will be placed at the 
                 '/sequenced/xsd/my/favorites/Customer.xsd' node, which will have
                 a primary type of 'xs:schemaDocument' and will contain under it
                 the components within the schema document.  Of course, the path
                 expression can be modified as needed. -->
            <mode:pathExpression>/files(//)(*.xsd[*])/jcr:content[@jcr:data] 
                              => /sequenced/xsd/$1 </mode:pathExpression>
        </mode:sequencer>
        ...
    </mode:sequencers>
    ...
</configuration>
]]></programlisting>
		<para>or using the &JcrConfiguration;:</para>
   	<programlisting language="JAVA" role="JAVA"><![CDATA[
JcrConfiguration config = ...

config.sequencer("XSD Sequencer")
      .usingClass(XsdSequencer.class)
      .setDescription("Sequences XML Schema documents")
      .sequencingFrom("/files(//)(*.xsd[*])/jcr:content[@jcr:data]")
      .andOutputtingTo("/sequenced/xsd/$1");
]]></programlisting>
	</sect1>
</chapter>
