Interface SimpleType

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

        AtomicSequence getTypedValue​(UnicodeString 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:
        the atomic sequence comprising the typed value. The objects returned by this SequenceIterator will all be of type AtomicValue,
        Throws:
        ValidationException - if the supplied value is not in the lexical space of the data type
      • validateContent

        ValidationFailure validateContent​(UnicodeString 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:
        java.lang.UnsupportedOperationException - if the type is namespace-sensitive and no namespace resolver is supplied
      • preprocess

        UnicodeString preprocess​(UnicodeString 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

        UnicodeString postprocess​(UnicodeString 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