## com.saxonica.schema
Class UserSimpleType

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

All Implemented Interfaces:
  SerializableSchemaComponent, Serializable, SourceLocator, SchemaComponent, SchemaType, SimpleType

Direct Known Subclasses:
  SimpleTypeDefinition, UserAtomicType, UserListType, UserUnionType

    public abstract class UserSimpleType

extends SchemaTypeImpl
implements SimpleType, SerializableSchemaComponent

This class represents a used-defined simple type, as defined in the XML Schema specification. This may be an atomic type, a list type, or a union type. In the non-schema-aware version of Saxon, a simple type will always be a built-in type. With the schema-aware product, it may also be a user-defined simple type.

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`

Fields inherited from interface com.saxonica.schema.SerializableSchemaComponent
`ALL_COMPOSITOR, ATOMIC_TYPE, ATTRIBUTE_DECL, ATTRIBUTE_GROUP, ATTRIBUTE_GROUP_REF, ATTRIBUTE_USE, ATTRIBUTE_WILDCARD, CHOICE_COMPOSITOR, COMPLEX_TYPE, ELEMENT_DECL, ELEMENT_PARTICLE, ELEMENT_WILDCARD, FACET, KEY, KEYREF, LIST_TYPE, MODEL_GROUP, MODEL_GROUP_REF, NOTATION, SEQUENCE_COMPOSITOR, UNION_TYPE, UNIQUE`

Constructor Summary
`UserSimpleType()`

Method Summary
`void` `analyzeContentExpression(Expression expression, int kind, StaticContext env)` Analyze an expression to see whether the expression is capable of delivering a value of this type.
`CharSequence` `applyWhitespaceNormalization(CharSequence value)` Apply the whitespace normalization rules for this simple type
`Value` `atomize(NodeInfo node)` Get the typed value of a node that is annotated with this schema type.
`ValidationException` `checkAgainstFacets(AtomicValue primitiveValue, CharSequence lexicalValue)` Validate that the value conforms to all the facets for the given type.
`void` `checkTypeDerivationIsOK(SchemaType type, int block)` Check that this type is validly derived from a given type
`SchemaType` `getBuiltInBaseType()` Returns the built-in base type this type is derived from.
`Facet` `getFacet(String name)` Returns the first facet associated with the given name, defined either on this type or on a type from which it is derived
`FacetCollection` `getFacetCollection()` Get the FacetCollection for this simple type
`List` `getFacetList()` Return all the facets for this type
`Iterator` `getFacets()` Returns an Iterator over all the Facets (including inherited facets) for this type.
`Iterator` `getFacets(String name)` Return all the facets having the given name
`SequenceIterator` `getTypedValue(NodeInfo node)` Get the typed value of a node that is annotated with this schema type
`int` `getWhitespaceAction(TypeHierarchy th)` Determine the whitespace normalization required for values of this type
`boolean` `isAtomicType()` Test whether this Simple Type is an atomic type
`boolean` `isListType()` Returns true if this type is derived by list, or if it is derived by restriction from a list type, or if it is a union that contains a list as one of its members
`boolean` `isSimpleType()` Returns true if this SchemaType is a SimpleType
`static String` `isTypeDerivationOK(SimpleType d, SchemaType b, int derivation)` Check whether type derivation is allowed.
`boolean` `isUnionType()` Return true if this type is a union type (that is, if its variety is union)
`void` `setFacetCollection(FacetCollection facets)` Set the FacetCollection for this simple type.
`boolean` `validate(SchemaCompiler compiler)` Checks the validity of this SimpleType definition.

Methods inherited from class com.saxonica.schema.SchemaTypeImpl

`allowsDerivation, containingDeclarationIsElement, getBaseType, getBaseTypeFingerprint, getBaseTypeReference, getBlock, getContainingDeclarationName, getDerivationMethod, getDescription, getDisplayName, getFingerprint, getLocalName, getNameCode, getNamePool, isAnonymousType, isComplexType, isExternalType, isSameType, setBaseTypeReference, setContainingDeclaration, setDerivationMethod, setDerivationMethodName, setFinalProhibitions, setLocalName, setNameCode, setNamePool`

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.SimpleType
`getCommonAtomicType, getTypedValue, isBuiltInType, isExternalType, isNamespaceSensitive, validateContent`

Methods inherited from interface net.sf.saxon.type.SchemaType
`allowsDerivation, getBaseType, getBlock, getDerivationMethod, getDescription, getDisplayName, getFingerprint, getNameCode, isAnonymousType, isComplexType, isSameType`

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

Methods inherited from interface com.saxonica.schema.SerializableSchemaComponent
`getComponentTypeCode, serialize`

Constructor Detail

### UserSimpleType

    public UserSimpleType()

Method Detail

### isSimpleType

    public final boolean isSimpleType()

  Returns true if this SchemaType is a SimpleType

  Specified by:
    `isSimpleType` in interface `SchemaType`
  Returns:
    true (always)

### isAtomicType

    public boolean isAtomicType()

  Test whether this Simple Type is an atomic type

  Specified by:
    `isAtomicType` in interface `SchemaType`
  Specified by:
    `isAtomicType` in interface `SimpleType`
  Returns:
    the default implementation returns false

### isListType

    public boolean isListType()

  Returns true if this type is derived by list, or if it is derived by restriction from a list type, or if it is a union that contains a list as one of its members

  Specified by:
    `isListType` in interface `SimpleType`
  Returns:
    true if this is a list type

### isUnionType

    public boolean isUnionType()

  Return true if this type is a union type (that is, if its variety is union)

  Specified by:
    `isUnionType` in interface `SimpleType`
  Returns:
    true for a union type

### setFacetCollection

    public void setFacetCollection(FacetCollection facets)

  Set the FacetCollection for this simple type. For internal use only.

  Parameters:
    `facets` - the collection of facets for this type.

### getFacetCollection

    public FacetCollection getFacetCollection()

  Get the FacetCollection for this simple type

  Returns:
    a FacetCollection containing all the facets locally declared on this simple type (and providing access to the inherited facets also)

### getFacet

    public Facet getFacet(String name)

  Returns the first facet associated with the given name, defined either on this type or on a type from which it is derived

  Returns:
    the first facet associated with the given name

### getFacets

    public Iterator getFacets(String name)

  Return all the facets having the given name

  Returns:
    an iterator over all the facets with the given name, including those defined on a type from which this is derived by restriction or by union

### getFacets

    public Iterator getFacets()

  Returns an Iterator over all the Facets (including inherited facets) for this type.

  Returns:
    an Iterator over all the Facets for this type.

### getWhitespaceAction

    public int getWhitespaceAction(TypeHierarchy th)

  Determine the whitespace normalization required for values of this type

  Specified by:
    `getWhitespaceAction` in interface `SimpleType`
  Parameters:
    `th` -
  Returns:
    one of PRESERVE, REPLACE, COLLAPSE
  Throws:
    `IllegalStateException` - if the simple type is not fully validated and the whitespace facet is not yet known.

### applyWhitespaceNormalization

    public CharSequence applyWhitespaceNormalization(CharSequence value)
                                              throws ValidationException

  Apply the whitespace normalization rules for this simple type

  Parameters:
    `value` - the string before whitespace normalization
  Returns:
    the string after whitespace normalization
  Throws:
    `ValidationException`

### getBuiltInBaseType

    public SchemaType getBuiltInBaseType()

  Returns the built-in base type this type is derived from.

  Specified by:
    `getBuiltInBaseType` in interface `SimpleType`
  Returns:
    the first built-in type found when searching up the type hierarchy

### 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`
  Overrides:
    `checkTypeDerivationIsOK` in class `SchemaTypeImpl`
  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`

### validate

    public boolean validate(SchemaCompiler compiler)
                     throws SchemaException,
                            UnresolvedReferenceException,
                            ValidationException

  Checks the validity of this SimpleType definition.

  Parameters:
    `compiler` -
  Throws:
    `SchemaException` - if this SimpleType definition is invalid.
    `UnresolvedReferenceException`
    `ValidationException`

### analyzeContentExpression

    public void analyzeContentExpression(Expression expression,
                                         int kind,
                                         StaticContext env)
                                  throws XPathException

  Analyze an expression to see whether the expression is capable of delivering a value of this type.

  Specified by:
    `analyzeContentExpression` in interface `SchemaType`
  Parameters:
    `expression` - the expression that delivers the content
    `kind` - the node kind whose content is being delivered: `Type.ELEMENT`, `Type.ATTRIBUTE`, or `Type.DOCUMENT`
    `env` -
  Throws:
    `XPathException` - if the expression will never deliver a value of the correct type

### getTypedValue

    public final SequenceIterator getTypedValue(NodeInfo node)
                                         throws XPathException

  Get the typed value of a node that is annotated with this schema type

  Specified by:
    `getTypedValue` in interface `SchemaType`
  Parameters:
    `node` - the node whose typed value is required
  Returns:
    an iterator over the items making up the typed value of this node. The objects returned by this SequenceIterator will all be of type `AtomicValue`
  Throws:
    `XPathException`

### atomize

    public Value atomize(NodeInfo node)
                  throws XPathException

  Get the typed value of a node that is annotated with this schema type. The result of this method will always be consistent with the method `getTypedValue(net.sf.saxon.om.NodeInfo)`. However, this method is often more convenient and may be more efficient, especially in the common case where the value is expected to be a singleton.

  Specified by:
    `atomize` in interface `SchemaType`
  Parameters:
    `node` - the node whose typed value is required
  Returns:
    the typed value.
  Throws:
    `XPathException`
  Since:
    8.5

### isTypeDerivationOK

    public static String isTypeDerivationOK(SimpleType d,
                                            SchemaType b,
                                            int derivation)

  Check whether type derivation is allowed. This implements the Schema Component Constraint: Type Derivation OK (Simple). This type is D (the derived type); the type supplied as an argument is B (the base type), and the argument (a subset (extension, restriction, list, union)) is provided in the second argument. If type derivation is allowed, the method return null; otherwise it returns a string that can be used as an error message

  Parameters:
    `b` - the base type
    `derivation` - the disallowed derivations, as a bit-significant integer
  Returns:
    null if type derivation is OK; otherwise a string that can be used as an error message

### getFacetList

    public List getFacetList()

  Return all the facets for this type

  Returns:
    the list of facets defined on this simple type (this doesn't include inherited facets)

### checkAgainstFacets

    public ValidationException checkAgainstFacets(AtomicValue primitiveValue,
                                                  CharSequence lexicalValue)

  Validate that the value conforms to all the facets for the given type.

  Parameters:
    `lexicalValue` - The supplied value; this must be normalized using the whitespace facet, and then checked against the pattern facet. May be null; if so the actual value is converted to a string for checking against the pattern.
  Returns:
    null if the value is OK, otherwise an XPathException. Note that the exception is returned rather than being thrown. This is designed to make the "castable" operator more efficient.

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