net.sf.saxon.om

Class StructuredQName

java.lang.Object

net.sf.saxon.om.StructuredQName

All Implemented Interfaces:

IdentityComparable

Direct Known Subclasses:

FingerprintedQName

public class StructuredQName
extends Object
implements IdentityComparable

This class provides an economical representation of a QName triple (prefix, URI, and localname). The value is stored internally as a character array containing the concatenation of URI, localname, and prefix (in that order) with two integers giving the start positions of the localname and prefix.

Instances of this class are immutable.

Constructor Summary

Constructors

Constructor and Description
StructuredQName(String prefix, String uri, String localName) Construct a StructuredQName from a prefix, URI, and local name.

Method Summary

Methods

Modifier and Type	Method and Description
static int	computeHashCode(CharSequence uri, CharSequence local) Expose the hashCode algorithm so that other implementations of QNames can construct a compatible hashcode
boolean	equals(Object other) Compare two StructuredQName values for equality.
static StructuredQName	fromClarkName(String expandedName) Make a structuredQName from a Clark name
static StructuredQName	fromEQName(CharSequence eqName) Make a structured QName from a lexical QName, using a supplied NamespaceResolver to resolve the prefix
static StructuredQName	fromLexicalQName(CharSequence lexicalName, boolean useDefault, boolean allowEQName, NamespaceResolver resolver) Make a structured QName from a lexical QName, using a supplied NamespaceResolver to resolve the prefix
String	getClarkName() Get the expanded QName in Clark format, that is "{uri}local" if it is in a namespace, or just "local" otherwise.
String	getDisplayName() Get the display name, that is the lexical QName in the form [prefix:]local-part
String	getEQName() Get the expanded QName as an EQName, that is "Q{uri}local" for a name in a namespace, or "Q{}local" otherwise
int	getFingerprint() Get the fingerprint of this name if known.
String	getLocalPart() Get the local part of the QName
int	getNameCode() Get the nameCode of this name if known.
NamespaceBinding	getNamespaceBinding() Get the NamespaceBinding (prefix/uri pair) corresponding to this name
String	getPrefix() Get the prefix of the QName.
StructuredQName	getStructuredQName() Get the name as a StructuredQName (which it already is; but this satisfies the NodeName interface)
String	getURI() Get the namespace URI of the QName.
boolean	hasFingerprint() Ask whether this node name representation has a known namecode and fingerprint
int	hashCode() Get a hashcode to reflect the equals() method
boolean	hasURI(String uri) Test whether the URI is equal to some constant
int	identityHashCode() Get a hashCode that offers the guarantee that if A.isIdentical(B), then A.identityHashCode() == B.identityHashCode()
boolean	isIdentical(IdentityComparable other) Determine whether two IdentityComparable objects are identical.
boolean	isInSameNamespace(NodeName other) Test whether this name is in the same namespace as another name
QName	toJaxpQName() Convert the StructuredQName to a javax.xml.namespace.QName
String	toString() The toString() method displays the QName as a lexical QName, that is prefix:local

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

StructuredQName

public StructuredQName(String prefix,
               String uri,
               String localName)

Construct a StructuredQName from a prefix, URI, and local name. This method performs no validation.

Parameters:

prefix - The prefix. Use an empty string to represent the null prefix.

uri - The namespace URI. Use an empty string or null to represent the no-namespace

localName - The local part of the name

Method Detail

fromClarkName

public static StructuredQName fromClarkName(String expandedName)

Make a structuredQName from a Clark name

Parameters:

expandedName - the name in Clark notation "{uri}local" if in a namespace, or "local" otherwise. The format "{}local" is also accepted for a name in no namespace. The EQName syntax (Q{uri}local) is also accepted.

Returns:

the constructed StructuredQName

Throws:

IllegalArgumentException - if the Clark name is malformed

fromLexicalQName

public static StructuredQName fromLexicalQName(CharSequence lexicalName,
                               boolean useDefault,
                               boolean allowEQName,
                               NamespaceResolver resolver)
                                        throws XPathException

Make a structured QName from a lexical QName, using a supplied NamespaceResolver to resolve the prefix

Parameters:

lexicalName - the QName as a lexical name (prefix:local)

useDefault - set to true if an absent prefix implies use of the default namespace; set to false if an absent prefix implies no namespace

allowEQName - true if the EQName syntax Q{uri}local is acceptable

resolver - NamespaceResolver used to look up a URI for the prefix

Returns:

the StructuredQName object corresponding to this lexical QName

Throws:

XPathException - if the namespace prefix is not in scope or if the value is lexically invalid. Error code FONS0004 is set if the namespace prefix has not been declared; error code FOCA0002 is set if the name is lexically invalid.

fromEQName

public static StructuredQName fromEQName(CharSequence eqName)

Make a structured QName from a lexical QName, using a supplied NamespaceResolver to resolve the prefix

Parameters:

eqName - the QName as an EQname (Q{uri}local), or an unqualified local name. The format is not checked.

Returns:

the StructuredQName object corresponding to this lexical QName

Throws:

IllegalArgumentException - if the eqName is obviously invalid

getPrefix

public String getPrefix()

Get the prefix of the QName.

Returns:

the prefix. Returns the empty string if the name is unprefixed.

getURI

public String getURI()

Get the namespace URI of the QName.

Returns:

the URI. Returns the empty string to represent the no-namespace

hasURI

public boolean hasURI(String uri)

Test whether the URI is equal to some constant

Parameters:

uri - the namespace URI to be tested

Returns:

true if the namespace URI of this QName is equal to the supplied URI

getLocalPart

public String getLocalPart()

Get the local part of the QName

Returns:

the local part of the QName

getDisplayName

public String getDisplayName()

Get the display name, that is the lexical QName in the form [prefix:]local-part

Returns:

the lexical QName

getStructuredQName

public StructuredQName getStructuredQName()

Get the name as a StructuredQName (which it already is; but this satisfies the NodeName interface)

Returns:

the name as a StructuredQName

getClarkName

public String getClarkName()

Get the expanded QName in Clark format, that is "{uri}local" if it is in a namespace, or just "local" otherwise.

Returns:

the QName in Clark notation

getEQName

public String getEQName()

Get the expanded QName as an EQName, that is "Q{uri}local" for a name in a namespace, or "Q{}local" otherwise

Returns:

the QName in EQName notation

toString

public String toString()

The toString() method displays the QName as a lexical QName, that is prefix:local

Overrides:

toString in class Object

Returns:

the lexical QName

equals

public boolean equals(Object other)

Compare two StructuredQName values for equality. This compares the URI and local name parts, excluding any prefix

Overrides:

equals in class Object

hashCode

public int hashCode()

Get a hashcode to reflect the equals() method

Overrides:

hashCode in class Object

Returns:

a hashcode based on the URI and local part only, ignoring the prefix.

computeHashCode

public static int computeHashCode(CharSequence uri,
                  CharSequence local)

Expose the hashCode algorithm so that other implementations of QNames can construct a compatible hashcode

Parameters:

uri - the namespace URI

local - the local name

Returns:

a hash code computed from the URI and local name

isInSameNamespace

public boolean isInSameNamespace(NodeName other)

Test whether this name is in the same namespace as another name

Parameters:

other - the other name

Returns:

true if the two names are in the same namespace

toJaxpQName

public QName toJaxpQName()

Convert the StructuredQName to a javax.xml.namespace.QName

Returns:

an object of class javax.xml.namespace.QName representing this qualified name

getNamespaceBinding

public NamespaceBinding getNamespaceBinding()

Get the NamespaceBinding (prefix/uri pair) corresponding to this name

Returns:

a NamespaceBinding containing the prefix and URI present in this QName

hasFingerprint

public boolean hasFingerprint()

Ask whether this node name representation has a known namecode and fingerprint

Returns:

true if the methods getFingerprint() and getNameCode() will return a result other than -1

getFingerprint

public int getFingerprint()

Get the fingerprint of this name if known. This method should not to any work to allocate a fingerprint if none is already available

Returns:

the fingerprint if known; otherwise -1

getNameCode

public int getNameCode()

Get the nameCode of this name if known. This method should not to any work to allocate a nameCode if none is already available

Returns:

the fingerprint if known; otherwise -1

isIdentical

public boolean isIdentical(IdentityComparable other)

Determine whether two IdentityComparable objects are identical. This is a stronger test than equality (even schema-equality); for example two dateTime values are not identical unless they are in the same timezone. In the case of a StructuredQName, the identity test compares prefixes as well as the namespace URI and local name.

Specified by:

isIdentical in interface IdentityComparable

Parameters:

other - the value to be compared with

Returns:

true if the two values are indentical, false otherwise

identityHashCode

public int identityHashCode()

Get a hashCode that offers the guarantee that if A.isIdentical(B), then A.identityHashCode() == B.identityHashCode()

Specified by:

identityHashCode in interface IdentityComparable

Returns:

a hashCode suitable for use when testing for identity.