Package net.sf.saxon.om

## Class StructuredQName

- java.lang.Object
- - net.sf.saxon.om.StructuredQName

- All Implemented Interfaces:
    `IdentityComparable`

      public class StructuredQName
      extends java.lang.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 | Description
    --- | ---
    `StructuredQName​(java.lang.String prefix, java.lang.String uri, java.lang.String localName)` | Construct a StructuredQName from a prefix, URI, and local name.

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `static int` | `computeHashCode​(java.lang.CharSequence uri, java.lang.CharSequence local)` | Expose the hashCode algorithm so that other implementations of QNames can construct a compatible hashcode
    `boolean` | `equals​(java.lang.Object other)` | Compare two StructuredQName values for equality.
    `static StructuredQName` | `fromClarkName​(java.lang.String expandedName)` | Make a structuredQName from a Clark name
    `static StructuredQName` | `fromEQName​(java.lang.CharSequence eqName)` | Make a structured QName from an EQName in `Q{uri}local` format.
    `static StructuredQName` | `fromLexicalQName​(java.lang.CharSequence lexicalName, boolean useDefault, boolean allowEQName, NamespaceResolver resolver)` | Make a structured QName from a lexical QName, using a supplied NamespaceResolver to resolve the prefix
    `java.lang.String` | `getClarkName()` | Get the expanded QName in Clark format, that is "{uri}local" if it is in a namespace, or just "local" otherwise.
    `java.lang.String` | `getDisplayName()` | Get the display name, that is the lexical QName in the form [prefix:]local-part
    `java.lang.String` | `getEQName()` | Get the expanded QName as an EQName, that is "Q{uri}local" for a name in a namespace, or "Q{}local" otherwise
    `java.lang.String` | `getLocalPart()` | Get the local part of the QName
    `NamespaceBinding` | `getNamespaceBinding()` | Get the NamespaceBinding (prefix/uri pair) corresponding to this name
    `java.lang.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)
    `java.lang.String` | `getURI()` | Get the namespace URI of the QName.
    `int` | `hashCode()` | Get a hashcode to reflect the equals() method.
    `boolean` | `hasURI​(java.lang.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.
    `javax.xml.namespace.QName` | `toJaxpQName()` | Convert the StructuredQName to a javax.xml.namespace.QName
    `java.lang.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​(java.lang.String prefix,
                                 java.lang.String uri,
                                 java.lang.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​(java.lang.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:
        `java.lang.IllegalArgumentException` - if the Clark name is malformed

    - #### fromLexicalQName

          public static StructuredQName fromLexicalQName​(java.lang.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), or (Q{uri}local) if allowEQName is set to true. Leading and trailing whitespace is ignored.
        `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. These may need to be changed on return depending on the caller's requirements.

    - #### fromEQName

          public static StructuredQName fromEQName​(java.lang.CharSequence eqName)

      Make a structured QName from an EQName in `Q{uri}local` format.
      Parameters:
        `eqName` - the QName as an EQName (`Q{uri}local`), or an unqualified local name. The format of the local name is not checked.
      Returns:
        the StructuredQName object corresponding to this EQName
      Throws:
        `java.lang.IllegalArgumentException` - if the eqName syntax is invalid (but the format of the URI and local name parts are not checked)

    - #### getPrefix

          public java.lang.String getPrefix()

      Get the prefix of the QName.
      Returns:
        the prefix. Returns the empty string if the name is unprefixed.

    - #### getURI

          public java.lang.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​(java.lang.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 java.lang.String getLocalPart()

      Get the local part of the QName
      Returns:
        the local part of the QName

    - #### getDisplayName

          public java.lang.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 java.lang.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 java.lang.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 java.lang.String toString()

      The toString() method displays the QName as a lexical QName, that is prefix:local
      Overrides:
        `toString` in class `java.lang.Object`
      Returns:
        the lexical QName

    - #### equals

          public boolean equals​(java.lang.Object other)

      Compare two StructuredQName values for equality. This compares the URI and local name parts, excluding any prefix
      Overrides:
        `equals` in class `java.lang.Object`

    - #### hashCode

          public int hashCode()

      Get a hashcode to reflect the equals() method.

      The hashcode is based on the URI and local part only, ignoring the prefix. In fact the URI plays little part in computing the hashcode, because the URI is often long, and largely redundant: QNames with the same local name will rarely have different URIs, and there are significant performance savings in the NamePool if a cheaper hashcode is used. So the only contribution from the URI is that we take its length into account.

      Overrides:
        `hashCode` in class `java.lang.Object`
      Returns:
        a hashcode used to distinguish distinct QNames

    - #### computeHashCode

          public static int computeHashCode​(java.lang.CharSequence uri,
                                            java.lang.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

    - #### toJaxpQName

          public javax.xml.namespace.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

    - #### 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.