Package net.sf.saxon.type

Class TypeHierarchy

  • public class TypeHierarchy
extends Object
    This class exists to provide answers to questions about the type hierarchy. Because such questions are potentially expensive, it caches the answers. There is one instance of this class for a Configuration.

    • Field Detail

      • SAME_TYPE

        public static final int SAME_TYPE
        Constant denoting relationship between two types: A is the same type as B
        See Also:
        Constant Field Values

      • SUBSUMES

        public static final int SUBSUMES
        Constant denoting relationship between two types: A subsumes B
        See Also:
        Constant Field Values

      • SUBSUMED_BY

        public static final int SUBSUMED_BY
        Constant denoting relationship between two types: A is subsumed by B
        See Also:
        Constant Field Values

      • OVERLAPS

        public static final int OVERLAPS
        Constant denoting relationship between two types: A overlaps B
        See Also:
        Constant Field Values

      • DISJOINT

        public static final int DISJOINT
        Constant denoting relationship between two types: A is disjoint from B
        See Also:
        Constant Field Values

    • Constructor Detail

      • TypeHierarchy

        public TypeHierarchy​(Configuration config)
        Create the type hierarchy cache for a configuration
        Parameters:
        config - the configuration

    • Method Detail

      • applyFunctionConversionRules

        public Sequence<?> applyFunctionConversionRules​(Sequence<?> value,
                                                SequenceType requiredType,
                                                RoleDiagnostic role,
                                                Location locator)
                                         throws XPathException
        Apply the function conversion rules to a value, given a required type.
        Parameters:
        value - a value to be converted
        requiredType - the required type
        role - identifies the value to be converted in error messages
        locator - identifies the location for error messages
        Returns:
        the converted value
        Throws:
        XPathException - if the value cannot be converted to the required type

      • applyFunctionCoercion

        protected SequenceIterator<?> applyFunctionCoercion​(SequenceIterator<?> iterator,
                                                    ItemType suppliedItemType,
                                                    ItemType requiredItemType,
                                                    Location locator)
        Apply function coercion when function items are supplied as arguments to a function call. This does not happen in Saxon-HE, so the implementation is subclassed in Saxon-PE/EE
        Parameters:
        iterator - An iterator over the supplied value of the parameter
        suppliedItemType - the item type of the supplied value
        requiredItemType - the required item type (typically a function item type)
        locator - information for diagnostics
        Returns:
        an iterator over the converted value

      • getConfiguration

        public Configuration getConfiguration()
        Get the Saxon configuration to which this type hierarchy belongs
        Returns:
        the configuration

      • isSubType

        public boolean isSubType​(ItemType subtype,
                         ItemType supertype)
        Determine whether type A is type B or one of its subtypes, recursively. "Subtype" here means a type that is subsumed, that is, a type whose instances are a subset of the instances of the other type.
        Parameters:
        subtype - identifies the first type
        supertype - identifies the second type
        Returns:
        true if the first type is the second type or is subsumed by the second type

      • relationship

        public int relationship​(ItemType t1,
                        ItemType t2)
        Determine the relationship of one item type to another.
        Parameters:
        t1 - the first item type
        t2 - the second item type
        Returns:
        SAME_TYPE if the types are the same; SUBSUMES if the first type subsumes the second (that is, all instances of the second type are also instances of the first); SUBSUMED_BY if the second type subsumes the first; OVERLAPS if the two types overlap (have a non-empty intersection, but neither subsumes the other); DISJOINT if the two types are disjoint (have an empty intersection)

      • computeContentRelationship

        protected int computeContentRelationship​(ItemType t1,
                                         ItemType t2,
                                         Optional<IntSet> n1,
                                         Optional<IntSet> n2)
        Compute the relationship between the allowed content-types of two types, for example attribute(*, xs:integer) and attribute(xs:string). Note that although such types are fairly meaningless in a non-schema-aware environment, they are permitted, and supported in Saxon-HE.
        Parameters:
        t1 - the first type
        t2 - the second types
        n1 - the set of element names allowed by the first type
        n2 - the set of element names allowed by the second type
        Returns:
        the relationship (same type, subsumes, overlaps, subsumed-by)

      • schemaTypeRelationship

        public int schemaTypeRelationship​(SchemaType s1,
                                  SchemaType s2)
        Get the relationship of two schema types to each other
        Parameters:
        s1 - the first type
        s2 - the second type
        Returns:
        the relationship of the two types, as one of the constants SAME_TYPE, SUBSUMES, SUBSUMED_BY, DISJOINT

      • inverseRelationship

        public static int inverseRelationship​(int relation)

      • getGenericFunctionItemType

        public ItemType getGenericFunctionItemType()