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.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
`FIXED_UP, INCOMPLETE, INVALID, UNVALIDATED, VALIDATED, VALIDATING`

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`

Constructor Summary
`SimpleTypeDefinition(EnterpriseConfiguration config)` Create a SimpleTypeDefinition

Method Summary
`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
`SequenceIterator<AtomicValue>` | `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, getExtendedFacetList, getFacet, getFacets, getLocalFacetList, getTypedValue, getWhitespaceAction, isIdRefType, isIdType, isSimpleType, isTypeDerivationOK, mergeEnumerationFacets, postprocess, preprocess, setFacetList`

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

Methods inherited from interface net.sf.saxon.type.SchemaComponent
`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, 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 SequenceIterator<AtomicValue> 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`

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.