com.saxonica.schema.sdoc

## Class SimpleTypeDefinition

- java.lang.Object
- - com.saxonica.schema.SchemaStructure
  - - com.saxonica.schema.UserDefinedType
    - - com.saxonica.schema.UserSimpleType
      - - com.saxonica.schema.sdoc.SimpleTypeDefinition

- All Implemented Interfaces:
    SerializableSchemaComponent, UserSchemaComponent, Serializable, SourceLocator, SchemaComponent, SchemaType, SimpleType

      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, more specific objects are created, for example `UserListType`, `UserAtomicType`, or `UserUnionType`, and the SimpleTypeDefinition is then discarded.
  See Also:
    Serialized Form

- - ### Field Summary

    - ### Fields inherited from class com.saxonica.schema.UserDefinedType

      `extendedTypes, finalProhibitions`

    - ### Fields inherited from interface net.sf.saxon.type.SchemaComponent

      `COMPONENT_FUNCTION_TYPE, FIXED_UP, INCOMPLETE, INVALID, UNVALIDATED, VALIDATED, VALIDATING`

    - ### Fields inherited from interface net.sf.saxon.type.SchemaType

      `DERIVATION_EXTENSION, DERIVATION_LIST, DERIVATION_RESTRICTION, DERIVATION_UNION, DERIVE_BY_SUBSTITUTION`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `SimpleTypeDefinition(EnterpriseConfiguration config)` Create a SimpleTypeDefinition

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addMemberType(TypeReference memberType)` Add a member type to this union type
    `boolean` | `fixup(SchemaCompiler compiler)` Check references from this component to other components
    `UserSimpleType` | `getSimpleType()` Get the simple type created for this definition
    `AtomicSequence` | `getTypedValue(CharSequence value, NamespaceResolver resolver, ConversionRules rules)` Get the typed value corresponding to a given string value, assuming it is valid against this type
    `boolean` | `isAtomicType()` Test whether this Simple Type is an atomic type.
    `boolean` | `isBuiltInType()` Determine whether this is a built-in type or a user-defined type
    `boolean` | `isListType()` On a SimpleTypeDefinition, isListType() always returns true if the type is "derived by List".
    `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.
    `boolean` | `isUnionType()` On a SimpleTypeDefinition, isUnionType() always returns true if the type is "derived by Union".
    `void` | `serialize(SchemaModelSerializer serializer)` Serialize the schema component
    `protected void` | `serializeVariety(SchemaModelSerializer serializer)`
    `void` | `setIsSimpleContent(boolean b)` Indicate that this simple type represents the content type of a complex type with simple content
    `void` | `setItemTypeReference(TypeReference itemType)` Set the reference to an item type of this list type
    `boolean` | `validate(SchemaCompiler compiler)` Checks the validity of this SimpleType definition.
    `ValidationFailure` | `validateContent(CharSequence value, NamespaceResolver nsResolver, ConversionRules rules)` Check whether a given input string is valid according to this SimpleType

    - ### Methods inherited from class com.saxonica.schema.UserSimpleType

      `addFacet, addInheritedFacets, analyzeContentExpression, applyWhitespaceNormalization, atomize, checkAgainstFacets, checkTypeDerivationIsOK, convertFacetValues, elaborate, getBuiltInBaseType, getComponentAsFunction, getComponentAsFunction, getContextComponent, getEQName, getExtendedFacetList, getFacet, getLocalFacetList, getWhitespaceAction, isIdRefType, isIdType, isSimpleType, isTypeDerivationOK, mergeEnumerationFacets, postprocess, preprocess, setContextComponent, setFacetList`

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

      `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 com.saxonica.schema.UserSchemaComponent

      `elaborate, lookForCycles`

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

      `getComponentAsFunction, getRedefinitionLevel, getValidationStatus`

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

      `isExternalType`

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

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

- - ### Constructor Detail

    - #### SimpleTypeDefinition

          public SimpleTypeDefinition(EnterpriseConfiguration config)

      Create a SimpleTypeDefinition
      Parameters:
        `config` - the Saxon configuration

  - ### Method Detail

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

    - #### getSimpleType

          public UserSimpleType getSimpleType()

      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(CharSequence 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 `SimpleType`
      Returns:
        true if the type is namespace-sensitive

    - #### validateContent

          public ValidationFailure validateContent(CharSequence 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)

      Serialize the schema component
      Specified by:
        `serialize` in interface `SerializableSchemaComponent`
      Overrides:
        `serialize` in class `UserSimpleType`
      Parameters:
        `serializer` - the object responsible for performing the serialization

    - #### serializeVariety

          protected void serializeVariety(SchemaModelSerializer serializer)
                                   throws XPathException

      Specified by:
        `serializeVariety` in class `UserSimpleType`
      Throws:
        `XPathException`

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