com.saxonica.schema

## Class UserDefinedType

- java.lang.Object
- - com.saxonica.schema.SchemaStructure
  - - com.saxonica.schema.UserDefinedType

- All Implemented Interfaces:
    UserSchemaComponent, Serializable, SourceLocator, SchemaComponent, SchemaType
  Direct Known Subclasses:
    UserComplexType, UserSimpleType

      public abstract class UserDefinedType
      extends SchemaStructure
      implements Serializable, UserSchemaComponent, SchemaType

  This class represents a user-defined simple type or complex type as defined in XML Schema.
  See Also:
    Serialized Form

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected Set<UserComplexType>` | `extendedTypes` The set of all the types that are derived by extension from this type
    `protected int` | `finalProhibitions` Flags used to implement the "final" and "block" attributes

    - ### Fields inherited from interface net.sf.saxon.type.SchemaType

      `DERIVATION_EXTENSION, DERIVATION_LIST, DERIVATION_RESTRICTION, DERIVATION_UNION, DERIVE_BY_SUBSTITUTION`

    - ### Fields inherited from interface net.sf.saxon.type.SchemaComponent

      `COMPONENT_FUNCTION_TYPE, FIXED_UP, INCOMPLETE, INVALID, UNVALIDATED, VALIDATED, VALIDATING`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `UserDefinedType()` Default constructor.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `allowsDerivation(int derivation)` Determines whether derivation (of a particular kind) from this type is allowed, based on the "final" property
    `void` | `checkTypeDerivationIsOK(SchemaType type, int block)` Check that this type is validly derived from a given type
    `boolean` | `containingDeclarationIsElement()` Determine whether the containing declaration is an element declaration or an attribute declaration
    `SchemaType` | `getBaseType()` Returns the base type that this type inherits from.
    `int` | `getBaseTypeFingerprint()` Get the fingerprint of the name of the base type of this type
    `TypeReference` | `getBaseTypeReference()` Get the reference to the base type.
    `int` | `getBlock()` Returns the value of the 'block' attribute for this type, as a bit-signnificant integer with fields such as `SchemaType.DERIVATION_LIST` and `SchemaType.DERIVATION_EXTENSION`
    `int` | `getContainingDeclarationName()` Get the name of the containing element or attribute declaration, if any (and if known).
    `int` | `getDerivationMethod()` Gets the integer code of the derivation method used to derive this type from its parent.
    `String` | `getDescription()` Get a description of this type for use in diagnostics.
    `String` | `getDisplayName()` Get the display name of the type: that is, a lexical QName with an arbitrary prefix
    `Set<UserComplexType>` | `getExtensionTypes()` Get all the types defined as extensions of this type, transitively
    `int` | `getFinalProhibitions()` Get the types of derivation that are not permitted, by virtue of the "final" property.
    `int` | `getFingerprint()` Get the fingerprint of the name of this type
    `String` | `getLocalName()` Deprecated. since 9.0: use the equivalent method `getName()`
    `String` | `getName()` Get the local name of this type if it has one.
    `int` | `getNameCode()` Get the namecode of the name of this type.
    `NamePool` | `getNamePool()` Get the NamePool in which the name of this type is defined
    `String` | `getTargetNamespace()` Get the namespace URI of the name of this type if it has one.
    `boolean` | `isAnonymousType()` Test whether this is an anonymous type
    `boolean` | `isComplexType()` Test whether this SchemaType is a complex type
    `boolean` | `isExternalType()` Return true if this is an external object type, that is, a Saxon-defined type for external Java or .NET objects
    `boolean` | `isSameType(SchemaType other)` Test whether this is the same type as another type.
    `protected void` | `registerExtensionType(UserComplexType derived)` Register another type as an extension of this type
    `void` | `setBaseTypeReference(TypeReference baseType)` Sets the base type for this datatype.
    `void` | `setContainingDeclaration(int fingerprint, boolean isElement)` Set the name of the containing declaration (for diagnostics)
    `void` | `setDerivationMethod(int method)` Sets the derivation method code (without validating it)
    `void` | `setDerivationMethodName(String method)` Set the derivation method name.
    `void` | `setExtendedTypes(Set<UserComplexType> types)` Set the set of types derived by extension from this one
    `void` | `setFinalProhibitions(int finalValue)` Sets the value of the 'final' property, indicating which types of derivation are not allowed.
    `void` | `setNameCode(int nameCode)` Set the nameCode of the name of this type.

    - ### Methods inherited from class com.saxonica.schema.SchemaStructure

      `elaborate, fixup, getColumnNumber, getConfiguration, getFixupStatus, getLineNumber, getPublicId, getRedefinitionLevel, getSchemaDocumentURI, getSystemId, getValidationStatus, lookForCycles, makeXPathExpressionPropertyRecord, setConfiguration, setFixupStatus, setLineNumber, setLocator, setRedefinitionLevel, setSchemaDocumentURI, setSystemId, setValidationStatus`

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

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

    - ### Methods inherited from interface com.saxonica.schema.UserSchemaComponent

      `elaborate, fixup, lookForCycles, validate`

    - ### Methods inherited from interface net.sf.saxon.type.SchemaType

      `analyzeContentExpression, atomize, getEQName, getSystemId, isAtomicType, isIdRefType, isIdType, isSimpleType`

    - ### Methods inherited from interface net.sf.saxon.type.SchemaComponent

      `getComponentAsFunction, getRedefinitionLevel, getValidationStatus`

- - ### Field Detail

    - #### finalProhibitions

          protected int finalProhibitions

      Flags used to implement the "final" and "block" attributes

    - #### extendedTypes

          protected Set<UserComplexType> extendedTypes

      The set of all the types that are derived by extension from this type

  - ### Constructor Detail

    - #### UserDefinedType

          public UserDefinedType()

      Default constructor. For internal use only.

  - ### Method Detail

    - #### getName

          public String getName()

      Get the local name of this type if it has one. Returns a conventional system-allocated namespace if the type is anonymous.
      Specified by:
        `getName` in interface `SchemaType`
      Returns:
        the target namespace of the type component. Never null.

    - #### getTargetNamespace

          public String getTargetNamespace()

      Get the namespace URI of the name of this type if it has one. Returns a conventional system-allocated namespace if the type is anonymous.
      Specified by:
        `getTargetNamespace` in interface `SchemaType`
      Returns:
        the target namespace of the type component. Never null.

    - #### isExternalType

          public boolean isExternalType()

      Return true if this is an external object type, that is, a Saxon-defined type for external Java or .NET objects
      Returns:
        false (for this class)

    - #### getFingerprint

          public int getFingerprint()

      Get the fingerprint of the name of this type
      Specified by:
        `getFingerprint` in interface `SchemaType`
      Returns:
        the fingerprint. Returns an invented fingerprint for an anonymous type.

    - #### getNameCode

          public int getNameCode()

      Get the namecode of the name of this type. This includes the prefix from the original type declaration: in the case of built-in types, this will be a conventional prefix such as "xs" or "xdt".
      Specified by:
        `getNameCode` in interface `SchemaType`
      Returns:
        the namecode. Returns an invented namecode for an anonymous type.

    - #### isAnonymousType

          public boolean isAnonymousType()

      Test whether this is an anonymous type
      Specified by:
        `isAnonymousType` in interface `SchemaType`
      Returns:
        true if this SchemaType is an anonymous type

    - #### setNameCode

          public void setNameCode(int nameCode)

      Set the nameCode of the name of this type. For internal use only.
      Parameters:
        `nameCode` - the nameCode allocated in the namepool for this schema

    - #### getBaseTypeReference

          public TypeReference getBaseTypeReference()

      Get the reference to the base type. The result is never null, except in the case of the type AnyType, which is the root of the type hierarchy.
      Returns:
        a reference to the base type

    - #### getBaseTypeFingerprint

          public int getBaseTypeFingerprint()

      Get the fingerprint of the name of the base type of this type
      Returns:
        the fingerprint. Return an invented fingerprint for an anonymous type.

    - #### getLocalName

          public String getLocalName()

      Deprecated. since 9.0: use the equivalent method `getName()`
      Get the local name of this type
      Returns:
        the local part of the name, or null if the type is anonymous

    - #### getDisplayName

          public String getDisplayName()

      Get the display name of the type: that is, a lexical QName with an arbitrary prefix
      Specified by:
        `getDisplayName` in interface `SchemaType`
      Returns:
        a lexical QName identifying the type

    - #### isComplexType

          public final boolean isComplexType()

      Test whether this SchemaType is a complex type
      Specified by:
        `isComplexType` in interface `SchemaType`
      Returns:
        true if this SchemaType is a complex type

    - #### getBlock

          public int getBlock()

      Returns the value of the 'block' attribute for this type, as a bit-signnificant integer with fields such as `SchemaType.DERIVATION_LIST` and `SchemaType.DERIVATION_EXTENSION`
      Specified by:
        `getBlock` in interface `SchemaType`
      Returns:
        the value of the 'block' attribute for this type

    - #### getNamePool

          public NamePool getNamePool()

      Get the NamePool in which the name of this type is defined
      Returns:
        the name pool

    - #### getBaseType

          public SchemaType getBaseType()
                                 throws UnresolvedReferenceException

      Returns the base type that this type inherits from. If this type is a Simpletype that is a built in primitive type then null is returned.
      Specified by:
        `getBaseType` in interface `SchemaType`
      Returns:
        the base type.
      Throws:
        `UnresolvedReferenceException` - if this type has no known base type. This can only arise during schema construction, since a type with an unknown base type cannot be used for validation

    - #### setBaseTypeReference

          public void setBaseTypeReference(TypeReference baseType)

      Sets the base type for this datatype. For internal use only.
      Parameters:
        `baseType` - the base type which this type inherits from

    - #### getDerivationMethod

          public int getDerivationMethod()

      Gets the integer code of the derivation method used to derive this type from its parent. Returns zero for primitive types.
      Specified by:
        `getDerivationMethod` in interface `SchemaType`
      Returns:
        a numeric code representing the derivation method, for example `SchemaType.DERIVATION_RESTRICTION`

    - #### allowsDerivation

          public boolean allowsDerivation(int derivation)

      Determines whether derivation (of a particular kind) from this type is allowed, based on the "final" property
      Specified by:
        `allowsDerivation` in interface `SchemaType`
      Parameters:
        `derivation` - the kind of derivation, for example `SchemaType.DERIVATION_LIST`
      Returns:
        true if this kind of derivation is allowed

    - #### getFinalProhibitions

          public int getFinalProhibitions()

      Get the types of derivation that are not permitted, by virtue of the "final" property.
      Specified by:
        `getFinalProhibitions` in interface `SchemaType`
      Returns:
        the types of derivation that are not permitted, as a bit-significant integer containing bits such as `SchemaType.DERIVATION_EXTENSION`

    - #### setDerivationMethodName

          public void setDerivationMethodName(String method)
                                       throws SchemaException

      Set the derivation method name. For internal use only.
      Parameters:
        `method` - the derivation method, for example "restriction"
      Throws:
        `SchemaException` - for an unknown derivation method

    - #### setDerivationMethod

          public void setDerivationMethod(int method)

      Sets the derivation method code (without validating it)
      Parameters:
        `method` - the derivation method as an integer code, for example `SchemaType.DERIVATION_UNION`

    - #### setFinalProhibitions

          public void setFinalProhibitions(int finalValue)

      Sets the value of the 'final' property, indicating which types of derivation are not allowed. For internal use only.
      Parameters:
        `finalValue` - the value of the final property, as a bit-significant integer

    - #### checkTypeDerivationIsOK

          public void checkTypeDerivationIsOK(SchemaType type,
                                     int block)
                                       throws SchemaException

      Check that this type is validly derived from a given type
      Specified by:
        `checkTypeDerivationIsOK` in interface `SchemaType`
      Parameters:
        `type` - the type from which this type is derived
        `block` - the derivations that are blocked by the relevant element declaration
      Throws:
        `SchemaException` - if the derivation is not allowed

    - #### setContainingDeclaration

          public void setContainingDeclaration(int fingerprint,
                                      boolean isElement)

      Set the name of the containing declaration (for diagnostics)
      Parameters:
        `fingerprint` - The fingerprint of the element or attribute declaration "owning" this anonymous type definition
        `isElement` - True if the owning declaration is an element declaration, false if it is an attribute declaration

    - #### getDescription

          public String getDescription()

      Get a description of this type for use in diagnostics. In the case of a named type, this is the same as the display name. In the case of a type known to be defined immediately within an element or attribute declaration, it is a phrase that identifies the containing declaration. In other cases, it is a phrase of the form "defined at line L of URI". The description is designed to be inserted in a context such as "the type X is ..."
      Specified by:
        `getDescription` in interface `SchemaType`
      Returns:
        text identifing the type, for use in a phrase such as "the type XXXX".

    - #### getContainingDeclarationName

          public int getContainingDeclarationName()

      Get the name of the containing element or attribute declaration, if any (and if known).
      Returns:
        the name of the containing declaration, as a NamePool fingerprint.

    - #### containingDeclarationIsElement

          public boolean containingDeclarationIsElement()

      Determine whether the containing declaration is an element declaration or an attribute declaration
      Returns:
        true if the containin declaration is an element declaration, false if it is an attribute

    - #### isSameType

          public boolean isSameType(SchemaType other)

      Test whether this is the same type as another type. They are considered to be the same type if they are derived from the same type definition in the original XML representation (which can happen when there are multiple includes of the same file)
      Specified by:
        `isSameType` in interface `SchemaType`
      Parameters:
        `other` - the other type
      Returns:
        true if this is the same type as other

    - #### registerExtensionType

          protected void registerExtensionType(UserComplexType derived)

      Register another type as an extension of this type
      Parameters:
        `derived` - the type that is derived from this one by extension

    - #### getExtensionTypes

          public Set<UserComplexType> getExtensionTypes()

      Get all the types defined as extensions of this type, transitively
      Returns:
        the set of complex types derived by extension from this type, either directly or indirectly

    - #### setExtendedTypes

          public void setExtendedTypes(Set<UserComplexType> types)

      Set the set of types derived by extension from this one
      Parameters:
        `types` - the set of extended types

Copyright (c) 2004-2013 Saxonica Limited. All rights reserved.