com.saxonica.ee.schema

Class UserSimpleType

java.lang.Object

com.saxonica.ee.schema.SchemaStructure

com.saxonica.ee.schema.UserDefinedType

com.saxonica.ee.schema.UserSimpleType

All Implemented Interfaces:

SerializableSchemaComponent, UserSchemaComponent, SourceLocator, SchemaComponent, SchemaType, SimpleType

Direct Known Subclasses:

SimpleTypeDefinition, UserAtomicType, UserListType, UserUnionType

public abstract class UserSimpleType
extends UserDefinedType
implements SimpleType, UserSchemaComponent, 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.

Field Summary

Fields inherited from class com.saxonica.ee.schema.UserDefinedType

extendedTypes, finalProhibitions

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
UserSimpleType() Construct a UserSimpleType

Method Summary

Methods

Modifier and Type	Method and Description
void	addFacet(Facet facet) Add the given Facet to this Simpletype.
protected List<Facet>	addInheritedFacets(List<Facet> localFacets)
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
AtomicSequence	atomize(NodeInfo node) Get the typed value of a node that is annotated with this schema type.
ValidationFailure	checkAgainstFacets(AtomicSequence primitiveValue, CharSequence lexicalValue, List<Facet> facets, ConversionRules rules) Validate that the value conforms to all the constraining facets for the given type.
void	checkTypeDerivationIsOK(SchemaType type, int block) Check that this type is validly derived from a given type
void	convertFacetValues() Convert the values of facets to the target data type
void	elaborate(SchemaCompiler compiler) Elaborate the schema component: after reloading a serialized schema component model, this expands the component with derived information needed during validation episodes.
SchemaType	getBuiltInBaseType() Returns the built-in base type this type is derived from.
FunctionItem	getComponentAsFunction() Get the schema component in the form of a function item.
static FunctionItem	getComponentAsFunction(SimpleType type) Get schema information for a simple type in the form of a function item
SchemaComponent	getContextComponent() Get the component that contains the definition of this anonymous simple type definition
String	getEQName() Get the name of this type as an EQName, that is, a string in the format Q{uri}local.
List<Facet>	getExtendedFacetList() Get the extended facet list, creating it if necessary.
Facet	getFacet(Class name) Returns the first facet associated with the given name, defined either on this type or on a type from which it is derived
List<Facet>	getLocalFacetList() Return all the facets for this type
int	getWhitespaceAction() Determine the whitespace normalization required for values of this type
boolean	isAtomicType() Test whether this Simple Type is an atomic type
boolean	isIdRefType() Ask whether this type is an IDREF or IDREFS type.
boolean	isIdType() Ask whether this type is an ID 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), which will be true if is derived by union, or if it is derived by restriction from a type whose variety is union.
void	mergeEnumerationFacets(SchemaCompiler compiler) Merge enumeration facets into a single enumerationSet pseudo-facet.
CharSequence	postprocess(CharSequence input) Reverse any pre-lexical facets, other than whitespace.
CharSequence	preprocess(CharSequence input) Apply any pre-lexical facets, other than whitespace.
void	serialize(SchemaModelSerializer serializer) Serialize the schema component
protected abstract void	serializeVariety(SchemaModelSerializer serializer)
void	setContextComponent(SchemaComponent contextComponent) Set the component that contains the definition of this anonymous simple type definition
void	setFacetList(List<Facet> facetList) Set the local facet list for this simple type
boolean	validate(SchemaCompiler compiler) Checks the validity of this SimpleType definition.

Methods inherited from class com.saxonica.ee.schema.UserDefinedType

allowsDerivation, containingDeclarationIsElement, getBaseType, getBaseTypeFingerprint, getBaseTypeReference, getBlock, getContainingDeclarationName, getDerivationMethod, getDescription, getDisplayName, getExtensionTypes, getFinalProhibitions, getFingerprint, getLocalName, getName, getNameCode, getNamePool, getTargetNamespace, isAnonymousType, isComplexType, isExternalType, isSameType, registerExtensionType, setBaseTypeReference, setContainingDeclaration, setDerivationMethod, setDerivationMethodName, setExtendedTypes, setFinalProhibitions, setNameCode, toString

Methods inherited from class com.saxonica.ee.schema.SchemaStructure

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, wait, wait, wait

Methods inherited from interface net.sf.saxon.type.SimpleType

getTypedValue, isBuiltInType, isExternalType, isNamespaceSensitive, validateContent

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

allowsDerivation, getBaseType, getBlock, getDerivationMethod, getDescription, getDisplayName, getFinalProhibitions, getFingerprint, getName, getNameCode, getSystemId, getTargetNamespace, isAnonymousType, isComplexType, isSameType

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

getRedefinitionLevel, getValidationStatus

Methods inherited from interface com.saxonica.ee.schema.UserSchemaComponent

fixup, lookForCycles

Constructor Detail

UserSimpleType

public UserSimpleType()

Construct a 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

isIdType

public boolean isIdType()

Ask whether this type is an ID type. This is defined to be any simple type who typed value may contain atomic values of type xs:ID: that is, it includes types derived from ID by restriction, list, or union. Note that for a node to be treated as an ID, its typed value must be a *single* atomic value of type ID; the type of the node, however, can still allow a list.

Specified by:

isIdType in interface SchemaType

Returns:

true if this type is an ID type

isIdRefType

public boolean isIdRefType()

Ask whether this type is an IDREF or IDREFS type. This is defined to be any simple type who typed value may contain atomic values of type xs:IDREF: that is, it includes types derived from IDREF or IDREFS by restriction, list, or union

Specified by:

isIdRefType in interface SchemaType

Returns:

true if this type is an IDREF type

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), which will be true if is derived by union, or if it is derived by restriction from a type whose variety is union.

Specified by:

isUnionType in interface SimpleType

Returns:

true for a union type

getContextComponent

public SchemaComponent getContextComponent()

Get the component that contains the definition of this anonymous simple type definition

Returns:

the containing component, or null of the type is not anonymous

setContextComponent

public void setContextComponent(SchemaComponent contextComponent)

Set the component that contains the definition of this anonymous simple type definition

Parameters:

contextComponent - the containing component, or null of the type is not anonymous

getExtendedFacetList

public List<Facet> getExtendedFacetList()

Get the extended facet list, creating it if necessary. The extended facet list includes facets inherited from supertypes, unless they are redundant. This includes all constraining facets (but not fundamental facets)

Returns:

the extended facet list

addInheritedFacets

protected List<Facet> addInheritedFacets(List<Facet> localFacets)

getEQName

public String getEQName()

Get the name of this type as an EQName, that is, a string in the format Q{uri}local.

Specified by:

getEQName in interface SchemaType

Returns:

an EQName identifying the type. In the case of an anonymous type, an internally-generated name is returned

addFacet

public void addFacet(Facet facet)

Add the given Facet to this Simpletype.

Parameters:

facet - the Facet to add to this Simpletype

mergeEnumerationFacets

public void mergeEnumerationFacets(SchemaCompiler compiler)
                            throws SchemaException,
                                   UnresolvedReferenceException

Merge enumeration facets into a single enumerationSet pseudo-facet. This method also merges multiple pattern facets into a single pattern facet with multiple branches.

Parameters:

compiler - used for error reporting

Throws:

SchemaException - if a schema validity error is found

UnresolvedReferenceException - if an unresolved reference to a schema component is found

getFacet

public Facet getFacet(Class name)

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

Parameters:

name - the required class of facet

Returns:

the first facet associated with the given name

setFacetList

public void setFacetList(List<Facet> facetList)

Set the local facet list for this simple type

Parameters:

facetList - the list of facets

convertFacetValues

public void convertFacetValues()
                        throws SchemaException

Convert the values of facets to the target data type

Throws:

SchemaException - if conversion fails

getWhitespaceAction

public int getWhitespaceAction()

Determine the whitespace normalization required for values of this type

Specified by:

getWhitespaceAction in interface SimpleType

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)

Apply the whitespace normalization rules for this simple type

Parameters:

value - the string before whitespace normalization

Returns:

the string after whitespace normalization

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

Check that this type is validly derived from a given type

Specified by:

checkTypeDerivationIsOK in interface SchemaType

Overrides:

checkTypeDerivationIsOK in class UserDefinedType

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

validate

public boolean validate(SchemaCompiler compiler)
                 throws SchemaException,
                        UnresolvedReferenceException

Checks the validity of this SimpleType definition.

Specified by:

validate in interface UserSchemaComponent

Parameters:

compiler - used for error reporting

Returns:

true when this Schema definition is valid, otherwise false.

Throws:

SchemaException - if this SimpleType definition is invalid.

UnresolvedReferenceException

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 - the static context

Throws:

XPathException - if the expression will never deliver a value of the correct type

atomize

public AtomicSequence atomize(NodeInfo node)
                       throws XPathException

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

Specified by:

atomize in interface SchemaType

Parameters:

node - the node whose typed value is required

Returns:

the typed value.

Throws:

XPathException - if the node cannot be atomized, for example if this is a complex type with element-only content

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:

d - the derived type

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

getLocalFacetList

public List<Facet> getLocalFacetList()

Return all the facets for this type

Returns:

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

preprocess

public CharSequence preprocess(CharSequence input)
                        throws ValidationException

Apply any pre-lexical facets, other than whitespace. At the moment the only such facet is saxon:preprocess

Specified by:

preprocess in interface SimpleType

Parameters:

input - the value to be preprocessed

Returns:

the value after preprocessing

Throws:

ValidationException - if preprocessing detects that the value is invalid

postprocess

public CharSequence postprocess(CharSequence input)
                         throws ValidationException

Reverse any pre-lexical facets, other than whitespace. At the moment the only such facet is saxon:preprocess. This is called when converting a value of this type to a string

Specified by:

postprocess in interface SimpleType

Parameters:

input - the value to be postprocessed: this is the "ordinary" result of converting the value to a string

Returns:

the value after postprocessing

Throws:

ValidationException - if postprocessing detects that the value is invalid

checkAgainstFacets

public ValidationFailure checkAgainstFacets(AtomicSequence primitiveValue,
                                   CharSequence lexicalValue,
                                   List<Facet> facets,
                                   ConversionRules rules)

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

Parameters:

primitiveValue - the typed value to be checked, as an instance of its primitive type

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.

facets - List of the facets to be checked: can be obtained using one of the various getFacets() methods.

rules - Validation context (including values of parameters declared using saxon:param)

Returns:

null if the value is OK, otherwise a ValidationFailure. Note that the exception is returned rather than being thrown. This is designed to make the "castable" operator more efficient.

elaborate

public void elaborate(SchemaCompiler compiler)
               throws SchemaException

Elaborate the schema component: after reloading a serialized schema component model, this expands the component with derived information needed during validation episodes. The model is assumed to be valid.

Specified by:

elaborate in interface UserSchemaComponent

Overrides:

elaborate in class SchemaStructure

Parameters:

compiler - the schema compiler

Throws:

SchemaException - if a fatal error occurs

serialize

public void serialize(SchemaModelSerializer serializer)
               throws XPathException

Serialize the schema component

Specified by:

serialize in interface SerializableSchemaComponent

Parameters:

serializer - the object responsible for performing the serialization

Throws:

XPathException - if serialization fails

serializeVariety

protected abstract void serializeVariety(SchemaModelSerializer serializer)
                                  throws XPathException

Throws:

XPathException

getComponentAsFunction

public FunctionItem getComponentAsFunction()

Description copied from interface: SchemaComponent

Get the schema component in the form of a function item. This allows schema information to be made visible to XSLT or XQuery code. The function makes available the contents of the schema component as defined in the XSD specification. The function takes a string as argument representing a property name, and returns the corresponding property of the schema component. There is also a property "class" which returns the kind of schema component, for example "Attribute Declaration".

Specified by:

getComponentAsFunction in interface SchemaComponent

Returns:

the schema component represented as a function from property names to property values.

getComponentAsFunction

public static FunctionItem getComponentAsFunction(SimpleType type)

Get schema information for a simple type in the form of a function item

Parameters:

type - The type whose component information is required

Returns:

a function item representing a function whose argument is a property name and whose result is the value of that property