Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.10

             

---

NamespacesHandler.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(XALAN_NAMESPACESHANDLER_HEADER_GUARD)
#define XALAN_NAMESPACESHANDLER_HEADER_GUARD



// Base include file.  Must be first.
#include <xalanc/XSLT/XSLTDefinitions.hpp>



#include <xalanc/Include/XalanVector.hpp>
#include <xalanc/Include/XalanMap.hpp>



#include <xalanc/PlatformSupport/DOMStringHelper.hpp>



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



XALAN_CPP_NAMESPACE_BEGIN



class StylesheetConstructionContext;
class StylesheetExecutionContext;



class XALAN_XSLT_EXPORT NamespacesHandler
{
    
public:

    class PrefixChecker
    {
    public:

        PrefixChecker();

        virtual
        ~PrefixChecker();

        virtual bool
        isActive(const XalanDOMString&  thePrefix) const = 0;
    };

    class XALAN_XSLT_EXPORT Namespace
    {
    public:

        Namespace() :
            m_prefix(&s_emptyString),
            m_uri(&s_emptyString)
        {
        }

        Namespace(
                    const XalanDOMString&   prefix,
                    const XalanDOMString&   uri) :
            m_prefix(&prefix),
            m_uri(&uri)
        {
        }

        const XalanDOMString&
        getPrefix() const
        {
            assert(m_prefix != 0);

            return *m_prefix;
        }

        void
        setPrefix(const XalanDOMString&     prefix)
        {
            m_prefix = &prefix;
        }

        const XalanDOMString&
        getURI() const
        {
            assert(m_uri != 0);

            return *m_uri;
        }

        void
        setURI(const XalanDOMString&    uri)
        {
            m_uri = &uri;
        }

    protected:

        static const XalanDOMString     s_emptyString;

    private:

        const XalanDOMString*   m_prefix;

        const XalanDOMString*   m_uri;
    };

    class XALAN_XSLT_EXPORT NamespaceExtended : public Namespace
    {
    public:

        NamespaceExtended() :
            Namespace(),
            m_resultAttributeName(&s_emptyString)
        {
        }

        NamespaceExtended(
                    const XalanDOMString&   prefix,
                    const XalanDOMString&   uri) :
            Namespace(prefix, uri),
            m_resultAttributeName(&s_emptyString)
        {
        }

        const XalanDOMString&
        getResultAttributeName() const
        {
            assert(m_resultAttributeName != 0);

            return *m_resultAttributeName;
        }

        void
        setResultAttributeName(const XalanDOMString&    name)
        {
            m_resultAttributeName = &name;
        }

    private:

        const XalanDOMString*   m_resultAttributeName;
    };

    typedef XalanQName::NamespaceVectorType             NamespaceVectorType;
    typedef XalanQName::NamespacesStackType             NamespacesStackType;

    typedef XalanVector<Namespace>                      NamespacesVectorType;
    typedef XalanVector<NamespaceExtended>              NamespaceExtendedVectorType;
    typedef XalanVector<const XalanDOMString*>          XalanDOMStringPointerVectorType;

    typedef XalanMap<const XalanDOMString*,
                    const XalanDOMString*>              NamespaceAliasesMapType;


    explicit
    NamespacesHandler(MemoryManagerType& theManager);

    NamespacesHandler(
            StylesheetConstructionContext&  theConstructionContext,
            const NamespacesHandler&        stylesheetNamespacesHandler,
            const NamespacesStackType&      theCurrentNamespaces,
            const XalanDOMString&           theXSLTNamespaceURI);

    ~NamespacesHandler();

    void
    processExcludeResultPrefixes(
            StylesheetConstructionContext&  theConstructionContext,
            const XalanDOMChar*             theValue,
            const NamespacesStackType&      theCurrentNamespaces);

    void
    processExtensionElementPrefixes(
            StylesheetConstructionContext&  theConstructionContext,
            const XalanDOMChar*             theValue,
            const NamespacesStackType&      theCurrentNamespaces);

    void
    postConstruction(
            StylesheetConstructionContext&  theConstructionContext,
            bool                            fProcessNamespaceAliases = true,
            const XalanDOMString&           theElementName = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            const NamespacesHandler*        parentNamespacesHandler = 0,
            const PrefixChecker*            prefixChecker = 0);

    NamespacesHandler&
    operator=(const NamespacesHandler&  theRHS);

    bool
    shouldExcludeResultNamespaceNode(
            const XalanDOMString&   theXSLTNamespaceURI,
            const XalanDOMString&   theURI) const;

    void
    addExtensionNamespaceURI(
            StylesheetConstructionContext&  theConstructionContext,
            const XalanDOMString&   theURI);

    const XalanDOMString*
    getNamespace(const XalanDOMString&  thePrefix) const;

    const XalanDOMString*
    getNamespaceAlias(const XalanDOMString&     theStylesheetNamespace) const;

    void
    setNamespaceAlias(
            StylesheetConstructionContext&  theConstructionContext,
            const XalanDOMString&           theStylesheetNamespace,
            const XalanDOMString&           theResultNamespace);

    void
    copyNamespaceAliases(const NamespacesHandler&   parentNamespacesHandler);

    void
    outputResultNamespaces(
            StylesheetExecutionContext&     theExecutionContext,
            bool                            supressDefault = false) const;

    void
    clear();

    void
    swap(NamespacesHandler&     theOther);

    NamespaceExtendedVectorType::size_type
    getNamespaceDeclarationsCount() const
    {
        return m_namespaceDeclarations.size();
    }

private:

    void
    createResultAttributeNames(StylesheetConstructionContext&   theConstructionContext);

    void
    processExcludeResultPrefixes(
            StylesheetConstructionContext&  theConstructionContext,
            const XalanDOMString&           theElementPrefix,
            const PrefixChecker*            prefixChecker);

    void
    processNamespaceAliases();

    void
    copyNamespaceAliases(const NamespaceAliasesMapType&     theNamespaceAliases);

    void
    copyExtensionNamespaceURIs(const XalanDOMStringPointerVectorType&   theExtensionNamespaceURIs);

    void
    copyExcludeResultPrefixes(const NamespacesVectorType&   theExcludeResultPrefixes);

    bool
    isExcludedNamespaceURI(const XalanDOMString&    theNamespaceURI) const;

    bool
    isExtensionNamespaceURI(const XalanDOMString&   theNamespaceURI) const
    {
        return findString(theNamespaceURI, m_extensionNamespaceURIs);
    }

    static bool
    findString(
            const XalanDOMString&                   theString,
            const XalanDOMStringPointerVectorType&  theVector);


    // Not implemented...
    bool
    operator==(const NamespacesHandler&) const;


    // Data members...
    NamespacesVectorType                m_excludedResultPrefixes;

    NamespaceExtendedVectorType         m_namespaceDeclarations;

    XalanDOMStringPointerVectorType     m_extensionNamespaceURIs;

    NamespaceAliasesMapType             m_namespaceAliases;
};



XALAN_CPP_NAMESPACE_END



#endif  // XALAN_NAMESPACESHANDLER_HEADER_GUARD

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.