Package net.sf.saxon.type

Class 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	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	FUNCTION	A type number for function()
static short	ITEM	An item type that matches any item
static ItemType	ITEM_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	TEXTUAL_ELEMENT	Node kind used in the tiny tree to represent an element node having simple text content
static short	WHITESPACE_TEXT	Item type representing a text node stored in the tiny tree as compressed whitespace

Method Summary

Modifier and Type	Method	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 SequenceType	getCommonSuperType(SequenceType t1, SequenceType t2)
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

TEXTUAL_ELEMENT

public static final short TEXTUAL_ELEMENT

Node kind used in the tiny tree to represent an element node having simple text content

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

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. In most cases this can be null, but the returned type may then be less precise (for example, the type returned for a map or array will simply be map(*) or array(*)). For external objects, the parameter must not be null

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

getCommonSuperType

public static SequenceType getCommonSuperType(SequenceType t1,
                                              SequenceType t2)

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