Overview | Package | Class | Deprecated | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

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

Overview | Package | Class | Deprecated | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

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