XalanQName.hpp

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the  "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * 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.
 */
#if !defined(XALANQNAME_HEADER_GUARD_1357924680)
#define XALANQNAME_HEADER_GUARD_1357924680



// Base header file.  Must be first.
#include <xalanc/XPath/XPathDefinitions.hpp>



#include <xalanc/Include/XalanMap.hpp>
#include <xalanc/Include/XalanDeque.hpp>
#include <xalanc/Include/STLHelper.hpp>



#include <xalanc/XalanDOM/XalanDOMString.hpp>



#include <xalanc/PlatformSupport/DOMStringHelper.hpp>
#include <xalanc/PlatformSupport/PrefixResolver.hpp>



#include <xalanc/XPath/NameSpace.hpp>
#include <xalanc/XPath/XalanXPathException.hpp>



XALAN_CPP_NAMESPACE_BEGIN



class XalanElement;
class XPathEnvSupport;



/**
 * Class to represent a qualified name. The name of an internal XSLT object, 
 * specifically a named template (see [7 Named Templates]), a mode (see [6.7 Modes]), 
 * an attribute set (see [8.1.4 Named Attribute Sets]), a key (see [14.2 Keys]), 
 * a locale (see [14.3 Number Formatting]), a variable or a parameter (see 
 * [12 Variables and Parameters]) is specified as a QName. If it has a prefix, 
 * then the prefix is expanded into a URI reference using the namespace declarations 
 * in effect on the attribute in which the name occurs. The expanded name 
 * consisting of the local part of the name and the possibly null URI reference 
 * is used as the name of the object. The default namespace is not used for 
 * unprefixed names.
 */

class XALAN_XPATH_EXPORT XalanQName
{
public:

    typedef XalanDeque<NameSpace, ConstructWithMemoryManagerTraits<NameSpace> >
                                                            NamespaceVectorType;
    typedef XalanDeque<NamespaceVectorType, ConstructWithMemoryManagerTraits<NamespaceVectorType> >
                                                            NamespacesStackType;

    /**
     * Construct an empty XalanQName.
     *
     */
    explicit
    XalanQName()
    {
    }

    virtual
    ~XalanQName()
    {
    }

    XalanQName(const XalanQName&)
    {
    }

    /**
     * Retrieve the local part of qualified name.
     * 
     * @return local part string
     */
    virtual const XalanDOMString&
    getLocalPart() const = 0;

    /**
     * Retrieve the namespace of qualified name.
     * 
     * @return namespace string
     */
    virtual const XalanDOMString&
    getNamespace() const = 0;

    /**
     * Determine if the qualified name is valid.
     * 
     * @return true if the instance is a valid QName, false if not.
     */
    bool
    isValid() const
    {
        return isValidNCName(getLocalPart());
    }

    /**
     * Whether the qualified name is empty.
     * 
     * @return true if namespace and local part are both empty
     */
    bool
    isEmpty() const
    {
        return getNamespace().empty() && getLocalPart().empty();
    }

    /**
     * Override equals and agree that we're equal if the passed object is a
     * string and it matches the name of the arg.
     * 
     * @param theRHS namespace to compare
     * @return true if namespace and local part are both empty
     */
    bool
    equals(const XalanQName&    theRHS) const
    {
        // Note that we do not use our member variables here.  See
        // class QNameReference for details...
        return getLocalPart() == theRHS.getLocalPart() &&
               getNamespace() == theRHS.getNamespace();
    }

    /**
     * Format the QName using the notation "{namespace-uri}local-part" or
     * "local-part" if the namespace URI is empty.  The result is appended
     * to the provided string.
     * 
     * @param theString The string to format with the
     * @return A reference to the parameter.
     */
    XalanDOMString&
    format(XalanDOMString&  theString) const;

    size_t
    hash() const
    {
        return getLocalPart().hash() % (getNamespace().hash() + 1);
    }

    class XALAN_XPATH_EXPORT PrefixResolverProxy : public PrefixResolver
    {
    public:

        /**