src/XPath/MutableNodeRefList.hpp - xalan-c - Git at Google

 /*
  * The Apache Software License, Version 1.1
  *
  *
  * Copyright (c) 1999 The Apache Software Foundation.  All rights
  * reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  *
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
  *    the documentation and/or other materials provided with the
  *    distribution.
  *
  * 3. The end-user documentation included with the redistribution,
  *    if any, must include the following acknowledgment:
  *       "This product includes software developed by the
  *        Apache Software Foundation (http://www.apache.org/)."
  *    Alternately, this acknowledgment may appear in the software itself,
  *    if and wherever such third-party acknowledgments normally appear.
  *
  * 4. The names "Xalan" and "Apache Software Foundation" must
  *    not be used to endorse or promote products derived from this
  *    software without prior written permission. For written
  *    permission, please contact apache@apache.org.
  *
  * 5. Products derived from this software may not be called "Apache",
  *    nor may "Apache" appear in their name, without prior written
  *    permission of the Apache Software Foundation.
  *
  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * ====================================================================
  *
  * This software consists of voluntary contributions made by many
  * individuals on behalf of the Apache Software Foundation and was
  * originally based on software copyright (c) 1999, International
  * Business Machines, Inc., http://www.ibm.com.  For more
  * information on the Apache Software Foundation, please see
  * <http://www.apache.org/>.
  */
 #if !defined(MUTABLENODEREFLIST_HEADER_GUARD_1357924680)
 #define MUTABLENODEREFLIST_HEADER_GUARD_1357924680


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


 #include <XPath/NodeRefList.hpp>


 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();

 	/**
 	 * Construct a mutable node list from another list.
 	 *
 	 * @param theSource source list
 	 */
 	MutableNodeRefList(const MutableNodeRefList&	theSource);

 	/**
 	 * Construct a mutable node list from another list.
 	 *
 	 * @param theSource  source list
 	 */
 	explicit
 	MutableNodeRefList(const NodeRefListBase&	theSource);

 	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;
 	}

 	/**
 	 * 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;
 	};

 private:

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

 	eOrder	m_order;
 };


 #endif	// MUTABLENODEREFLIST_HEADER_GUARD_1357924680
	/*
	* The Apache Software License, Version 1.1
	*
	*
	* Copyright (c) 1999 The Apache Software Foundation. All rights
	* reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	*
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	*
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in
	* the documentation and/or other materials provided with the
	* distribution.
	*
	* 3. The end-user documentation included with the redistribution,
	* if any, must include the following acknowledgment:
	* "This product includes software developed by the
	* Apache Software Foundation (http://www.apache.org/)."
	* Alternately, this acknowledgment may appear in the software itself,
	* if and wherever such third-party acknowledgments normally appear.
	*
	* 4. The names "Xalan" and "Apache Software Foundation" must
	* not be used to endorse or promote products derived from this
	* software without prior written permission. For written
	* permission, please contact apache@apache.org.
	*
	* 5. Products derived from this software may not be called "Apache",
	* nor may "Apache" appear in their name, without prior written
	* permission of the Apache Software Foundation.
	*
	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
	* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	* SUCH DAMAGE.
	* ====================================================================
	*
	* This software consists of voluntary contributions made by many
	* individuals on behalf of the Apache Software Foundation and was
	* originally based on software copyright (c) 1999, International
	* Business Machines, Inc., http://www.ibm.com. For more
	* information on the Apache Software Foundation, please see
	* <http://www.apache.org/>.
	*/
	#if !defined(MUTABLENODEREFLIST_HEADER_GUARD_1357924680)
	#define MUTABLENODEREFLIST_HEADER_GUARD_1357924680



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



	#include <XPath/NodeRefList.hpp>



	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();

	/**
	* Construct a mutable node list from another list.
	*
	* @param theSource source list
	*/
	MutableNodeRefList(const MutableNodeRefList& theSource);

	/**
	* Construct a mutable node list from another list.
	*
	* @param theSource source list
	*/
	explicit
	MutableNodeRefList(const NodeRefListBase& theSource);

	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;
	}

	/**
	* 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;
	};

	private:

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

	eOrder m_order;
	};



	#endif // MUTABLENODEREFLIST_HEADER_GUARD_1357924680