Package net.sf.saxon.type

## Class TypeHierarchy

- java.lang.Object
- - net.sf.saxon.type.TypeHierarchy

- Direct Known Subclasses:
    `TypeHierarchyEE`

      public class TypeHierarchy
      extends java.lang.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 Summary

    Fields
    Modifier and Type | Field | Description
    --- | --- | ---
    `protected Configuration` | `config` |

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `TypeHierarchy​(Configuration config)` | Create the type hierarchy cache for a configuration

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `protected SequenceIterator` | `applyFunctionCoercion​(SequenceIterator iterator, ItemType suppliedItemType, ItemType requiredItemType, Location locator)` | Apply function coercion when a function item is supplied as a parameter in a function call
    `Sequence` | `applyFunctionConversionRules​(Sequence value, SequenceType requiredType, RoleDiagnostic role, Location locator)` | Apply the function conversion rules to a value, given a required type.
    `protected Affinity` | `computeContentRelationship​(ItemType t1, ItemType t2, java.util.Optional<IntSet> n1, java.util.Optional<IntSet> n2)` | Compute the relationship between the allowed content-types of two types, for example attribute(*, xs:integer) and attribute(xs:string).
    `Configuration` | `getConfiguration()` | Get the Saxon configuration to which this type hierarchy belongs
    `ItemType` | `getGenericFunctionItemType()` |
    `static Affinity` | `inverseRelationship​(Affinity relation)` |
    `boolean` | `isSubType​(ItemType subtype, ItemType supertype)` | Determine whether type A is type B or one of its subtypes, recursively.
    `Affinity` | `relationship​(ItemType t1, ItemType t2)` | Determine the relationship of one item type to another.
    `Affinity` | `schemaTypeRelationship​(SchemaType s1, SchemaType s2)` | Get the relationship of two schema types to each other
    `Affinity` | `sequenceTypeRelationship​(SequenceType s1, SequenceType s2)` | Get the relationship of two sequence types to each other

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### config

          protected Configuration config

  - ### 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 a function item is supplied as a parameter in a function call
      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 Affinity 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:
        One of:
        - `Affinity.SAME_TYPE` if the types are the same;
        - `Affinity.SUBSUMES` if the first type subsumes the second (that is, all instances of the second type are also instances of the first);
        - `Affinity.SUBSUMED_BY` if the second type subsumes the first;
        - `Affinity.OVERLAPS` if the two types overlap (have a non-empty intersection, but neither subsumes the other);
        - `Affinity.DISJOINT` if the two types are disjoint (have an empty intersection)

    - #### computeContentRelationship

          protected Affinity computeContentRelationship​(ItemType t1,
                                                        ItemType t2,
                                                        java.util.Optional<IntSet> n1,
                                                        java.util.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)

    - #### sequenceTypeRelationship

          public Affinity sequenceTypeRelationship​(SequenceType s1,
                                                   SequenceType s2)

      Get the relationship of two sequence types to each other
      Parameters:
        `s1` - the first type
        `s2` - the second type
      Returns:
        the relationship, as one of the constants `Affinity.SAME_TYPE`, `Affinity.SUBSUMES`, `Affinity.SUBSUMED_BY`, `Affinity.DISJOINT`, `Affinity.OVERLAPS`

    - #### schemaTypeRelationship

          public Affinity 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 `Affinity.SAME_TYPE`, `Affinity.SUBSUMES`, `Affinity.SUBSUMED_BY`, `Affinity.DISJOINT`, `Affinity.OVERLAPS`

    - #### inverseRelationship

          public static Affinity inverseRelationship​(Affinity relation)

    - #### getGenericFunctionItemType

          public ItemType getGenericFunctionItemType()