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

    - ### Methods inherited from class com.saxonica.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, 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, 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.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

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