Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.10

             

---

MutableNodeRefList.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(MUTABLENODEREFLIST_HEADER_GUARD_1357924680)
#define MUTABLENODEREFLIST_HEADER_GUARD_1357924680



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



#include <xalanc/XPath/NodeRefList.hpp>



XALAN_CPP_NAMESPACE_BEGIN



class XPathExecutionContext;
class XalanDocument;
class XalanNodeList;



class XALAN_XPATH_EXPORT MutableNodeRefList : public NodeRefList
{
public:

    explicit
    MutableNodeRefList(MemoryManagerType& theManager);

    static MutableNodeRefList*
    create(MemoryManagerType& theManager);
    MutableNodeRefList(const MutableNodeRefList&    theSource,
                        MemoryManagerType& theManager);

    explicit
    MutableNodeRefList(const NodeRefListBase&   theSource,
                        MemoryManagerType& theManager);

    virtual
    ~MutableNodeRefList();

    MutableNodeRefList&
    operator=(const MutableNodeRefList&     theRHS);

    MutableNodeRefList&
    operator=(const NodeRefList&        theRHS);

    MutableNodeRefList&
    operator=(const NodeRefListBase&    theRHS);

    MutableNodeRefList&
    operator=(const XalanNodeList*  theRHS);

    void
    addNode(XalanNode*  n);

    void
    insertNode(
            XalanNode*  n,
            size_type   pos);

    void
    removeNode(const XalanNode*     n);

    void
    removeNode(size_type    pos);

    void
    clear();

    void
    setNode(
            size_type   pos,
            XalanNode*  n = 0);

    void
    addNodes(const XalanNodeList&   nodelist);

    void
    addNodes(const NodeRefListBase&     nodelist);

    void
    addNodesInDocOrder(
            const XalanNodeList&    nodelist,
            XPathExecutionContext&  executionContext);
  
    void
    addNodesInDocOrder(
            const NodeRefListBase&  nodelist,
            XPathExecutionContext&  executionContext);

    void
    addNodesInDocOrder(
            const MutableNodeRefList&   nodelist,
            XPathExecutionContext&      executionContext);
  
    void
    addNodeInDocOrder(
            XalanNode*              node,
            XPathExecutionContext&  executionContext);

    void
    clearNulls();

    void
    reverse();

    void
    reserve(size_type   theCount)
    {
        m_nodeList.reserve(theCount);
    }

    bool
    getUnknownOrder() const
    {
        return m_order == eUnknownOrder ? true : false;
    }

    void
    setUnknownOrder()
    {
        m_order = eUnknownOrder;
    }

    bool
    getDocumentOrder() const
    {
        return m_order == eDocumentOrder ? true : false;
    }

    void
    setDocumentOrder()
    {
        m_order = eDocumentOrder;
    }

    bool
    getReverseDocumentOrder() const
    {
        return m_order == eReverseDocumentOrder ? true : false;
    }

    void
    setReverseDocumentOrder()
    {
        m_order = eReverseDocumentOrder;
    }

    typedef NodeListVectorType::iterator    NodeListIteratorType;

    class addNodeInDocOrderFunctor
    {
    public:

        addNodeInDocOrderFunctor(
                MutableNodeRefList&     theList,
                XPathExecutionContext&  theExecutionContext) :
            m_list(theList),
            m_executionContext(theExecutionContext)
        {
        }

        void
        operator()(XalanNode*   theNode) const
        {
            m_list.addNodeInDocOrder(theNode, m_executionContext);
        }

    private:

        MutableNodeRefList&     m_list;

        XPathExecutionContext&  m_executionContext;
    };

    void
    swap(MutableNodeRefList&    theOther)
    {
        NodeRefList::swap(theOther);

        const eOrder    temp = m_order;

        m_order = theOther.m_order;

        theOther.m_order = temp;
    }

private:
    //not defined
    MutableNodeRefList(const MutableNodeRefList&    theSource);

    // An enum to determine what the order of the nodes is...
    enum eOrder { eUnknownOrder, eDocumentOrder, eReverseDocumentOrder };

    eOrder  m_order;
};

XALAN_USES_MEMORY_MANAGER(MutableNodeRefList)

XALAN_CPP_NAMESPACE_END



#endif  // MUTABLENODEREFLIST_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.