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

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

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 - the conversion rules from the configuration
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 - the conversion rules from 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

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 - if preprocessing detects that the value is invalid

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 - if postprocessing detects that the value is invalid


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