/*
 * 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(XALAN_XALANNAMESPACESSTACK_HEADER_GUARD)
#define XALAN_XALANNAMESPACESSTACK_HEADER_GUARD


// Base include file.  Must be first.
#include <xalanc/DOMSupport/DOMSupportDefinitions.hpp>


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


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


namespace XALAN_CPP_NAMESPACE {


class XalanDOMString;


class XALAN_DOMSUPPORT_EXPORT XalanNamespacesStack
{
public:

    class XALAN_DOMSUPPORT_EXPORT PrefixResolverProxy : public PrefixResolver
    {
    public:

        /**
         * Construct a PrefixResolver from a XalanNamespaceStack
         * instance.
         *
         * @param theStack The stack to use for prefix resolution
         * @param theURI The namespace URI of the resolver, if any.  Only a reference is kept, so this cannot be a temporary
         * @return pointer to the string value if found, otherwise 0.
         */
        PrefixResolverProxy(
                const XalanNamespacesStack&     theStack,
                const XalanDOMString&           theURI);

        virtual
        ~PrefixResolverProxy();

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

        virtual const XalanDOMString&
        getURI() const;

    private:

        const XalanNamespacesStack&     m_stack;

        const XalanDOMString&           m_uri;
    };

    class XALAN_DOMSUPPORT_EXPORT XalanNamespacesStackEntry
    {
    public:

        typedef XalanNamespace  value_type;

        typedef XalanDeque<value_type>  NamespaceCollectionType;

        typedef const XalanDOMString& (value_type::*MemberFunctionType)() const;

        typedef NamespaceCollectionType::iterator                   iterator;
        typedef NamespaceCollectionType::reverse_iterator           reverse_iterator;
        typedef NamespaceCollectionType::const_iterator             const_iterator;
        typedef NamespaceCollectionType::const_reverse_iterator     const_reverse_iterator;

        XalanNamespacesStackEntry(MemoryManager& theManager);

        XalanNamespacesStackEntry(const XalanNamespacesStackEntry&  theSource,
                                    MemoryManager&              theManager);

        ~XalanNamespacesStackEntry();

        XalanNamespacesStackEntry&
        set(const XalanNamespacesStackEntry&    theRHS,
                  MemoryManager&                theManager);

        void
        addDeclaration(
                const XalanDOMString&       thePrefix,
                const XalanDOMChar*         theNamespaceURI,
                XalanDOMString::size_type   theLength);

        /**
         * Get the namespace for a prefix.
         *
         * @param thePrefix The prefix to find
         * @return pointer to the string value if found, otherwise 0.
         */
        const XalanDOMString*
        getNamespaceForPrefix(const XalanDOMString&     thePrefix) const
        {
            return findEntry(thePrefix, &XalanNamespace::getPrefix, &XalanNamespace::getURI);
        }

        /**
         * Get the prefix for a namespace.
         *
         * @param theURI The namespace URI to find
         * @return pointer to the string value if found, otherwise 0.
         */
        const XalanDOMString*
        getPrefixForNamespace(const XalanDOMString&     theURI) const
        {
            return findEntry(theURI, &XalanNamespace::getURI, &XalanNamespace::getPrefix);
        }

        bool
        isPrefixPresent(const XalanDOMString&   thePrefix) const
        {
            return getNamespaceForPrefix(thePrefix) == 0 ? false : true;
        }

        iterator
        begin()
        {
            return m_namespaces.begin();
        }

        const_iterator
        begin() const
        {
            return m_namespaces.begin();
        }

        iterator
        end()
        {
            return m_position;
        }

        const_iterator
        end() const
        {
            return const_iterator(m_position);
        }

        reverse_iterator
        rbegin()
        {
            return reverse_iterator(end());
        }

        const_reverse_iterator
        rbegin() const
        {
            return const_reverse_iterator(end());
        }

        reverse_iterator
        rend()
        {
            return reverse_iterator(begin());
        }

        const_reverse_iterator
        rend() const
        {
            return const_reverse_iterator(begin());
        }

        void
        clear();

        void
        reset()
        {
            m_position = m_namespaces.begin();
        }

        void
        swap(XalanNamespacesStackEntry&     theOther);

    private:
        //Not implemented
        XalanNamespacesStackEntry();
        XalanNamespacesStackEntry(const XalanNamespacesStackEntry&  theSource);

        const XalanDOMString*
        findEntry(
            const XalanDOMString&   theKey,
            MemberFunctionType      theKeyFunction,
            MemberFunctionType      theValueFunction) const;

        NamespaceCollectionType     m_namespaces;

        iterator                    m_position;
    };


    typedef XalanNamespacesStackEntry   value_type;

    typedef XalanDeque<value_type, ConstructWithMemoryManagerTraits<value_type> >       NamespacesStackType;
    typedef XalanVector<bool>           BoolVectorType;

    typedef NamespacesStackType::iterator                   iterator;
    typedef NamespacesStackType::reverse_iterator           reverse_iterator;
    typedef NamespacesStackType::const_iterator             const_iterator;
    typedef NamespacesStackType::const_reverse_iterator     const_reverse_iterator;

    typedef NamespacesStackType::size_type  size_type;

    typedef const XalanDOMString* (value_type::*MemberFunctionType)(const XalanDOMString&) const;


    explicit
    XalanNamespacesStack(MemoryManager& theManager);

    ~XalanNamespacesStack();

    void
    addDeclaration(
            const XalanDOMString&   thePrefix,
            const XalanDOMString&   theURI)
    {
        addDeclaration(
            thePrefix,
            theURI.c_str(),
            theURI.length());
    }

    void
    addDeclaration(
            const XalanDOMString&   thePrefix,
            const XalanDOMChar*     theURI)
    {
        addDeclaration(
            thePrefix,
            theURI,
            length(theURI));
    }

    void
    addDeclaration(
            const XalanDOMString&       thePrefix,
            const XalanDOMChar*         theURI,
            XalanDOMString::size_type   theLength);

    void
    pushContext();

    void
    popContext();

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

    const XalanDOMString*
    getPrefixForNamespace(const XalanDOMString&     theURI) const
    {
        return findEntry(theURI, &value_type::getPrefixForNamespace);
    }

    /**
     * See if the prefix has been mapped to a namespace in the current
     * context, without looking down the stack of namespaces.
     */
    bool
    prefixIsPresentLocal(const XalanDOMString&  thePrefix);

    void
    clear();

    iterator
    begin()
    {
        return m_stackBegin + 1;
    }

    const_iterator
    begin() const
    {
        return const_iterator(m_stackBegin + 1);
    }

    iterator
    end()
    {
        return m_stackPosition + 1;
    }

    const_iterator
    end() const
    {
        return const_iterator(m_stackPosition + 1);
    }

    reverse_iterator
    rbegin()
    {
        return reverse_iterator(end());
    }

    const_reverse_iterator
    rbegin() const
    {
        return const_reverse_iterator(end());
    }

    reverse_iterator
    rend()
    {
        return reverse_iterator(begin());
    }

    const_reverse_iterator
    rend() const
    {
        return const_reverse_iterator(begin());
    }

    size_type
    size() const
    {
        return m_resultNamespaces.size() - 1;
    }

    bool
    empty() const
    {
        return NamespacesStackType::const_iterator(m_stackPosition) == m_resultNamespaces.begin() ? true : false;
    }

private:

    // not implemented
    XalanNamespacesStack(const XalanNamespacesStack&);
    XalanNamespacesStack();
    XalanNamespacesStackEntry&
    operator=(const XalanNamespacesStackEntry&  theRHS);

    bool
    operator==(const XalanNamespacesStack&) const;

    XalanNamespacesStack&
    operator=(const XalanNamespacesStack&);

    enum { eDefaultCreateNewContextStackSize = 25 };

    const XalanDOMString*
    findEntry(
            const XalanDOMString&   theKey,
            MemberFunctionType      theFunction) const;

    /**
     * A stack to keep track of the result tree namespaces.
     */
    NamespacesStackType             m_resultNamespaces;

    NamespacesStackType::iterator   m_stackBegin;

    NamespacesStackType::iterator   m_stackPosition;

    BoolVectorType                  m_createNewContextStack;
};


}


#endif  // XALAN_XALANNAMESPACESSTACK_HEADER_GUARD