Package org.apache.xmlbeans

Interface SchemaType

  • All Superinterfaces:
    SchemaAnnotated, SchemaComponent
    All Known Implementing Classes:
    SchemaTypeImpl
    public interface SchemaType
extends SchemaComponent, SchemaAnnotated
    Represents a schema type.

    SchemaType is the metadata "type" class for XmlObject, and it plays the analogous role for XmlObject that Class plays for Object.

    Every XML Bean class corresponds to a singleton SchemaType object obtainable by ClassName.type (e.g., XmlNonPositiveInteger.type), and every XML Bean instance has an actual SchemaType, obtainable by XmlObject.schemaType(). The ClassName.type and schemaType() mechanisms are analogous to the ordinary Java ClassName.class and obj.getClass() mechanisms.

    All schema types are represented by a SchemaType, this includes all types regardless of whether they are built-in or user-defined, compiled or uncompiled, simple or complex.

    In addition, a compiled XML Bean type system includes special "document" schema types each representing a document containing nothing but a single element for each global element, and special "attribute" schema types each representing a fragment containing nothing but a single global attribute for global attribute.

    Do not confuse Schema Types with other types of Schema Components such as Global Elements, Global Attributes, Named Model Groups, or Attribute Groups. SchemaType represents a Type component, not any of the other kinds of components. There are different kinds of metadata objects for the different Schema components.

    The space of SchemaTypes is divided as follows:

    • First, there is the universal base type and the universal subtype. These are XmlObject.type (corresponding to xs:anyType) and XmlBeans.NO_TYPE, respectively. The first type is a base type of all other types. The other type indicates the absence of type information and, at least in set-theoretic terms, is a subtype of all other types.
    • There is another universal base type that is the base type for all simple types. This is the XmlAnySimpleType.type, corresponding to xs:anySimpleType. Only XmlObject.type and XmlAnySimpleType.type return true for isURType(), and only XmlBeans.NO_TYPE returns true for isNoType().
    • The two "special" kinds of types that are generated that do not formally exist in the actual Schema specification are document types and global attribute types (corresponding to documents that contain a global element, or fragments that contain a global attribute). They can be detected using isDocumentType() and isAttributeType(). Other than their anonymity (lack of a type name) and their appearance only at the root of an instance, they are otherwise just like ordinary complex types.
    • Simple types can be detected using isSimpleType(). Complex types are considered to be all the types that are not simple.
    • Simple types are divided into three varieties: atomic types, list types, and union types. Which variety of simple type you have can be discoverd using getSimpleVariety(). It will return either ATOMIC, LIST, or UNION.
    • An ATOMIC simple type is always based on one of the 20 built-in primitive schema types. You can determine the underlying primitive type for an atomic simple type by calling getPrimitiveType(). An atomic type may add facet restrictions on top of the primitive type, and these facets can be explored using getFacet(int), getWhiteSpaceRule(), matchPatternFacet(java.lang.String), getEnumerationValues(), and related methods.
    • A LIST simple type is always based on another non-list simple type. The underlying list item type can be obtained by using getListItemType().
    • A UNION simple type is always composed out of a number of other simple types. The direct members of the union can be obtained by getUnionMemberTypes(). When unions consist of other unions, it is useful to know useful to know the "leaves of the union tree", so the set of non-union types making up the union can be obtained by getUnionConstituentTypes(). The closure of the entire "union tree" is getUnionSubTypes() (this includes the type itself). For simple unions that do not consist of other unions, all three of these sets are the same.
    • Complex types have nested structure. They are divided into four content types: empty content, simple content, element-only content, and mixed content. All kinds of complex types may have attributes. The content type for a complex type can be dermined using getContentType(). This will return EMPTY_CONTENT, SIMPLE_CONTENT, ELEMENT_CONTENT, or MIXED_CONTENT.
    • If a complex type has EMPTY_CONTENT, the content model will be null.
    • If a complex type has SIMPLE_CONTENT, then it will extend the simple type that describes the content. In addition, the type may impose additional simple type facet restrictions; these can be determined in the same way they are for a simple type.
    • If a complex type has ELEMENT_CONTENT or MIXED_CONTENT, then the detailed content model can be determined by examining the particle tree (which may be null for MIXED_CONTENT). The particle tree can be obtained via getContentModel().
    • When working with a complex type, most users will find it sufficient to discover the summarized shape of the content model and attribute model using getElementProperties(), getAttributeProperties(), and related methods rather than examining the particle tree and attribute model directly.
    See Also:
    SchemaTypeLoader, XmlObject.schemaType(), SimpleValue.instanceType()

    • Method Detail

      • getName

        QName getName()
        The name used to describe the type in the schema. Null if the type is anonymous (nested), or if it is a document type.
        Specified by:
        getName in interface SchemaComponent

      • getContainerField

        SchemaField getContainerField()
        The parent schema element. Null for top-level (named) types and document types.

      • isDocumentType

        boolean isDocumentType()
        True if this is a document type.

        Document types are generated for every global element. A document type is an unnamed complex type that contains exactly one element: we define these types, because they are the types of the "documents" which contain the defined global elements, and they all turn into Java types. (Named ElementnameDocument.)

      • isAttributeType

        boolean isAttributeType()
        True if this is a attribute type.

        Attribute types are generated for every global attribute. An attribute type is an unnamed complex type that contains exactly one attribute: we define these types, because they are the types of the "attribute documents" which contain the defined global attribute, and they all turn into Java types. (Named AttributenameAttribute.)

      • getDocumentElementName

        QName getDocumentElementName()
        Returns the document element name if this is a document type, or null otherwise.

      • getAttributeTypeAttributeName

        QName getAttributeTypeAttributeName()
        Returns the attribute qname if this is a attribute type, or null otherwise.

      • getOuterType

        SchemaType getOuterType()
        The outer schema type. Null for top-level (named) types.

      • isSkippedAnonymousType

        boolean isSkippedAnonymousType()
        True if this anonymous type has no corresponding Java type. True for anonymous types nested within simple type restrictions.

      • isCompiled

        boolean isCompiled()
        True if this schema type was compiled to have a corresponding Java class.

      • getFullJavaName

        String getFullJavaName()
        The fully-qualified Java type name of the class.

      • getShortJavaName

        String getShortJavaName()
        The short unqualfiied Java name for the class.

      • getFullJavaImplName

        String getFullJavaImplName()
        The fully-qualified Java type name of the implementation class.

      • getShortJavaImplName

        String getShortJavaImplName()
        The short unqualfiied Java name for the implementation class.

      • getJavaClass

        Class<? extends XmlObject> getJavaClass()
        The Java class corresponding to this schema type.

      • getEnumJavaClass

        Class<? extends StringEnumAbstractBase> getEnumJavaClass()
        The Java class corresponding to the enumeration type for this schema type, if applicable (or null if not an enumeration).

      • isAnonymousType

        boolean isAnonymousType()
        True if the Xsd type is anonymous (i.e., not top-level).

      • isBuiltinType

        boolean isBuiltinType()
        True for any of the 40+ built-in types.

      • isSimpleType

        boolean isSimpleType()
        True for the anySimpleType and any restrictions/unions/lists.

      • getBaseType

        SchemaType getBaseType()
        Returns base restriction or extension type. Unions and lists return the anySimpleType.

      • getCommonBaseType

        SchemaType getCommonBaseType​(SchemaType type)
        Returns common base type with the given type. The returned type is the most specific declared base type of both types.

      • isAssignableFrom

        boolean isAssignableFrom​(SchemaType type)
        True if the specified type derives from this type (or if it is the same type).

        Note that XmlObject.type (the anyType) is assignable from all type, and the XmlBeans.noType (the absence of a type) is assignable to all types.

      • getBuiltinTypeCode

        int getBuiltinTypeCode()
        Returns an integer for builtin types that can be used for quick comparison.

      • isURType

        boolean isURType()
        True for anyType and anySimpleType.

      • isNoType

        boolean isNoType()
        True for the type object that represents a the absence of a determined type. XML Objects whose type isNoType() are never valid.

      • getTypeSystem

        SchemaTypeSystem getTypeSystem()
        Returns the SchemaTypeLoader in which this type was defined. Complex types are defined and used in exactly one schema type system, but simple types are defined in one type system and can be used in any number of type systems. The most common case is the builtin types, which are defined in the builtin type system and used elsewhere.
        Specified by:
        getTypeSystem in interface SchemaComponent

      • isAbstract

        boolean isAbstract()
        True if this type cannot be used directly in instances

      • finalExtension

        boolean finalExtension()
        True if other types cannot extend this type (only for complex types)

      • finalRestriction

        boolean finalRestriction()
        True if other types cannot restrict this type

      • finalList

        boolean finalList()
        True if list derivation of this type is prohibited (only for simple types)

      • finalUnion

        boolean finalUnion()
        True if union derivation of this type is prohibited (only for simple types)

      • blockExtension

        boolean blockExtension()
        True if extensions of this type cannot be substituted for this type

      • blockRestriction

        boolean blockRestriction()
        True if restrictions of this type cannot be substituted for this type

      • getContentBasedOnType

        SchemaType getContentBasedOnType()
        For complex types with simple content returns the base type for this type's content. In most cases, this is the same as the base type, but it can also be an anonymous type.

      • getElementSequencer

        SchemaTypeElementSequencer getElementSequencer()
        Returns a SchemaTypeElementSequencer object, which can then be used to validate complex content inside this element. This is useful for example for trying out different names and see which one would be valid as a child of this element.

      • getAnonymousTypes

        SchemaType[] getAnonymousTypes()
        The array of inner (anonymous) types defined within this type.

      • getElementProperty

        SchemaProperty getElementProperty​(QName eltName)
        Returns a SchemaProperty corresponding to an element within this complex type by looking up the element name.

      • getElementProperties

        SchemaProperty[] getElementProperties()
        Returns all the SchemaProperties corresponding to elements.

      • getAttributeProperty

        SchemaProperty getAttributeProperty​(QName attrName)
        Returns a SchemaProperty corresponding to an attribute within this complex type by looking up the attribute name.

      • getAttributeProperties

        SchemaProperty[] getAttributeProperties()
        Returns all the SchemaProperties corresponding to attributes.

      • getProperties

        SchemaProperty[] getProperties()
        Returns all the SchemaProperties within this complex type, elements followed by attributes.

      • getDerivedProperties

        SchemaProperty[] getDerivedProperties()
        Returns the SchemaProperties defined by this complex type, exclusive of the base type (if any).

      • getAttributeModel

        SchemaAttributeModel getAttributeModel()
        Returns the attribute model for this complex type (with simple or complex content).

      • hasAttributeWildcards

        boolean hasAttributeWildcards()
        True if this type permits wildcard attributes. See the attribute model for more information about which wildcards are allowed.

      • getContentModel

        SchemaParticle getContentModel()
        Returns the complex content model for this complex type (with complex content).

      • hasElementWildcards

        boolean hasElementWildcards()
        True if this type permits element wildcards. See the content model for more information about which wildcards are allowed, and where.

      • isValidSubstitution

        boolean isValidSubstitution​(QName name)
        For document types, true if the given name can be substituted for the document element name.

      • hasAllContent

        boolean hasAllContent()
        True if the complex content model for this complex type is an "all" group.

      • isOrderSensitive

        boolean isOrderSensitive()
        True if particles have same defaults, nillability, etc, that are invariant when order changes. Computed only for Javaized types.

      • getElementType

        SchemaType getElementType​(QName eltName,
                          QName xsiType,
                          SchemaTypeLoader wildcardTypeLoader)
        Returns the type of a child element based on the element name and an xsi:type attribute (and the type system within which names are resolved).

      • getAttributeType

        SchemaType getAttributeType​(QName eltName,
                            SchemaTypeLoader wildcardTypeLoader)
        Returns the type of an attribute based on the attribute name and the type system within which (wildcard) names are resolved.

      • getFacet

        XmlAnySimpleType getFacet​(int facetCode)
        Returns the value of the given facet, or null if none is set.

      • isFacetFixed

        boolean isFacetFixed​(int facetCode)
        True if the given facet is fixed.

      • isBounded

        boolean isBounded()
        True if bounded.

      • isFinite

        boolean isFinite()
        True if finite.

      • isNumeric

        boolean isNumeric()
        True if numeric.

      • hasPatternFacet

        boolean hasPatternFacet()
        True if there are regex pattern facents

      • getPatterns

        String[] getPatterns()
        True

      • matchPatternFacet

        boolean matchPatternFacet​(String s)
        True if the given string matches the pattern facets. Always true if there are no pattern facets.

      • getEnumerationValues

        XmlAnySimpleType[] getEnumerationValues()
        Returns the array of valid objects from the enumeration facet, null if no enumeration defined.

      • hasStringEnumValues

        boolean hasStringEnumValues()
        True if this is a string enum where an integer is assigned to each enumerated value.

      • getBaseEnumType

        SchemaType getBaseEnumType()
        If this is a string enumeration, returns the most basic base schema type that this enuemration is based on. Otherwise returns null.

      • getStringEnumEntries

        SchemaStringEnumEntry[] getStringEnumEntries()
        Returns the array of SchemaStringEnumEntries for this type: this array includes information about the java constant names used for each string enum entry.

      • enumEntryForString

        SchemaStringEnumEntry enumEntryForString​(String s)
        Returns the string enum entry corresponding to the given enumerated string, or null if there is no match or this type is not a string enumeration.

      • enumForString

        StringEnumAbstractBase enumForString​(String s)
        Returns the string enum value corresponding to the given enumerated string, or null if there is no match or this type is not a string enumeration.

      • enumForInt

        StringEnumAbstractBase enumForInt​(int i)
        Returns the string enum value corresponding to the given enumerated string, or null if there is no match or this type is not a string enumeration.

      • isPrimitiveType

        boolean isPrimitiveType()
        True for any of the 20 primitive types (plus anySimpleType)

      • getSimpleVariety

        int getSimpleVariety()
        Returns whether the simple type is ATOMIC, UNION, or LIST. Returns NOT_SIMPLE, ATOMIC, UNION, or LIST.

      • getPrimitiveType

        SchemaType getPrimitiveType()
        For atomic types only: get the primitive type underlying this one.

        Returns null if this is not an atomic type.

      • getUnionMemberTypes

        SchemaType[] getUnionMemberTypes()
        For union types only: get the shallow member types. This returns the declared member types of the union, so, for example if the type contains another union, the nested members of that union are NOT returned here.

        Returns null if this type is not a union.

      • getUnionSubTypes

        SchemaType[] getUnionSubTypes()
        For union types only: gets the full tree of member types. This computes the closure of the set returned by getUnionMemberTypes(), so, for example, it returns all the types nested within unions of unions as well as the top-level members; the set also includes the type itself. If you are seeking only the basic non-union consituents, use getUnionConstituentTypes.

        Returns null if this type is not a union.

      • getUnionConstituentTypes

        SchemaType[] getUnionConstituentTypes()
        For union types only: get the constituent member types. This returns only non-union types, so, for example, for unions of unions, this returns the flattened list of individual member types within the innermost unions.

        Returns null if this type is not a union.

      • getUnionCommonBaseType

        SchemaType getUnionCommonBaseType()
        For union types only: get the most specific common base type of the constituent member types. May return a UR type.

        Returns null if this type is not a union.

      • getAnonymousUnionMemberOrdinal

        int getAnonymousUnionMemberOrdinal()
        For anonymous types defined inside a union only: gets the integer indicating the declaration order of this type within the outer union type, or zero if this is not applicable. The first anonymous union member within a union type is numbered "1". Used to differentiate between different anonymous types.

      • getListItemType

        SchemaType getListItemType()
        For list types only: get the item type. This is the atomic or union type that is the type of every entry in the list.

        Returns null if this type is not a list.

      • newValue

        XmlAnySimpleType newValue​(Object v)
        Creates an immutable simple type value that does not reside in a tree.

      • getRef

        SchemaType.Ref getRef()
        Retruns a SchemaType.Ref pointing to this schema type itself.

      • qnameSetForWildcardElements

        QNameSet qnameSetForWildcardElements()
        Returns a QNameSet of elements that may exist in wildcard buchets and are not explicitly defined in this schema type. Note: In this example: 
        
 <xs:complexType name="exampleType">
 <xs:sequence>
 <xs:element name="someElement" type='xs:string' />
 <xs:any namespace="##targetNamespace" />
 </xs:sequence>
 </xs:complexType>
        the returned QNameSet will not contain the qname of 'someElement'.
        Returns:
        the constructed QNameSet

      • qnameSetForWildcardAttributes

        QNameSet qnameSetForWildcardAttributes()
        Returns a QNameSet of attributes that may exist in wildcard buchets and are not explicitly defined in this schema type. Note: In this example: 
        
 <xs:complexType name="exampleType">
 ...
 <xs:attribute name='someAttribute' type='xs:string' />
 <xs:anyAttribute namespace="##targetNamespace" />
 </xs:complexType>
        the returned QNameSet will not contain the qname of 'someAttribute'.
        Returns:
        the constructed QNameSet

      • getDocumentation

        String getDocumentation()
        returns user specified documentation 
        
 <xs:complexType ...>
   <xs:annotation>
      <xs:documentation>
          getDocumentation method will return whatever stuff here.
      </xs:docmentation>
   </xs:annotation>
 </xs complexType>