## com.saxonica.schema
Class SchemaTypeImpl

    java.lang.Object
      com.saxonica.schema.SchemaStructure
          com.saxonica.schema.SchemaTypeImpl

All Implemented Interfaces:
  Serializable, SourceLocator, SchemaComponent, SchemaType

Direct Known Subclasses:
  UserComplexType, UserSimpleType

    public abstract class SchemaTypeImpl

extends SchemaStructure
implements Serializable, SchemaType

This class represents a simple type or complex type as defined in XML Schema. In the non-schema-aware version of Saxon it is used to represent built-in schema types only. In the schema-aware version it is subclassed to represent user-defined types.

See Also:
  Serialized Form

Field Summary

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
`FIXED_UP, INCOMPLETE, INVALID, UNVALIDATED, VALIDATED, VALIDATING`

Constructor Summary
`SchemaTypeImpl()` Default constructor.

Method Summary
`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
`int` `getFingerprint()` Get the fingerprint of the name of this type
`String` `getLocalName()` Get the local name of this type
`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
`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.
`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` `setFinalProhibitions(int finalValue)` Sets the value of the 'final' property, indicating which types of derivation are not allowed.
`void` `setLocalName(String localName)` Set the local name of this type
`void` `setNameCode(int nameCode)` Set the nameCode of the name of this type.
`void` `setNamePool(NamePool pool)` Set the NamePool in which the type is defined.

Methods inherited from class com.saxonica.schema.SchemaStructure
`getColumnNumber, getConfiguration, getFixupStatus, getLineNumber, getPublicId, getSystemId, getValidationStatus, lookForCycles, setConfiguration, setFixupStatus, setLineNumber, setLocator, setSystemId, setValidationStatus`

Methods inherited from class java.lang.Object
`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Methods inherited from interface net.sf.saxon.type.SchemaType
`analyzeContentExpression, atomize, getTypedValue, isAtomicType, isSimpleType`

Methods inherited from interface net.sf.saxon.type.SchemaComponent
`getValidationStatus`

Constructor Detail

### SchemaTypeImpl

    public SchemaTypeImpl()

  Default constructor. For internal use only.

Method Detail

### 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

### 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`

### 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.

### 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()

  Get the local name of this type

  Returns:
    the local part of the name, or null if the type is anonymous

### setLocalName

    public void setLocalName(String localName)

  Set the local name of this type

  Parameters:
    `localName` - the local name of the type

### 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

### setNamePool

    public void setNamePool(NamePool pool)

  Set the NamePool in which the type is defined. For internal use only.

  Parameters:
    `pool` - the NamePool containing the names in this schema

### 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)
                              throws SchemaException

  Sets the base type for this datatype. For internal use only.

  Parameters:
    `baseType` - the base type which this type inherits from
  Throws:
    `SchemaException`

### 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

### 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,
                                        ValidationException

  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
    `ValidationException`

### 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`

Copyright (C) Michael H. Kay. All rights reserved.