net.sf.saxon.type
public final class AnySimpleType extends Object implements SimpleType
Method Summary | |
---|---|
boolean | allowsDerivation(int derivation)
Determines whether derivation (of a particular kind)
from this type is allowed, based on the "final" property
|
void | analyzeContentExpression(Expression expression, int kind, StaticContext env)
Analyze an expression to see whether the expression is capable of delivering a value of this
type.
|
Value | atomize(NodeInfo node)
Get the typed value of a node that is annotated with this schema type. |
SchemaType | getBaseType()
Get the base type |
int | getBlock()
Returns the value of the 'block' attribute for this type, as a bit-signnificant
integer with fields such as DERIVATION_LIST and DERIVATION_EXTENSION
|
SchemaType | getBuiltInBaseType()
Get the built-in ancestor of this type in the type hierarchy |
AtomicType | getCommonAtomicType()
Get the most specific possible atomic type that all items in this SimpleType belong to |
int | getDerivationMethod()
Gets the integer code of the derivation method used to derive this type from its
parent. |
String | getDescription()
Get a description of this type for use in diagnostics |
String | getDisplayName()
Get the display name of the type: that is, a lexical QName with an arbitrary prefix
|
int | getFingerprint()
Get the fingerprint of the name of this type |
static AnySimpleType | getInstance()
Get the singular instance of this class |
SchemaType | getKnownBaseType()
Returns the base type that this type inherits from. |
int | getNameCode()
Get the namecode of the name of this type. |
SequenceIterator | getTypedValue(NodeInfo node)
Get the typed value of a node that is annotated with this schema type. |
SequenceIterator | getTypedValue(CharSequence value, NamespaceResolver resolver, NameChecker nameChecker)
Get the typed value corresponding to a given string value, assuming it is
valid against this type
|
int | getValidationStatus()
Get the validation status - always valid |
int | getWhitespaceAction(TypeHierarchy th)
Determine how values of this simple type are whitespace-normalized.
|
boolean | isAtomicType()
Test whether this Simple Type is an atomic type |
boolean | isComplexType()
Test whether this SchemaType is a complex type
|
boolean | isListType()
Determine whether this is a list type |
boolean | isNamespaceSensitive()
Test whether this type represents namespace-sensitive content |
boolean | isSameType(SchemaType other)
Test whether this is the same type as another type. |
boolean | isSimpleType()
Test whether this SchemaType is a simple type |
void | isTypeDerivationOK(SchemaType type, int block)
Check that this type is validly derived from a given type
|
boolean | isUnionType()
Determin whether this is a union type |
ValidationException | validateContent(CharSequence value, NamespaceResolver nsResolver, NameChecker nameChecker)
Check whether a given input string is valid according to this SimpleType |
Parameters: derivation the kind of derivation, for example DERIVATION_LIST
Returns: true if this kind of derivation is allowed
Parameters: expression the expression that delivers the content kind the node kind whose content is being delivered: ELEMENT, ATTRIBUTE, or DOCUMENT env
Parameters: node the node whose typed value is required
Returns: the typed value.
Since: 8.5
Returns: AnyType
Returns: the value of the 'block' attribute for this type
Returns: this type itself
Returns: the lowest common supertype of all member types
Returns: a numeric code representing the derivation method, for example DERIVATION_RESTRICTION
Returns: the string "xs:anyType"
Returns: a lexical QName identifying the type
Returns: the fingerprint.
Returns: the singular object representing xs:anyType
Returns: the base type.
Parameters: node the node whose typed value is required
Returns: an iterator returning a single untyped atomic value, equivalent to the string value of the node.
Parameters: value the string value resolver a namespace resolver used to resolve any namespace prefixes appearing in the content of values. Can supply null, in which case any namespace-sensitive content will be rejected. nameChecker
Returns: an iterator over the atomic sequence comprising the typed value. The objects returned by this SequenceIterator will all be of type AtomicValue
Parameters: th
Returns: false, this is not (necessarily) an atomic type
Returns: true if this SchemaType is a complex type
Returns: false (it isn't a list type)
Returns: false
Returns: true if this SchemaType is a simple type
Parameters: type the type from which this type is derived block the derivations that are blocked by the relevant element declaration
Throws: SchemaException if the derivation is not allowed
Returns: false (it isn't a union type)
Parameters: value the input string to be checked nsResolver a namespace resolver used to resolve namespace prefixes if the type is namespace sensitive. The value supplied may be null; in this case any namespace-sensitive content will throw an UnsupportedOperationException. nameChecker
Returns: null if validation succeeds (which it always does for this implementation)
Throws: UnsupportedOperationException if the type is namespace-sensitive and no namespace resolver is supplied