Class Type

java.lang.Object
net.sf.saxon.type.Type
All Implemented Interfaces:
Serializable

public abstract class Type extends Object implements Serializable
This class contains static information about types and methods for constructing type codes. The class is never instantiated.

The constant integers used for type names in earlier versions of this class have been replaced by constants in StandardNames. The constants representing AtomicType objects are now available through the BuiltInAtomicType class.

See Also:
  • Field Details

    • ELEMENT

      public static final short ELEMENT
      Type representing an element node - element()
      See Also:
    • ATTRIBUTE

      public static final short ATTRIBUTE
      Item type representing an attribute node - attribute()
      See Also:
    • TEXT

      public static final short TEXT
      Item type representing a text node - text()
      See Also:
    • WHITESPACE_TEXT

      public static final short WHITESPACE_TEXT
      Item type representing a text node stored in the tiny tree as compressed whitespace
      See Also:
    • PROCESSING_INSTRUCTION

      public static final short PROCESSING_INSTRUCTION
      Item type representing a processing-instruction node
      See Also:
    • COMMENT

      public static final short COMMENT
      Item type representing a comment node
      See Also:
    • DOCUMENT

      public static final short DOCUMENT
      Item type representing a document node
      See Also:
    • NAMESPACE

      public static final short NAMESPACE
      Item type representing a namespace node
      See Also:
    • STOPPER

      public static final short STOPPER
      Dummy node kind used in the tiny tree to mark the end of the tree
      See Also:
    • PARENT_POINTER

      public static final short PARENT_POINTER
      Dummy node kind used in the tiny tree to contain a parent pointer
      See Also:
    • NODE

      public static final short NODE
      An item type that matches any node
      See Also:
    • NODE_TYPE

      public static final ItemType NODE_TYPE
    • ITEM

      public static final short ITEM
      An item type that matches any item
      See Also:
    • ITEM_TYPE

      public static final ItemType ITEM_TYPE
    • FUNCTION

      public static final short FUNCTION
      A type number for function()
      See Also:
    • MAX_NODE_TYPE

      public static final short MAX_NODE_TYPE
      See Also:
    • EMPTY

      public static final short EMPTY
      Item type that matches no items (corresponds to SequenceType empty())
      See Also:
  • Method Details

    • isNodeType

      public static boolean isNodeType(ItemType type)
      Test whether a given type is (some subtype of) node()
      Parameters:
      type - The type to be tested
      Returns:
      true if the item type is node() or a subtype of node()
    • getItemType

      public static ItemType getItemType(Item item, TypeHierarchy th)
      Get the ItemType of an Item
      Parameters:
      item - the item whose type is required
      th - the type hierarchy cache. If null, the returned type may be less precise
      Returns:
      the item type of the item
    • displayTypeName

      public static String displayTypeName(Item item)
      Output (for diagnostics) a representation of the type of an item. This does not have to be the most specific type
      Parameters:
      item - the item whose type is to be displayed
      Returns:
      a string representation of the type of the item
    • getBuiltInItemType

      public static ItemType getBuiltInItemType(String namespace, String localName)
      Get the ItemType object for a built-in atomic type
      Parameters:
      namespace - the namespace URI of the type
      localName - the local name of the type
      Returns:
      the ItemType, or null if not found
    • getBuiltInSimpleType

      public static SimpleType getBuiltInSimpleType(String namespace, String localName)
      Get the SimpleType object for a built-in simple type (atomic type or list type)
      Parameters:
      namespace - the namespace URI of the type
      localName - the local name of the type
      Returns:
      the SimpleType, or null if not found
    • getCommonSuperType

      public static ItemType getCommonSuperType(ItemType t1, ItemType t2, TypeHierarchy th)
      Get a type that is a common supertype of two given item types
      Parameters:
      t1 - the first item type
      t2 - the second item type
      th - the type hierarchy cache
      Returns:
      the item type that is a supertype of both the supplied item types
    • getCommonSuperType

      public static ItemType getCommonSuperType(ItemType t1, ItemType t2)
      Get a type that is a common supertype of two given item types, without the benefit of a TypeHierarchy cache. This will generally give a less precise answer than the method getCommonSuperType(ItemType, ItemType, TypeHierarchy)
      Parameters:
      t1 - the first item type
      t2 - the second item type
      Returns:
      an item type that is a supertype of both the supplied item types
    • isPrimitiveType

      public static boolean isPrimitiveType(int code)
      Determine whether this type is a primitive type. The primitive types are the 19 primitive types of XML Schema, plus xs:integer, xs:dayTimeDuration and xs:yearMonthDuration; xs:untypedAtomic; the 7 node kinds; and all supertypes of these (item(), node(), xs:anyAtomicType, xs:numeric, ...)
      Parameters:
      code - the item type code to be tested
      Returns:
      true if the type is considered primitive under the above rules
    • isComparable

      public static boolean isComparable(BuiltInAtomicType t1, BuiltInAtomicType t2, boolean ordered)
      Determine whether two primitive atomic types are comparable under the rules for ValueComparisons (that is, untyped atomic values treated as strings)
      Parameters:
      t1 - the first type to compared. This must be a primitive atomic type as defined by ItemType.getPrimitiveType()
      t2 - the second type to compared. This must be a primitive atomic type as defined by ItemType.getPrimitiveType()
      ordered - true if testing for an ordering comparison (lt, gt, le, ge). False if testing for an equality comparison (eq, ne)
      Returns:
      true if the types are comparable, as defined by the rules of the "eq" operator
    • isGenerallyComparable

      public static boolean isGenerallyComparable(BuiltInAtomicType t1, BuiltInAtomicType t2, boolean ordered)
      Determine whether two primitive atomic types are comparable under the rules for GeneralComparisons (that is, untyped atomic values treated as comparable to anything)
      Parameters:
      t1 - the first type to compared. This must be a primitive atomic type as defined by ItemType.getPrimitiveType()
      t2 - the second type to compared. This must be a primitive atomic type as defined by ItemType.getPrimitiveType()
      ordered - true if testing for an ordering comparison (lt, gt, le, ge). False if testing for an equality comparison (eq, ne)
      Returns:
      true if the types are comparable, as defined by the rules of the "=" operator
    • isGuaranteedGenerallyComparable

      public static boolean isGuaranteedGenerallyComparable(BuiltInAtomicType t1, BuiltInAtomicType t2, boolean ordered)
      Determine whether two primitive atomic types are guaranteed comparable under the rules for GeneralComparisons (that is, untyped atomic values treated as comparable to anything). This method returns false if a run-time check is necessary.
      Parameters:
      t1 - the first type to compared. This must be a primitive atomic type as defined by ItemType.getPrimitiveType()
      t2 - the second type to compared. This must be a primitive atomic type as defined by ItemType.getPrimitiveType()
      ordered - true if testing for an ordering comparison (lt, gt, le, ge). False if testing for an equality comparison (eq, ne)
      Returns:
      true if the types are comparable, as defined by the rules of the "=" operator