org.apache.xmlbeans.impl.schema

## Class SchemaTypeImpl

- java.lang.Object
- - org.apache.xmlbeans.impl.schema.SchemaTypeImpl

- All Implemented Interfaces:
    TypeStoreUserFactory, SchemaAnnotated, SchemaComponent, SchemaType

      public final class SchemaTypeImpl
      extends Object
      implements SchemaType, TypeStoreUserFactory

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from interface org.apache.xmlbeans.SchemaType

      `SchemaType.Ref`

  - ### Field Summary

    - ### Fields inherited from interface org.apache.xmlbeans.SchemaType

      `ATOMIC, BTC_ANY_SIMPLE, BTC_ANY_TYPE, BTC_ANY_URI, BTC_BASE_64_BINARY, BTC_BOOLEAN, BTC_BYTE, BTC_DATE, BTC_DATE_TIME, BTC_DECIMAL, BTC_DOUBLE, BTC_DURATION, BTC_ENTITIES, BTC_ENTITY, BTC_FIRST_PRIMITIVE, BTC_FLOAT, BTC_G_DAY, BTC_G_MONTH, BTC_G_MONTH_DAY, BTC_G_YEAR, BTC_G_YEAR_MONTH, BTC_HEX_BINARY, BTC_ID, BTC_IDREF, BTC_IDREFS, BTC_INT, BTC_INTEGER, BTC_LANGUAGE, BTC_LAST_BUILTIN, BTC_LAST_PRIMITIVE, BTC_LONG, BTC_NAME, BTC_NCNAME, BTC_NEGATIVE_INTEGER, BTC_NMTOKEN, BTC_NMTOKENS, BTC_NON_NEGATIVE_INTEGER, BTC_NON_POSITIVE_INTEGER, BTC_NORMALIZED_STRING, BTC_NOT_BUILTIN, BTC_NOTATION, BTC_POSITIVE_INTEGER, BTC_QNAME, BTC_SHORT, BTC_STRING, BTC_TIME, BTC_TOKEN, BTC_UNSIGNED_BYTE, BTC_UNSIGNED_INT, BTC_UNSIGNED_LONG, BTC_UNSIGNED_SHORT, DT_EXTENSION, DT_NOT_DERIVED, DT_RESTRICTION, ELEMENT_CONTENT, EMPTY_CONTENT, FACET_ENUMERATION, FACET_FRACTION_DIGITS, FACET_LENGTH, FACET_MAX_EXCLUSIVE, FACET_MAX_INCLUSIVE, FACET_MAX_LENGTH, FACET_MIN_EXCLUSIVE, FACET_MIN_INCLUSIVE, FACET_MIN_LENGTH, FACET_PATTERN, FACET_TOTAL_DIGITS, FACET_WHITE_SPACE, LAST_BASIC_FACET, LAST_FACET, LAST_PROPERTY, LIST, MIXED_CONTENT, NOT_COMPLEX_TYPE, NOT_DECIMAL, NOT_SIMPLE, PARTIAL_ORDER, PROPERTY_BOUNDED, PROPERTY_CARDINALITY, PROPERTY_NUMERIC, PROPERTY_ORDERED, SIMPLE_CONTENT, SIZE_BIG_DECIMAL, SIZE_BIG_INTEGER, SIZE_BYTE, SIZE_INT, SIZE_LONG, SIZE_SHORT, TOTAL_ORDER, UNION, UNORDERED, WS_COLLAPSE, WS_PRESERVE, WS_REPLACE, WS_UNSPECIFIED`

    - ### Fields inherited from interface org.apache.xmlbeans.SchemaComponent

      `ANNOTATION, ATTRIBUTE, ATTRIBUTE_GROUP, ELEMENT, IDENTITY_CONSTRAINT, MODEL_GROUP, NOTATION, TYPE`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addSubstitutionGroupMember(QName member)`
    `boolean` | `blockExtension()` True if extensions of this type cannot be substituted for this type
    `boolean` | `blockRestriction()` True if restrictions of this type cannot be substituted for this type
    `void` | `copyEnumerationValues(SchemaTypeImpl baseImpl)`
    `XmlObject` | `createAttributeType(QName attrName, SchemaTypeLoader wildcardTypeLoader)`
    `XmlObject` | `createElementType(QName eltName, QName xsiType, SchemaTypeLoader wildcardTypeLoader)`
    `TypeStoreUser` | `createTypeStoreUser()` TypeStoreUserFactory implementation
    `XmlObject` | `createUnwrappedNode()`
    `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.
    `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.
    `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.
    `boolean` | `finalExtension()` True if other types cannot extend this type (only for complex types)
    `boolean` | `finalList()` True if list derivation of this type is prohibited (only for simple types)
    `boolean` | `finalRestriction()` True if other types cannot restrict this type
    `boolean` | `finalUnion()` True if union derivation of this type is prohibited (only for simple types)
    `void` | `finishJavaizing()`
    `void` | `finishLoading()`
    `void` | `finishResolving()`
    `void` | `finishResolvingSGs()`
    `SchemaAnnotation` | `getAnnotation()` Returns the Schema annotation object or null if none present
    `SchemaType[]` | `getAnonymousTypes()` The array of inner (anonymous) types defined within this type.
    `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.
    `String` | `getAttFormDefault()`
    `SchemaAttributeModel` | `getAttributeModel()` Returns the attribute model for this complex type (with simple or complex content).
    `SchemaProperty[]` | `getAttributeProperties()` Returns all the SchemaProperties corresponding to attributes.
    `SchemaProperty` | `getAttributeProperty(QName attrName)` Returns a SchemaProperty corresponding to an attribute within this complex type by looking up the attribute name.
    `SchemaType` | `getAttributeType(QName attrName, SchemaTypeLoader wildcardTypeLoader)` Returns the type of an attribute based on the attribute name and the type system within which (wildcard) names are resolved.
    `QName` | `getAttributeTypeAttributeName()` Returns the attribute qname if this is a attribute type, or null otherwise.
    `int` | `getBaseDepth()`
    `SchemaType` | `getBaseEnumType()` If this is a string enumeration, returns the most basic base schema type that this enuemration is based on.
    `SchemaType` | `getBaseType()` Returns base restriction or extension type.
    `XmlAnySimpleType[]` | `getBasicFacets()`
    `int` | `getBuiltinTypeCode()` Returns an integer for builtin types that can be used for quick comparison.
    `String` | `getChameleonNamespace()`
    `SchemaType` | `getCommonBaseType(SchemaType type)` Returns common base type with the given type.
    `SchemaComponent.Ref` | `getComponentRef()` Used for on-demand loading of schema components.
    `int` | `getComponentType()` Returns the type code for the schema object, either `SchemaComponent.TYPE`, `SchemaComponent.ELEMENT`, `SchemaComponent.ATTRIBUTE`, `SchemaComponent.ATTRIBUTE_GROUP`, `SchemaComponent.MODEL_GROUP`, `SchemaComponent.IDENTITY_CONSTRAINT`, or `SchemaComponent.NOTATION`.
    `SchemaField` | `getContainerField()` The parent schema element.
    `SchemaType` | `getContentBasedOnType()` For complex types with simple content returns the base type for this type's content.
    `SchemaParticle` | `getContentModel()` Returns the complex content model for this complex type (with complex content).
    `int` | `getContentType()` Returns `SchemaType.EMPTY_CONTENT`, `SchemaType.SIMPLE_CONTENT`, `SchemaType.ELEMENT_CONTENT`, or `SchemaType.MIXED_CONTENT` for complex types.
    `int` | `getDecimalSize()` For atomic numeric restrictions of decimal only: the numeric size category.
    `int` | `getDerivationType()` Returns an integer for the derivation type, either `SchemaType.DT_EXTENSION`, `SchemaType.DT_RESTRICTION`, `SchemaType.DT_NOT_DERIVED`.
    `SchemaProperty[]` | `getDerivedProperties()` Returns the SchemaProperties defined by this complex type, exclusive of the base type (if any).
    `String` | `getDocumentation()` returns user specified documentation
    `QName` | `getDocumentElementName()` Returns the document element name if this is a document type, or null otherwise.
    `SchemaProperty[]` | `getElementProperties()` Returns all the SchemaProperties corresponding to elements.
    `SchemaProperty` | `getElementProperty(QName eltName)` Returns a SchemaProperty corresponding to an element within this complex type by looking up the element name.
    `SchemaTypeElementSequencer` | `getElementSequencer()` Returns a `SchemaTypeElementSequencer` object, which can then be used to validate complex content inside this element.
    `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).
    `String` | `getElemFormDefault()`
    `XmlAnySimpleType[]` | `getEnumerationValues()` Returns the array of valid objects from the enumeration facet, null if no enumeration defined.
    `Class<? extends StringEnumAbstractBase>` | `getEnumJavaClass()` The Java class corresponding to the enumeration type for this schema type, if applicable (or null if not an enumeration).
    `XmlAnySimpleType` | `getFacet(int facetCode)` Returns the value of the given facet, or null if none is set.
    `boolean[]` | `getFixedFacets()`
    `String` | `getFullJavaImplName()` The fully-qualified Java type name of the implementation class.
    `String` | `getFullJavaName()` The fully-qualified Java type name of the class.
    `int` | `getIndexForLocalAttribute(SchemaLocalAttribute attr)`
    `int` | `getIndexForLocalElement(SchemaLocalElement elt)`
    `InterfaceExtension[]` | `getInterfaceExtensions()`
    `Class<? extends XmlObject>` | `getJavaClass()` The Java class corresponding to this schema type.
    `Class<? extends XmlObjectBase>` | `getJavaImplClass()`
    `Constructor<? extends XmlObjectBase>` | `getJavaImplConstructor()`
    `Constructor<? extends XmlObjectBase>` | `getJavaImplConstructor2()`
    `SchemaType` | `getListItemType()` For list types only: get the item type.
    `SchemaLocalElement` | `getLocalElementByIndex(int i)`
    `QName` | `getName()` The name used to describe the type in the schema.
    `SchemaType` | `getOuterType()` The outer schema type.
    `XmlObject` | `getParseObject()`
    `RegularExpression[]` | `getPatternExpressions()`
    `String[]` | `getPatterns()` True
    `PrePostExtension` | `getPrePostExtension()`
    `SchemaType` | `getPrimitiveType()` For atomic types only: get the primitive type underlying this one.
    `SchemaProperty[]` | `getProperties()` Returns all the SchemaProperties within this complex type, elements followed by attributes.
    `SchemaType.Ref` | `getRef()` Retruns a SchemaType.Ref pointing to this schema type itself.
    `String` | `getShortJavaImplName()` The short unqualfiied Java name for the implementation class.
    `String` | `getShortJavaName()` The short unqualfiied Java name for the class.
    `int` | `getSimpleVariety()` Returns whether the simple type is ATOMIC, UNION, or LIST.
    `String` | `getSourceName()` The name of resource that represends the source .xsd in which this component was defined (if known) See: `SchemaTypeLoader.getSourceAsStream(String)` Example:
    `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.
    `QName` | `getSubstitutionGroup()`
    `QName[]` | `getSubstitutionGroupMembers()`
    `String` | `getTargetNamespace()`
    `SchemaTypeSystem` | `getTypeSystem()` Returns the SchemaTypeLoader in which this type was defined.
    `SchemaType` | `getUnionCommonBaseType()` For union types only: get the most specific common base type of the constituent member types.
    `SchemaType[]` | `getUnionConstituentTypes()` For union types only: get the constituent member types.
    `SchemaType[]` | `getUnionMemberTypes()` For union types only: get the shallow member types.
    `SchemaType[]` | `getUnionSubTypes()` For union types only: gets the full tree of member types.
    `Object` | `getUserData()` Returns user-specific information.
    `String` | `getUserTypeHandlerName()`
    `String` | `getUserTypeName()`
    `int` | `getWhiteSpaceRule()` For nonunion simple types: get the whitespace rule.
    `boolean` | `hasAllContent()` True if the complex content model for this complex type is an "all" group.
    `boolean` | `hasAttributeWildcards()` True if this type permits wildcard attributes.
    `boolean` | `hasElementWildcards()` True if this type permits element wildcards.
    `boolean` | `hasPatternFacet()` True if there are regex pattern facents
    `boolean` | `hasStringEnumValues()` True if this is a string enum where an integer is assigned to each enumerated value.
    `boolean` | `isAbstract()` True if this type cannot be used directly in instances
    `boolean` | `isAnonymousType()` True if the Xsd type is anonymous (i.e., not top-level).
    `boolean` | `isAssignableFrom(SchemaType type)` True if the specified type derives from this type (or if it is the same type).
    `boolean` | `isAttributeType()` True if this is a attribute type.
    `boolean` | `isBounded()` True if bounded.
    `boolean` | `isBuiltinType()` True for any of the 40+ built-in types.
    `boolean` | `isChameleon()`
    `boolean` | `isCompiled()` True if this schema type was compiled to have a corresponding Java class.
    `boolean` | `isDocumentType()` True if this is a document type.
    `boolean` | `isFacetFixed(int facetCode)` True if the given facet is fixed.
    `boolean` | `isFinite()` True if finite.
    `boolean` | `isJavaized()`
    `boolean` | `isNoType()` True for the type object that represents a the absence of a determined type.
    `boolean` | `isNumeric()` True if numeric.
    `boolean` | `isOrderSensitive()` True if particles have same defaults, nillability, etc, that are invariant when order changes.
    `boolean` | `isPrimitiveType()` True for any of the 20 primitive types (plus anySimpleType)
    `boolean` | `isRedefinition()`
    `boolean` | `isResolved()`
    `boolean` | `isResolving()`
    `boolean` | `isSGResolved()`
    `boolean` | `isSGResolving()`
    `boolean` | `isSimpleType()` True for the anySimpleType and any restrictions/unions/lists.
    `boolean` | `isSkippedAnonymousType()` True if this anonymous type has no corresponding Java type.
    `boolean` | `isUnionOfLists()`
    `boolean` | `isUnjavaized()`
    `boolean` | `isUnloaded()`
    `boolean` | `isURType()` True for anyType and anySimpleType.
    `boolean` | `isValidSubstitution(QName name)` For document types, true if the given name can be substituted for the document element name.
    `boolean` | `matchPatternFacet(String s)` True if the given string matches the pattern facets.
    `XmlAnySimpleType` | `newValidatingValue(Object obj)`
    `XmlAnySimpleType` | `newValue(Object obj)` Creates an immutable simple value.
    `XmlAnySimpleType` | `newValue(Object obj, boolean validateOnSet)`
    `int` | `ordered()` True if ordered.
    `QNameSet` | `qnameSetForWildcardAttributes()` Returns a QNameSet of attributes that may exist in wildcard buchets and are not explicitly defined in this schema type.
    `QNameSet` | `qnameSetForWildcardElements()` Returns a QNameSet of elements that may exist in wildcard buchets and are not explicitly defined in this schema type.
    `void` | `setAnnotation(SchemaAnnotation ann)`
    `void` | `setAnonymousTypeRefs(SchemaType.Ref[] anonymousTyperefs)`
    `void` | `setAnonymousUnionMemberOrdinal(int i)`
    `void` | `setAttributeType(boolean isAttribute)`
    `void` | `setBaseDepth(int depth)`
    `void` | `setBaseEnumTypeRef(SchemaType.Ref baseEnumTyperef)`
    `void` | `setBaseTypeRef(SchemaType.Ref typeref)`
    `void` | `setBasicFacets(XmlValueRef[] values, boolean[] fixed)`
    `void` | `setBounded(boolean f)`
    `void` | `setBuiltinTypeCode(int builtinTypeCode)`
    `void` | `setCompiled(boolean f)`
    `void` | `setComplexTypeVariety(int complexTypeVariety)`
    `void` | `setContainerField(SchemaField field)`
    `void` | `setContainerFieldIndex(short code, int index)`
    `void` | `setContainerFieldRef(SchemaComponent.Ref ref)`
    `void` | `setContentBasedOnTypeRef(SchemaType.Ref typeref)`
    `void` | `setContentModel(SchemaParticle contentModel, SchemaAttributeModel attrModel, Map<QName,SchemaProperty> propertyModelByElementName, Map<QName,SchemaProperty> propertyModelByAttributeName, boolean isAll)`
    `void` | `setDecimalSize(int bits)`
    `void` | `setDerivationType(int type)`
    `void` | `setDocumentType(boolean isDocument)`
    `void` | `setEnumerationValues(XmlValueRef[] a)`
    `void` | `setFilename(String filename)`
    `void` | `setFinite(boolean f)`
    `void` | `setFullJavaImplName(String name)`
    `void` | `setFullJavaName(String name)`
    `void` | `setInterfaceExtensions(InterfaceExtension[] interfaces)`
    `void` | `setJavaClass(Class<? extends XmlObject> javaClass)`
    `void` | `setListItemTypeRef(SchemaType.Ref typeref)`
    `void` | `setName(QName name)`
    `void` | `setNumeric(boolean f)`
    `void` | `setOrdered(int ordering)`
    `void` | `setOrderSensitive(boolean sensitive)`
    `void` | `setOuterSchemaTypeRef(SchemaType.Ref typeref)`
    `void` | `setParseContext(XmlObject parseObject, String targetNamespace, boolean chameleon, String elemFormDefault, String attFormDefault, boolean redefinition)`
    `void` | `setPatternFacet(boolean hasPatterns)`
    `void` | `setPatterns(RegularExpression[] list)`
    `void` | `setPrePostExtension(PrePostExtension prepost)`
    `void` | `setPrimitiveTypeRef(SchemaType.Ref typeref)`
    `void` | `setShortJavaImplName(String name)`
    `void` | `setShortJavaName(String name)`
    `void` | `setSimpleType(boolean f)`
    `void` | `setSimpleTypeVariety(int variety)`
    `void` | `setStringEnumEntries(SchemaStringEnumEntry[] sEnums)`
    `void` | `setSubstitutionGroup(QName sg)`
    `void` | `setUnionMemberTypeRefs(SchemaType.Ref[] typerefs)`
    `void` | `setUnionOfLists(boolean f)`
    `void` | `setUserData(Object data)`
    `void` | `setUserTypeHandlerName(String typeHandler)`
    `void` | `setUserTypeName(String userTypeName)`
    `void` | `setWhiteSpaceRule(int ws)`
    `void` | `setWildcardSummary(QNameSet elementSet, boolean haswcElt, QNameSet attributeSet, boolean haswcAtt)`
    `void` | `startJavaizing()`
    `void` | `startResolving()`
    `void` | `startResolvingSGs()`
    `String` | `toString()`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Method Detail

    - #### isUnloaded

          public boolean isUnloaded()

    - #### finishLoading

          public void finishLoading()

    - #### isSGResolved

          public boolean isSGResolved()

    - #### isSGResolving

          public boolean isSGResolving()

    - #### isResolved

          public boolean isResolved()

    - #### isResolving

          public boolean isResolving()

    - #### isUnjavaized

          public boolean isUnjavaized()

    - #### isJavaized

          public boolean isJavaized()

    - #### startResolvingSGs

          public void startResolvingSGs()

    - #### finishResolvingSGs

          public void finishResolvingSGs()

    - #### startResolving

          public void startResolving()

    - #### finishResolving

          public void finishResolving()

    - #### startJavaizing

          public void startJavaizing()

    - #### finishJavaizing

          public void finishJavaizing()

    - #### getName

          public QName getName()

      Description copied from interface: `SchemaType`
      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`
      Specified by:
        `getName` in interface `SchemaType`

    - #### setName

          public void setName(QName name)

    - #### getSourceName

          public String getSourceName()

      Description copied from interface: `SchemaComponent`
      The name of resource that represends the source .xsd in which this component was defined (if known)
      See: `SchemaTypeLoader.getSourceAsStream(String)`
      Example:

             SchemaType schemaType = ..;
             InputStream is = schemaType.getTypeSystem().getSourceAsStream(schemaType.getSourceName());

      Specified by:
        `getSourceName` in interface `SchemaComponent`

    - #### setFilename

          public void setFilename(String filename)

    - #### getComponentType

          public int getComponentType()

      Description copied from interface: `SchemaComponent`
      Returns the type code for the schema object, either `SchemaComponent.TYPE`, `SchemaComponent.ELEMENT`, `SchemaComponent.ATTRIBUTE`, `SchemaComponent.ATTRIBUTE_GROUP`, `SchemaComponent.MODEL_GROUP`, `SchemaComponent.IDENTITY_CONSTRAINT`, or `SchemaComponent.NOTATION`.
      Specified by:
        `getComponentType` in interface `SchemaComponent`

    - #### isAnonymousType

          public boolean isAnonymousType()

      Description copied from interface: `SchemaType`
      True if the Xsd type is anonymous (i.e., not top-level).
      Specified by:
        `isAnonymousType` in interface `SchemaType`

    - #### isDocumentType

          public boolean isDocumentType()

      Description copied from interface: `SchemaType`
      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.)

      Specified by:
        `isDocumentType` in interface `SchemaType`

    - #### isAttributeType

          public boolean isAttributeType()

      Description copied from interface: `SchemaType`
      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.)

      Specified by:
        `isAttributeType` in interface `SchemaType`

    - #### getDocumentElementName

          public QName getDocumentElementName()

      Description copied from interface: `SchemaType`
      Returns the document element name if this is a document type, or null otherwise.
      Specified by:
        `getDocumentElementName` in interface `SchemaType`

    - #### getAttributeTypeAttributeName

          public QName getAttributeTypeAttributeName()

      Description copied from interface: `SchemaType`
      Returns the attribute qname if this is a attribute type, or null otherwise.
      Specified by:
        `getAttributeTypeAttributeName` in interface `SchemaType`

    - #### setAnnotation

          public void setAnnotation(SchemaAnnotation ann)

    - #### getAnnotation

          public SchemaAnnotation getAnnotation()

      Description copied from interface: `SchemaAnnotated`
      Returns the Schema annotation object or null if none present
      Specified by:
        `getAnnotation` in interface `SchemaAnnotated`

    - #### setDocumentType

          public void setDocumentType(boolean isDocument)

    - #### setAttributeType

          public void setAttributeType(boolean isAttribute)

    - #### getContentType

          public int getContentType()

      Description copied from interface: `SchemaType`
      Returns `SchemaType.EMPTY_CONTENT`, `SchemaType.SIMPLE_CONTENT`, `SchemaType.ELEMENT_CONTENT`, or `SchemaType.MIXED_CONTENT` for complex types. For noncomplex types, returns `SchemaType.NOT_COMPLEX_TYPE`.
      Specified by:
        `getContentType` in interface `SchemaType`

    - #### setComplexTypeVariety

          public void setComplexTypeVariety(int complexTypeVariety)

    - #### getElementSequencer

          public SchemaTypeElementSequencer getElementSequencer()

      Description copied from interface: `SchemaType`
      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.
      Specified by:
        `getElementSequencer` in interface `SchemaType`

    - #### blockRestriction

          public boolean blockRestriction()

      Description copied from interface: `SchemaType`
      True if restrictions of this type cannot be substituted for this type
      Specified by:
        `blockRestriction` in interface `SchemaType`

    - #### blockExtension

          public boolean blockExtension()

      Description copied from interface: `SchemaType`
      True if extensions of this type cannot be substituted for this type
      Specified by:
        `blockExtension` in interface `SchemaType`

    - #### isAbstract

          public boolean isAbstract()

      Description copied from interface: `SchemaType`
      True if this type cannot be used directly in instances
      Specified by:
        `isAbstract` in interface `SchemaType`

    - #### finalExtension

          public boolean finalExtension()

      Description copied from interface: `SchemaType`
      True if other types cannot extend this type (only for complex types)
      Specified by:
        `finalExtension` in interface `SchemaType`

    - #### finalRestriction

          public boolean finalRestriction()

      Description copied from interface: `SchemaType`
      True if other types cannot restrict this type
      Specified by:
        `finalRestriction` in interface `SchemaType`

    - #### finalList

          public boolean finalList()

      Description copied from interface: `SchemaType`
      True if list derivation of this type is prohibited (only for simple types)
      Specified by:
        `finalList` in interface `SchemaType`

    - #### finalUnion

          public boolean finalUnion()

      Description copied from interface: `SchemaType`
      True if union derivation of this type is prohibited (only for simple types)
      Specified by:
        `finalUnion` in interface `SchemaType`

    - #### getContainerField

          public SchemaField getContainerField()

      Description copied from interface: `SchemaType`
      The parent schema element. Null for top-level (named) types and document types.
      Specified by:
        `getContainerField` in interface `SchemaType`

    - #### setContainerField

          public void setContainerField(SchemaField field)

    - #### setContainerFieldRef

          public void setContainerFieldRef(SchemaComponent.Ref ref)

    - #### setContainerFieldIndex

          public void setContainerFieldIndex(short code,
                                             int index)

    - #### getOuterType

          public SchemaType getOuterType()

      Description copied from interface: `SchemaType`
      The outer schema type. Null for top-level (named) types.
      Specified by:
        `getOuterType` in interface `SchemaType`

    - #### setOuterSchemaTypeRef

          public void setOuterSchemaTypeRef(SchemaType.Ref typeref)

    - #### isCompiled

          public boolean isCompiled()

      Description copied from interface: `SchemaType`
      True if this schema type was compiled to have a corresponding Java class.
      Specified by:
        `isCompiled` in interface `SchemaType`

    - #### setCompiled

          public void setCompiled(boolean f)

    - #### isSkippedAnonymousType

          public boolean isSkippedAnonymousType()

      Description copied from interface: `SchemaType`
      True if this anonymous type has no corresponding Java type. True for anonymous types nested within simple type restrictions.
      Specified by:
        `isSkippedAnonymousType` in interface `SchemaType`

    - #### getShortJavaName

          public String getShortJavaName()

      Description copied from interface: `SchemaType`
      The short unqualfiied Java name for the class.
      Specified by:
        `getShortJavaName` in interface `SchemaType`

    - #### setShortJavaName

          public void setShortJavaName(String name)

    - #### getFullJavaName

          public String getFullJavaName()

      Description copied from interface: `SchemaType`
      The fully-qualified Java type name of the class.
      Specified by:
        `getFullJavaName` in interface `SchemaType`

    - #### setFullJavaName

          public void setFullJavaName(String name)

    - #### setShortJavaImplName

          public void setShortJavaImplName(String name)

    - #### setFullJavaImplName

          public void setFullJavaImplName(String name)

    - #### getFullJavaImplName

          public String getFullJavaImplName()

      Description copied from interface: `SchemaType`
      The fully-qualified Java type name of the implementation class.
      Specified by:
        `getFullJavaImplName` in interface `SchemaType`

    - #### getShortJavaImplName

          public String getShortJavaImplName()

      Description copied from interface: `SchemaType`
      The short unqualfiied Java name for the implementation class.
      Specified by:
        `getShortJavaImplName` in interface `SchemaType`

    - #### getUserTypeName

          public String getUserTypeName()

    - #### setUserTypeName

          public void setUserTypeName(String userTypeName)

    - #### getUserTypeHandlerName

          public String getUserTypeHandlerName()

    - #### setUserTypeHandlerName

          public void setUserTypeHandlerName(String typeHandler)

    - #### setInterfaceExtensions

          public void setInterfaceExtensions(InterfaceExtension[] interfaces)

    - #### getInterfaceExtensions

          public InterfaceExtension[] getInterfaceExtensions()

    - #### setPrePostExtension

          public void setPrePostExtension(PrePostExtension prepost)

    - #### getPrePostExtension

          public PrePostExtension getPrePostExtension()

    - #### getUserData

          public Object getUserData()

      Description copied from interface: `SchemaType`
      Returns user-specific information.
      Specified by:
        `getUserData` in interface `SchemaType`
      See Also:
        `SchemaBookmark`

    - #### setUserData

          public void setUserData(Object data)

    - #### getTypeSystem

          public SchemaTypeSystem getTypeSystem()

      Description copied from interface: `SchemaType`
      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`
      Specified by:
        `getTypeSystem` in interface `SchemaType`

    - #### getContentModel

          public SchemaParticle getContentModel()

      Description copied from interface: `SchemaType`
      Returns the complex content model for this complex type (with complex content).
      Specified by:
        `getContentModel` in interface `SchemaType`

    - #### getLocalElementByIndex

          public SchemaLocalElement getLocalElementByIndex(int i)

    - #### getIndexForLocalElement

          public int getIndexForLocalElement(SchemaLocalElement elt)

    - #### getIndexForLocalAttribute

          public int getIndexForLocalAttribute(SchemaLocalAttribute attr)

    - #### getAttributeModel

          public SchemaAttributeModel getAttributeModel()

      Description copied from interface: `SchemaType`
      Returns the attribute model for this complex type (with simple or complex content).
      Specified by:
        `getAttributeModel` in interface `SchemaType`

    - #### getProperties

          public SchemaProperty[] getProperties()

      Description copied from interface: `SchemaType`
      Returns all the SchemaProperties within this complex type, elements followed by attributes.
      Specified by:
        `getProperties` in interface `SchemaType`

    - #### getDerivedProperties

          public SchemaProperty[] getDerivedProperties()

      Description copied from interface: `SchemaType`
      Returns the SchemaProperties defined by this complex type, exclusive of the base type (if any).
      Specified by:
        `getDerivedProperties` in interface `SchemaType`

    - #### getElementProperties

          public SchemaProperty[] getElementProperties()

      Description copied from interface: `SchemaType`
      Returns all the SchemaProperties corresponding to elements.
      Specified by:
        `getElementProperties` in interface `SchemaType`

    - #### getAttributeProperties

          public SchemaProperty[] getAttributeProperties()

      Description copied from interface: `SchemaType`
      Returns all the SchemaProperties corresponding to attributes.
      Specified by:
        `getAttributeProperties` in interface `SchemaType`

    - #### getElementProperty

          public SchemaProperty getElementProperty(QName eltName)

      Description copied from interface: `SchemaType`
      Returns a SchemaProperty corresponding to an element within this complex type by looking up the element name.
      Specified by:
        `getElementProperty` in interface `SchemaType`

    - #### getAttributeProperty

          public SchemaProperty getAttributeProperty(QName attrName)

      Description copied from interface: `SchemaType`
      Returns a SchemaProperty corresponding to an attribute within this complex type by looking up the attribute name.
      Specified by:
        `getAttributeProperty` in interface `SchemaType`

    - #### hasAllContent

          public boolean hasAllContent()

      Description copied from interface: `SchemaType`
      True if the complex content model for this complex type is an "all" group.
      Specified by:
        `hasAllContent` in interface `SchemaType`

    - #### isOrderSensitive

          public boolean isOrderSensitive()

      Description copied from interface: `SchemaType`
      True if particles have same defaults, nillability, etc, that are invariant when order changes. Computed only for Javaized types.
      Specified by:
        `isOrderSensitive` in interface `SchemaType`

    - #### setOrderSensitive

          public void setOrderSensitive(boolean sensitive)

    - #### setContentModel

          public void setContentModel(SchemaParticle contentModel,
                                      SchemaAttributeModel attrModel,
                                      Map<QName,SchemaProperty> propertyModelByElementName,
                                      Map<QName,SchemaProperty> propertyModelByAttributeName,
                                      boolean isAll)

    - #### hasAttributeWildcards

          public boolean hasAttributeWildcards()

      Description copied from interface: `SchemaType`
      True if this type permits wildcard attributes. See the attribute model for more information about which wildcards are allowed.
      Specified by:
        `hasAttributeWildcards` in interface `SchemaType`

    - #### hasElementWildcards

          public boolean hasElementWildcards()

      Description copied from interface: `SchemaType`
      True if this type permits element wildcards. See the content model for more information about which wildcards are allowed, and where.
      Specified by:
        `hasElementWildcards` in interface `SchemaType`

    - #### isValidSubstitution

          public boolean isValidSubstitution(QName name)

      Description copied from interface: `SchemaType`
      For document types, true if the given name can be substituted for the document element name.
      Specified by:
        `isValidSubstitution` in interface `SchemaType`

    - #### getElementType

          public SchemaType getElementType(QName eltName,
                                           QName xsiType,
                                           SchemaTypeLoader wildcardTypeLoader)

      Description copied from interface: `SchemaType`
      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).
      Specified by:
        `getElementType` in interface `SchemaType`

    - #### getAttributeType

          public SchemaType getAttributeType(QName attrName,
                                             SchemaTypeLoader wildcardTypeLoader)

      Description copied from interface: `SchemaType`
      Returns the type of an attribute based on the attribute name and the type system within which (wildcard) names are resolved.
      Specified by:
        `getAttributeType` in interface `SchemaType`

    - #### createElementType

          public XmlObject createElementType(QName eltName,
                                             QName xsiType,
                                             SchemaTypeLoader wildcardTypeLoader)

    - #### createAttributeType

          public XmlObject createAttributeType(QName attrName,
                                               SchemaTypeLoader wildcardTypeLoader)

    - #### setWildcardSummary

          public void setWildcardSummary(QNameSet elementSet,
                                         boolean haswcElt,
                                         QNameSet attributeSet,
                                         boolean haswcAtt)

    - #### getAnonymousTypes

          public SchemaType[] getAnonymousTypes()

      Description copied from interface: `SchemaType`
      The array of inner (anonymous) types defined within this type.
      Specified by:
        `getAnonymousTypes` in interface `SchemaType`

    - #### setAnonymousTypeRefs

          public void setAnonymousTypeRefs(SchemaType.Ref[] anonymousTyperefs)

    - #### setSimpleTypeVariety

          public void setSimpleTypeVariety(int variety)

    - #### getSimpleVariety

          public int getSimpleVariety()

      Description copied from interface: `SchemaType`
      Returns whether the simple type is ATOMIC, UNION, or LIST. Returns `SchemaType.NOT_SIMPLE`, `SchemaType.ATOMIC`, `SchemaType.UNION`, or `SchemaType.LIST`.
      Specified by:
        `getSimpleVariety` in interface `SchemaType`

    - #### isURType

          public boolean isURType()

      Description copied from interface: `SchemaType`
      True for anyType and anySimpleType.
      Specified by:
        `isURType` in interface `SchemaType`

    - #### isNoType

          public boolean isNoType()

      Description copied from interface: `SchemaType`
      True for the type object that represents a the absence of a determined type. XML Objects whose type isNoType() are never valid.
      Specified by:
        `isNoType` in interface `SchemaType`

    - #### isSimpleType

          public boolean isSimpleType()

      Description copied from interface: `SchemaType`
      True for the anySimpleType and any restrictions/unions/lists.
      Specified by:
        `isSimpleType` in interface `SchemaType`

    - #### setSimpleType

          public void setSimpleType(boolean f)

    - #### isUnionOfLists

          public boolean isUnionOfLists()

    - #### setUnionOfLists

          public void setUnionOfLists(boolean f)

    - #### getPrimitiveType

          public SchemaType getPrimitiveType()

      Description copied from interface: `SchemaType`
      For atomic types only: get the primitive type underlying this one.

      Returns null if this is not an atomic type.

      Specified by:
        `getPrimitiveType` in interface `SchemaType`

    - #### setPrimitiveTypeRef

          public void setPrimitiveTypeRef(SchemaType.Ref typeref)

    - #### getDecimalSize

          public int getDecimalSize()

      Description copied from interface: `SchemaType`
      For atomic numeric restrictions of decimal only: the numeric size category. Takes into account min and max restrictions as well as totalDigits and fractionDigits facets.

      Returns either `SchemaType.NOT_DECIMAL`, `SchemaType.SIZE_BYTE`, `SchemaType.SIZE_SHORT`, `SchemaType.SIZE_INT`, `SchemaType.SIZE_LONG`, `SchemaType.SIZE_BIG_INTEGER`, or `SchemaType.SIZE_BIG_DECIMAL`.

      Specified by:
        `getDecimalSize` in interface `SchemaType`

    - #### setDecimalSize

          public void setDecimalSize(int bits)

    - #### getBaseType

          public SchemaType getBaseType()

      Description copied from interface: `SchemaType`
      Returns base restriction or extension type. Unions and lists return the anySimpleType.
      Specified by:
        `getBaseType` in interface `SchemaType`

    - #### setBaseTypeRef

          public void setBaseTypeRef(SchemaType.Ref typeref)

    - #### getBaseDepth

          public int getBaseDepth()

    - #### setBaseDepth

          public void setBaseDepth(int depth)

    - #### getContentBasedOnType

          public SchemaType getContentBasedOnType()

      Description copied from interface: `SchemaType`
      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.
      Specified by:
        `getContentBasedOnType` in interface `SchemaType`

    - #### setContentBasedOnTypeRef

          public void setContentBasedOnTypeRef(SchemaType.Ref typeref)

    - #### getDerivationType

          public int getDerivationType()

      Description copied from interface: `SchemaType`
      Returns an integer for the derivation type, either `SchemaType.DT_EXTENSION`, `SchemaType.DT_RESTRICTION`, `SchemaType.DT_NOT_DERIVED`.
      Specified by:
        `getDerivationType` in interface `SchemaType`

    - #### setDerivationType

          public void setDerivationType(int type)

    - #### getListItemType

          public SchemaType getListItemType()

      Description copied from interface: `SchemaType`
      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.

      Specified by:
        `getListItemType` in interface `SchemaType`

    - #### setListItemTypeRef

          public void setListItemTypeRef(SchemaType.Ref typeref)

    - #### getUnionMemberTypes

          public SchemaType[] getUnionMemberTypes()

      Description copied from interface: `SchemaType`
      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.

      Specified by:
        `getUnionMemberTypes` in interface `SchemaType`

    - #### setUnionMemberTypeRefs

          public void setUnionMemberTypeRefs(SchemaType.Ref[] typerefs)

    - #### getAnonymousUnionMemberOrdinal

          public int getAnonymousUnionMemberOrdinal()

      Description copied from interface: `SchemaType`
      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.
      Specified by:
        `getAnonymousUnionMemberOrdinal` in interface `SchemaType`

    - #### setAnonymousUnionMemberOrdinal

          public void setAnonymousUnionMemberOrdinal(int i)

    - #### getUnionConstituentTypes

          public SchemaType[] getUnionConstituentTypes()

      Description copied from interface: `SchemaType`
      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.

      Specified by:
        `getUnionConstituentTypes` in interface `SchemaType`

    - #### getUnionSubTypes

          public SchemaType[] getUnionSubTypes()

      Description copied from interface: `SchemaType`
      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.

      Specified by:
        `getUnionSubTypes` in interface `SchemaType`

    - #### getUnionCommonBaseType

          public SchemaType getUnionCommonBaseType()

      Description copied from interface: `SchemaType`
      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.

      Specified by:
        `getUnionCommonBaseType` in interface `SchemaType`

    - #### getSubstitutionGroup

          public QName getSubstitutionGroup()

    - #### setSubstitutionGroup

          public void setSubstitutionGroup(QName sg)

    - #### addSubstitutionGroupMember

          public void addSubstitutionGroupMember(QName member)

    - #### getSubstitutionGroupMembers

          public QName[] getSubstitutionGroupMembers()

    - #### getWhiteSpaceRule

          public int getWhiteSpaceRule()

      Description copied from interface: `SchemaType`
      For nonunion simple types: get the whitespace rule. This is either `SchemaType.WS_PRESERVE`, `SchemaType.WS_REPLACE`, or `SchemaType.WS_COLLAPSE`. Returns `SchemaType.WS_UNSPECIFIED` for unions and complex types.
      Specified by:
        `getWhiteSpaceRule` in interface `SchemaType`

    - #### setWhiteSpaceRule

          public void setWhiteSpaceRule(int ws)

    - #### getFacet

          public XmlAnySimpleType getFacet(int facetCode)

      Description copied from interface: `SchemaType`
      Returns the value of the given facet, or null if none is set.
      Specified by:
        `getFacet` in interface `SchemaType`

    - #### isFacetFixed

          public boolean isFacetFixed(int facetCode)

      Description copied from interface: `SchemaType`
      True if the given facet is fixed.
      Specified by:
        `isFacetFixed` in interface `SchemaType`

    - #### getBasicFacets

          public XmlAnySimpleType[] getBasicFacets()

    - #### getFixedFacets

          public boolean[] getFixedFacets()

    - #### setBasicFacets

          public void setBasicFacets(XmlValueRef[] values,
                                     boolean[] fixed)

    - #### ordered

          public int ordered()

      Description copied from interface: `SchemaType`
      True if ordered. Returns either `SchemaType.UNORDERED`, `SchemaType.PARTIAL_ORDER`, or `SchemaType.TOTAL_ORDER`.
      Specified by:
        `ordered` in interface `SchemaType`

    - #### setOrdered

          public void setOrdered(int ordering)

    - #### isBounded

          public boolean isBounded()

      Description copied from interface: `SchemaType`
      True if bounded.
      Specified by:
        `isBounded` in interface `SchemaType`

    - #### setBounded

          public void setBounded(boolean f)

    - #### isFinite

          public boolean isFinite()

      Description copied from interface: `SchemaType`
      True if finite.
      Specified by:
        `isFinite` in interface `SchemaType`

    - #### setFinite

          public void setFinite(boolean f)

    - #### isNumeric

          public boolean isNumeric()

      Description copied from interface: `SchemaType`
      True if numeric.
      Specified by:
        `isNumeric` in interface `SchemaType`

    - #### setNumeric

          public void setNumeric(boolean f)

    - #### hasPatternFacet

          public boolean hasPatternFacet()

      Description copied from interface: `SchemaType`
      True if there are regex pattern facents
      Specified by:
        `hasPatternFacet` in interface `SchemaType`

    - #### setPatternFacet

          public void setPatternFacet(boolean hasPatterns)

    - #### matchPatternFacet

          public boolean matchPatternFacet(String s)

      Description copied from interface: `SchemaType`
      True if the given string matches the pattern facets. Always true if there are no pattern facets.
      Specified by:
        `matchPatternFacet` in interface `SchemaType`

    - #### getPatterns

          public String[] getPatterns()

      Description copied from interface: `SchemaType`
      True
      Specified by:
        `getPatterns` in interface `SchemaType`

    - #### getPatternExpressions

          public RegularExpression[] getPatternExpressions()

    - #### setPatterns

          public void setPatterns(RegularExpression[] list)

    - #### getEnumerationValues

          public XmlAnySimpleType[] getEnumerationValues()

      Description copied from interface: `SchemaType`
      Returns the array of valid objects from the enumeration facet, null if no enumeration defined.
      Specified by:
        `getEnumerationValues` in interface `SchemaType`

    - #### setEnumerationValues

          public void setEnumerationValues(XmlValueRef[] a)

    - #### enumForString

          public StringEnumAbstractBase enumForString(String s)

      Description copied from interface: `SchemaType`
      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.
      Specified by:
        `enumForString` in interface `SchemaType`

    - #### enumForInt

          public StringEnumAbstractBase enumForInt(int i)

      Description copied from interface: `SchemaType`
      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.
      Specified by:
        `enumForInt` in interface `SchemaType`

    - #### enumEntryForString

          public SchemaStringEnumEntry enumEntryForString(String s)

      Description copied from interface: `SchemaType`
      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.
      Specified by:
        `enumEntryForString` in interface `SchemaType`

    - #### getBaseEnumType

          public SchemaType getBaseEnumType()

      Description copied from interface: `SchemaType`
      If this is a string enumeration, returns the most basic base schema type that this enuemration is based on. Otherwise returns null.
      Specified by:
        `getBaseEnumType` in interface `SchemaType`

    - #### setBaseEnumTypeRef

          public void setBaseEnumTypeRef(SchemaType.Ref baseEnumTyperef)

    - #### getStringEnumEntries

          public SchemaStringEnumEntry[] getStringEnumEntries()

      Description copied from interface: `SchemaType`
      Returns the array of SchemaStringEnumEntries for this type: this array includes information about the java constant names used for each string enum entry.
      Specified by:
        `getStringEnumEntries` in interface `SchemaType`

    - #### setStringEnumEntries

          public void setStringEnumEntries(SchemaStringEnumEntry[] sEnums)

    - #### hasStringEnumValues

          public boolean hasStringEnumValues()

      Description copied from interface: `SchemaType`
      True if this is a string enum where an integer is assigned to each enumerated value.
      Specified by:
        `hasStringEnumValues` in interface `SchemaType`

    - #### copyEnumerationValues

          public void copyEnumerationValues(SchemaTypeImpl baseImpl)

    - #### getBuiltinTypeCode

          public int getBuiltinTypeCode()

      Description copied from interface: `SchemaType`
      Returns an integer for builtin types that can be used for quick comparison.
      Specified by:
        `getBuiltinTypeCode` in interface `SchemaType`

    - #### setBuiltinTypeCode

          public void setBuiltinTypeCode(int builtinTypeCode)

    - #### getJavaClass

          public Class<? extends XmlObject> getJavaClass()

      Description copied from interface: `SchemaType`
      The Java class corresponding to this schema type.
      Specified by:
        `getJavaClass` in interface `SchemaType`

    - #### getJavaImplClass

          public Class<? extends XmlObjectBase> getJavaImplClass()

    - #### getJavaImplConstructor

          public Constructor<? extends XmlObjectBase> getJavaImplConstructor()

    - #### getJavaImplConstructor2

          public Constructor<? extends XmlObjectBase> getJavaImplConstructor2()

    - #### getEnumJavaClass

          public Class<? extends StringEnumAbstractBase> getEnumJavaClass()

      Description copied from interface: `SchemaType`
      The Java class corresponding to the enumeration type for this schema type, if applicable (or null if not an enumeration).
      Specified by:
        `getEnumJavaClass` in interface `SchemaType`

    - #### setJavaClass

          public void setJavaClass(Class<? extends XmlObject> javaClass)

    - #### isPrimitiveType

          public boolean isPrimitiveType()

      Description copied from interface: `SchemaType`
      True for any of the 20 primitive types (plus anySimpleType)
      Specified by:
        `isPrimitiveType` in interface `SchemaType`

    - #### isBuiltinType

          public boolean isBuiltinType()

      Description copied from interface: `SchemaType`
      True for any of the 40+ built-in types.
      Specified by:
        `isBuiltinType` in interface `SchemaType`

    - #### createUnwrappedNode

          public XmlObject createUnwrappedNode()

    - #### createTypeStoreUser

          public TypeStoreUser createTypeStoreUser()

      TypeStoreUserFactory implementation
      Specified by:
        `createTypeStoreUser` in interface `TypeStoreUserFactory`

    - #### newValidatingValue

          public XmlAnySimpleType newValidatingValue(Object obj)

    - #### newValue

          public XmlAnySimpleType newValue(Object obj)

      Creates an immutable simple value.
      Specified by:
        `newValue` in interface `SchemaType`

    - #### newValue

          public XmlAnySimpleType newValue(Object obj,
                                           boolean validateOnSet)

    - #### getCommonBaseType

          public SchemaType getCommonBaseType(SchemaType type)

      Description copied from interface: `SchemaType`
      Returns common base type with the given type. The returned type is the most specific declared base type of both types.
      Specified by:
        `getCommonBaseType` in interface `SchemaType`

    - #### isAssignableFrom

          public boolean isAssignableFrom(SchemaType type)

      Description copied from interface: `SchemaType`
      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.

      Specified by:
        `isAssignableFrom` in interface `SchemaType`

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

    - #### setParseContext

          public void setParseContext(XmlObject parseObject,
                                      String targetNamespace,
                                      boolean chameleon,
                                      String elemFormDefault,
                                      String attFormDefault,
                                      boolean redefinition)

    - #### getParseObject

          public XmlObject getParseObject()

    - #### getTargetNamespace

          public String getTargetNamespace()

    - #### isChameleon

          public boolean isChameleon()

    - #### getElemFormDefault

          public String getElemFormDefault()

    - #### getAttFormDefault

          public String getAttFormDefault()

    - #### getChameleonNamespace

          public String getChameleonNamespace()

    - #### isRedefinition

          public boolean isRedefinition()

    - #### getRef

          public SchemaType.Ref getRef()

      Description copied from interface: `SchemaType`
      Retruns a SchemaType.Ref pointing to this schema type itself.
      Specified by:
        `getRef` in interface `SchemaType`

    - #### getComponentRef

          public SchemaComponent.Ref getComponentRef()

      Description copied from interface: `SchemaComponent`
      Used for on-demand loading of schema components.
      Specified by:
        `getComponentRef` in interface `SchemaComponent`

    - #### qnameSetForWildcardElements

          public 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'.
      Specified by:
        `qnameSetForWildcardElements` in interface `SchemaType`
      Returns:
        the constructed QNameSet

    - #### qnameSetForWildcardAttributes

          public 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'.
      Specified by:
        `qnameSetForWildcardAttributes` in interface `SchemaType`
      Returns:
        the constructed QNameSet

    - #### getDocumentation

          public String getDocumentation()

      Description copied from interface: `SchemaType`
      returns user specified documentation

           <xs:complexType ...>
             <xs:annotation>
                <xs:documentation>
                    getDocumentation method will return whatever stuff here.
                </xs:docmentation>
             </xs:annotation>
           </xs complexType>

      Specified by:
        `getDocumentation` in interface `SchemaType`