MutableNodeRefList.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(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>
 
 
 
namespace XALAN_CPP_NAMESPACE {
 
 
 
class XPathExecutionContext;
class XalanDocument;
class XalanNodeList;
 
 
 
/**
 * Local implementation of MutableNodeRefList.  This class is for internal use
 * only.
 */
class XALAN_XPATH_EXPORT MutableNodeRefList : public NodeRefList
{
public:
 
    /**
     * Construct an empty mutable node list.
     */
    explicit
    MutableNodeRefList(MemoryManager& theManager);
 
    static MutableNodeRefList*
    create(MemoryManager& theManager);
    /**
     * Construct a mutable node list from another list.
     * 
     * @param theSource source list
     */
    MutableNodeRefList(const MutableNodeRefList&    theSource,
                        MemoryManager& theManager);
 
    /**
     * Construct a mutable node list from another list.
     * 
     * @param theSource  source list
     */
    explicit
    MutableNodeRefList(const NodeRefListBase&   theSource,
                        MemoryManager& theManager);
 
    virtual
    ~MutableNodeRefList();
 
    MutableNodeRefList&
    operator=(const MutableNodeRefList&     theRHS);
 
    MutableNodeRefList&
    operator=(const NodeRefList&        theRHS);
 
    MutableNodeRefList&
    operator=(const NodeRefListBase&    theRHS);
 
    MutableNodeRefList&
    operator=(const XalanNodeList*  theRHS);
 
    /**
     * Add a node at to the list.
     * 
     * @param n node to add
     */
    void
    addNode(XalanNode*  n);
 
    /**
     * Insert a node at a given position.
     * 
     * @param n   node to insert
     * @param pos position of insertion
     */
    void
    insertNode(
            XalanNode*  n,
            size_type   pos);
 
    /**
     * Remove a node from the list.
     * 
     * @param n   node to insert
     */
    void
    removeNode(const XalanNode*     n);
 
    /**
     * Remove a node from the list.
     * 
     * @param pos position of node in list
     */
    void
    removeNode(size_type    pos);
 
    /**
     * Remove all nodes.
     */
    void
    clear();
 
    /**
     * Set a item.
     * 
     * @param pos position of node to modify
     * @param n   node to insert, default is empty node
     */
    void
    setNode(
            size_type   pos,
            XalanNode*  n = 0);
 
    /**
     * Copy NodeList members into this nodelist, adding in document order.  If
     * a node is null, don't add it.
     * 
     * @param nodelist node list to add
     */
    void
    addNodes(const XalanNodeList&   nodelist);
 
    /**
     * Copy NodeList members into this nodelist, adding in document order.  If
     * a node is null, don't add it.
     * 
     * @param nodelist node list to add
     */
    void
    addNodes(const NodeRefListBase&     nodelist);
 
    /**
     * Copy NodeList members into this nodelist, adding in document order.
     * 
     * @param nodelist node list to add
     * @param executionContext the current execution context
     */
    void
    addNodesInDocOrder(
            const XalanNodeList&    nodelist,
            XPathExecutionContext&  executionContext);
  
    /**
     * Copy NodeList members into this nodelist, adding in document order.
     * 
     * @param nodelist node list to add
     * @param executionContext the current execution context
     */
    void
    addNodesInDocOrder(
            const NodeRefListBase&  nodelist,
            XPathExecutionContext&  executionContext);
 
    /**
     * Copy NodeList members into this nodelist, adding in document order.
     * 
     * @param nodelist node list to add
     * @param executionContext the current execution context
     */
    void
    addNodesInDocOrder(
            const MutableNodeRefList&   nodelist,
            XPathExecutionContext&      executionContext);
  
    /**
     * Add a node into list where it should occur in document order.
     *
     * @param node node object to add
     * @param executionContext the current execution context
     */
    void
    addNodeInDocOrder(
            XalanNode*              node,
            XPathExecutionContext&  executionContext);
 
    /**
     * Clear any null entries in the node list.
     */
    void
    clearNulls();
 
    /**
     * Reverse the nodes in the list.
     */
    void
    reverse();
 
    /**
     * Reserve space for the supplied number of nodes.
     * This is taken as an optimization, and may be
     * ignored.  You might want to call this when you
     * know the number of nodes you're about to add to
     * this list.
     *
     * Remember to take into account the current size of
     * the list when calling this.  That means you will
     * probably want to add the result of getLength() to
     * the number of nodes you're planning to add.
     *
     * @param theCount the number of nodes to reserve space for
     */
    void
    reserve(size_type   theCount)
    {
        m_nodeList.reserve(theCount);
    }
 
    /**
     * See if the order of the nodes is an unknown order.
     */
    bool
    getUnknownOrder() const
    {
        return m_order == eUnknownOrder ? true : false;
    }
 
    void
    setUnknownOrder()
    {
        m_order = eUnknownOrder;
    }
 
    /**
     * See if the order of the nodes is document order.
     */
    bool
    getDocumentOrder() const
    {
        return m_order == eDocumentOrder ? true : false;
    }
 
    /**
     * Set the known order of the nodes.  This should
     * only be done when the order is known. Otherwise,
     * disaster will ensue.
     */
    void
    setDocumentOrder()
    {
        m_order = eDocumentOrder;
    }
 
    /**
     * See if the order of the nodes is reverse document order.
     */
    bool
    getReverseDocumentOrder() const
    {
        return m_order == eReverseDocumentOrder ? true : false;
    }
 
    /**
     * Set the known order of the nodes.  This should
     * only be done when the order is known. Otherwise,
     * disaster will ensue.
     */
    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)
 
}
 
 
 
#endif  // MUTABLENODEREFLIST_HEADER_GUARD_1357924680