Overview | Package | Class | Tree | Deprecated | Index | 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.UserDefinedType
              com.saxonica.schema.UserSimpleType

All Implemented Interfaces:
  SerializableSchemaComponent, UserSchemaComponent, Serializable, 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.

See Also:
  Serialized Form

Field Summary

Fields inherited from class com.saxonica.schema.UserDefinedType
`extendedTypes, finalProhibitions`

Fields inherited from interface net.sf.saxon.type.SimpleType
`VARIETY_ATOMIC, VARIETY_LIST, VARIETY_UNION, VARIETY_UNSPECIFIED_SIMPLE`

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

Method Summary
`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
`Value` | `atomize(NodeInfo node)` Get the typed value of a node that is annotated with this schema type.
`ValidationFailure` | `checkAgainstFacets(Value primitiveValue, CharSequence lexicalValue, Iterator iter)` 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.
`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
`Iterator<Facet>` | `getFacets()` Returns an Iterator over all the Facets (including inherited facets) for this type.
`List<Facet>` | `getLocalFacetList()` Return all the facets for this type
`SequenceIterator<AtomicValue>` | `getTypedValue(NodeInfo node)` Get the typed value of a node that is annotated with this schema 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` | `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.schema.UserDefinedType
`allowsDerivation, containingDeclarationIsElement, getBaseType, getBaseTypeFingerprint, getBaseTypeReference, getBlock, getContainingDeclarationName, getDerivationMethod, getDescription, getDisplayName, getFingerprint, getLocalName, getName, getNameCode, getNamePool, getTargetNamespace, hasRegisteredExtension, isAnonymousType, isComplexType, isExternalType, isSameType, iterateExtensionTypes, registerExtensionType, setBaseTypeReference, setContainingDeclaration, setDerivationMethod, setDerivationMethodName, setExtendedTypes, setFinalProhibitions, setNameCode`

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

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, 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, 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.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

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

  Returns:
    the extended facet list

### addInheritedFacets

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

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

### getFacets

    public Iterator<Facet> getFacets()

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

  Returns:
    an Iterator over all the Facets for this type. The objects returned by the iterator will be instanceof of `Facet`

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

### getTypedValue

    public final SequenceIterator<AtomicValue> 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` - if the node has no typed value (typically, if it is an element with an element-only content type)

### 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` - 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(Value primitiveValue,
                                                CharSequence lexicalValue,
                                                Iterator iter)

  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.
    `iter` - Iterator over the facets to be checked: can be obtained using one of the various getFacets() methods.
  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`

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

Copyright (c) 2004-2011 Saxonica Limited. All rights reserved.