Package com.saxonica.ee.schema.sdoc

Class SimpleTypeDefinition

java.lang.Object
com.saxonica.ee.schema.SchemaStructure
com.saxonica.ee.schema.UserDefinedType
com.saxonica.ee.schema.UserSimpleType
com.saxonica.ee.schema.sdoc.SimpleTypeDefinition
All Implemented Interfaces:
SerializableSchemaComponent, UserSchemaComponent, SourceLocator, Location, HyperType, SchemaComponent, SchemaType, SimpleType, Locator
public class SimpleTypeDefinition extends UserSimpleType implements UserSchemaComponent
A simple type definition holds all the information about a simpleType during the course of schema processing. On completion of schema processing, a more specific SimpleType object is created, called the WorkingType: this will be for example a UserListType, UserAtomicType, or UserUnionType, and the SimpleTypeDefinition is then discarded.

  • Constructor Details

    • SimpleTypeDefinition

      public SimpleTypeDefinition(EnterpriseConfiguration config)
      Create a SimpleTypeDefinition
      Parameters:
      config - the Saxon configuration

  • Method Details

    • setItemTypeReference

      public void setItemTypeReference(TypeReference itemType)
      Set the reference to an item type of this list type
      Parameters:
      itemType - reference to a type forming the item type of this list type

    • isAtomicType

      public boolean isAtomicType()
      Test whether this Simple Type is an atomic type. On a SimpleTypeDefinition, the variety of the type cannot be reliably determined until fixup() has been called to determine the base type.
      Specified by:
      isAtomicType in interface SchemaType
      Specified by:
      isAtomicType in interface SimpleType
      Overrides:
      isAtomicType in class UserSimpleType
      Returns:
      true if this type is known to be atomic

    • isListType

      public boolean isListType()
      On a SimpleTypeDefinition, isListType() always returns true if the type is "derived by List". A list type that is derived by restricting another List type cannot be reliably recognized until fixup() has been called to determine the base type.
      Specified by:
      isListType in interface SimpleType
      Overrides:
      isListType in class UserSimpleType
      Returns:
      true if this type is "derived by List"

    • isUnionType

      public boolean isUnionType()
      On a SimpleTypeDefinition, isUnionType() always returns true if the type is "derived by Union". A union type that is derived by restricting another Union type cannot be reliably recognized until the fixup() method has been called to determine the base type.
      Specified by:
      isUnionType in interface SimpleType
      Overrides:
      isUnionType in class UserSimpleType
      Returns:
      true if this type is "derived by Union"

    • setIsSimpleContent

      public void setIsSimpleContent(boolean b)
      Indicate that this simple type represents the content type of a complex type with simple content
      Parameters:
      b - true if this is the content type of a complex type with simple content

    • addMemberType

      public void addMemberType(TypeReference memberType)
      Add a member type to this union type
      Parameters:
      memberType - the member type to be added

    • setTokenSeparator

      public void setTokenSeparator(RegularExpression separator)

    • getWorkingType

      public UserSimpleType getWorkingType()
      Get the simple type created for this definition
      Returns:
      the UserSimpleType object if it has been created, otherwise null

    • fixup

      public boolean fixup(SchemaCompiler compiler) throws SchemaException
      Check references from this component to other components
      Specified by:
      fixup in interface UserSchemaComponent
      Overrides:
      fixup in class SchemaStructure
      Parameters:
      compiler - used for error reporting
      Returns:
      true if all is well, false if errors found
      Throws:
      SchemaException

    • validate

      public boolean validate(SchemaCompiler compiler) throws SchemaException
      Checks the validity of this SimpleType definition.
      Specified by:
      validate in interface UserSchemaComponent
      Overrides:
      validate in class UserSimpleType
      Parameters:
      compiler - used for error reporting
      Returns:
      true when this Schema definition is valid, otherwise false.
      Throws:
      SchemaException - when this SimpleType definition is invalid.

    • getTypedValue

      public AtomicSequence getTypedValue(UnicodeString value, NamespaceResolver resolver, ConversionRules rules) throws ValidationException
      Get the typed value corresponding to a given string value, assuming it is valid against this type
      Specified by:
      getTypedValue in interface SimpleType
      Parameters:
      value - the string value
      resolver - a namespace resolver used to resolve prefixes in QNames and notations
      rules - the conversion rules for the Configuration
      Returns:
      an iterator over the atomic sequence comprising the typed value
      Throws:
      ValidationException - if the supplied value is invalid against this simple type

    • isBuiltInType

      public boolean isBuiltInType()
      Determine whether this is a built-in type or a user-defined type
      Specified by:
      isBuiltInType in interface SimpleType
      Returns:
      true if this is a built-in type

    • isNamespaceSensitive

      public boolean isNamespaceSensitive()
      Test whether this type is namespace sensitive, that is, if a namespace context is needed to translate between the lexical space and the value space. This is true for types derived from, or containing, QNames and NOTATIONs
      Specified by:
      isNamespaceSensitive in interface HyperType
      Returns:
      true if the type is namespace-sensitive

    • validateContent

      public ValidationFailure validateContent(UnicodeString value, NamespaceResolver nsResolver, ConversionRules rules)
      Check whether a given input string is valid according to this SimpleType
      Specified by:
      validateContent in interface SimpleType
      Parameters:
      value - the input string to be checked
      nsResolver - a namespace resolver used to resolve namespace prefixes if the type is namespace sensitive. The value supplied may be null; in this case any namespace-sensitive content will throw an UnsupportedOperationException.
      rules - the conversion rules for the configuration
      Returns:
      null if validation succeeds; or return a ValidationFailure describing the validation failure if validation fails. Note that the exception is returned rather than being thrown.
      Throws:
      UnsupportedOperationException - if the type is namespace-sensitive and no namespace resolver is supplied

    • serialize

      public void serialize(SchemaModelSerializer serializer) throws XPathException
      Serialize the schema component
      Specified by:
      serialize in interface SerializableSchemaComponent
      Overrides:
      serialize in class UserSimpleType
      Parameters:
      serializer - the object responsible for performing the serialization
      Throws:
      XPathException - if serialization fails

    • serializeVariety

      protected void serializeVariety(SchemaModelSerializer serializer)
      Specified by:
      serializeVariety in class UserSimpleType