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.