## net.sf.saxon.type
Interface SimpleType

All Superinterfaces:
  SchemaComponent, SchemaType, Serializable

All Known Subinterfaces:
  AtomicType, ListType

All Known Implementing Classes:
  AnySimpleType, BuiltInAtomicType, BuiltInListType, ErrorType, ExternalObjectType, SimpleTypeDefinition, UserAtomicType, UserListType, UserSimpleType, UserUnionType

    public interface SimpleType

extends SchemaType

This interface represents a simple type, which may be a built-in simple type, or a user-defined simple type.

Field Summary
`static int` `VARIETY_ATOMIC`
`static int` `VARIETY_LIST`
`static int` `VARIETY_UNION`
`static int` `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`

Method Summary
`SchemaType` `getBuiltInBaseType()` Get the built-in type from which this type is derived by restriction
`AtomicType` `getCommonAtomicType()` Get the most specific possible atomic type that all items in this SimpleType belong to
`SequenceIterator` `getTypedValue(CharSequence value, NamespaceResolver resolver, ConversionRules rules)` Get the typed value corresponding to a given string value, assuming it is valid against this type
`int` `getWhitespaceAction()` Determine how values of this simple type are whitespace-normalized.
`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` `isExternalType()` Return true if this is an external object type, that is, a Saxon-defined type for external Java or .NET objects
`boolean` `isListType()` Test whether this Simple Type is a list type
`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()` Test whether this Simple Type is a union type
`CharSequence` `postprocess(CharSequence input)` Reverse any pre-lexical facets, other than whitespace.
`CharSequence` `preprocess(CharSequence input)` Apply any pre-lexical facets, other than whitespace.
`ValidationFailure` `validateContent(CharSequence value, NamespaceResolver nsResolver, ConversionRules rules)` Check whether a given input string is valid according to this SimpleType

Methods inherited from interface net.sf.saxon.type.SchemaType
`allowsDerivation, analyzeContentExpression, atomize, checkTypeDerivationIsOK, getBaseType, getBlock, getDerivationMethod, getDescription, getDisplayName, getFingerprint, getName, getNameCode, getSystemId, getTargetNamespace, getTypedValue, isAnonymousType, isComplexType, isIdRefType, isIdType, isSameType, isSimpleType`

Methods inherited from interface net.sf.saxon.type.SchemaComponent
`getRedefinitionLevel, getValidationStatus`

Field Detail

### VARIETY_ATOMIC

    static final int VARIETY_ATOMIC

See Also:
  Constant Field Values

### VARIETY_LIST

    static final int VARIETY_LIST

See Also:
  Constant Field Values

### VARIETY_UNION

    static final int VARIETY_UNION

See Also:
  Constant Field Values

### VARIETY_UNSPECIFIED_SIMPLE

    static final int VARIETY_UNSPECIFIED_SIMPLE

See Also:
  Constant Field Values

Method Detail

### isAtomicType

    boolean isAtomicType()

  Test whether this Simple Type is an atomic type

  Specified by:
    `isAtomicType` in interface `SchemaType`
  Returns:
    true if this is an atomic type

### isListType

    boolean isListType()

  Test whether this Simple Type is a list type

  Returns:
    true if this is a list type

### isUnionType

    boolean isUnionType()

  Test whether this Simple Type is a union type

  Returns:
    true if this is a union type

### isExternalType

    boolean isExternalType()

  Return true if this is an external object type, that is, a Saxon-defined type for external Java or .NET objects

  Returns:
    true if this is an external type

### getCommonAtomicType

    AtomicType getCommonAtomicType()

  Get the most specific possible atomic type that all items in this SimpleType belong to

  Returns:
    the lowest common supertype of all member types

### isBuiltInType

    boolean isBuiltInType()

  Determine whether this is a built-in type or a user-defined type

  Returns:
    true if this is a built-in type

### getBuiltInBaseType

    SchemaType getBuiltInBaseType()

  Get the built-in type from which this type is derived by restriction

  Returns:
    the built-in type from which this type is derived by restriction. This will not necessarily be a primitive type.

### getTypedValue

    SequenceIterator 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

  Parameters:
    `value` - the string value
    `resolver` - a namespace resolver used to resolve any namespace prefixes appearing in the content of values. Can supply null, in which case any namespace-sensitive content will be rejected.
    `rules` -
  Returns:
    an iterator over the atomic sequence comprising the typed value. The objects returned by this SequenceIterator will all be of type `AtomicValue`, The next() method on the iterator throws no checked exceptions, although it is not actually declared as an UnfailingIterator.
  Throws:
    `ValidationException` - if the supplied value is not in the lexical space of the data type

### validateContent

    ValidationFailure validateContent(CharSequence value,
                                      NamespaceResolver nsResolver,
                                      ConversionRules rules)

  Check whether a given input string is valid according to this 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` -
  Returns:
    null if validation succeeds; 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

### isNamespaceSensitive

    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

  Returns:
    true if the type is namespace-sensitive

### getWhitespaceAction

    int getWhitespaceAction()

  Determine how values of this simple type are whitespace-normalized.

  Returns:
    one of `Whitespace.PRESERVE`, `Whitespace.COLLAPSE`, `Whitespace.REPLACE`.

### preprocess

    CharSequence preprocess(CharSequence input)
                            throws ValidationException

  Apply any pre-lexical facets, other than whitespace. At the moment the only such facet is saxon:preprocess

  Parameters:
    `input` - the value to be preprocessed
  Returns:
    the value after preprocessing
  Throws:
    `ValidationException`

### postprocess

    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

  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`

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