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
`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 unqualified Java name for the implementation class.
`String` `getShortJavaName()` The short unqualified 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 unqualified 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 unqualified 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`