Interface SimpleType

All Superinterfaces:
SchemaComponent, SchemaType, Serializable
All Known Subinterfaces:
AtomicType, ListType
All Known Implementing Classes:
AnySimpleType, BuiltInAtomicType, BuiltInListType, ErrorType, ExternalObjectType

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 Details

  • Method Details

    • 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

      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