Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.10

             

---

XalanQName.hpp

Go to the documentation of this file.

/*
 * Copyright 1999-2004 The Apache Software Foundation.
 *
 * Licensed 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/PlatformSupport/XSLException.hpp>



#include <xalanc/XPath/NameSpace.hpp>



XALAN_CPP_NAMESPACE_BEGIN



class XalanElement;
class XPathEnvSupport;




class XALAN_XPATH_EXPORT XalanQName
{
public:

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

    explicit
    XalanQName()
    {
    }

    virtual
    ~XalanQName()
    {
    }

    virtual const XalanDOMString&
    getLocalPart() const = 0;

    virtual const XalanDOMString&
    getNamespace() const = 0;

    bool
    isValid() const
    {
        return isValidNCName(getLocalPart());
    }

    bool
    isEmpty() const
    {
        return getNamespace().empty() && getLocalPart().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();
    }

    XalanDOMString::size_type
    hash() const
    {
        return getLocalPart().hash() % (getNamespace().hash() + 1);
    }

    class XALAN_XPATH_EXPORT PrefixResolverProxy : public PrefixResolver
    {
    public:

        PrefixResolverProxy(
                const NamespacesStackType&  theStack,
                const XalanDOMString&       theURI);

        virtual
        ~PrefixResolverProxy();

        virtual const XalanDOMString*
        getNamespaceForPrefix(const XalanDOMString&     prefix) const;

        virtual const XalanDOMString&
        getURI() const;

    private:

        const NamespacesStackType&  m_stack;

        const XalanDOMString&       m_uri;
    };

    static const XalanDOMString*
    getNamespaceForPrefix(
            const NamespaceVectorType&  namespaces,
            const XalanDOMString&       prefix);

    static const XalanDOMString*
    getNamespaceForPrefix(
            const NamespacesStackType&  nsStack,
            const XalanDOMString&       prefix);

    static const XalanDOMString*
    getNamespaceForPrefix(
            const NamespacesStackType&  nsStack,
            const XalanDOMChar*         prefix);

    static const XalanDOMString*
    getNamespaceForPrefix(
            NamespacesStackType::const_iterator     theBegin,
            NamespacesStackType::const_iterator     theEnd,
            const XalanDOMString&                   prefix);

    static const XalanDOMString*
    getPrefixForNamespace(
            const NamespaceVectorType&  namespaces,
            const XalanDOMString&       uri);

    static const XalanDOMString*
    getNamespaceForPrefix(
            const NamespaceVectorType&  namespaces,
            const XalanDOMChar*         prefix);

    static const XalanDOMString*
    getPrefixForNamespace(
            const NamespacesStackType&  nsStack,
            const XalanDOMString&       uri);

    static const XalanDOMString*
    getPrefixForNamespace(
            NamespacesStackType::const_iterator     theBegin,
            NamespacesStackType::const_iterator     theEnd,
            const XalanDOMString&                   uri);

    static const XalanDOMString*
    getNamespaceForPrefix(
            NamespacesStackType::const_iterator     theBegin,
            NamespacesStackType::const_iterator     theEnd,
            const XalanDOMChar*                     prefix);
    static bool
    isValidNCName(const XalanDOMString&     theNCName);

    static bool
    isValidNCName(
            const XalanDOMChar*         theNCName,
            XalanDOMString::size_type   theLength = XalanDOMString::npos);

    static bool
    isValidQName(const XalanDOMString&  theQName);

    static bool
    isValidQName(
            const XalanDOMChar*         theQName,
            XalanDOMString::size_type   theLength = XalanDOMString::npos);

    class InvalidQNameException : public XSLException
    {
    public:

        InvalidQNameException(
                const XalanDOMChar*         theQName,
                XalanDOMString::size_type   theQNameLength,
                const XalanDOMString&       theURI,
                int                         theLineNumber,
                int                         theColumnNumber,
                XalanDOMString&             theResult);

        InvalidQNameException(
                const LocatorType&          theLocator,
                const XalanDOMChar*         theQName,
                XalanDOMString::size_type   theQNameLength,
                XalanDOMString&             theResult);

        InvalidQNameException(
                const XalanDOMChar*         theQName,
                XalanDOMString::size_type   theQNameLength,
                XalanDOMString&             theResult);

        virtual
        ~InvalidQNameException();

        virtual const XalanDOMChar*
        getType() const
        {
            return m_type;
        }

    private:

        static const XalanDOMChar   m_type[];

        static const XalanDOMString&
        format(
                const XalanDOMChar*         theQName,
                XalanDOMString::size_type   theQNameLength,
                XalanDOMString&             theResult);
    };

protected:

    static const XalanDOMString     s_emptyString;
};


inline bool
operator==(
            const XalanQName&   theLHS,
            const XalanQName&   theRHS)
{
    return theLHS.equals(theRHS);
}



inline bool
operator!=(
            const XalanQName&   theLHS,
            const XalanQName&   theRHS)
{
    return !(theLHS == theRHS);
}



inline bool
operator<(
            const XalanQName&   theLHS,
            const XalanQName&   theRHS)
{
    if (theLHS.getNamespace() < theRHS.getNamespace())
    {
        return true;
    }
    else if (equals(theLHS.getNamespace(), theRHS.getNamespace()))
    {
        return theLHS.getLocalPart() < theRHS.getLocalPart();
    }
    else
    {
        return false;
    }
}

template<>
struct XalanMapKeyTraits<XalanQName>
{
    typedef XalanHashMemberReference<XalanQName>        Hasher;
    typedef XALAN_STD_QUALIFIER equal_to<XalanQName>    Comparator;
};

template<>
struct XalanMapKeyTraits<const XalanQName*>
{
    typedef XalanHashMemberPointer<XalanQName>      Hasher;
    typedef pointer_equal<XalanQName>               Comparator;
};


XALAN_CPP_NAMESPACE_END



#endif  // XALANQNAME_HEADER_GUARD_1357924680

Interpreting class diagrams

Doxygen and GraphViz are used to generate this API documentation from the Xalan-C header files.

Xalan-C++ XSLT Processor Version 1.10 Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.