Package com.saxonica.ee.schema

Class UserSimpleType

    • Constructor Detail

      • UserSimpleType

        public UserSimpleType()
        Construct a UserSimpleType

    • Method Detail

      • isSimpleType

        public final boolean isSimpleType()
        Returns true if this SchemaType is a SimpleType
        Specified by:
        isSimpleType in interface SchemaType
        Returns:
        true (always)

      • isAtomicType

        public boolean isAtomicType()
        Test whether this Simple Type is an atomic type
        Specified by:
        isAtomicType in interface SchemaType
        Specified by:
        isAtomicType in interface SimpleType
        Returns:
        the default implementation returns false

      • isIdType

        public boolean isIdType()
                 throws MissingComponentException
        Ask whether this type is an ID type. This is defined to be any simple type who typed value may contain atomic values of type xs:ID: that is, it includes types derived from ID by restriction, list, or union. Note that for a node to be treated as an ID, its typed value must be a *single* atomic value of type ID; the type of the node, however, can still allow a list.
        Specified by:
        isIdType in interface SchemaType
        Returns:
        true if this type is an ID type
        Throws:
        MissingComponentException

      • isIdRefType

        public boolean isIdRefType()
                    throws MissingComponentException
        Ask whether this type is an IDREF or IDREFS type. This is defined to be any simple type who typed value may contain atomic values of type xs:IDREF: that is, it includes types derived from IDREF or IDREFS by restriction, list, or union
        Specified by:
        isIdRefType in interface SchemaType
        Returns:
        true if this type is an IDREF type
        Throws:
        MissingComponentException

      • isListType

        public boolean isListType()
        Returns true if this type is derived by list, or if it is derived by restriction from a list type, or if it is a union that contains a list as one of its members
        Specified by:
        isListType in interface SimpleType
        Returns:
        true if this is a list type

      • isUnionType

        public boolean isUnionType()
        Return true if this type is a union type (that is, if its variety is union), which will be true if is derived by union, or if it is derived by restriction from a type whose variety is union.
        Specified by:
        isUnionType in interface SimpleType
        Returns:
        true for a union type

      • getContextComponent

        public SchemaComponent getContextComponent()
        Get the component that contains the definition of this anonymous simple type definition
        Returns:
        the containing component, or null of the type is not anonymous

      • setContextComponent

        public void setContextComponent​(SchemaComponent contextComponent)
        Set the component that contains the definition of this anonymous simple type definition
        Parameters:
        contextComponent - the containing component, or null of the type is not anonymous

      • getExtendedFacetList

        public java.util.List<Facet> getExtendedFacetList()
        Get the extended facet list, creating it if necessary. The extended facet list includes facets inherited from supertypes, unless they are redundant. This includes all constraining facets (but not fundamental facets). It does not include facets from built-in base types.
        Returns:
        the extended facet list

      • addInheritedFacets

        protected java.util.List<Facet> addInheritedFacets​(java.util.List<Facet> localFacets)

      • getEQName

        public java.lang.String getEQName()
        Get the name of this type as an EQName, that is, a string in the format Q{uri}local.
        Specified by:
        getEQName in interface SchemaType
        Overrides:
        getEQName in class UserDefinedType
        Returns:
        an EQName identifying the type. In the case of an anonymous type, an internally-generated name is returned

      • addFacet

        public void addFacet​(Facet facet)
        Add the given Facet to this Simpletype.
        Parameters:
        facet - the Facet to add to this Simpletype

      • mergeEnumerationFacets

        public void mergeEnumerationFacets​(SchemaCompiler compiler)
                            throws SchemaException,
                                   MissingComponentException
        Merge enumeration facets into a single enumerationSet pseudo-facet. This method also merges multiple pattern facets into a single pattern facet with multiple branches.
        Parameters:
        compiler - used for error reporting
        Throws:
        SchemaException - if a schema validity error is found
        MissingComponentException - if an unresolved reference to a schema component is found

      • getFacet

        public Facet getFacet​(java.lang.Class name)
        Returns the first facet associated with the given name, defined either on this type or on a type from which it is derived
        Parameters:
        name - the required class of facet
        Returns:
        the first facet associated with the given name

      • setFacetList

        public void setFacetList​(java.util.List<Facet> facetList)
        Set the local facet list for this simple type
        Parameters:
        facetList - the list of facets

      • convertFacetValues

        public void convertFacetValues()
                        throws SchemaException
        Convert the values of facets to the target data type
        Throws:
        SchemaException - if conversion fails

      • getWhitespaceAction

        public int getWhitespaceAction()
        Determine the whitespace normalization required for values of this type
        Specified by:
        getWhitespaceAction in interface SimpleType
        Returns:
        one of PRESERVE, REPLACE, COLLAPSE
        Throws:
        java.lang.IllegalStateException - if the simple type is not fully validated and the whitespace facet is not yet known.

      • applyWhitespaceNormalization

        public java.lang.CharSequence applyWhitespaceNormalization​(java.lang.CharSequence value)
        Apply the whitespace normalization rules for this simple type
        Parameters:
        value - the string before whitespace normalization
        Returns:
        the string after whitespace normalization

      • getBuiltInBaseType

        public SchemaType getBuiltInBaseType()
        Returns the built-in base type this type is derived from.
        Specified by:
        getBuiltInBaseType in interface SimpleType
        Returns:
        the first built-in type found when searching up the type hierarchy

      • validate

        public boolean validate​(SchemaCompiler compiler)
                 throws SchemaException
        Checks the validity of this SimpleType definition.
        Specified by:
        validate in interface UserSchemaComponent
        Parameters:
        compiler - used for error reporting
        Returns:
        true when this Schema definition is valid, otherwise false.
        Throws:
        SchemaException - if this SimpleType definition is invalid.

      • atomize

        public AtomicSequence atomize​(NodeInfo node)
                       throws XPathException
        Get the typed value of a node that is annotated with this schema type.
        Specified by:
        atomize in interface SchemaType
        Parameters:
        node - the node whose typed value is required
        Returns:
        the typed value.
        Throws:
        XPathException - if the node cannot be atomized, for example if this is a complex type with element-only content
        Since:
        8.5

      • isTypeDerivationOK

        public static java.lang.String isTypeDerivationOK​(SimpleType d,
                                                  SchemaType b,
                                                  int derivation)
                                           throws MissingComponentException
        Check whether type derivation is allowed. This implements the Schema Component Constraint: Type Derivation OK (Simple). This type is D (the derived type); the type supplied as an argument is B (the base type), and the argument (a subset (extension, restriction, list, union)) is provided in the second argument. If type derivation is allowed, the method return null; otherwise it returns a string that can be used as an error message
        Parameters:
        d - the derived type
        b - the base type
        derivation - the disallowed derivations, as a bit-significant integer
        Returns:
        null if type derivation is OK; otherwise a string that can be used as an error message
        Throws:
        MissingComponentException

      • getLocalFacetList

        public java.util.List<Facet> getLocalFacetList()
        Return all the facets for this type
        Returns:
        the list of facets defined on this simple type (this doesn't include inherited facets)

      • preprocess

        public java.lang.CharSequence preprocess​(java.lang.CharSequence input)
                                  throws ValidationException
        Apply any pre-lexical facets, other than whitespace. At the moment the only such facet is saxon:preprocess
        Specified by:
        preprocess in interface SimpleType
        Parameters:
        input - the value to be preprocessed
        Returns:
        the value after preprocessing
        Throws:
        ValidationException - if preprocessing detects that the value is invalid

      • postprocess

        public java.lang.CharSequence postprocess​(java.lang.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
        Specified by:
        postprocess in interface SimpleType
        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

      • checkAgainstFacets

        public ValidationFailure checkAgainstFacets​(AtomicSequence primitiveValue,
                                            java.lang.CharSequence lexicalValue,
                                            java.util.List<Facet> facets,
                                            ConversionRules rules)
        Validate that the value conforms to all the constraining facets for the given type.
        Parameters:
        primitiveValue - the typed value to be checked, as an instance of its primitive type
        lexicalValue - The supplied value; this must be normalized using the whitespace facet, and then checked against the pattern facet. May be null; if so the actual value is converted to a string for checking against the pattern.
        facets - List of the facets to be checked: can be obtained using one of the various getFacets() methods.
        rules - Validation context (including values of parameters declared using saxon:param)
        Returns:
        null if the value is OK, otherwise a ValidationFailure. Note that the exception is returned rather than being thrown. This is designed to make the "castable" operator more efficient.

      • elaborate

        public void elaborate​(SchemaCompiler compiler)
               throws SchemaException
        Elaborate the schema component: after reloading a serialized schema component model, this expands the component with derived information needed during validation episodes. The model is assumed to be valid.
        Specified by:
        elaborate in interface UserSchemaComponent
        Overrides:
        elaborate in class SchemaStructure
        Parameters:
        compiler - the schema compiler
        Throws:
        SchemaException - if a fatal error occurs

      • getComponentAsFunction

        public Function getComponentAsFunction()
        Description copied from interface: SchemaComponent
        Get the schema component in the form of a function item. This allows schema information to be made visible to XSLT or XQuery code. The function makes available the contents of the schema component as defined in the XSD specification. The function takes a string as argument representing a property name, and returns the corresponding property of the schema component. There is also a property "class" which returns the kind of schema component, for example "Attribute Declaration".
        Specified by:
        getComponentAsFunction in interface SchemaComponent
        Returns:
        the schema component represented as a function from property names to property values.

      • getComponentAsFunction

        public static Function getComponentAsFunction​(SimpleType type)
        Get schema information for a simple type in the form of a function item
        Parameters:
        type - The type whose component information is required
        Returns:
        a function item representing a function whose argument is a property name and whose result is the value of that property