Type

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

```
public abstract class Type
extends java.lang.Object
```
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.

Field Summary

Fields
Modifier and Type	Field and Description
`static short`	`ATTRIBUTE` Item type representing an attribute node - attribute()
`static short`	`COMMENT` Item type representing a comment node
`static short`	`DOCUMENT` Item type representing a document node
`static short`	`ELEMENT` Type representing an element node - element()
`static short`	`EMPTY` Item type that matches no items (corresponds to SequenceType empty())
`static short`	`FUNCTION` A type number for function()
`static short`	`ITEM` An item type that matches any item
`static ItemType`	`ITEM_TYPE`
`static short`	`MAX_NODE_TYPE`
`static short`	`NAMESPACE` Item type representing a namespace node
`static short`	`NODE` An item type that matches any node
`static ItemType`	`NODE_TYPE`
`static short`	`PARENT_POINTER` Dummy node kind used in the tiny tree to contain a parent pointer
`static short`	`PROCESSING_INSTRUCTION` Item type representing a processing-instruction node
`static short`	`STOPPER` Dummy node kind used in the tiny tree to mark the end of the tree
`static short`	`TEXT` Item type representing a text node - text()
`static short`	`WHITESPACE_TEXT` Item type representing a text node stored in the tiny tree as compressed whitespace

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static java.lang.String`	`displayTypeName(Item item)` Output (for diagnostics) a representation of the type of an item.
`static ItemType`	`getBuiltInItemType(java.lang.String namespace, java.lang.String localName)` Get the ItemType object for a built-in atomic or list type
`static SimpleType`	`getBuiltInSimpleType(java.lang.String namespace, java.lang.String localName)` Get the SimpleType object for a built-in simple type (atomic type or list type)
`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.
`static ItemType`	`getCommonSuperType(ItemType t1, ItemType t2, TypeHierarchy th)` Get a type that is a common supertype of two given item types
`static ItemType`	`getItemType(Item item, TypeHierarchy th)` Get the ItemType of an Item.
`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)
`static boolean`	`isGuaranteedComparable(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)
`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).
`static boolean`	`isNodeType(ItemType type)` Test whether a given type is (some subtype of) node()
`static boolean`	`isPossiblyComparable(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)
`static boolean`	`isPrimitiveAtomicType(int fingerprint)` Determine whether a given atomic type is a primitive type.
`static boolean`	`isPrimitiveAtomicUType(int fingerprint)` Determine whether this type is a type that corresponds exactly to a UType
`static boolean`	`isSubType(AtomicType one, AtomicType two)` Determine whether one atomic type is a subtype of another (without access to the TypeHierarchy object)

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - ELEMENT
```
public static final short ELEMENT
```
    Type representing an element node - element()
    
    See Also:
    
    Constant Field Values
  - ATTRIBUTE
```
public static final short ATTRIBUTE
```
    Item type representing an attribute node - attribute()
    
    See Also:
    
    Constant Field Values
  - TEXT
```
public static final short TEXT
```
    Item type representing a text node - text()
    
    See Also:
    
    Constant Field Values
  - WHITESPACE_TEXT
```
public static final short WHITESPACE_TEXT
```
    Item type representing a text node stored in the tiny tree as compressed whitespace
    
    See Also:
    
    Constant Field Values
  - PROCESSING_INSTRUCTION
```
public static final short PROCESSING_INSTRUCTION
```
    Item type representing a processing-instruction node
    
    See Also:
    
    Constant Field Values
  - COMMENT
```
public static final short COMMENT
```
    Item type representing a comment node
    
    See Also:
    
    Constant Field Values
  - DOCUMENT
```
public static final short DOCUMENT
```
    Item type representing a document node
    
    See Also:
    
    Constant Field Values
  - NAMESPACE
```
public static final short NAMESPACE
```
    Item type representing a namespace node
    
    See Also:
    
    Constant Field Values
  - STOPPER
```
public static final short STOPPER
```
    Dummy node kind used in the tiny tree to mark the end of the tree
    
    See Also:
    
    Constant Field Values
  - PARENT_POINTER
```
public static final short PARENT_POINTER
```
    Dummy node kind used in the tiny tree to contain a parent pointer
    
    See Also:
    
    Constant Field Values
  - NODE
```
public static final short NODE
```
    An item type that matches any node
    
    See Also:
    
    Constant Field Values
  - NODE_TYPE
```
public static final ItemType NODE_TYPE
```
  - ITEM
```
public static final short ITEM
```
    An item type that matches any item
    
    See Also:
    
    Constant Field Values
  - ITEM_TYPE
```
public static final ItemType ITEM_TYPE
```
  - FUNCTION
```
public static final short FUNCTION
```
    A type number for function()
    
    See Also:
    
    Constant Field Values
  - MAX_NODE_TYPE
```
public static final short MAX_NODE_TYPE
```
    See Also:
    
    Constant Field Values
  - EMPTY
```
public static final short EMPTY
```
    Item type that matches no items (corresponds to SequenceType empty())
    
    See Also:
    
    Constant Field Values
- Method Detail
  - 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. This method is used almost entirely for diagnostics, to report the actual type of an item when it differs from the required type. The actual result is not completely well-defined, since there are many item types that a given type conforms to, and it is not always the case that one of them is a subtype of all the others.
    
    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 java.lang.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(java.lang.String namespace,
                                          java.lang.String localName)
```
    Get the ItemType object for a built-in atomic or list 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(java.lang.String namespace,
                                              java.lang.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
  - isSubType
```
public static boolean isSubType(AtomicType one,
                                AtomicType two)
```
    Determine whether one atomic type is a subtype of another (without access to the TypeHierarchy object)
    
    Parameters:
    
    one - the first atomic type
    
    two - the second atomic type
    
    Returns:
    
    true if the first atomic type is equal to, or derived by restriction from, the second atomic type
  - 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
  - isPrimitiveAtomicType
```
public static boolean isPrimitiveAtomicType(int fingerprint)
```
    Determine whether a given atomic 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:
    
    fingerprint - the item type code to be tested
    
    Returns:
    
    true if the type is considered primitive under the above rules
  - isPrimitiveAtomicUType
```
public static boolean isPrimitiveAtomicUType(int fingerprint)
```
    Determine whether this type is a type that corresponds exactly to a UType
    
    Parameters:
    
    fingerprint - the item type code to be tested
    
    Returns:
    
    true if the type is considered primitive under the above rules
  - isGuaranteedComparable
```
public static boolean isGuaranteedComparable(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; false if they are not comparable, or if we don't yet know (because some subtypes of the static type are comparable and others are not)
  - isPossiblyComparable
```
public static boolean isPossiblyComparable(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 guaranteed comparable, as defined by the rules of the "eq" operator, or if we don't yet know (because some subtypes of the static type are comparable and others are not). False if they are definitely not comparable.
  - 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

Class Type

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

ELEMENT

ATTRIBUTE

TEXT

WHITESPACE_TEXT

PROCESSING_INSTRUCTION

COMMENT

DOCUMENT

NAMESPACE

STOPPER

PARENT_POINTER

NODE

NODE_TYPE

ITEM

ITEM_TYPE

FUNCTION

MAX_NODE_TYPE

EMPTY

Method Detail

isNodeType

getItemType

displayTypeName

getBuiltInItemType

getBuiltInSimpleType

isSubType

getCommonSuperType

getCommonSuperType

isPrimitiveAtomicType

isPrimitiveAtomicUType

isGuaranteedComparable

isPossiblyComparable

isGenerallyComparable

isGuaranteedGenerallyComparable