W3C home > Mailing lists > Public > public-ws-desc-eds@w3.org > July 2005

2002/ws/desc/schema-patterns xml-schema-patterns.html,1.2,1.3 xml-schema-patterns.xml,1.2,1.3

From: Paul Downey via cvs-syncmail <cvsmail@w3.org>
Date: Thu, 14 Jul 2005 14:32:33 +0000
To: public-ws-desc-eds@w3.org
Message-Id: <E1Dt4lN-0006fe-88@lionel-hutz.w3.org>

Update of /sources/public/2002/ws/desc/schema-patterns
In directory hutz:/tmp/cvs-serv25621

Modified Files:
	xml-schema-patterns.html xml-schema-patterns.xml 
Log Message:
first real draft, maps missing

Index: xml-schema-patterns.xml
===================================================================
RCS file: /sources/public/2002/ws/desc/schema-patterns/xml-schema-patterns.xml,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** xml-schema-patterns.xml	1 Jul 2005 15:32:17 -0000	1.2
--- xml-schema-patterns.xml	14 Jul 2005 14:32:30 -0000	1.3
***************
*** 43,50 ****
      </authlist>
      <status id="Status">
        <p>
!         <emph>The intention is that this document will be published as a Web Services Description
!           Working Group Note, although the Working Group has show interest in this work taking
!           place, the Working Group has yet to review or approve this document.</emph>
        </p>
      </status>
--- 43,61 ----
      </authlist>
      <status id="Status">
+       <p> This origin if this document stems from discussions surrounding a set of example XML
+         Schema patterns submitted as examples for the <loc
+           href="http://www.w3.org/TR/wsdl20-primer/">WSDL 2.0 Primer</loc> [<loc
+           href="http://lists.w3.org/Archives/Public/www-ws-desc/2004May/0007.html"
+           >http://lists.w3.org/Archives/Public/www-ws-desc/2004May/0007.html</loc>]. </p>
+       <p> However, as a result of discussions during the <loc
+           href="http://www.w3.org/2005/03/xml-schema-user-program.html">W3C Workshop on XML Schema
+           1.0 User Experiences</loc>, the W3C may form a dedicated Working Group to <emph>develop a
+           set of patterns for common data structures of XML Schema for the purpose of simplifying
+           the mapping of XML Schemas into programming language structures</emph> [<loc
+           href="http://lists.w3.org/Archives/Public/www-ws/2005Jul/0000.html"
+           >http://lists.w3.org/Archives/Public/www-ws/2005Jul/0000.html</loc>]. This note may
+         provide useful input to such a Working Group. </p>
        <p>
!         <emph>The WSD Working Group has yet to review or approve this document.</emph>
        </p>
      </status>
***************
*** 53,60 ****
          data structures. The data structures described are intended to be independent of any
          particular programming language or database or modelling environment.</p>
-       <p> Authors of tools which map or bind data structures to XML may find these simple patterns
-         useful in facilitating the mapping of commonplace constructs to and from XML. </p>
-       <p> Authors of XML Schema 1.0 documents may also find these patterns useful in providing a
-         good user experience for consumers using data mapping and binding tools. </p>
      </abstract>
      <langusage>
--- 64,67 ----
***************
*** 68,76 ****
      <div1 id="introduction">
        <head>Introduction</head>
!       <p>
! 
!         <ednote><edtext>Explanation of how schema may be used as a description language, as well as for
!           validation. Reference to WSDL which uses XML Schema for such a purpose</edtext></ednote>
!       </p>
        <div2 id="notational">
          <head>Notational Conventions</head>
--- 75,92 ----
      <div1 id="introduction">
        <head>Introduction</head>
!       <p> This note provides a set of example XML Schema structures <bibref ref="XMLSchemaP1"/> and
!         types <bibref ref="XMLSchemaP2"/> which may be used to exchange commonly used data
!         structures in the form of an XML document.</p>
!       <p>Authors of tools which map or bind data structures to XML may find these patterns useful to
!         represent simple and common place constructs. Recognising these patterns and presenting them
!         in terms most appropriate to the specific language, database or environment may preserve
!         such data structures across boundaries, as well as providing an improved <emph>user
!           experience</emph> when using data mapping and binding tools. </p>
!       <p> Authors of XML Schema 1.0 documents may find these patterns useful in providing a better
!           <emph>user experience</emph> for consumers of their schemas using data mapping and binding
!         tools. </p>
!       <p>It is not intended that these constructs should constrain the use of the XML Schema
!         Recommendation. A processor using these constructs to map data structures should continue to
!         support the whole of the XML Schema Recommendation.</p>
        <div2 id="notational">
          <head>Notational Conventions</head>
***************
*** 113,126 ****
      </div1>
      <div1 id="Data-Structures">
!       <head>Common Data Structures</head>
!       <p/>
! 
        <div2 id="Enumerated">
! 	<head>Enumerated Types</head>
! 	<p></p>
! 
! 	<example id="eg-closed-enum">
! 	  <head>Closed Enumerated Type</head>
! 	  <eg xml:space="preserve"><![CDATA[
  <xs:simpleType name='Beatle' >
    <xs:restriction base='xs:string' >
--- 129,148 ----
      </div1>
      <div1 id="Data-Structures">
!       <head>Patterns for Common Data Structures</head>
!       <div2 id="Naming">
!         <head>Naming Types</head>
!         <p>Giving each data structure an individual type, following the so-called "venetian blind"
!           schema authoring style, simplifies mapping to and from a data model.</p>
!         <p>The name of a schema type, attribute or element may be any valid XML non-colonized name
!           including names which may be reserved or not directly representable in some programming
!           languages, such as "object", "static", "final", "class", "Customer-Profile", etc.</p>
!       </div2>
        <div2 id="Enumerated">
!         <head>Enumerated Type</head>
!         <p>The XML Schema enumerated type provides a useful mechanism for expressing a controlled
!           vocabulary for an element or attribute value. </p>
!         <example id="eg-enum">
!           <head>Enumerated Type</head>
!           <eg xml:space="preserve"><![CDATA[
  <xs:simpleType name='Beatle' >
    <xs:restriction base='xs:string' >
***************
*** 133,288 ****
    </xs:restriction>
  </xs:simpleType>
! ]]></eg>
! 	</example>
! <p>
! </p>
! 
! 	<example id="eg-open-enum">
! 	  <head>Open Enumerated Type</head>
! 	  <eg xml:space="preserve"><![CDATA[
! <xs:simpleType name='Fruit' >
    <xs:restriction base='xs:string' >
!    <xs:enumeration value='Apple' />
!    <xs:enumeration value='Pear' />
!    <xs:enumeration value='Banana' />
    </xs:restriction>
  </xs:simpleType>
  
! <xs:simpleType name='Pudding' >
!   <xs:union memberTypes='tns:Fruit  xs:string' />
  </xs:simpleType>
- ]]></eg>
- 	</example>
  
        </div2>
- 
        <div2 id="Collection">
! 	<head>Collections</head>
! 	<p></p>
! 
! <ednote><edtext>
! A collection of data items (an object, class, structure, record etc)
! is best represented as a complexType with the individual items as
! elements and/or attributes. Sadly it needs saying that the compositors
! "sequence", "all" *and* "choice" should be supported.
! </edtext></ednote>
! 
! 
! 	<example id="eg-simple-collection">
! 	  <head>Simple Collection</head>
! 	  <eg xml:space="preserve"><![CDATA[
  <xs:complexType name="ProductType">
    <xs:sequence>
      <xs:element name="name" type="xs:string"/>
!     <xs:element name="colour" type="xs:string"/>
    </xs:sequence>
    <xs:attribute name="id" type="xs:string" />
  </xs:complexType>
! ]]></eg>
! 	</example>
! 	<p></p>
! 
! 
! <ednote><edtext>
! Explicit (active) extensibility of a collection may be expressed
! using 'any' and 'anyAttribute' as in the following example adapted 
! from the draft TAG finding on extensibility and versioning[2]:
! </edtext></ednote>
! 
! 
! 	<example id="eg-extended-collection">
! 	  <head>Extending a Collection</head>
! 	  <eg xml:space="preserve"><![CDATA[
   <xs:complexType name="ProductType">
      <xs:sequence>
!       <xs:element name="name" type="xs:string"
! 	  minOccurs="1" maxOccurs="1"/>
!       <xs:element name="colour" type="xs:string"/>
!       <xs:any processContents="lax"
! 	    minOccurs="0" maxOccurs="unbounded"/>
     </xs:sequence>
     <xs:attribute name="id" type="xs:string" />
!    <xs:anyAttribute/>
   </xs:complexType>
! ]]></eg>
! 	</example>
! 
! <ednote><edtext>
! The 'any' wildcard is only deterministic when applied to the end of
! a 'sequence' - determinism being particularly important when generating
! messages from a schema definition. Again it needs saying that tools 
! should support the 'namespace' attribute including the '##any', 
! '##other' and '#
! </edtext></ednote>
! 
! 	<ednote>
! 	  <edtext>Add Dare Obasanjo's pattern for subverting greedy 'any'.</edtext>
! 	</ednote>
        </div2>
  
        <div2 id="Vector">
! 	<head>Vectors</head>
! 	<p>
! 
! A vector is an ordered sequence of items of the same data type. This is
! a very common construct in programming languages appearing as an array or
! list. Multi-dimensional arrays may be built by composing vectors within
! vectors.  Formalising more complex constructs such as sparse or jagged
! matrices are beyond the scope of these examples.
! </p>
! 
! 	<example id="eg-wrapped-vector">
! 	  <head>Wrapped Vector</head>
! 	  <eg xml:space="preserve"><![CDATA[
! <xsd:complexType name="ItemList">
    <xsd:sequence>
      <xsd:element name="item" type="xsd:string" minOccurs=0 maxOccurs="unbounded"/>
!     </xsd:sequence>
  </xsd:complexType>
! ]]></eg>
! 	</example>
! 
! 	<example id="eg-bare-vectors">
! 	  <head>Bare Vector</head>
! 	  <eg xml:space="preserve"><![CDATA[
!  <xs:complexType name="Address">
!     <xs:sequence>
!       <xs:element name="lines" type="xs:string" maxOccurs="unbounded"/>
!       <xs:element name="telnos" type="xs:string" maxOccurs="unbounded"/>
!     <xs:sequence>
!   </xs:complexType>
! ]]></eg>
! 	</example>
! 
        </div2>
  
!       <div2 id="Maps">
! 	<head>Maps</head>
! 	<p></p>
! <ednote><edtext>
! xs:ID is similar to the DTD ID type with the following properties:
! 
!    - the type has the same lexical space as xs:NCName
!    - the ID may be an attribute or an element
!    - the ID value must be unique with the document
!    - there may be one or more ID's associated with an element
! 
! </edtext></ednote>
! <ednote><edtext>
! The PSVI set contains a ID/IDREF table[7] which is an index pointing
! to nodes with an included xs:ID element/attribute.
! </edtext></ednote>
! 
! <ednote><edtext>
! The new xml:id[8] attribute from the XML Base WG offers an neat way of
! expressing an ID value for an element targeted at recipients who may not
! have access to a schema. A so called 'disengaged' agent may easily more
! recognise a map from a document containing xml:id attributes and present 
! the repeated element as an associative array, e.g:
! </edtext></ednote>
! 
! 	<example id="eg-map-xml-id">
! 	  <head>Map Keyed Using xml:id</head>
! 	  <eg xml:space="preserve"><![CDATA[
  <xs:schema targetNamespace="http://www.w3.org/1998/XML/Namespace">
   <xs:attribute name="id" type="xs:ID"/>
--- 155,414 ----
    </xs:restriction>
  </xs:simpleType>
!           ]]></eg>
!         </example>
!       </div2>
!       <div2 id="Enumerated-Open">
!         <head>Open Enumerated Type</head>
!         <p>Reusing the enumeration in a union with the base type or in combination with other
!           enumerations may be used to express a vocabulary open to additional values. </p>
!         <example id="eg-open-enum">
!           <head>Open Enumerated Type</head>
!           <eg xml:space="preserve"><![CDATA[
! <xs:simpleType name='AppleVariety' >
    <xs:restriction base='xs:string' >
!    <xs:enumeration value='Braeburn' />
!    <xs:enumeration value='Cox' />
!    <xs:enumeration value='Egremont Russet' />
!    <xs:enumeration value='Granny Smith' />
    </xs:restriction>
  </xs:simpleType>
  
! <xs:simpleType name='PlumVariety' >
!   <xs:restriction base='xs:string' >
!    <xs:enumeration value='Damson' />
!    <xs:enumeration value='Greengage' />
!    <xs:enumeration value='Victoria' />
!   </xs:restriction>
  </xs:simpleType>
  
+ <xs:simpleType name='FruitVariety' >
+   <xs:union memberTypes='tns:AppleVariety tns:PlumVariety xs:string' />
+ </xs:simpleType>
+           ]]></eg>
+         </example>
        </div2>
        <div2 id="Collection">
!         <head>Collection</head>
!         <p> A collection of data items, typically contained by a programming language object, class,
!           structure, or a database record, may be represented in XML Schema using a single model
!           group. The individual items held in a collection may appear either as XML element or
!           attribute values.</p>
!         <example id="eg-simple-collection">
!           <head>Simple Collection</head>
!           <eg xml:space="preserve"><![CDATA[
  <xs:complexType name="ProductType">
    <xs:sequence>
      <xs:element name="name" type="xs:string"/>
!     <xs:element name="shade" type="xs:string"/>
    </xs:sequence>
    <xs:attribute name="id" type="xs:string" />
+   <xs:attribute name="inStock" type="xs:int" />
  </xs:complexType>
!           ]]></eg>
!         </example>
!         <p> The collection may be composed using a model group of either:</p>
!         <ulist>
!           <item>
!             <p>
!               <code>sequence</code> - the elements are ordered</p>
!           </item>
!           <item>
!             <p>
!               <code>all</code> - the elements are unordered</p>
!           </item>
!           <item>
!             <p>
!               <code>choice</code> - only one of the elements may be present</p>
!           </item>
!         </ulist>
!         <p>The <code>all</code> model group may appear attractive given programming language
!           techniques such as introspection or reflection often return items in a random order.
!           However, there are significant restrictions placed upon <code>all</code> types, not least
!           an element cannot have a <code>maxOccurs</code> value greater than <code>1</code>. The
!             <loc href="http://www.w3.org/TR/2004/REC-xmlschema-1-20041028/#cos-nonambig">Unique
!             Particle Attribution</loc> (UPA) constraint prevents a model group of <code>all</code>
!           from being extended, either by containing an <code>any</code> element wildcard, being
!           incorporated in a substitution group or derived using extension or restriction. </p>
!       </div2>
!       <div2 id="Collection-Extending-Attributes">
!         <head>Extending A Collection With Attributes</head>
!         <p>A collection may be made open to extension by the addition of attributes using the
!             <code>anyAttribute</code> construct.</p>
!         <example id="eg-extended-collection-attributes">
!           <head>Extending a Collection with Attributes</head>
!           <eg xml:space="preserve"><![CDATA[
   <xs:complexType name="ProductType">
      <xs:sequence>
!       <xs:element name="name" type="xs:string" />
!       <xs:element name="shade" type="xs:string"/>
     </xs:sequence>
     <xs:attribute name="id" type="xs:string" />
!    <xs:anyAttribute namespace="##any" processContents="lax"/>
   </xs:complexType>
!           ]]></eg>
!         </example>
!         <p>The <code>namespace</code> value will typically either be: <ulist>
!             <item>
!               <p>
!                 <code>##targetNamespace</code> - the additional items will appear in the same
!                 namespace </p>
!             </item>
!             <item>
!               <p>
!                 <code>##other</code> - the additional items may appear in a different namespace </p>
!             </item>
!             <item>
!               <p>
!                 <code>##any</code> - the additional items may appear in any namespace</p>
!             </item>
!           </ulist>
!         </p>
!         <p>The <code>processContents</code> value of <code>lax</code> is typically used to indicate
!           that additional items are unlikely to be known to the schema, this is a common case when
!           evolving a schema to another version.</p>
        </div2>
+       <div2 id="Collection-Extending-Elements">
+         <head>Extending A Collection With Elements</head>
+         <example id="eg-extended-collection-elements">
+           <head>Extending a Collection with Elements in Another Namespace</head>
+           <eg xml:space="preserve"><![CDATA[
+  <xs:complexType name="ProductType">
+     <xs:sequence>
+       <xs:element name="name" type="xs:string" />
+       <xs:element name="shade" type="xs:string" />
+       <xs:any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+    </xs:sequence>
+  </xs:complexType>
+           ]]></eg>
+         </example>
+         <p> An <code>any</code> construct with a namespace of <code>##other</code> may directly
+           follow an optional element. </p>
+         <example id="eg-extended-collection-other">
+           <head>Extending a Collection with Elements After an Optional Element</head>
+           <eg xml:space="preserve"><![CDATA[
+  <xs:complexType name="ProductType">
+     <xs:sequence>
+       <xs:element name="name" type="xs:string" />
+       <xs:element name="shade" type="xs:string" />
+       <xs:element name="nickName" type="xs:string" minOccurs="0"/>
+       <xs:any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+    </xs:sequence>
+  </xs:complexType>
+           ]]></eg>
+         </example>
+         <p>The UPA constraint prevents an <code>any</code> wildcard with a <code>namespace</code>
+           value of <code>any</code> or <code>targetNamespace</code> to follow an element with a
+             <code>minOccurs</code> value of <code>0</code>. In the case where a collection may be
+           extended within the same namespace, an optional wrapper element may be used to contain the
+             <code>any</code> wildcard.</p>
+         <example id="eg-extended-collection-wrapper">
+           <head>Extending a Collection within a Single Namespace</head>
+           <eg xml:space="preserve"><![CDATA[
+ <xs:complexType name="CustomerType">
+   <xs:sequence>
+     <xs:element name="firstName" type="xs:string" />
+     <xs:element name="lastName" type="xs:string" />
+     <xs:element name="extension" type="tns:CustomerExtensionType" minOccurs="0" />
+   </xs:sequence>
+   <xs:anyAttribute/>
+ </xs:complexType>
  
+ <xs:complexType name="CustomerExtensionType">
+   <xs:sequence>
+     <xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"
+ 	  namespace="##targetNamespace"/>
+     </xs:sequence>
+ </xs:complexType>
+           ]]></eg>
+           <p>Optional elements may be added to the CustomerExtenstionType whilst remaining
+             compatible with previous versions of the schema:</p>
+           <eg xml:space="preserve"><![CDATA[
+ <xs:complexType name="CustomerExtensionType">
+   <xs:sequence>
+     <xs:element name="middleName" type="xs:string" minOccurs="0" />
+     <xs:element name="title" type="xs:string" minOccurs="0" />
+     <xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"
+ 	  namespace="##targetNamespace"/>
+     </xs:sequence>
+ </xs:complexType>
+           ]]></eg>
+         </example>
+         <p>Note that the 'any' element wildcard cannot be not be used within an <code>all</code>
+           model group.</p>
+       </div2>
+       <div2 id="Inheritence">
+         <head>Inheritance</head>
+         <ednote>
+           <name>PaulD</name>
+           <date>2005-07-14</date>
+           <edtext>Examples of extending a collection into another namespace as for a class being
+             extended into another package</edtext>
+         </ednote>
+       </div2>
        <div2 id="Vector">
!         <head>Vector</head>
!         <p> A vector is an ordered sequence of repeated items of the same data type. This is a very
!           common construct in programming languages appearing as an array or list. Some tools which
!           generate schemas from a model may elect to give each vector a dedicated type including a
!           wrapper element.</p>
!         <example id="eg-wrapped-vector">
!           <head>Wrapped Vector</head>
!           <eg xml:space="preserve"><![CDATA[
! <xsd:complexType name="ItemListType">
    <xsd:sequence>
      <xsd:element name="item" type="xsd:string" minOccurs=0 maxOccurs="unbounded"/>
!   </xsd:sequence>
  </xsd:complexType>
!           ]]></eg>
!         </example>
!         <p> However, this may not always be the case, and a collection may contain repeated
!           elements.</p>
!         <example id="eg-bare-vectors">
!           <head>A Collection of Vectors</head>
!           <eg xml:space="preserve"><![CDATA[
!  <xs:complexType name="CustomerType">
!   <xs:sequence>
!     <xs:element name="name" type="xs:string" minOccurs="0" maxOccurs="unbounded"/>
!     <xs:element name="addressLine" type="xs:string" minOccurs="0" maxOccurs="unbounded"/>
!     <xs:element name="telephoneNumber" type="xs:string" minOccurs="0" maxOccurs="unbounded"/>
!   <xs:sequence>
! </xs:complexType>
!           ]]></eg>
!         </example>
!         <p>A multi-dimensional array may be built by composing collections and vectors which contain
!           vectors. More complicated array structures such as a sparse or jagged matrices are beyond
!           the scope of this note.</p>
        </div2>
+       <div2 id="Map">
+         <head>Map</head>
+         <ednote>
+           <name>PaulD</name>
+           <date>2005-07-14</date>
+           <edtext>This section is work in progress ..</edtext>
+         </ednote>
+         <p>A map is an unordered collection of appearing in programming languages as a "hash table",
+           "dictionary", "associative array", "associative memory", "indexed table", "keyed data",
+           etc.</p>
+         <example id="eg-map-simple">
+           <head>A Basic Map</head>
+           <eg xml:space="preserve"><![CDATA[
+ <xs:complexType name="CountryCodeMap">
+   <xs:all>
+     <xs:element name="name" type="tns:CountryCodeItem" minOccurs="0" maxOccurs="unbounded"/>
+   <xs:all>
+ </xs:complexType>
  
! <xs:complexType name="CountryCodeMapItem">
!   <xs:sequence>
!     <xs:element name="countryName" type="xs:string"/>
!   </xs:sequence>
!   <xs:attribute type="xs:ID" use="required" />
! </xs:complexType>
!           ]]></eg>
!         </example>
!         <p/>
!         <example id="eg-map-xml-id">
!           <head>Map Keyed Using xml:id</head>
!           <eg xml:space="preserve"><![CDATA[
  <xs:schema targetNamespace="http://www.w3.org/1998/XML/Namespace">
   <xs:attribute name="id" type="xs:ID"/>
***************
*** 301,392 ****
    
  </xs:schema>
! ]]></eg>
! 	</example>
! 
! <ednote><edtext>
! The xs:unique provides a means of expressing that an element or attribute
! value is unique within a specified set of elements. A selector XPath
! expression defines the set of elements and attributes which constitute 
! the context, a second field XPath expression identifies an element or
! attribute which must be unique within the context, e.g.:
! </edtext></ednote>
! 
! 	<example id="eg-map-unique">
! 	  <head>Map Keyed Using xs:unique</head>
! 	  <eg xml:space="preserve"><![CDATA[
! <xs:element name="products">
!   <xs:complexType>
!     <xs:sequence>
!       <xs:element name="product" type="ProductType" 
! 	     maxOccurs="unbounded"/>
!     </xs:sequence>
!   </xs:complexType>
! 
!   <xs:unique name="product">
!     <xs:selector xpath="product"/>
!     <xs:field xpath="@id"/>
!   </xs:unique>
! 
! </xs:element>
! 
! <xs:complexType name="ProductType">
!   <xs:sequence>
!     <xs:element name="name" type="xs:string"/>
!     <xs:element name="price" type="xs:string"/>
!   </xs:sequence>
!   <xs:attribute name="id" type="xs:string" />
! </xs:complexType>
! ]]></eg>
! 	</example>
! 
!   <ednote>
!     <edtext>xs:key is very similar to xs:unique, but adds a constaint that all 
! nodes corresponding to all fields have to be present. Key has been 
! designed for use with xs:keyref - similar to ID/IDREF in DTD with 
! the difference that the uniqueness is within a XPath defined scope. 
! xs:key is therefore preferable to xs:unique when describing a key.</edtext></ednote>
! 
! <ednote><edtext>
! - ID is an NCName datatype. A raw number such as an ISBN such as
!      "0123456789" could be represented as "isbn_0123456789", more
!      complex types such as a Java object will require a hashed key
!      value.
! - ID is an NCName datatype. A raw number such as an ISBN such as
! 
!    - ID has to be unique within the entire document. A context specific
!      prefix could added to the front of each key.
! 
!    - there may be more than one ID, xs:unique or xs:key value for
!      a repeated element. Rules as to which element/attribute should be
!      used as the primary key could be provided, or be left undefined.
! 
!    - ID's are presented in the PSVI ID/IDREF table. May assist processing.
! 
!    - xs:unique and xs:key are more explicit in which containing elements
!      form the map.
! 
!    - xs:unique and xs:key allow multiple fields to form a composite key
! 
!    - xs:unique and xs:key are complex and not well supported by current
!      implementations
! 
!    - not all schema languages have a means of expressing a uniqueness
!      constraint. xs:unique and xs:key don't map well to Relax NG.
! </edtext></ednote>
! 
! <ednote><edtext>
! I'd suggest using the simple xml:id as a good mechanism for generating 
! a map from code with the caveats on the key having to be NCName as well
! as document wide unique.
! 
! I suggest we offer xml:id, xs:ID, xs:unique and xs:key as patterns for
! recognising a map when binding schema to code.
! </edtext></ednote>
! 
        </div2>
- 
- 
- 
- 
      </div1>
      <div1 id="normative-references">
--- 427,433 ----
    
  </xs:schema>
!           ]]></eg>
!         </example>
        </div2>
      </div1>
      <div1 id="normative-references">

Index: xml-schema-patterns.html
===================================================================
RCS file: /sources/public/2002/ws/desc/schema-patterns/xml-schema-patterns.html,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** xml-schema-patterns.html	1 Jul 2005 15:32:17 -0000	1.2
--- xml-schema-patterns.html	14 Jul 2005 14:32:30 -0000	1.3
***************
*** 89,98 ****
  described are intended to be independent of any particular
  programming language or database or modelling environment.</p>
- <p>Authors of tools which map or bind data structures to XML may
- find these simple patterns useful in facilitating the mapping of
- commonplace constructs to and from XML.</p>
- <p>Authors of XML Schema 1.0 documents may also find these patterns
- useful in providing a good user experience for consumers using data
- mapping and binding tools.</p>
  </div>
  <div>
--- 89,92 ----
***************
*** 100,107 ****
  <p><strong>This document is an editors' copy that has no official
  standing.</strong></p>
! <p><em>The intention is that this document will be published as a
! Web Services Description Working Group Note, although the Working
! Group has show interest in this work taking place, the Working
! Group has yet to review or approve this document.</em></p>
  </div>
  <div class="toc">
--- 94,113 ----
  <p><strong>This document is an editors' copy that has no official
  standing.</strong></p>
! <p>This origin if this document stems from discussions surrounding
! a set of example XML Schema patterns submitted as examples for the
! <a href="http://www.w3.org/TR/wsdl20-primer/">WSDL 2.0 Primer</a>
! [<a href=
! "http://lists.w3.org/Archives/Public/www-ws-desc/2004May/0007.html">http://lists.w3.org/Archives/Public/www-ws-desc/2004May/0007.html</a>].</p>
! <p>However, as a result of discussions during the <a href=
! "http://www.w3.org/2005/03/xml-schema-user-program.html">W3C
! Workshop on XML Schema 1.0 User Experiences</a>, the W3C may form a
! dedicated Working Group to <em>develop a set of patterns for common
! data structures of XML Schema for the purpose of simplifying the
! mapping of XML Schemas into programming language structures</em>
! [<a href=
! "http://lists.w3.org/Archives/Public/www-ws/2005Jul/0000.html">http://lists.w3.org/Archives/Public/www-ws/2005Jul/0000.html</a>].
! This note may provide useful input to such a Working Group.</p>
! <p><em>The WSD Working Group has yet to review or approve this
! document.</em></p>
  </div>
  <div class="toc">
***************
*** 110,120 ****
  &nbsp;&nbsp;&nbsp;&nbsp;1.1 <a href="#notational">Notational
  Conventions</a><br />
! 2 <a href="#Data-Structures">Common Data Structures</a><br />
! &nbsp;&nbsp;&nbsp;&nbsp;2.1 <a href="#Enumerated">Enumerated
  Types</a><br />
! &nbsp;&nbsp;&nbsp;&nbsp;2.2 <a href=
! "#Collection">Collections</a><br />
! &nbsp;&nbsp;&nbsp;&nbsp;2.3 <a href="#Vector">Vectors</a><br />
! &nbsp;&nbsp;&nbsp;&nbsp;2.4 <a href="#Maps">Maps</a><br />
  3 <a href="#normative-references">Normative References</a><br />
  4 <a href="#informative-references">Informative
--- 116,139 ----
  &nbsp;&nbsp;&nbsp;&nbsp;1.1 <a href="#notational">Notational
  Conventions</a><br />
! 2 <a href="#Data-Structures">Patterns for Common Data
! Structures</a><br />
! &nbsp;&nbsp;&nbsp;&nbsp;2.1 <a href="#Naming">Naming
  Types</a><br />
! &nbsp;&nbsp;&nbsp;&nbsp;2.2 <a href="#Enumerated">Enumerated
! Type</a><br />
! &nbsp;&nbsp;&nbsp;&nbsp;2.3 <a href="#Enumerated-Open">Open
! Enumerated Type</a><br />
! &nbsp;&nbsp;&nbsp;&nbsp;2.4 <a href=
! "#Collection">Collection</a><br />
! &nbsp;&nbsp;&nbsp;&nbsp;2.5 <a href=
! "#Collection-Extending-Attributes">Extending A Collection With
! Attributes</a><br />
! &nbsp;&nbsp;&nbsp;&nbsp;2.6 <a href=
! "#Collection-Extending-Elements">Extending A Collection With
! Elements</a><br />
! &nbsp;&nbsp;&nbsp;&nbsp;2.7 <a href=
! "#Inheritence">Inheritance</a><br />
! &nbsp;&nbsp;&nbsp;&nbsp;2.8 <a href="#Vector">Vector</a><br />
! &nbsp;&nbsp;&nbsp;&nbsp;2.9 <a href="#Map">Map</a><br />
  3 <a href="#normative-references">Normative References</a><br />
  4 <a href="#informative-references">Informative
***************
*** 128,143 ****
  <h2><a name="introduction" id="introduction"></a>1
  Introduction</h2>
! <table border="1" summary="Editorial note">
! <tr>
! <td align="left" valign="top" width="50%"><b>Editorial
! note</b></td>
! <td align="right" valign="top" width="50%">&nbsp;</td>
! </tr>
! <tr>
! <td colspan="2" align="left" valign="top">Explanation of how schema
! may be used as a description language, as well as for validation.
! Reference to WSDL which uses XML Schema for such a purpose</td>
! </tr>
! </table>
  <div class="div2">
  <h3><a name="notational" id="notational"></a>1.1 Notational
--- 147,169 ----
  <h2><a name="introduction" id="introduction"></a>1
  Introduction</h2>
! <p>This note provides a set of example XML Schema structures
! <a href="#XMLSchemaP1">[XML Schema: Structures]</a> and types
! <a href="#XMLSchemaP2">[XML Schema: Datatypes]</a> which may be
! used to exchange commonly used data structures in the form of an
! XML document.</p>
! <p>Authors of tools which map or bind data structures to XML may
! find these patterns useful to represent simple and common place
! constructs. Recognising these patterns and presenting them in terms
! most appropriate to the specific language, database or environment
! may preserve such data structures across boundaries, as well as
! providing an improved <em>user experience</em> when using data
! mapping and binding tools.</p>
! <p>Authors of XML Schema 1.0 documents may find these patterns
! useful in providing a better <em>user experience</em> for consumers
! of their schemas using data mapping and binding tools.</p>
! <p>It is not intended that these constructs should constrain the
! use of the XML Schema Recommendation. A processor using these
! constructs to map data structures should continue to support the
! whole of the XML Schema Recommendation.</p>
  <div class="div2">
  <h3><a name="notational" id="notational"></a>1.1 Notational
***************
*** 190,201 ****
  </div>
  <div class="div1">
! <h2><a name="Data-Structures" id="Data-Structures"></a>2 Common
! Data Structures</h2>
  <div class="div2">
! <h3><a name="Enumerated" id="Enumerated"></a>2.1 Enumerated
! Types</h3>
  <div class="exampleOuter">
! <div class="exampleHeader"><a name="eg-closed-enum" id=
! "eg-closed-enum"></a>Example 1: Closed Enumerated Type</div>
  <div class="exampleInner">
  <pre>
--- 216,240 ----
  </div>
  <div class="div1">
! <h2><a name="Data-Structures" id="Data-Structures"></a>2 Patterns
! for Common Data Structures</h2>
  <div class="div2">
! <h3><a name="Naming" id="Naming"></a>2.1 Naming Types</h3>
! <p>Giving each data structure an individual type, following the
! so-called "venetian blind" schema authoring style, simplifies
! mapping to and from a data model.</p>
! <p>The name of a schema type, attribute or element may be any valid
! XML non-colonized name including names which may be reserved or not
! directly representable in some programming languages, such as
! "object", "static", "final", "class", "Customer-Profile", etc.</p>
! </div>
! <div class="div2">
! <h3><a name="Enumerated" id="Enumerated"></a>2.2 Enumerated
! Type</h3>
! <p>The XML Schema enumerated type provides a useful mechanism for
! expressing a controlled vocabulary for an element or attribute
! value.</p>
  <div class="exampleOuter">
! <div class="exampleHeader"><a name="eg-enum" id=
! "eg-enum"></a>Example 1: Enumerated Type</div>
  <div class="exampleInner">
  <pre>
***************
*** 210,215 ****
--- 249,262 ----
    &lt;/xs:restriction&gt;
  &lt;/xs:simpleType&gt;
+           
  </pre></div>
  </div>
+ </div>
+ <div class="div2">
+ <h3><a name="Enumerated-Open" id="Enumerated-Open"></a>2.3 Open
+ Enumerated Type</h3>
+ <p>Reusing the enumeration in a union with the base type or in
+ combination with other enumerations may be used to express a
+ vocabulary open to additional values.</p>
  <div class="exampleOuter">
  <div class="exampleHeader"><a name="eg-open-enum" id=
***************
*** 217,250 ****
  <div class="exampleInner">
  <pre>
! &lt;xs:simpleType name='Fruit' &gt;
    &lt;xs:restriction base='xs:string' &gt;
!    &lt;xs:enumeration value='Apple' /&gt;
!    &lt;xs:enumeration value='Pear' /&gt;
!    &lt;xs:enumeration value='Banana' /&gt;
    &lt;/xs:restriction&gt;
  &lt;/xs:simpleType&gt;
  
! &lt;xs:simpleType name='Pudding' &gt;
!   &lt;xs:union memberTypes='tns:Fruit  xs:string' /&gt;
  &lt;/xs:simpleType&gt;
  </pre></div>
  </div>
  </div>
  <div class="div2">
! <h3><a name="Collection" id="Collection"></a>2.2 Collections</h3>
! <table border="1" summary="Editorial note">
! <tr>
! <td align="left" valign="top" width="50%"><b>Editorial
! note</b></td>
! <td align="right" valign="top" width="50%">&nbsp;</td>
! </tr>
! <tr>
! <td colspan="2" align="left" valign="top">A collection of data
! items (an object, class, structure, record etc) is best represented
! as a complexType with the individual items as elements and/or
! attributes. Sadly it needs saying that the compositors "sequence",
! "all" *and* "choice" should be supported.</td>
! </tr>
! </table>
  <div class="exampleOuter">
  <div class="exampleHeader"><a name="eg-simple-collection" id=
--- 264,298 ----
  <div class="exampleInner">
  <pre>
! &lt;xs:simpleType name='AppleVariety' &gt;
    &lt;xs:restriction base='xs:string' &gt;
!    &lt;xs:enumeration value='Braeburn' /&gt;
!    &lt;xs:enumeration value='Cox' /&gt;
!    &lt;xs:enumeration value='Egremont Russet' /&gt;
!    &lt;xs:enumeration value='Granny Smith' /&gt;
    &lt;/xs:restriction&gt;
  &lt;/xs:simpleType&gt;
  
! &lt;xs:simpleType name='PlumVariety' &gt;
!   &lt;xs:restriction base='xs:string' &gt;
!    &lt;xs:enumeration value='Damson' /&gt;
!    &lt;xs:enumeration value='Greengage' /&gt;
!    &lt;xs:enumeration value='Victoria' /&gt;
!   &lt;/xs:restriction&gt;
! &lt;/xs:simpleType&gt;
! 
! &lt;xs:simpleType name='FruitVariety' &gt;
!   &lt;xs:union memberTypes='tns:AppleVariety tns:PlumVariety xs:string' /&gt;
  &lt;/xs:simpleType&gt;
+           
  </pre></div>
  </div>
  </div>
  <div class="div2">
! <h3><a name="Collection" id="Collection"></a>2.4 Collection</h3>
! <p>A collection of data items, typically contained by a programming
! language object, class, structure, or a database record, may be
! represented in XML Schema using a single model group. The
! individual items held in a collection may appear either as XML
! element or attribute values.</p>
  <div class="exampleOuter">
  <div class="exampleHeader"><a name="eg-simple-collection" id=
***************
*** 255,403 ****
    &lt;xs:sequence&gt;
      &lt;xs:element name="name" type="xs:string"/&gt;
!     &lt;xs:element name="colour" type="xs:string"/&gt;
    &lt;/xs:sequence&gt;
    &lt;xs:attribute name="id" type="xs:string" /&gt;
  &lt;/xs:complexType&gt;
  </pre></div>
  </div>
! <table border="1" summary="Editorial note">
! <tr>
! <td align="left" valign="top" width="50%"><b>Editorial
! note</b></td>
! <td align="right" valign="top" width="50%">&nbsp;</td>
! </tr>
! <tr>
! <td colspan="2" align="left" valign="top">Explicit (active)
! extensibility of a collection may be expressed using 'any' and
! 'anyAttribute' as in the following example adapted from the draft
! TAG finding on extensibility and versioning[2]:</td>
! </tr>
! </table>
  <div class="exampleOuter">
! <div class="exampleHeader"><a name="eg-extended-collection" id=
! "eg-extended-collection"></a>Example 4: Extending a
! Collection</div>
  <div class="exampleInner">
  <pre>
   &lt;xs:complexType name="ProductType"&gt;
      &lt;xs:sequence&gt;
!       &lt;xs:element name="name" type="xs:string"
!           minOccurs="1" maxOccurs="1"/&gt;
!       &lt;xs:element name="colour" type="xs:string"/&gt;
!       &lt;xs:any processContents="lax"
!             minOccurs="0" maxOccurs="unbounded"/&gt;
     &lt;/xs:sequence&gt;
     &lt;xs:attribute name="id" type="xs:string" /&gt;
!    &lt;xs:anyAttribute/&gt;
   &lt;/xs:complexType&gt;
  </pre></div>
  </div>
! <table border="1" summary="Editorial note">
! <tr>
! <td align="left" valign="top" width="50%"><b>Editorial
! note</b></td>
! <td align="right" valign="top" width="50%">&nbsp;</td>
! </tr>
! <tr>
! <td colspan="2" align="left" valign="top">The 'any' wildcard is
! only deterministic when applied to the end of a 'sequence' -
! determinism being particularly important when generating messages
! from a schema definition. Again it needs saying that tools should
! support the 'namespace' attribute including the '##any', '##other'
! and '#</td>
! </tr>
! </table>
! <table border="1" summary="Editorial note">
  <tr>
! <td align="left" valign="top" width="50%"><b>Editorial
! note</b></td>
! <td align="right" valign="top" width="50%">&nbsp;</td>
  </tr>
  <tr>
! <td colspan="2" align="left" valign="top">Add Dare Obasanjo's
! pattern for subverting greedy 'any'.</td>
  </tr>
  </table>
  </div>
  <div class="div2">
! <h3><a name="Vector" id="Vector"></a>2.3 Vectors</h3>
! <p>A vector is an ordered sequence of items of the same data type.
! This is a very common construct in programming languages appearing
! as an array or list. Multi-dimensional arrays may be built by
! composing vectors within vectors. Formalising more complex
! constructs such as sparse or jagged matrices are beyond the scope
! of these examples.</p>
  <div class="exampleOuter">
  <div class="exampleHeader"><a name="eg-wrapped-vector" id=
! "eg-wrapped-vector"></a>Example 5: Wrapped Vector</div>
  <div class="exampleInner">
  <pre>
! &lt;xsd:complexType name="ItemList"&gt;
    &lt;xsd:sequence&gt;
      &lt;xsd:element name="item" type="xsd:string" minOccurs=0 maxOccurs="unbounded"/&gt;
!     &lt;/xsd:sequence&gt;
  &lt;/xsd:complexType&gt;
  </pre></div>
  </div>
  <div class="exampleOuter">
  <div class="exampleHeader"><a name="eg-bare-vectors" id=
! "eg-bare-vectors"></a>Example 6: Bare Vector</div>
  <div class="exampleInner">
  <pre>
!  &lt;xs:complexType name="Address"&gt;
!     &lt;xs:sequence&gt;
!       &lt;xs:element name="lines" type="xs:string" maxOccurs="unbounded"/&gt;
!       &lt;xs:element name="telnos" type="xs:string" maxOccurs="unbounded"/&gt;
!     &lt;xs:sequence&gt;
!   &lt;/xs:complexType&gt;
  </pre></div>
  </div>
  </div>
  <div class="div2">
! <h3><a name="Maps" id="Maps"></a>2.4 Maps</h3>
! <table border="1" summary="Editorial note">
! <tr>
! <td align="left" valign="top" width="50%"><b>Editorial
! note</b></td>
! <td align="right" valign="top" width="50%">&nbsp;</td>
! </tr>
! <tr>
! <td colspan="2" align="left" valign="top">xs:ID is similar to the
! DTD ID type with the following properties: - the type has the same
! lexical space as xs:NCName - the ID may be an attribute or an
! element - the ID value must be unique with the document - there may
! be one or more ID's associated with an element</td>
! </tr>
! </table>
! <table border="1" summary="Editorial note">
! <tr>
! <td align="left" valign="top" width="50%"><b>Editorial
! note</b></td>
! <td align="right" valign="top" width="50%">&nbsp;</td>
! </tr>
! <tr>
! <td colspan="2" align="left" valign="top">The PSVI set contains a
! ID/IDREF table[7] which is an index pointing to nodes with an
! included xs:ID element/attribute.</td>
! </tr>
! </table>
! <table border="1" summary="Editorial note">
  <tr>
! <td align="left" valign="top" width="50%"><b>Editorial
! note</b></td>
! <td align="right" valign="top" width="50%">&nbsp;</td>
  </tr>
  <tr>
! <td colspan="2" align="left" valign="top">The new xml:id[8]
! attribute from the XML Base WG offers an neat way of expressing an
! ID value for an element targeted at recipients who may not have
! access to a schema. A so called 'disengaged' agent may easily more
! recognise a map from a document containing xml:id attributes and
! present the repeated element as an associative array, e.g:</td>
  </tr>
  </table>
  <div class="exampleOuter">
  <div class="exampleHeader"><a name="eg-map-xml-id" id=
! "eg-map-xml-id"></a>Example 7: Map Keyed Using xml:id</div>
  <div class="exampleInner">
  <pre>
--- 303,569 ----
    &lt;xs:sequence&gt;
      &lt;xs:element name="name" type="xs:string"/&gt;
!     &lt;xs:element name="shade" type="xs:string"/&gt;
    &lt;/xs:sequence&gt;
    &lt;xs:attribute name="id" type="xs:string" /&gt;
+   &lt;xs:attribute name="inStock" type="xs:int" /&gt;
  &lt;/xs:complexType&gt;
+           
  </pre></div>
  </div>
! <p>The collection may be composed using a model group of
! either:</p>
! <ul>
! <li>
! <p><code>sequence</code> - the elements are ordered</p>
! </li>
! <li>
! <p><code>all</code> - the elements are unordered</p>
! </li>
! <li>
! <p><code>choice</code> - only one of the elements may be
! present</p>
! </li>
! </ul>
! <p>The <code>all</code> model group may appear attractive given
! programming language techniques such as introspection or reflection
! often return items in a random order. However, there are
! significant restrictions placed upon <code>all</code> types, not
! least an element cannot have a <code>maxOccurs</code> value greater
! than <code>1</code>. The <a href=
! "http://www.w3.org/TR/2004/REC-xmlschema-1-20041028/#cos-nonambig">Unique
! Particle Attribution</a> (UPA) constraint prevents a model group of
! <code>all</code> from being extended, either by containing an
! <code>any</code> element wildcard, being incorporated in a
! substitution group or derived using extension or restriction.</p>
! </div>
! <div class="div2">
! <h3><a name="Collection-Extending-Attributes" id=
! "Collection-Extending-Attributes"></a>2.5 Extending A Collection
! With Attributes</h3>
! <p>A collection may be made open to extension by the addition of
! attributes using the <code>anyAttribute</code> construct.</p>
  <div class="exampleOuter">
! <div class="exampleHeader"><a name=
! "eg-extended-collection-attributes" id=
! "eg-extended-collection-attributes"></a>Example 4: Extending a
! Collection with Attributes</div>
  <div class="exampleInner">
  <pre>
   &lt;xs:complexType name="ProductType"&gt;
      &lt;xs:sequence&gt;
!       &lt;xs:element name="name" type="xs:string" /&gt;
!       &lt;xs:element name="shade" type="xs:string"/&gt;
     &lt;/xs:sequence&gt;
     &lt;xs:attribute name="id" type="xs:string" /&gt;
!    &lt;xs:anyAttribute namespace="##any" processContents="lax"/&gt;
   &lt;/xs:complexType&gt;
+           
  </pre></div>
  </div>
! <p>The <code>namespace</code> value will typically either be:</p>
! <ul>
! <li>
! <p><code>##targetNamespace</code> - the additional items will
! appear in the same namespace</p>
! </li>
! <li>
! <p><code>##other</code> - the additional items may appear in a
! different namespace</p>
! </li>
! <li>
! <p><code>##any</code> - the additional items may appear in any
! namespace</p>
! </li>
! </ul>
! <p>The <code>processContents</code> value of <code>lax</code> is
! typically used to indicate that additional items are unlikely to be
! known to the schema, this is a common case when evolving a schema
! to another version.</p>
! </div>
! <div class="div2">
! <h3><a name="Collection-Extending-Elements" id=
! "Collection-Extending-Elements"></a>2.6 Extending A Collection With
! Elements</h3>
! <div class="exampleOuter">
! <div class="exampleHeader"><a name=
! "eg-extended-collection-elements" id=
! "eg-extended-collection-elements"></a>Example 5: Extending a
! Collection with Elements in Another Namespace</div>
! <div class="exampleInner">
! <pre>
!  &lt;xs:complexType name="ProductType"&gt;
!     &lt;xs:sequence&gt;
!       &lt;xs:element name="name" type="xs:string" /&gt;
!       &lt;xs:element name="shade" type="xs:string" /&gt;
!       &lt;xs:any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/&gt;
!    &lt;/xs:sequence&gt;
!  &lt;/xs:complexType&gt;
!           
! </pre></div>
! </div>
! <p>An <code>any</code> construct with a namespace of
! <code>##other</code> may directly follow an optional element.</p>
! <div class="exampleOuter">
! <div class="exampleHeader"><a name="eg-extended-collection-other"
! id="eg-extended-collection-other"></a>Example 6: Extending a
! Collection with Elements After an Optional Element</div>
! <div class="exampleInner">
! <pre>
!  &lt;xs:complexType name="ProductType"&gt;
!     &lt;xs:sequence&gt;
!       &lt;xs:element name="name" type="xs:string" /&gt;
!       &lt;xs:element name="shade" type="xs:string" /&gt;
!       &lt;xs:element name="nickName" type="xs:string" minOccurs="0"/&gt;
!       &lt;xs:any namespace="##other" processContents="lax" minOccurs="0" maxOccurs="unbounded"/&gt;
!    &lt;/xs:sequence&gt;
!  &lt;/xs:complexType&gt;
!           
! </pre></div>
! </div>
! <p>The UPA constraint prevents an <code>any</code> wildcard with a
! <code>namespace</code> value of <code>any</code> or
! <code>targetNamespace</code> to follow an element with a
! <code>minOccurs</code> value of <code>0</code>. In the case where a
! collection may be extended within the same namespace, an optional
! wrapper element may be used to contain the <code>any</code>
! wildcard.</p>
! <div class="exampleOuter">
! <div class="exampleHeader"><a name="eg-extended-collection-wrapper"
! id="eg-extended-collection-wrapper"></a>Example 7: Extending a
! Collection within a Single Namespace</div>
! <div class="exampleInner">
! <pre>
! &lt;xs:complexType name="CustomerType"&gt;
!   &lt;xs:sequence&gt;
!     &lt;xs:element name="firstName" type="xs:string" /&gt;
!     &lt;xs:element name="lastName" type="xs:string" /&gt;
!     &lt;xs:element name="extension" type="tns:CustomerExtensionType" minOccurs="0" /&gt;
!   &lt;/xs:sequence&gt;
!   &lt;xs:anyAttribute/&gt;
! &lt;/xs:complexType&gt;
! 
! &lt;xs:complexType name="CustomerExtensionType"&gt;
!   &lt;xs:sequence&gt;
!     &lt;xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"
!           namespace="##targetNamespace"/&gt;
!     &lt;/xs:sequence&gt;
! &lt;/xs:complexType&gt;
!           
! </pre></div>
! <p>Optional elements may be added to the CustomerExtenstionType
! whilst remaining compatible with previous versions of the
! schema:</p>
! <div class="exampleInner">
! <pre>
! &lt;xs:complexType name="CustomerExtensionType"&gt;
!   &lt;xs:sequence&gt;
!     &lt;xs:element name="middleName" type="xs:string" minOccurs="0" /&gt;
!     &lt;xs:element name="title" type="xs:string" minOccurs="0" /&gt;
!     &lt;xs:any processContents="lax" minOccurs="0" maxOccurs="unbounded"
!           namespace="##targetNamespace"/&gt;
!     &lt;/xs:sequence&gt;
! &lt;/xs:complexType&gt;
!           
! </pre></div>
! </div>
! <p>Note that the 'any' element wildcard cannot be not be used
! within an <code>all</code> model group.</p>
! </div>
! <div class="div2">
! <h3><a name="Inheritence" id="Inheritence"></a>2.7 Inheritance</h3>
! <table border="1" summary="Editorial note: PaulD">
  <tr>
! <td align="left" valign="top" width="50%"><b>Editorial note:
! PaulD</b></td>
! <td align="right" valign="top" width="50%">2005-07-14</td>
  </tr>
  <tr>
! <td colspan="2" align="left" valign="top">Examples of extending a
! collection into another namespace as for a class being extended
! into another package</td>
  </tr>
  </table>
  </div>
  <div class="div2">
! <h3><a name="Vector" id="Vector"></a>2.8 Vector</h3>
! <p>A vector is an ordered sequence of repeated items of the same
! data type. This is a very common construct in programming languages
! appearing as an array or list. Some tools which generate schemas
! from a model may elect to give each vector a dedicated type
! including a wrapper element.</p>
  <div class="exampleOuter">
  <div class="exampleHeader"><a name="eg-wrapped-vector" id=
! "eg-wrapped-vector"></a>Example 8: Wrapped Vector</div>
  <div class="exampleInner">
  <pre>
! &lt;xsd:complexType name="ItemListType"&gt;
    &lt;xsd:sequence&gt;
      &lt;xsd:element name="item" type="xsd:string" minOccurs=0 maxOccurs="unbounded"/&gt;
!   &lt;/xsd:sequence&gt;
  &lt;/xsd:complexType&gt;
+           
  </pre></div>
  </div>
+ <p>However, this may not always be the case, and a collection may
+ contain repeated elements.</p>
  <div class="exampleOuter">
  <div class="exampleHeader"><a name="eg-bare-vectors" id=
! "eg-bare-vectors"></a>Example 9: A Collection of Vectors</div>
  <div class="exampleInner">
  <pre>
!  &lt;xs:complexType name="CustomerType"&gt;
!   &lt;xs:sequence&gt;
!     &lt;xs:element name="name" type="xs:string" minOccurs="0" maxOccurs="unbounded"/&gt;
!     &lt;xs:element name="addressLine" type="xs:string" minOccurs="0" maxOccurs="unbounded"/&gt;
!     &lt;xs:element name="telephoneNumber" type="xs:string" minOccurs="0" maxOccurs="unbounded"/&gt;
!   &lt;xs:sequence&gt;
! &lt;/xs:complexType&gt;
!           
  </pre></div>
  </div>
+ <p>A multi-dimensional array may be built by composing collections
+ and vectors which contain vectors. More complicated array
+ structures such as a sparse or jagged matrices are beyond the scope
+ of this note.</p>
  </div>
  <div class="div2">
! <h3><a name="Map" id="Map"></a>2.9 Map</h3>
! <table border="1" summary="Editorial note: PaulD">
  <tr>
! <td align="left" valign="top" width="50%"><b>Editorial note:
! PaulD</b></td>
! <td align="right" valign="top" width="50%">2005-07-14</td>
  </tr>
  <tr>
! <td colspan="2" align="left" valign="top">This section is work in
! progress ..</td>
  </tr>
  </table>
+ <p>A map is an unordered collection of appearing in programming
+ languages as a "hash table", "dictionary", "associative array",
+ "associative memory", "indexed table", "keyed data", etc.</p>
+ <div class="exampleOuter">
+ <div class="exampleHeader"><a name="eg-map-simple" id=
+ "eg-map-simple"></a>Example 10: A Basic Map</div>
+ <div class="exampleInner">
+ <pre>
+ &lt;xs:complexType name="CountryCodeMap"&gt;
+   &lt;xs:all&gt;
+     &lt;xs:element name="name" type="tns:CountryCodeItem" minOccurs="0" maxOccurs="unbounded"/&gt;
+   &lt;xs:all&gt;
+ &lt;/xs:complexType&gt;
+ 
+ &lt;xs:complexType name="CountryCodeMapItem"&gt;
+   &lt;xs:sequence&gt;
+     &lt;xs:element name="countryName" type="xs:string"/&gt;
+   &lt;/xs:sequence&gt;
+   &lt;xs:attribute type="xs:ID" use="required" /&gt;
+ &lt;/xs:complexType&gt;
+           
+ </pre></div>
+ </div>
  <div class="exampleOuter">
  <div class="exampleHeader"><a name="eg-map-xml-id" id=
! "eg-map-xml-id"></a>Example 11: Map Keyed Using xml:id</div>
  <div class="exampleInner">
  <pre>
***************
*** 418,522 ****
    
  &lt;/xs:schema&gt;
  </pre></div>
  </div>
- <table border="1" summary="Editorial note">
- <tr>
- <td align="left" valign="top" width="50%"><b>Editorial
- note</b></td>
- <td align="right" valign="top" width="50%">&nbsp;</td>
- </tr>
- <tr>
- <td colspan="2" align="left" valign="top">The xs:unique provides a
- means of expressing that an element or attribute value is unique
- within a specified set of elements. A selector XPath expression
- defines the set of elements and attributes which constitute the
- context, a second field XPath expression identifies an element or
- attribute which must be unique within the context, e.g.:</td>
- </tr>
- </table>
- <div class="exampleOuter">
- <div class="exampleHeader"><a name="eg-map-unique" id=
- "eg-map-unique"></a>Example 8: Map Keyed Using xs:unique</div>
- <div class="exampleInner">
- <pre>
- &lt;xs:element name="products"&gt;
-   &lt;xs:complexType&gt;
-     &lt;xs:sequence&gt;
-       &lt;xs:element name="product" type="ProductType" 
-              maxOccurs="unbounded"/&gt;
-     &lt;/xs:sequence&gt;
-   &lt;/xs:complexType&gt;
- 
-   &lt;xs:unique name="product"&gt;
-     &lt;xs:selector xpath="product"/&gt;
-     &lt;xs:field xpath="@id"/&gt;
-   &lt;/xs:unique&gt;
- 
- &lt;/xs:element&gt;
- 
- &lt;xs:complexType name="ProductType"&gt;
-   &lt;xs:sequence&gt;
-     &lt;xs:element name="name" type="xs:string"/&gt;
-     &lt;xs:element name="price" type="xs:string"/&gt;
-   &lt;/xs:sequence&gt;
-   &lt;xs:attribute name="id" type="xs:string" /&gt;
- &lt;/xs:complexType&gt;
- </pre></div>
- </div>
- <table border="1" summary="Editorial note">
- <tr>
- <td align="left" valign="top" width="50%"><b>Editorial
- note</b></td>
- <td align="right" valign="top" width="50%">&nbsp;</td>
- </tr>
- <tr>
- <td colspan="2" align="left" valign="top">xs:key is very similar to
- xs:unique, but adds a constaint that all nodes corresponding to all
- fields have to be present. Key has been designed for use with
- xs:keyref - similar to ID/IDREF in DTD with the difference that the
- uniqueness is within a XPath defined scope. xs:key is therefore
- preferable to xs:unique when describing a key.</td>
- </tr>
- </table>
- <table border="1" summary="Editorial note">
- <tr>
- <td align="left" valign="top" width="50%"><b>Editorial
- note</b></td>
- <td align="right" valign="top" width="50%">&nbsp;</td>
- </tr>
- <tr>
- <td colspan="2" align="left" valign="top">- ID is an NCName
- datatype. A raw number such as an ISBN such as "0123456789" could
- be represented as "isbn_0123456789", more complex types such as a
- Java object will require a hashed key value. - ID is an NCName
- datatype. A raw number such as an ISBN such as - ID has to be
- unique within the entire document. A context specific prefix could
- added to the front of each key. - there may be more than one ID,
- xs:unique or xs:key value for a repeated element. Rules as to which
- element/attribute should be used as the primary key could be
- provided, or be left undefined. - ID's are presented in the PSVI
- ID/IDREF table. May assist processing. - xs:unique and xs:key are
- more explicit in which containing elements form the map. -
- xs:unique and xs:key allow multiple fields to form a composite key
- - xs:unique and xs:key are complex and not well supported by
- current implementations - not all schema languages have a means of
- expressing a uniqueness constraint. xs:unique and xs:key don't map
- well to Relax NG.</td>
- </tr>
- </table>
- <table border="1" summary="Editorial note">
- <tr>
- <td align="left" valign="top" width="50%"><b>Editorial
- note</b></td>
- <td align="right" valign="top" width="50%">&nbsp;</td>
- </tr>
- <tr>
- <td colspan="2" align="left" valign="top">I'd suggest using the
- simple xml:id as a good mechanism for generating a map from code
- with the caveats on the key having to be NCName as well as document
- wide unique. I suggest we offer xml:id, xs:ID, xs:unique and xs:key
- as patterns for recognising a map when binding schema to code.</td>
- </tr>
- </table>
  </div>
  </div>
--- 584,590 ----
    
  &lt;/xs:schema&gt;
+           
  </pre></div>
  </div>
  </div>
  </div>
Received on Thursday, 14 July 2005 14:32:44 GMT

This archive was generated by hypermail 2.2.0 + w3c-0.30 : Thursday, 14 July 2005 14:32:45 GMT