Package org.apache.ws.jaxme.xs.xml.impl

Contains an implementation of the JaxMeXS schema object model type.

Class Summary

XsAGDefRefImplImplementation of the attribute group xs:defRef, as specified by the following:
  <xs:attributeGroup name="defRef">
    <xs:annotation>
      <xs:documentation>
        for element, group and attributeGroup,
        which both define and reference
      </xs:documentation>
    </xs:annotation>
    <xs:attribute name="name" type="xs:NCName"/>
    <xs:attribute name="ref" type="xs:QName"/>
  </xs:attributeGroup>
 

Implementation note: The 'name' and 'ref' attributes are mutually exclusive.

XsAGOccursImplImplementation of the attribute group xs:occurs, as specified by the following:
  <xs:attributeGroup name="occurs">
    <xs:annotation>
      <xs:documentation>
        for all particles
      </xs:documentation>
    </xs:annotation>
    <xs:attribute name="minOccurs" type="xs:nonNegativeInteger"
      use="optional" default="1"/>
    <xs:attribute name="maxOccurs" type="xs:allNNI"
      use="optional" default="1"/>
  </xs:attributeGroup>
 

Implementation note: The implementation must ensure that either 'maxOccurs' is unbounded or 'minOccurs' <= 'maxOccurs'.

XsEAnnotationImplImplementation of xs:annotation, as specified by the following:
  <xs:element name="annotation" id="annotation">
    <xs:annotation>
      <xs:documentation source="http://www.w3.org/TR/xmlschema-1/#element-annotation"/>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="xs:openAttrs">
          <xs:choice minOccurs="0" maxOccurs="unbounded">
            <xs:element ref="xs:appinfo"/>
            <xs:element ref="xs:documentation"/>
          </xs:choice>
          <xs:attribute name="id" type="xs:ID"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
 
XsEAnyImplImplementation of the xs:any element, as specified by the following:
  <xs:element name="any" id="any">
    <xs:annotation>
      <xs:documentation source="http://www.w3.org/TR/xmlschema-1/#element-any"/>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="xs:wildcard">
          <xs:attributeGroup ref="xs:occurs"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
 
XsEAppinfoImplImplementation of xs:appinfo, as specified by the following:
  <xs:element name="appinfo" id="appinfo">
    <xs:annotation>
      <xs:documentation source="http://www.w3.org/TR/xmlschema-1/#element-appinfo"/>
    </xs:annotation>
    <xs:complexType mixed="true">
      <xs:sequence minOccurs="0" maxOccurs="unbounded">
        <xs:any processContents="lax"/>
      </xs:sequence>
      <xs:attribute name="source" type="xs:anyURI"/>
    </xs:complexType>
  </xs:element>
 
XsEChoiceImplImplementation of the xs:choice element, with the following specification:
  <xs:element name="choice" type="xs:explicitGroup" id="choice">
    <xs:annotation>
      <xs:documentation source="http://www.w3.org/TR/xmlschema-1/#element-choice"/>
    </xs:annotation>
  </xs:element>
 
XsEComplexContentImplImplementation of the element xs:complexContent, as specified by:
  <xs:element name="complexContent" id="complexContent">
    <xs:annotation>
      <xs:documentation
          source="http://www.w3.org/TR/xmlschema-1/#element-complexContent"/>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="xs:annotated">
          <xs:choice>
            <xs:element name="restriction" type="xs:complexRestrictionType"/>
            <xs:element name="extension" type="xs:extensionType"/>
          </xs:choice>
          <xs:attribute name="mixed" type="xs:boolean">
            <xs:annotation>
              <xs:documentation>
                Overrides any setting on complexType parent.
XsEDocumentationImplImplementation of xs:documentation, as specified by the following:
  <xs:element name="documentation" id="documentation">
    <xs:annotation>
      <xs:documentation source="http://www.w3.org/TR/xmlschema-1/#element-documentation"/>
    </xs:annotation>
    <xs:complexType mixed="true">
      <xs:sequence minOccurs="0" maxOccurs="unbounded">
        <xs:any processContents="lax"/>
      </xs:sequence>
      <xs:attribute name="source" type="xs:anyURI"/>
      <xs:attribute ref="xml:lang"/>
    </xs:complexType>
  </xs:element>
 
XsEEnumerationImplImplementation of xs:enumeration, following this specification:
  <xs:element name="enumeration" id="enumeration" type="xs:noFixedFacet">
    <xs:annotation>
      <xs:documentation
        source="http://www.w3.org/TR/xmlschema-2/#element-enumeration"/>
    </xs:annotation>
  </xs:element>
 
XsEFieldImplInterface of the xs:field element, with the following specification:
   
     
       
     
     
       
         
           
             
               
                 
                   A subset of XPath expressions for use in fields
                 
                 
                   A utility type, not for public use
                 
               
               
                 
                   
                     The following pattern is intended to allow XPath
                     expressions per the same EBNF as for selector,
                     with the following change:
                       Path    ::=    ('.//')? ( Step '/' )* ( Step | '@' NameTest ) 
                   
                 
                 
                 
               
             
           
         
       
     
   
 
XsEFractionDigitsImplImplementation of xs:fractionDigits, following this specification:
  <xs:element name="fractionDigits" id="fractionDigits" type="xs:numFacet">
    <xs:annotation>
      <xs:documentation
        source="http://www.w3.org/TR/xmlschema-2/#element-fractionDigits"/>
    </xs:annotation>
  </xs:element>
 
XsEImportImplImplementation of xs:import, as specified by the following:
  <xs:element name="import" id="import">
    <xs:annotation>
      <xs:documentation source="http://www.w3.org/TR/xmlschema-1/#element-import"/>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="xs:annotated">
          <xs:attribute name="namespace" type="xs:anyURI"/>
          <xs:attribute name="schemaLocation" type="xs:anyURI"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
 
XsEIncludeImplImplementation of xs:include, as specified by the following declaration:
  <xs:element name="include" id="include">
    <xs:annotation>
      <xs:documentation source="http://www.w3.org/TR/xmlschema-1/#element-include"/>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="xs:annotated">
          <xs:attribute name="schemaLocation" type="xs:anyURI" use="required"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
 
XsEKeyImplImplementation of the xs:key element, specified as follows:
  <xs:element name="key" type="xs:keybase" id="key">
    <xs:annotation>
      <xs:documentation source="http://www.w3.org/TR/xmlschema-1/#element-key"/>
    </xs:annotation>
  </xs:element>
 
XsEKeyrefImplImplementation of the xs:keyref element, with the following specification:
  
    
      
    
    
      
        
          
        
      
    
  
 
XsELengthImplImplementation of xs:length, following this specification:
  <xs:element name="length" id="length" type="xs:numFacet">
    <xs:annotation>
      <xs:documentation
        source="http://www.w3.org/TR/xmlschema-2/#element-length"/>
    </xs:annotation>
  </xs:element>
 
XsEListImplImplementation of xs:list, following the specification below:
  <xs:element name="list" id="list">
    <xs:complexType>
      <xs:annotation>
        <xs:documentation
            source="http://www.w3.org/TR/xmlschema-2/#element-list">
          itemType attribute and simpleType child are mutually
          exclusive, but one or other is required
        </xs:documentation>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="xs:annotated">
          <xs:sequence>
            <xs:element name="simpleType" type="xs:localSimpleType"
                minOccurs="0"/>
          </xs:sequence>
          <xs:attribute name="itemType" type="xs:QName" use="optional"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
 
XsEMaxExclusiveImplImplementation of xs:maxExclusive, following this specification:
  <xs:element name="maxExclusive" id="maxExclusive" type="xs:facet">
    <xs:annotation>
      <xs:documentation
        source="http://www.w3.org/TR/xmlschema-2/#element-maxExclusive"/>
    </xs:annotation>
  </xs:element>
 
XsEMaxInclusiveImplImplementation of xs:maxInclusive, following this specification:
  <xs:element name="maxInclusive" id="maxInclusive" type="xs:facet">
    <xs:annotation>
      <xs:documentation
        source="http://www.w3.org/TR/xmlschema-2/#element-maxInclusive"/>
    </xs:annotation>
  </xs:element>
 
XsEMaxLengthImplImplementation of xs:maxLength, following this specification:
  
    
      
    
  
 
XsEMinExclusiveImplImplementation of xs:minExclusive, following this specification:
  <xs:element name="minExclusive" id="minExclusive" type="xs:facet">
    <xs:annotation>
      <xs:documentation
        source="http://www.w3.org/TR/xmlschema-2/#element-minExclusive"/>
    </xs:annotation>
  </xs:element>
 
XsEMinInclusiveImplImplementation of xs:minInclusive, following this specification:
  
    
      
    
  
 
XsEMinLengthImplImplementation of xs:minLength, following this specification:
  <xs:element name="minLength" id="minLength" type="xs:numFacet">
    <xs:annotation>
      <xs:documentation
        source="http://www.w3.org/TR/xmlschema-2/#element-minLength"/>
    </xs:annotation>
  </xs:element>
 
XsENotationImplInterface of the xs:notation element, with the following specification:
  
    
      
    
    
      
        
          
          
          
        
      
    
  
 
XsEPatternImplImplementation of xs:pattern, following this specification:
  <xs:element name="pattern" id="pattern" type="xs:noFixedFacet">
    <xs:annotation>
      <xs:documentation
        source="http://www.w3.org/TR/xmlschema-2/#element-pattern"/>
    </xs:annotation>
  </xs:element>
 
XsERedefineImplImplementation of xs:redefine, as specified by the following:
  <xs:element name="redefine" id="redefine">
    <xs:annotation>
      <xs:documentation source="http://www.w3.org/TR/xmlschema-1/#element-redefine"/>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="xs:openAttrs">
          <xs:choice minOccurs="0" maxOccurs="unbounded">
            <xs:element ref="xs:annotation"/>
            <xs:group ref="xs:redefinable"/>
          </xs:choice>
          <xs:attribute name="schemaLocation" type="xs:anyURI" use="required"/>
          <xs:attribute name="id" type="xs:ID"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
 
XsERestrictionImplImplementation of xs:restriction, following this specification:
  <xs:element name="restriction" id="restriction">
    <xs:complexType>
      <xs:annotation>
        <xs:documentation
            source="http://www.w3.org/TR/xmlschema-2/#element-restriction">
          base attribute and simpleType child are mutually
          exclusive, but one or other is required
        </xs:documentation>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="xs:annotated">
          <xs:group ref="xs:simpleRestrictionModel"/>
          <xs:attribute name="base" type="xs:QName" use="optional"/>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>

  <xs:group name="simpleRestrictionModel">
    <xs:sequence>
      <xs:element name="simpleType" type="xs:localSimpleType" minOccurs="0"/>
      <xs:group ref="xs:facets" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:group>

  <xs:group name="facets">
    <xs:annotation>
      <xs:documentation>
        We should use a substitution group for facets, but
        that's ruled out because it would allow users to
        add their own, which we're not ready for yet.
XsESchemaImplImplementation of xs:schema.
XsESelectorImplInterface of the xs:selector element, specified by the following:
   
     
       
     
     
       
         
           
             
               
                 
                   A subset of XPath expressions for use
                   in selectors
                 
                 
                   A utility type, not for public use
                 
               
               
                 
                   
                     The following pattern is intended to allow XPath
                     expressions per the following EBNF:
                       Selector    ::=    Path ( '|' Path )*
                       Path        ::=    ('.//')? Step ( '/' Step )*
                       Step    ::=    '.' | NameTest
                       NameTest    ::=    QName | '*' | NCName ':' '*'
                                          child:: is also allowed
                   
                 
                 
                 
               
             
           
         
       
     
   
 
XsESequenceImplImplementation of the xs:sequence element, with the following specification:
  <xs:element name="sequence" type="xs:explicitGroup" id="sequence">
    <xs:annotation>
      <xs:documentation source="http://www.w3.org/TR/xmlschema-1/#element-sequence"/>
    </xs:annotation>
  </xs:element>
 
XsESimpleContentImplImplementation of xs:simpleContent, as specified by the following:
  <xs:element name="simpleContent" id="simpleContent">
    <xs:annotation>
      <xs:documentation source="http://www.w3.org/TR/xmlschema-1/#element-simpleContent"/>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:extension base="xs:annotated">
          <xs:choice>
            <xs:element name="restriction" type="xs:simpleRestrictionType"/>
            <xs:element name="extension" type="xs:simpleExtensionType"/>
          </xs:choice>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
 
XsETopLevelSimpleTypeImplImplementation of xs:simpleType>, as specified by the following:
  <xs:element name="simpleType" type="xs:topLevelSimpleType" id="simpleType">
    <xs:annotation>
      <xs:documentation
        source="http://www.w3.org/TR/xmlschema-2/#element-simpleType"/>
    </xs:annotation>
  </xs:element>

  <xs:complexType name="topLevelSimpleType">
    <xs:complexContent>
      <xs:restriction base="xs:simpleType">
        <xs:sequence>
          <xs:element ref="xs:annotation" minOccurs="0"/>
          <xs:group ref="xs:simpleDerivation"/>
        </xs:sequence>
        <xs:attribute name="name" use="required" type="xs:NCName">
          <xs:annotation>
            <xs:documentation>
              Required at the top level
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:restriction>
    </xs:complexContent>
  </xs:complexType>
 
XsETotalDigitsImplImplementation of xs:totalDigits, following this specification:
  <xs:element name="totalDigits" id="totalDigits">
    <xs:annotation>
      <xs:documentation
        source="http://www.w3.org/TR/xmlschema-2/#element-totalDigits"/>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:restriction base="xs:numFacet">
          <xs:sequence>
            <xs:element ref="xs:annotation" minOccurs="0"/>
          </xs:sequence>
          <xs:attribute name="value" type="xs:positiveInteger" use="required"/>
        </xs:restriction>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
 
XsEUnionImplImplementation of xs:union, following the specification below:
  <xs:element name="union" id="union">
    <xs:complexType>
      <xs:annotation>
        <xs:documentation
            source="http://www.w3.org/TR/xmlschema-2/#element-union">
          memberTypes attribute must be non-empty or there must be
          at least one simpleType child
        </xs:documentation>
      </xs:annotation>
      <xs:complexContent>
        <xs:extension base="xs:annotated">
          <xs:sequence>
            <xs:element name="simpleType" type="xs:localSimpleType"
                minOccurs="0" maxOccurs="unbounded"/>
          </xs:sequence>
          <xs:attribute name="memberTypes" use="optional">
            <xs:simpleType>
              <xs:list itemType="xs:QName"/>
            </xs:simpleType>
          </xs:attribute>
        </xs:extension>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
 
XsEUniqueImplImplementation of the xs:unique element, with the following specification:
  <xs:element name="unique" type="xs:keybase" id="unique">
    <xs:annotation>
      <xs:documentation source="http://www.w3.org/TR/xmlschema-1/#element-unique"/>
    </xs:annotation>
  </xs:element>
 
XsEWhiteSpaceImplImplementation of xs:whiteSpace, following this specification:
  <xs:element name="whiteSpace" id="whiteSpace">
    <xs:annotation>
      <xs:documentation
        source="http://www.w3.org/TR/xmlschema-2/#element-whiteSpace"/>
    </xs:annotation>
    <xs:complexType>
      <xs:complexContent>
        <xs:restriction base="xs:facet">
          <xs:sequence>
            <xs:element ref="xs:annotation" minOccurs="0"/>
          </xs:sequence>
          <xs:attribute name="value" use="required">
            <xs:simpleType>
              <xs:restriction base="xs:NMTOKEN">
                <xs:enumeration value="preserve"/>
                <xs:enumeration value="replace"/>
                <xs:enumeration value="collapse"/>
              </xs:restriction>
            </xs:simpleType>
          </xs:attribute>
        </xs:restriction>
      </xs:complexContent>
    </xs:complexType>
  </xs:element>
 
XsGAllModelImplImplementation of xs:allModel, as specified by the following:
  <xs:group name="allModel">
    <xs:sequence>
      <xs:element ref="xs:annotation" minOccurs="0"/>
      <xs:element name="element" minOccurs="0" maxOccurs="unbounded">
        <xs:complexType>
          <xs:annotation>
            <xs:documentation>restricted max/min</xs:documentation>
          </xs:annotation>
          <xs:complexContent>
            <xs:restriction base="xs:localElement">
              <xs:sequence>
                <xs:element ref="xs:annotation" minOccurs="0"/>
                <xs:choice minOccurs="0">
                  <xs:element name="simpleType" type="xs:localSimpleType"/>
                  <xs:element name="complexType" type="xs:localComplexType"/>
                </xs:choice>
                <xs:group ref="xs:identityConstraint" minOccurs="0"
                    maxOccurs="unbounded"/>
              </xs:sequence>
              <xs:attribute name="minOccurs" use="optional" default="1">
                <xs:simpleType>
                  <xs:restriction base="xs:nonNegativeInteger">
                    <xs:enumeration value="0"/>
                    <xs:enumeration value="1"/>
                  </xs:restriction>
                </xs:simpleType>
              </xs:attribute>
              <xs:attribute name="maxOccurs" use="optional" default="1">
                <xs:simpleType>
                  <xs:restriction base="xs:allNNI">
                    <xs:enumeration value="0"/>
                    <xs:enumeration value="1"/>
                  </xs:restriction>
                </xs:simpleType>
              </xs:attribute>
            </xs:restriction>
          </xs:complexContent>
        </xs:complexType>
       </xs:element>
    </xs:sequence>
  </xs:group>
 

Implementation note: The above restriction of a XsTLocalElement is interpreted as a usual local element, except that the minOccurs and maxOccurs attributes must be 0 or 1.

XsGAttrDeclsImplImplementation of xs:attrDecls, with the following specification:
  <xs:group name="attrDecls">
    <xs:sequence>
      <xs:choice minOccurs="0" maxOccurs="unbounded">
        <xs:element name="attribute" type="xs:attribute"/>
        <xs:element name="attributeGroup" type="xs:attributeGroupRef"/>
      </xs:choice>
      <xs:element ref="xs:anyAttribute" minOccurs="0"/>
    </xs:sequence>
  </xs:group>
 
XsGComplexTypeModelImplImplementation of the group xs:complexTypeModel, as specified by the following:
  <xs:group name="complexTypeModel">
    <xs:choice>
      <xs:element ref="xs:simpleContent"/>
      <xs:element ref="xs:complexContent"/>
      <xs:sequence>
        <xs:annotation>
          <xs:documentation>
            This branch is short for &lt;complexContent&gt;
            &lt;restriction base="xs:anyType"&gt;
            ...
XsGIdentityConstraintImplImplementation of the group xs:identityConstraint, specified as follows:
  
    
      
        The three kinds of identity constraints, all with
        type of or derived from 'keybase'.
XsGParticleImplImplementation of the xs:typeDefParticle group, as specified by the following:
  
    
      
        'complexType' uses this
      
    
    
      
      
      
      
    
  
 
XsGSimpleRestrictionModelImplInterface of xs:simpleRestrictionModel, following this specification:
  <xs:group name="simpleRestrictionModel">
    <xs:sequence>
      <xs:element name="simpleType" type="xs:localSimpleType" minOccurs="0"/>
      <xs:group ref="xs:facets" minOccurs="0" maxOccurs="unbounded"/>
    </xs:sequence>
  </xs:group>

  <xs:group name="facets">
    <xs:annotation>
      <xs:documentation>
        We should use a substitution group for facets, but
        that's ruled out because it would allow users to
        add their own, which we're not ready for yet.
XsGTypeDefParticleImplImplementation of the xs:typeDefParticle group, as specified by the following:
  
    
      
        'complexType' uses this
      
    
    
      
      
      
      
    
  
 
XsObjectFactoryImplThe XsObjectFactory, which allows to extend the parser.
XsObjectImplBase class for all the types, attributes, elements, ...
XsTAllImplImplementation of the following type:
   <xs:complexType name="all">
     <xs:annotation>
       <xs:documentation>
         Only elements allowed inside
       </xs:documentation>
     </xs:annotation>
     <xs:complexContent>
       <xs:restriction base="xs:explicitGroup">
         <xs:group ref="xs:allModel"/>
         <xs:attribute name="minOccurs" use="optional" default="1">
           <xs:simpleType>
             <xs:restriction base="xs:nonNegativeInteger">
               <xs:enumeration value="0"/>
               <xs:enumeration value="1"/>
             </xs:restriction>
           </xs:simpleType>
         </xs:attribute>
         <xs:attribute name="maxOccurs" use="optional" default="1">
           <xs:simpleType>
             <xs:restriction base="xs:allNNI">
               <xs:enumeration value="1"/>
             </xs:restriction>
           </xs:simpleType>
         </xs:attribute>
       </xs:restriction>
     </xs:complexContent>
   </xs:complexType>
 
XsTAnnotatedImplImplementation of an annotated element, as specified by the following:
  <xs:complexType name="annotated">
    <xs:annotation>
      <xs:documentation>
        This type is extended by all types which allow annotation
        other than <schema> itself.
XsTAttributeGroupImplImplementation of an xs:attributeGroup, with the following specification:
  <xs:complexType name="attributeGroup" abstract="true">
    <xs:complexContent>
      <xs:extension base="xs:annotated">
        <xs:group ref="xs:attrDecls"/>
        <xs:attributeGroup ref="xs:defRef"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
 
XsTAttributeGroupRefImplImplementation of the xs:attributeGroupRef type, specified as follows:
  <xs:complexType name="attributeGroupRef">
    <xs:complexContent>
      <xs:restriction base="xs:attributeGroup">
        <xs:sequence>
          <xs:element ref="xs:annotation" minOccurs="0"/>
        </xs:sequence>
        <xs:attribute name="ref" use="required" type="xs:QName"/>
        <xs:attribute name="name" use="prohibited"/>
      </xs:restriction>
    </xs:complexContent>
  </xs:complexType>
 
XsTAttributeImplImplementation of xs:attribute, following this specification:
  <xs:complexType name="attribute">
    <xs:complexContent>
      <xs:extension base="xs:annotated">
        <xs:sequence>
          <xs:element name="simpleType" minOccurs="0" type="xs:localSimpleType"/>
        </xs:sequence>
        <xs:attributeGroup ref="xs:defRef"/>
        <xs:attribute name="type" type="xs:QName"/>
        <xs:attribute name="use" use="optional" default="optional">
          <xs:simpleType>
            <xs:restriction base="xs:NMTOKEN">
              <xs:enumeration value="prohibited"/>
              <xs:enumeration value="optional"/>
              <xs:enumeration value="required"/>
            </xs:restriction>
          </xs:simpleType>
        </xs:attribute>
        <xs:attribute name="default" type="xs:string"/>
        <xs:attribute name="fixed" type="xs:string"/>
        <xs:attribute name="form" type="xs:formChoice"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
 
XsTComplexRestrictionTypeImplImplementation of xs:complexRestrictionType, as specified by the following:
  <xs:complexType name="complexRestrictionType">
    <xs:complexContent>
      <xs:restriction base="xs:restrictionType">
        <xs:sequence>
          <xs:element ref="xs:annotation" minOccurs="0"/>
          <xs:group ref="xs:typeDefParticle" minOccurs="0"/>
          <xs:group ref="xs:attrDecls"/>
        </xs:sequence>
      </xs:restriction>
    </xs:complexContent>
  </xs:complexType>
 
XsTComplexTypeImplBase implementation of a complex type, to be shared by XsTLocalComplexType and XsTComplexType.
XsTElementImplImplementation of the xs:element type, as specified by the following:
  <xs:complexType name="element" abstract="true">
    <xs:annotation>
      <xs:documentation>
        The element element can be used either
        at the top level to define an element-type binding globally,
        or within a content model to either reference a globally-defined
        element or type or declare an element-type binding locally.
XsTExplicitGroupImplImplementation of the xs:explicitGroup type, as specified by the following:
  
    
      
        group type for the three kinds of group
      
    
    
      
        
          
          
        
        
        
      
    
  
 

Implementation note: This interface doesn't specify any additional methods.

XsTExtensionTypeImplImplementation of the xs:extensionType type, as specified by:
  <xs:complexType name="extensionType">
    <xs:complexContent>
      <xs:extension base="xs:annotated">
        <xs:sequence>
          <xs:group ref="xs:typeDefParticle" minOccurs="0"/>
          <xs:group ref="xs:attrDecls"/>
        </xs:sequence>
        <xs:attribute name="base" type="xs:QName" use="required"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
 
XsTFacetBaseImpl
XsTFacetImplImplementation of a facet, following this specification:
  <xs:complexType name="facet">
    <xs:complexContent>
      <xs:extension base="xs:annotated">
        <xs:attribute name="value" use="required"/>
        <xs:attribute name="fixed" type="xs:boolean" use="optional"
                    default="false"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
 
XsTFixedFacetImplA common base class for XsTFacet and XsTNumFacet.
XsTGroupImplImplementation of the xs:group, type, with the following specification:
  <xs:complexType name="group" abstract="true">
    <xs:annotation>
      <xs:documentation>
        group type for explicit groups, named top-level groups and
        group references
      </xs:documentation>
    </xs:annotation>
    <xs:complexContent>
      <xs:extension base="xs:annotated">
        <xs:group ref="xs:particle" minOccurs="0" maxOccurs="unbounded"/>
        <xs:attributeGroup ref="xs:defRef"/>
        <xs:attributeGroup ref="xs:occurs"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
 
XsTGroupRefImplImplementation of the xs:groupRef type, with the following specification:
  
    
      
        
          
        
        
        
      
   
 
XsTKeybaseImplImplementation of the xs:keybase type, with the following specification:
  <xs:complexType name="keybase">
    <xs:complexContent>
      <xs:extension base="xs:annotated">
        <xs:sequence>
          <xs:element ref="xs:selector"/>
          <xs:element ref="xs:field" minOccurs="1" maxOccurs="unbounded"/>
        </xs:sequence>
        <xs:attribute name="name" type="xs:NCName" use="required"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
 
XsTLocalAllElementImpl
XsTLocalComplexTypeImplInterface of a local xs:complexType, following the specification below:
  <xs:complexType name="localComplexType">
    <xs:complexContent>
      <xs:restriction base="xs:complexType">
        <xs:sequence>
          <xs:element ref="xs:annotation" minOccurs="0"/>
          <xs:group ref="xs:complexTypeModel"/>
        </xs:sequence>
        <xs:attribute name="name" use="prohibited"/>
        <xs:attribute name="abstract" use="prohibited"/>
        <xs:attribute name="final" use="prohibited"/>
        <xs:attribute name="block" use="prohibited"/>
      </xs:restriction>
    </xs:complexContent>
  </xs:complexType>
 
XsTLocalElementImplImplementation of the xs:localElement type, as specified by:
  <xs:complexType name="localElement">
    <xs:complexContent>
      <xs:restriction base="xs:element">
        <xs:sequence>
          <xs:element ref="xs:annotation" minOccurs="0"/>
          <xs:choice minOccurs="0">
            <xs:element name="simpleType" type="xs:localSimpleType"/>
            <xs:element name="complexType" type="xs:localComplexType"/>
          </xs:choice>
          <xs:group ref="xs:identityConstraint" minOccurs="0" maxOccurs="unbounded"/>
        </xs:sequence>
        <xs:attribute name="substitutionGroup" use="prohibited"/>
        <xs:attribute name="final" use="prohibited"/>
        <xs:attribute name="abstract" use="prohibited"/>
      </xs:restriction>
    </xs:complexContent>
  </xs:complexType>
 

Implementation note: This class doesn't specify any additional methods.

XsTLocalSimpleTypeImplImplementation of the xs:localSimpleType type, as specified by the following:
  <xs:complexType name="localSimpleType">
    <xs:complexContent>
      <xs:restriction base="xs:simpleType">
        <xs:sequence>
          <xs:element ref="xs:annotation" minOccurs="0"/>
          <xs:group ref="xs:simpleDerivation"/>
        </xs:sequence>
        <xs:attribute name="name" use="prohibited">
          <xs:annotation>
            <xs:documentation>
              Forbidden when nested
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
        <xs:attribute name="final" use="prohibited"/>
      </xs:restriction>
    </xs:complexContent>
  </xs:complexType>
 

Implementation note: The implementation must ensure, that the 'final' and 'name' attributes aren't set.

XsTNamedGroupImplImplementation of a named top-level group, with the following specification:
  <xs:complexType name="namedGroup">
    <xs:annotation>
      <xs:documentation>
        Should derive this from realGroup, but too complicated for now
      </xs:documentation>
    </xs:annotation>
    <xs:sequence>
      <xs:element ref="xs:annotation" minOccurs="0"/>
      <xs:choice minOccurs="1" maxOccurs="1">
        <xs:element name="all">
          <xs:complexType>
            <xs:complexContent>
              <xs:restriction base="xs:all">
                <xs:group ref="xs:allModel"/>
                <xs:attribute name="minOccurs" use="prohibited"/>
                <xs:attribute name="maxOccurs" use="prohibited"/>
              </xs:restriction>
            </xs:complexContent>
          </xs:complexType>
        </xs:element>
        <xs:element name="choice" type="xs:simpleExplicitGroup"/>
        <xs:element name="sequence" type="xs:simpleExplicitGroup"/>
      </xs:choice>
    </xs:sequence>
    <xs:attribute name="name" use="required" type="xs:NCName"/>
    <xs:attribute name="ref" use="prohibited"/>
    <xs:attribute name="minOccurs" use="prohibited"/>
    <xs:attribute name="maxOccurs" use="prohibited"/>
  </xs:complexType>
 </pre></p>
XsTNumFacetImplImplementation of xs:numFacet, following this specification:
  <xs:complexType name="numFacet">
    <xs:complexContent>
      <xs:restriction base="xs:facet">
        <xs:sequence>
          <xs:element ref="xs:annotation" minOccurs="0"/>
        </xs:sequence>
        <xs:attribute name="value" type="xs:nonNegativeInteger" use="required"/>
      </xs:restriction>
    </xs:complexContent>
  </xs:complexType>
 
XsTOpenAttrsImplA common base type for most of the schema elements.
XsTRealGroupImplImplementation of the xs:realGroup type, as specified by the following:
  <xs:complexType name="realGroup">
    <xs:complexContent>
      <xs:restriction base="xs:group">
        <xs:sequence>
          <xs:element ref="xs:annotation" minOccurs="0"/>
          <xs:choice minOccurs="0" maxOccurs="1">
            <xs:element ref="xs:all"/>
            <xs:element ref="xs:choice"/>
            <xs:element ref="xs:sequence"/>
          </xs:choice>
        </xs:sequence>
      </xs:restriction>
    </xs:complexContent>
  </xs:complexType>
 

Implementation note: This interface does not define any additional methods.

XsTRestrictionTypeImplImplementation of xs:restrictionType, as specified by the following:
  <xs:complexType name="restrictionType">
    <xs:complexContent>
      <xs:extension base="xs:annotated">
        <xs:sequence>
          <xs:choice>
            <xs:group ref="xs:typeDefParticle" minOccurs="0"/>
            <xs:group ref="xs:simpleRestrictionModel" minOccurs="0"/>
          </xs:choice>
          <xs:group ref="xs:attrDecls"/>
        </xs:sequence>
        <xs:attribute name="base" type="xs:QName" use="required"/>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
 
XsTSimpleExplicitGroupImpl
XsTSimpleExtensionTypeImplImplementation of the xs:simpleExtensionType, as specified by:
  
    
      
        
          
            
              No typeDefParticle group reference
            
          
          
          
        
      
    
  
 
XsTSimpleRestrictionTypeImplImplementation of xs:simpleRestrictionType, as specified by the following:
  <xs:complexType name="simpleRestrictionType">
    <xs:complexContent>
      <xs:restriction base="xs:restrictionType">
        <xs:sequence>
          <xs:element ref="xs:annotation" minOccurs="0"/>
          <xs:group ref="xs:simpleRestrictionModel" minOccurs="0"/>
          <xs:group ref="xs:attrDecls"/>
        </xs:sequence>
      </xs:restriction>
    </xs:complexContent>
  </xs:complexType>
 
XsTSimpleTypeImplImplementation of the following specification for xs:simpleType:
  <xs:complexType name="simpleType" abstract="true">
    <xs:complexContent>
      <xs:extension base="xs:annotated">
        <xs:group ref="xs:simpleDerivation"/>
        <xs:attribute name="final" type="xs:simpleDerivationSet"/>
        <xs:attribute name="name" type="xs:NCName">
          <xs:annotation>
            <xs:documentation>
              Can be restricted to required or forbidden
            </xs:documentation>
          </xs:annotation>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>

  <xs:group name="simpleDerivation">
    <xs:choice>
      <xs:element ref="xs:restriction"/>
      <xs:element ref="xs:list"/>
      <xs:element ref="xs:union"/>
    </xs:choice>
  </xs:group>
 
XsTTopLevelComplexTypeImplImplementation of a top level xs:complexType, following the specification below:
  <xs:complexType name="topLevelComplexType">
    <xs:complexContent>
      <xs:restriction base="xs:complexType">
        <xs:sequence>
          <xs:element ref="xs:annotation" minOccurs="0"/>
          <xs:group ref="xs:complexTypeModel"/>
        </xs:sequence>
        <xs:attribute name="name" type="xs:NCName" use="required"/>
      </xs:restriction>
    </xs:complexContent>
  </xs:complexType>
 
XsTTopLevelElementImplInterface of the xs:topLevelElement type, with the following specification:
  
    
      
        
          
          
            
            
          
          
        
        
        
        
        
        
      
    
 
XsTWildcardImplImplementation of the xs:wildcard type, with the following specification:
  <xs:complexType name="wildcard">
    <xs:complexContent>
      <xs:extension base="xs:annotated">
        <xs:attribute name="namespace" type="xs:namespaceList" use="optional" default="##any"/>
        <xs:attribute name="processContents" use="optional" default="strict"
          <xs:simpleType>
            <xs:restriction base="xs:NMTOKEN">
              <xs:enumeration value="skip"/>
              <xs:enumeration value="lax"/>
              <xs:enumeration value="strict"/>
            </xs:restriction>
          </xs:simpleType>
        </xs:attribute>
      </xs:extension>
    </xs:complexContent>
  </xs:complexType>
 
Contains an implementation of the JaxMeXS schema object model type.