src.java.com.ctc.wstx.dtd.NameKey Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of wstx-lgpl
There is a newer version: 3.2.7
/* Woodstox XML processor
 *
 * Copyright (c) 2004 Tatu Saloranta, [email protected]
 *
 * Licensed under the License specified in file LICENSE, included with
 * the source code.
 * You may not use this file except in compliance with the License.
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.ctc.wstx.dtd;

import javax.xml.XMLConstants;

/**
 * Simple key Object to be used for storing/accessing of potentially namespace
 * scoped element and attribute names.
 *
 * One important note about usage is that two of the name components (prefix
 * and local name) HAVE to have been interned some way, as all comparisons
 * are done using identity comparison; whereas URI is NOT necessarily
 * interned.
 *

 * Note that the main reason this class is mutable -- unlike most key classes
 * -- is that this allows reusing key objects for access, as long as the code
 * using it knows ramifications of trying to modify a key that's used
 * in a data structure.
 *

 * Note, too, that the hash code is cached as this class is mostly used as
 * a Map key, and hash code is used a lot.
 */
public final class NameKey
    implements Comparable // to allow alphabetic ordering
{
    private String mPrefix, mLocalName;

    volatile int mHash = 0;

    /*
    ///////////////////////////////////////////////////
    // Life-cycle
    ///////////////////////////////////////////////////
     */

    public NameKey(String prefix, String localName)
    {
        mLocalName = localName;
        mPrefix = (prefix != null && prefix.length() == 0) ?
            null : prefix;
    }

    public NameKey reset(String prefix, String localName)
    {
        mLocalName = localName;
        mPrefix = (prefix != null && prefix.length() == 0) ?
            null : prefix;
        mHash = 0;
        return this;
    }

    /*
    ///////////////////////////////////////////////////
    // Accessors:
    ///////////////////////////////////////////////////
     */

    public String getPrefix() { return mPrefix; }

    public String getLocalName() { return mLocalName; }

    /**
     * @return True, if this attribute name would result in a namespace
     *    binding (ie. it's "xmlns" or starts with "xmlns:").
     */
    public boolean isaNsDeclaration()
    {
        if (mPrefix == null) {
            return mLocalName == "xmlns";
        }
        return mPrefix == "xmlns";
    }

    /**
     * Method used to check for xml reserved attribute names, like
     * "xml:space" and "xml:id".
     *
     * Note: it is assumed that the passed-in localName is also
     * interned.
     */
    boolean isXmlReservedAttr(boolean nsAware, String localName)
    {
        if (nsAware) {
            if ("xml" == mPrefix) {
                return mLocalName == localName;
            }
        } else {
            if (mLocalName.length() == (4 + localName.length())) {
                return (mLocalName.startsWith("xml:")
                        && mLocalName.endsWith(localName));
            }
        }
        return false;
    }

    /*
    ///////////////////////////////////////////////////
    // Overridden standard methods:
    ///////////////////////////////////////////////////
     */
    
    public String toString()
    {
        if (mPrefix == null || mPrefix.length() == 0) {
            return mLocalName;
        }
        StringBuffer sb = new StringBuffer(mPrefix.length() + 1 + mLocalName.length());
        sb.append(mPrefix);
        sb.append(':');
        sb.append(mLocalName);
        return sb.toString();
    }

    public boolean equals(Object o)
    {
        if (o == this) {
            return true;
        }
        if (!(o instanceof NameKey)) { // also filters out nulls
            return false;
        }
        NameKey other = (NameKey) o;

        if (mLocalName != other.mLocalName) { // assumes equality
            return false;
        }
        return (mPrefix == other.mPrefix);
    }

    public int hashCode() {
        int hash = mHash;

        if (hash == 0) {
            hash = mLocalName.hashCode();
            if (mPrefix != null) {
                hash ^= mPrefix.hashCode();
            }
            mHash = hash;
        }
        return hash;
    }

    public int compareTo(Object o)
    {
        NameKey other = (NameKey) o;

        // First, by prefix, then by local name:
        String op = other.mPrefix;

        // Missing prefix is ordered before existing prefix
        if (op == null || op.length() == 0) {
            if (mPrefix != null && mPrefix.length() > 0) {
                return 1;
            }
        } else if (mPrefix == null || mPrefix.length() == 0) {
            return -1;
        } else {
            int result = mPrefix.compareTo(op);
            if (result != 0) {
                return result;
            }
        }

        return mLocalName.compareTo(other.mLocalName);
    }
}