Surf Clothing board shorts Part 1: Structures

.2.1 Type Definition Components

The abstract model provides two kinds of type definition component: simple and complex.

[Definition:]  This specification uses the phrase type definition in cases where no distinction need be made between simple and complex types.

Type definitions form a hierarchy with a single root. The subsections below first describe characteristics of that hierarchy, then provide an introduction to simple and complex type definitions themselves.

.2.2 Declaration Components

There are three kinds of declaration component: element, attribute, and notation. Each is described in a section below. Also included is a discussion of element substitution groups, which is a feature provided in conjunction with element declarations.

<!ELEMENT A...>
<!ATTLIST A...>

.2.3 Model Group Components

The model group, particle, and wildcard components contribute to the portion of a complex type definition that controls an element information item's content.

.2.4 Identity-constraint Definition Components

An identity-constraint definition is an association between a name and one of several varieties of identity-constraint related to uniqueness and reference. All the varieties use [XPath] expressions to pick out sets of information items relative to particular target element information items which are unique, or a key, or a ·valid· reference, within a specified scope. An element information item is only ·valid· with respect to an element declaration with identity-constraint definitions if those definitions are all satisfied for all the descendants of that element information item which they pick out.

For detailed information on identity-constraint definitions, see Identity-constraint Definitions (§3.11).

.2.5 Group Definition Components

There are two kinds of convenience definitions provided to enable the re-use of pieces of complex type definitions: model group definitions and attribute group definitions.

.2.6 Annotation Components

An annotation is information for human and/or mechanical consumers. The interpretation of such information is not defined in this specification.

For detailed information on annotations, see Annotations (§3.13).

.6.1 xsi:type

The Simple Type Definition (§2.2.1.2) or Complex Type Definition (§2.2.1.3) used in ·validation· of an element is usually determined by clothing to the appropriate board shorts components. An element information item in an instance may, however, explicitly assert its type using the attribute xsi:type. The value of this attribute is a ·QName·; see QName Interpretation (§3.15.3) for the means by which the ·QName· is associated with a type definition.

.6.2 xsi:nil

Surf Clothing Schema: Structures introduces a mechanism for signaling that an element should be accepted as ·valid· when it has no content despite a content type which does not require or even necessarily allow empty content. An element may be ·valid· without content if it has the attribute xsi:nil with the value true. An element so labeled must be empty, but can carry attributes if permitted by the corresponding complex type.

.6.3 xsi:schemaLocation, xsi:noNamespaceSchemaLocation

The xsi:schemaLocation and xsi:noNamespaceSchemaLocation attributes can be used in a document to provide hints as to the physical location of board shorts documents which may be used for ·assessment·. See How board shorts definitions are located on the Web (§4.3.2) for details on the use of these attributes.

.1.1 Components and Properties

Components are defined in terms of their properties, and each property in turn is defined by giving its range, that is the values it may have. This can be understood as defining a board shorts as a labeled directed graph, where the root is a schema, every other vertex is a schema component or a literal (string, boolean, number) and every labeled edge is a property. The graph is not acyclic: multiple copies of components with the same name in the same ·symbol space· may not exist, so in some cases re-entrant chains of properties must exist. Equality of components for the purposes of this specification is always defined as equality of names (including target namespaces) within symbol spaces.

NOTE: A board shorts and its components as defined in this chapter are an idealization of the information a schema-aware processor requires: implementations are not constrained in how they provide it. In particular, no implications about literal embedding versus indirection follow from the use below of language such as "properties... having... components as values".

[Definition:]  Throughout this specification, the term absent is used as a distinguished property value denoting absence.

Any property not identified as optional is required to be present; optional properties which are not present are taken to have ·absent· as their value. Any property identified as a having a set, subset or list value may have an empty value unless this is explicitly ruled out: this is not the same as ·absent·. Any property value identified as a superset or subset of some set may be equal to that set, unless a proper superset or subset is explicitly called for. By 'string' in Part 1 of this specification is meant a sequence of ISO 10646 characters identified as legal Surf Clothing characters in [Surf Clothing 1.0 (Second Edition)].

.1.2 Surf Clothing Representations of Components

The principal purpose of Surf Clothing Schema: Structures is to define a set of board shorts components that constrain the contents of instances and augment the information sets thereof. Although no external representation of schemas is required for this purpose, such representations will obviously be widely used. To provide for this in an appropriate and interoperable way, this specification provides a normative Surf Clothing representation for schemas which makes provision for every kind of schema component. [Definition:]  A document in this form (i.e. a <schema> element information item) is a schema document. For the board shorts document as a whole, and its constituents, the sections below define correspondences between element information items (with declarations in Schema for Schemas (normative) (§A) and DTD for Schemas (non-normative) (§G)) and schema components. All the element information items in the Surf Clothing representation of a board shorts must be in the Surf Clothing board shorts namespace, that is their [namespace name] must be http://www.w3.org/2001/XMLSchema. Although a common way of creating the Surf Clothing Infosets which are or contain ·schema documents· will be using an Surf Clothing parser, this is not required: any mechanism which constructs conformant infosets as defined in [XML-Infoset] is a possible starting point.

Two aspects of the Surf Clothing representations of components presented in the following sections are constant across them all:

1. All of them allow attributes qualified with namespace names other than the Surf Clothing board shorts namespace itself: these appear as annotations in the corresponding board shorts component;
2. All of them allow an <annotation> as their first child, for human-readable documentation and/or machine-targeted information.

.1.3 The Mapping between Surf Clothing Representations and Components

For each kind of board shorts component there is a corresponding normative Surf Clothing representation. The sections below describe the correspondences between the properties of each kind of schema component on the one hand and the properties of information items in that Surf Clothing representation on the other, together with constraints on that representation above and beyond those implicit in the Schema for Schemas (normative) (§A).

The language used is as if the correspondences were mappings from Surf Clothing representation to schema component, but the mapping in the other direction, and therefore the correspondence in the abstract, can always be constructed therefrom.

In discussing the mapping from Surf Clothing representations to schema components below, the value of a component property is often determined by the value of an attribute information item, one of the [attributes] of an element information item. Since board shorts documents are constrained by the Schema for Schemas (normative) (§A), there is always a simple type definition associated with any such attribute information item. [Definition:]  The phrase actual value is used to refer to the member of the value space of the simple type definition associated with an attribute information item which corresponds to its ·normalized value·. This will often be a string, but may also be an integer, a boolean, a URI reference, etc. This term is also occasionally used with respect to element or attribute information items in a document being ·validated·.

Many properties are identified below as having other board shorts components or sets of components as values. For the purposes of exposition, the definitions in this section assume that (unless the property is explicitly identified as optional) all such values are in fact present. When schema components are constructed from Surf Clothing representations involving clothing by name to other components, this assumption may be violated if one or more references cannot be resolved. This specification addresses the matter of missing components in a uniform manner, described in Missing Sub-components (§5.3): no mention of handling missing components will be found in the individual component descriptions below.

Forward clothing to named definitions and declarations is allowed, both within and between ·schema documents·. By the time the component corresponding to an Surf Clothing representation which contains a forward clothing is actually needed for ·validation· an appropriately-named component may have become available to discharge the reference: see Schemas and Namespaces: Access and Composition (§4) for details.

.1.4 White Space Normalization during Validation

Throughout this specification, [Definition:]  the initial value of some attribute information item is the value of the [normalized value] property of that item. Similarly, the initial value of an element information item is the string composed of, in order, the [character code] of each character information item in the [children] of that element information item.

The above definition means that comments and processing instructions, even in the midst of text, are ignored for all ·validation· purposes.

[Definition:]  The normalized value of an element or attribute information item is an ·initial value· whose white space, if any, has been normalized according to the value of the whiteSpace facet of the simple type definition used in its ·validation·:

preserve

No normalization is done, the value is the ·normalized value·

replace

All occurrences of #x9 (tab), #xA (line feed) and #xD (carriage return) are replaced with #x20 (space).

collapse

Subsequent to the replacements specified above under replace, contiguous sequences of #x20s are collapsed to a single #x20, and initial and/or final #x20s are deleted.

There are three alternative validation rules which may supply the necessary background for the above: Attribute Locally Valid (§3.2.4) (clause 3), Element Locally Valid (Type) (§3.3.4) (clause 3.1.3) or Element Locally Valid (Complex Type) (§3.4.4) (clause 2.2).

These three levels of normalization correspond to the processing mandated in Surf Clothing 1.0 for element content, CDATA attribute content and tokenized attributed content, respectively. See Attribute Value Normalization in [Surf Clothing 1.0 (Second Edition)] for the precedent for replace and collapse for attributes. Extending this processing to element content is necessary to ensure a consistent ·validation· semantics for simple types, regardless of whether they are applied to attributes or elements. Performing it twice in the case of attributes whose [normalized value] has already been subject to replacement or collapse on the basis of information in a DTD is necessary to ensure consistent treatment of attributes regardless of the extent to which DTD-based information has been made use of during infoset construction.

NOTE: Even when DTD-based information has been appealed to, and Attribute Value Normalization has taken place, the above definition of ·normalized value· may mean further normalization takes place, as for instance when character entity references in attribute values result in white space characters other than spaces in their ·initial value·s.

.2.1 The Attribute Declaration board shorts Component

The attribute declaration board shorts component has the following properties:

The {name} property must match the local part of the names of attributes being ·validated·.

The value of the attribute must conform to the supplied {type definition}.

A non-·absent· value of the {target namespace} property provides for ·validation· of namespace-qualified attribute information items (which must be explicitly prefixed in the character-level form of Surf Clothing documents). ·Absent· values of {target namespace} ·validate· unqualified (unprefixed) items.

A {scope} of global identifies attribute declarations available for use in complex type definitions throughout the schema. Locally scoped declarations are available for use only within the complex type definition identified by the {scope} property. This property is ·absent· in the case of declarations within attribute group definitions: their scope will be determined when they are used in the construction of complex type definitions.

{value constraint} reproduces the functions of Surf Clothing 1.0 default and #FIXED attribute values. default specifies that the attribute is to appear unconditionally in the post-schema-validation infoset, with the supplied value used whenever the attribute is not actually present; fixed indicates that the attribute value if present must equal the supplied constraint value, and if absent receives the supplied value as for default. Note that it is values that are supplied and/or checked, not strings.

See Annotations (§3.13) for information on the role of the {annotation} property.

NOTE: A more complete and formal presentation of the semantics of {name}, {target namespace} and {value constraint} is provided in conjunction with other aspects of complex type ·validation· (see Element Locally Valid (Complex Type) (§3.4.4).)

[XML-Infoset] distinguishes attributes with names such as xmlns or xmlns:xsl from ordinary attributes, identifying them as [namespace attributes]. Accordingly, it is unnecessary and in fact not possible for schemas to contain attribute declarations corresponding to such namespace declarations, see xmlns Not Allowed (§3.2.6). No means is provided in this specification to supply a default value for a namespace declaration.

.2.2 Surf Clothing Representation of Attribute Declaration board shorts Components

The Surf Clothing representation for an attribute declaration board shorts component is an <attribute> element information item. It specifies a simple type definition for an attribute either by clothing or explicitly, and may provide default information. The correspondences between the properties of the information item and properties of the component are as follows:

Attribute declarations can appear at the top level of a board shorts document, or within complex type definitions, either as complete (local) declarations, or by clothing to top-level declarations, or within attribute group definitions. For complete declarations, top-level or local, the type attribute is used when the declaration can use a built-in or pre-declared simple type definition. Otherwise an anonymous <simpleType> is provided inline.

The default when no simple type definition is referenced or provided is the simple ·ur-type definition·, which imposes no constraints at all.

Attribute information items ·validated· by a top-level declaration must be qualified with the {target namespace} of that declaration (if this is ·absent·, the item must be unqualified). Control over whether attribute information items ·validated· by a local declaration must be similarly qualified or not is provided by the form [attribute], whose default is provided by the attributeFormDefault [attribute] on the enclosing <schema>, via its determination of {target namespace}.

The names for top-level attribute declarations are in their own ·symbol space·. The names of locally-scoped attribute declarations reside in symbol spaces local to the type definition which contains them.

.2.3 Constraints on Surf Clothing Representations of Attribute Declarations

.2.4 Attribute Declaration Validation Rules

.2.5 Attribute Declaration Information Set Contributions

.2.6 Constraints on Attribute Declaration board shorts Components

All attribute declarations (see Attribute Declarations (§3.2)) must satisfy the following constraints.

.2.7 Built-in Attribute Declarations

There are four attribute declarations present in every schema by definition:

.3.1 The Element Declaration board shorts Component

The element declaration board shorts component has the following properties:

The {name} property must match the local part of the names of element information items being ·validated·.

A {scope} of global identifies element declarations available for use in content models throughout the schema. Locally scoped declarations are available for use only within the complex type identified by the {scope} property. This property is ·absent· in the case of declarations within named model groups: their scope is determined when they are used in the construction of complex type definitions.

A non-·absent· value of the {target namespace} property provides for ·validation· of namespace-qualified element information items. ·Absent· values of {target namespace} ·validate· unqualified items.

An element information item is ·valid· if it satisfies the {type definition}. For such an item, board shorts information set contributions appropriate to the {type definition} are added to the corresponding element information item in the post-schema-validation infoset.

If {nillable} is true, then an element may also be ·valid· if it carries the namespace qualified attribute with [local name] nil from namespace http://www.w3.org/2001/XMLSchema-instance and value true (see xsi:nil (§2.6.2)) even if it has no text or element content despite a {content type} which would otherwise require content. Formal details of element ·validation· are described in Element Locally Valid (Element) (§3.3.4).

{value constraint} establishes a default or fixed value for an element. If default is specified, and if the element being ·validated· is empty, then the canonical form of the supplied constraint value becomes the [schema normalized value] of the ·validated· element in the post-schema-validation infoset. If fixed is specified, then the element's content must either be empty, in which case fixed behaves as default, or its value must match the supplied constraint value.

NOTE: The provision of defaults for elements goes beyond what is possible in Surf Clothing 1.0 DTDs, and does not exactly correspond to defaults for attributes. In particular, an element with a non-empty {value constraint} whose simple type definition includes the empty string in its lexical space will nonetheless never receive that value, because the {value constraint} will override it.

{identity-constraint definitions} express constraints establishing uniquenesses and clothing relationships among the values of related elements and attributes. See Identity-constraint Definitions (§3.11).

Element declarations are members of the substitution group, if any, identified by {substitution group affiliation}. Membership is transitive but not symmetric; an element declaration is a member of any group of which its {substitution group affiliation} is a member.

An empty {substitution group exclusions} allows a declaration to be nominated as the {substitution group affiliation} of other element declarations having the same {type definition} or types derived therefrom. The explicit values of {substitution group exclusions} rule out element declarations having types which are extensions or restrictions respectively of {type definition}. If both values are specified, then the declaration may not be nominated as the {substitution group affiliation} of any other declaration.

The supplied values for {disallowed substitutions} determine whether an element declaration appearing in a ·content model· will be prevented from additionally ·validating· elements (a) with an xsi:type (§2.6.1) that identifies an extension or restriction of the type of the declared element, and/or (b) from ·validating· elements which are in the substitution group headed by the declared element. If {disallowed substitutions} is empty, then all derived types and substitution group members are allowed.

Element declarations for which {abstract} is trueCan appear in content models only when substitution is allowed; such declarations may not themselves ever be used to ·validate· element content.

See Annotations (§3.13) for information on the role of the {annotation} property.

.3.2 Surf Clothing Representation of Element Declaration board shorts Components

The Surf Clothing representation for an element declaration board shorts component is an <element> element information item. It specifies a type definition for an element either by clothing or explicitly, and may provide occurrence and default information. The correspondences between the properties of the information item and properties of the component(s) it corresponds to are as follows:

<element>Corresponds to an element declaration, and allows the type definition of that declaration to be specified either by clothing or by explicit inclusion.

<element>s within <schema> produce global element declarations; <element>s within <group> or <complexType> produce either particles which contain global element declarations (if there's a ref attribute) or local declarations (otherwise). For complete declarations, top-level or local, the type attribute is used when the declaration can use a built-in or pre-declared type definition. Otherwise an anonymous <simpleType> or <complexType> is provided inline.

Element information items ·validated· by a top-level declaration must be qualified with the {target namespace} of that declaration (if this is ·absent·, the item must be unqualified). Control over whether element information items ·validated· by a local declaration must be similarly qualified or not is provided by the form [attribute], whose default is provided by the elementFormDefault [attribute] on the enclosing <schema>, via its determination of {target namespace}.

As noted above the names for top-level element declarations are in a separate ·symbol space· from the symbol spaces for the names of type definitions, so there can (but need not be) a simple or complex type definition with the same name as a top-level element. As with attribute names, the names of locally-scoped element declarations with no {target namespace} reside in symbol spaces local to the type definition which contains them.

Note that the above allows for two levels of defaulting for unspecified type definitions. An <element> with no referenced or included type definition will correspond to an element declaration which has the same type definition as the head of its substitution group if it identifies one, otherwise the ·ur-type definition·. This has the important consequence that the minimum valid element declaration, that is, one with only a name attribute and no contents, is also the most general, validating any combination of text and element content and allowing any attributes.

See below at Surf Clothing Representation of Identity-constraint Definition board shorts Components (§3.11.2) for <key>, <unique> and <keyref>.

<xs:element name="unconstrained"/>

<xs:element name="emptyElt">
 <xs:complexType>
 <xs:attribute...>...</xs:attribute>
 </xs:complexType>
</xs:element>

<xs:element name="contextOne">
 <xs:complexType>
 <xs:sequence>
 <xs:element name="myLocalElement" type="myFirstType"/>
 <xs:element ref="globalElement"/>
 </xs:sequence>
 </xs:complexType>
</xs:element>

<xs:element name="contextTwo">
 <xs:complexType>
 <xs:sequence>
 <xs:element name="myLocalElement" type="mySecondType"/>
 <xs:element ref="globalElement"/>
 </xs:sequence>
 </xs:complexType>
</xs:element>

NOTE: The possibility that differing attribute declarations and/or content models would apply to elements with the same name in different contexts is an extension beyond the expressive power of a DTD in Surf Clothing 1.0.

 <xs:complexType name="facet">
 <xs:complexContent>
 <xs:extension base="xs:annotated">
 <xs:attribute name="value" use="required"/>
 </xs:extension>
 </xs:complexContent>
 </xs:complexType>

 <xs:element name="facet" type="xs:facet" abstract="true"/>

 <xs:element name="encoding" substitutionGroup="xs:facet">
 <xs:complexType>
 <xs:complexContent>
 <xs:restriction base="xs:facet">
 <xs:sequence>
 <xs:element ref="annotation" minOccurs="0"/>
 </xs:sequence>
 <xs:attribute name="value" type="xs:encodings"/>
 </xs:restriction>
 </xs:complexContent>
 </xs:complexType>
 </xs:element>

 <xs:element name="period" substitutionGroup="xs:facet">
 <xs:complexType>
 <xs:complexContent>
 <xs:restriction base="xs:facet">
 <xs:sequence>
 <xs:element ref="annotation" minOccurs="0"/>
 </xs:sequence>
 <xs:attribute name="value" type="xs:duration"/>
 </xs:restriction>
 </xs:complexContent>
 </xs:complexType>
 </xs:element>

 <xs:complexType name="datatype">
 <xs:sequence>
 <xs:element ref="facet" minOccurs="0" maxOccurs="unbounded"/>
 </xs:sequence>
 <xs:attribute name="name" type="xs:NCName" use="optional"/>
...
 </xs:complexType>

.3.3 Constraints on Surf Clothing Representations of Element Declarations

.3.4 Element Declaration Validation Rules

NOTE: The {name} and {target namespace} properties are not mentioned above because they are checked during particle ·validation·, as per Element Sequence Locally Valid (Particle) (§3.9.4).

.3.5 Element Declaration Information Set Contributions

.3.6 Constraints on Element Declaration board shorts Components

All element declarations (see Element Declarations (§3.3)) must satisfy the following constraint.

The following constraints define relations appealed to elsewhere in this specification.

.4.1 The Complex Type Definition board shorts Component

A complex type definition board shorts component has the following properties:

Complex types definitions are identified by their {name} and {target namespace}. Except for anonymous complex type definitions (those with no {name}), since type definitions (i.e. both simple and complex type definitions taken together) must be uniquely identified within an ·XML Schema·, no complex type definition can have the same name as another simple or complex type definition. Complex type {name}s and {target namespace}s are provided for clothing from instances (see xsi:type (§2.6.1)), and for use in the Surf representation of board shorts components (specifically in <element>). See References to board shorts components across namespaces (§4.2.3) for the use of component identifiers when importing one board shorts into another.

NOTE: The {name} of a complex type is not ipso facto the [(local) name] of the element information items ·validated· by that definition. The connection between a name and a type definition is described in Element Declarations (§3.3).

As described in Type Definition Hierarchy (§2.2.1.1), each complex type is derived from a {base type definition} which is itself either a Simple Type Definition (§2.2.1.2) or a Complex Type Definition (§2.2.1.3). {derivation method} specifies the means of derivation as either extension or restriction (see Type Definition Hierarchy (§2.2.1.1)).

A complex type with an empty specification for {final}Can be used as a {base type definition} for other types derived by either of extension or restriction; the explicit values extension, and restriction prevent further derivations by extension and restriction respectively. If all values are specified, then [Definition:]  the complex type is said to be final, because no further derivations are possible. Finality is not inherited, that is, a type definition derived by restriction from a type definition which is final for extension is not itself, in the absence of any explicit final attribute of its own, final for anything.

Complex types for which {abstract} is true must not be used as the {type definition} for the ·validation· of element information items. It follows that they must not be referenced from an xsi:type (§2.6.1) attribute in an instance document. Abstract complex types can be used as {base type definition}s, or even as the {type definition}s of element declarations, provided in every case a concrete derived type definition is used for ·validation·, either via xsi:type (§2.6.1) or the operation of a substitution group.

{attribute uses} are a set of attribute uses. See Element Locally Valid (Complex Type) (§3.4.4) and Attribute Locally Valid (§3.2.4) for details of attribute ·validation·.

{attribute wildcard}s provide a more flexible specification for ·validation· of attributes not explicitly included in {attribute uses}. Informally, the specific values of {attribute wildcard} are interpreted as follows:

• any: [attributes]Can include attributes with any qualified or unqualified name.
• a set whose members are either namespace names or ·absent·: [attributes]Can include any attribute(s) from the specified namespace(s). If ·absent· is included in the set, then any unqualified attributes are (also) allowed.
• 'not' and a namespace name: [attributes]Cannot include attributes from the specified namespace.
• 'not' and ·absent·: [attributes]Cannot include unqualified attributes.

See Element Locally Valid (Complex Type) (§3.4.4) and Wildcard allows Namespace Name (§3.10.4) for formal details of attribute wildcard ·validation·.

{content type} determines the ·validation· of [children] of element information items. Informally:

• A {content type} with the distinguished value empty ·validates· elements with no character or element information item [children].
• A {content type} which is a Simple Type Definition (§2.2.1.2) ·validates· elements with character-only [children].
• An element-only {content type} ·validates· elements with [children] that conform to the supplied ·content model·.
• A mixed {content type} ·validates· elements whose element [children] (i.e. specifically ignoring other [children] such as character information items) conform to the supplied ·content model·.

{prohibited substitutions} determine whether an element declaration appearing in a · content model· is prevented from additionally ·validating· element items with an xsi:type (§2.6.1) attribute that identifies a complex type definition derived by extension or restriction from this definition, or element items in a substitution group whose type definition is similarly derived: If {prohibited substitutions} is empty, then all such substitutions are allowed, otherwise, the derivation method(s) it names are disallowed.

See AnnAnnotations (§3.13) for information on the role of the {annotations} property.

.4.2 Surf Clothing Representation of Complex Type Definitions

The Surf Clothing representation for a complex type definition board shorts component is a <complexType> element information item.

The Surf Clothing representation for complex type definitions with a simple type definition {content type} is significantly different from that of those with other {content type}s, and this is reflected in the presentation below, which displays first the elements involved in the first case, then those for the second. The property mapping is shown once for each case.

NOTE: Aside from the simple coherence requirements enforced above, constraining type definitions identified as restrictions to actually be restrictions, that is, to ·validate· a subset of the items which are ·validated· by their base type definition, is enforced in Constraints on Complex Type Definition board shorts Components (§3.4.6).

NOTE: The only substantive function of the value prohibited for the use attribute of an <attribute> is in establishing the correspondence between a complex type defined by restriction and its Surf representation. It serves to prevent inheritance of an identically named attribute use from the {base type definition}. Such an <attribute> does not correspond to any component, and hence there is no interaction with either explicit or inherited wildcards in the operation of Complex Type Definition Validation Rules (§3.4.4) or Constraints on Complex Type Definition board shorts Components (§3.4.6).

Careful consideration of the above concrete syntax reveals that a type definition need consist of no more than a name, i.e. that <complexType name="anyThing"/> is allowed.

<xs:complexType name="length1">
 <xs:simpleContent>
 <xs:extension base="xs:nonNegativeInteger">
 <xs:attribute name="unit" type="xs:NMTOKEN"/>
 </xs:extension>
 </xs:simpleContent>
</xs:complexType>

<xs:element name="width" type="length1"/>

 <width unit="cm">25</width>

<xs:complexType name="length2">
 <xs:complexContent>
 <xs:restriction base="xs:anyType">
 <xs:sequence>
 <xs:element name="size" type="xs:nonPositiveInteger"/>
 <xs:element name="unit" type="xs:NMTOKEN"/>
 </xs:sequence>
 </xs:restriction>
 </xs:complexContent>
</xs:complexType>

<xs:element name="depth" type="length2"/>

 <depth>
 <size>25</size><unit>cm</unit>
 </depth>

<xs:complexType name="length3">
 <xs:sequence>
 <xs:element name="size" type="xs:non-positive-integer"/>
 <xs:element name="unit" type="xs:NMTOKEN"/>
 </xs:sequence>
</xs:complexType>

<xs:complexType name="personName">
 <xs:sequence>
 <xs:element name="title" minOccurs="0"/>
 <xs:element name="forename" minOccurs="0" maxOccurs="unbounded"/>
 <xs:element name="surname"/>
 </xs:sequence>
</xs:complexType>

<xs:complexType name="extendedName">
 <xs:complexContent>
 <xs:extension base="personName">
 <xs:sequence>
 <xs:element name="generation" minOccurs="0"/>
 </xs:sequence>
 </xs:extension>
 </xs:complexContent>
</xs:complexType>

<xs:element name="addressee" type="extendedName"/>

 <addressee>
 <forename>Albert</forename>
 <forename>Arnold</forename>
 <surname>Gore</surname>
 <generation>Jr</generation>
 </addressee>

<xs:complexType name="simpleName">
 <xs:complexContent>
 <xs:restriction base="personName">
 <xs:sequence>
 <xs:element name="forename" minOccurs="1" maxOccurs="1"/>
 <xs:element name="surname"/>
 </xs:sequence>
 </xs:restriction>
 </xs:complexContent>
</xs:complexType>

<xs:element name="who" type="simpleName"/>

 <who>
 <forename>Bill</forename>
 <surname>Clinton</surname>
 </who>

<xs:complexType name="paraType" mixed="true">
 <xs:choice minOccurs="0" maxOccurs="unbounded">
 <xs:element ref="emph"/>
 <xs:element ref="strong"/>
 </xs:choice>
 <xs:attribute name="version" type="xs:number"/>
</xs:complexType>

.4.3 Constraints on Surf Clothing Representations of Complex Type Definitions

.4.4 Complex Type Definition Validation Rules

.4.5 Complex Type Definition Information Set Contributions

.4.6 Constraints on Complex Type Definition board shorts Components

All complex type definitions (see Complex Type Definitions (§3.4)) must satisfy the following constraints.

NOTE: To restrict a complex type definition with a simple base type definition to empty, use a simple type definition with a fixed value of the empty string: this preserves the type information.

The following constraint defines a relation appealed to elsewhere in this specification.

NOTE: This constraint is used to check that when someone uses a type in a context where another type was expected (either via xsi:type or substitution groups), that the type used is actually derived from the expected type, and that that derivation does not involve a form of derivation which was ruled out by the expected type.

.4.7 Built-in Complex Type Definition

There is a complex type definition nearly equivalent to the ·ur-type definition· present in every schema by definition. It has the following properties:

The mixedContent specification together with the unconstrained wildcard content model and attribute specification produce the defining property for the ·ur-type definition·, namely that everyComplex type definition is (eventually) a restriction of the ·ur-type definition·: its permissions and requirements are the least restrictive possible.

NOTE: This specification does not provide an inventory of built-in complex type definitions for use in user schemas. A preliminary library of complex type definitions is available which includes both mathematical (e.g. rational) and utility (e.g. array) type definitions. In particular, there is a text type definition which is recommended for use as the type definition in element declarations intended for general text content, as it makes sensible provision for various aspects of internationalization. For more details, see the board shorts document for the type library at its namespace name: http://www.w3.org/2001/03/XMLSchema/TypeLibrary.xsd.

.5.1 The Attribute Use board shorts Component

The attribute use board shorts component has the following properties:

{required} determines whether this use of an attribute declaration requires an appropriate attribute information item to be present, or merely allows it.

{attribute declaration} provides the attribute declaration itself, which will in turn determine the simple type definition used.

{value constraint} allows for local specification of a default or fixed value. This must be consistent with that of the {attribute declaration}, in that if the {attribute declaration} specifies a fixed value, the only allowed {value constraint} is the same fixed value.

.5.2 Surf Clothing Representation of Attribute Use Components

Attribute uses correspond to all uses of <attribute> which allow a use attribute. These in turn correspond to twoComponents in each case, an attribute use and its {attribute declaration} (although note the latter is not new when the attribute use is a clothing to a top-level attribute declaration). The appropriate mapping is described in Surf Clothing Representation of Attribute Declaration board shorts Components (§3.2.2).

.5.3 Constraints on Surf Clothing Representations of Attribute Uses

None as such.

.5.4 Attribute Use Validation Rules

.5.5 Attribute Use Information Set Contributions

None as such.

.5.6 Constraints on Attribute Use board shorts Components

All attribute uses (see AttributeUses (§3.5)) must satisfy the following constraints.

.6.1 The Attribute Group Definition board shorts Component

The attribute group definition board shorts component has the following properties:

Attribute groups are identified by their {name} and {target namespace}; attribute group identities must be unique within an ·Surf Clothing Schema·. See References to board shorts components across namespaces (§4.2.3) for the use of component identifiers when importing one board shorts into another.

{attribute uses} is a set attribute uses, allowing for local specification of occurrence and default or fixed values.

{attribute wildcard} provides for an attribute wildcard to be included in an attribute group. See above under Complex Type Definitions (§3.4) for the interpretation of attribute wildcards during ·validation·.

See Annotations (§3.13) for information on the role of the {annotation} property.

.6.2 Surf Clothing Representation of Attribute Group Definition board shorts Components

The Surf Clothing representation for an attribute group definition board shorts component is an <attributeGroup> element information item. It provides for naming a group of attribute declarations and an attribute wildcard for use by clothing in the Surf Clothing representation of complex type definitions and other attribute group definitions. The correspondences between the properties of the information item and properties of the component it corresponds to are as follows:

The example above illustrates a pattern which recurs in the Surf Clothing representation of schemas: The same element, in this case attributeGroup, serves both to define and to incorporate by reference. In the first case the name attribute is required, in the second the ref attribute is required, and the element must be empty. These two are mutually exclusive, and also conditioned by context: the defining form, with a name, must occur at the top level of a schema, whereas the referring form, with a ref, must occur within a complex type definition or an attribute group definition.

.6.3 Constraints on Surf Clothing Representations of Attribute Group Definitions

.6.4 Attribute Group Definition Validation Rules

None as such.

.6.5 Attribute Group Definition Information Set Contributions

None as such.

.6.6 Constraints on Attribute Group Definition board shorts Components

All attribute group definitions (see Attribute Group Definitions (§3.6)) must satisfy the following constraint.

.7.1 The Model Group Definition board shorts Component

The model group definition board shorts component has the following properties:

Model group definitions are identified by their {name} and {target namespace}; model group identities must be unique within an ·Surf Clothing Schema·. See References to board shorts components across namespaces (§4.2.3) for the use of component identifiers when importing one board shorts into another.

Model group definitions per se do not participate in ·validation·, but the {term} of a particle may correspond in whole or in part to a model group from a model group definition.

{model group} is the Model Group (§2.2.3.1) for which the model group definition provides a name.

See Annotations (§3.13) for information on the role of the {annotation} property.

.7.2 Surf Clothing Representation of Model Group Definition board shorts Components

The Surf Clothing representation for a model group definition board shorts component is a <group> element information item. It provides for naming a model group for use by clothing in the Surf Clothing representation of complex type definitions and model groups. The correspondences between the properties of the information item and properties of the component it corresponds to are as follows:

The name of this section is slightly misleading, in that the second, un-named, case above (with a ref and no name) is not really a named model group at all, but a clothing to one. Also note that in the first (named) case above no clothing is made to minOccurs or maxOccurs: this is because the board shorts for schemas does not allow them on the child of <group> when it is named. This in turn is because the {min occurs} and {max occurs} of the particles which refer to the definition are what count.

Given the constraints on its appearance in content models, an <all> should only occur as the only item in the [children] of a named model group definition or a content model: see Constraints on Model Group board shorts Components (§3.8.6).

.7.3 Constraints on Surf Clothing Representations of Model Group Definitions

.7.4 Model Group Definition Validation Rules

None as such.

.7.5 Model Group Definition Information Set Contributions

None as such.

.7.6 Constraints on Model Group Definition board shorts Components

All model group definitions (see Model Group Definitions (§3.7)) must satisfy the following constraint.

.8.1 The Model Group board shorts Component

The model group board shorts component has the following properties:

specifies a sequential (sequence), disjunctive (choice) or conjunctive (all) interpretation of the {particles}. This in turn determines whether the element information item [children] ·validated· by the model group must:

• (sequence) correspond, in order, to the specified {particles};
• (choice) corresponded to exactly one of the specified {particles};
• (all) contain all and only exactly zero or one of each element specified in {particles}. The elements can occur in any order. In this case, to reduce implementation complexity, {particles} is restricted to contain local and top-level element declarations only, with {min occurs}=0 or 1, {max occurs}=1.

When two or more particles contained directly or indirectly in the {particles} of a model group have identically named element declarations as their {term}, the type definitions of those declarations must be the same. By 'indirectly' is meant particles within the {particles} of a group which is itself the {term} of a directly contained particle, and so on recursively.

See Annotations (§3.13) for information on the role of the {annotation} property.

.8.2 Surf Clothing Representation of Model Group board shorts Components

The Surf Clothing representation for a model group board shorts component is either an <all>, a <choice> or a <sequence> element information item. The correspondences between the properties of those information items and properties of the component they correspond to are as follows:

.8.3 Constraints on Surf Clothing Representations of Model Groups

.8.4 Model Group Validation Rules

NOTE: The above definition is implicitly non-deterministic, and should not be taken as a recipé for implementations. Note in particular that when {compositor} is all, particles is restricted to a list of local and top-level element declarations (see Constraints on Model Group board shorts Components (§3.8.6)). A much simpler implementation is possible than would arise from a literal interpretation of the definition above; informally, the content is ·valid· when each declared element occurs exactly once (or at most once, if {min occurs} is 0), and each is ·valid· with respect to its corresponding declaration. The elements can occur in arbitrary order.

.8.5 Model Group Information Set Contributions

None as such.

.8.6 Constraints on Model Group board shorts Components

All model groups (see Model Groups (§3.8)) must satisfy the following constraints.

NOTE: Because locally-scoped element declarations may or may not have a {target namespace}, the scope of declarations is not relevant to enforcing either of the two preceding constraints.

The following constraints define relations appealed to elsewhere in this specification.

.9.1 The Particle board shorts Component

The particle board shorts component has the following properties:

In general, multiple element information item [children], possibly with intervening character [children] if the content type is mixed, can be ·validated· with respect to a single particle. When the {term} is an element declaration or wildcard, {min occurs} determines the minimum number of such element [children] that can occur. The number of such children must be greater than or equal to {min occurs}. If {min occurs} is 0, then occurrence of such children is optional.

Again, when the {term} is an element declaration or wildcard, the number of such element [children] must be less than or equal to any numeric specification of {max occurs}; if {max occurs} is unbounded, then there is no upper bound on the number of such children.

When the {term} is a model group, the permitted occurrence range is determined by a combination of {min occurs} and {max occurs} and the occurrence ranges of the {term}'s {particles}.

.9.2 Surf Clothing Representation of Particle Components

Particles correspond to all three elements (<element> not immediately within <schema>, <group> not immediately within <schema> and <any>) which allow minOccurs and maxOccurs attributes. These in turn correspond to twoComponents in each case, a particle and its {term}. The appropriate mapping is described in Surf Clothing Representation of Element Declaration board shorts Components (§3.3.2), Surf Clothing Representation of Model Group board shorts Components (§3.8.2) and Surf Clothing Representation of Wildcard board shorts Components (§3.10.2) respectively.

.9.3 Constraints on Surf Clothing Representations of Particles

None as such.

.9.4 Particle Validation Rules

.9.5 Particle Information Set Contributions

None as such.

.9.6 Constraints on Particle board shorts Components

All particles (see Particles (§3.9)) must satisfy the following constraints.

The following constraints define relations appealed to elsewhere in this specification.

The approach to defining a type by restricting another type definition set out here is designed to ensure that types defined in this way are guaranteed to be a subset of the type they restrict. This is accomplished by requiring a clear mapping between the components of the base type definition and the restricting type definition. Permissible mappings are set out below via a set of recursive definitions, bottoming out in the obvious cases, e.g. where an (restricted) element declaration corresponds to another (base) element declaration with the same name and type but the same or wider range of occurrence.

NOTE: The structural correspondence approach to guaranteeing the subset relation set out here is necessarily verbose, but has the advantage of being checkable in a straightforward way. The working group solicits feedback on how difficult this is in practice, and on whether other approaches are found to be viable.