// Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// MDXMLNode.CPP
// @file
// This file contains the implementation of the CMDXMLNode class which
// is the base class for the Mini-DOM.
// This class forms the basis for the Mini-DOM.  It is a
// pure abstract class and it's sole concern is the node
// type and name and the management of the list of child
// nodes.
// The node name and type are set in the constructor and
// cannot be changed thereafter.
// The list of child nodes is managed as a doubly-linked
// list, not an array or similar structure.  Derived
// classes which are not allowed children will override the
// operations to manipulate the child list.
// 
//

#include <gmxmlnode.h>
#include <gmxmldomconstants.h>
#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS 
#include "gmxmldummydtd.h"
#endif

CMDXMLNode::CMDXMLNode( TDOMNodeType aNodeType, TBool aCanHaveChildren, CMDXMLDocument* aOwnerDocument ):
	iElementType(KXMLUndefinedElement),
	iNodeType(aNodeType),
	iCanHaveChildren(aCanHaveChildren)
//
// The node type will normally be hard-wired in any derived class constructor.
// The node name and HaveChildren flag will normally be hard-wired in a derived class constructor unless it
// covers a generic element.
// @param aNodeType The tpe of node to be created
// @param aCanHaveChildren Flag to indicate if the node represents a node which is allowed children
// @param aOwnerDocument Pointer to the document at the root of the DOM tree
//
	{
	iOwnerDocument = aOwnerDocument;
	}

EXPORT_C CMDXMLNode::~CMDXMLNode()
//
// When this node is deleted it will links its previous and next siblings across the gap, will
// delete all of its children and will correct its parents first and last child pointers if necessary.
//
	{
	// Perform housekeeping on parent and siblings - shouldn't be necessary as the links to
	// this element should have been removed first or we are in a tree delete but 
	// let's be helpful anyway.
	if((iNextSiblingPtr != NULL) && (iNextSiblingPtr->iPrevSiblingPtr == this))
		{
		iNextSiblingPtr->iPrevSiblingPtr = iPrevSiblingPtr;
		}
	if((iPrevSiblingPtr != NULL) && (iPrevSiblingPtr->iNextSiblingPtr == this))
		{
		iPrevSiblingPtr->iNextSiblingPtr = iNextSiblingPtr;
		}
	if( iParentPtr != NULL )
		{
		if(iParentPtr->iFirstChildPtr == this)
			{
			iParentPtr->iFirstChildPtr = iNextSiblingPtr;
			}
		if(iParentPtr->iLastChildPtr == this)
			{
			iParentPtr->iLastChildPtr = iPrevSiblingPtr;
			}
		}

	// Delete all children
	CMDXMLNode* childToDelete;
	CMDXMLNode* nextChild;
	childToDelete = iFirstChildPtr;
	while( childToDelete != NULL )
		{
		nextChild = childToDelete->iNextSiblingPtr;
		delete childToDelete;
		childToDelete = nextChild;
		}

	delete iNodeName;
	iNodeName = NULL;
	}

EXPORT_C void CMDXMLNode::SetNodeNameL( const TDesC& aNodeName)
//
// @param aNodeName The name of the node.
// @leave Can Leave due to OOM
//
	{
	iNodeName = HBufC::NewMaxL(aNodeName.Length());
	TPtr nodeAccess = iNodeName->Des();
	nodeAccess = aNodeName;
	}

EXPORT_C TPtrC CMDXMLNode::NodeName()
//
// @return Returns the name of the node
//
	{
	TPtrC retVal = iNodeName->Des();
	return retVal;
	}


EXPORT_C CMDXMLNode* CMDXMLNode::PreviousSameTypeSibling()
//
// @return Returns a pointer to the previous sibling node of the same type if any,
// oherwise returns NULL
//
	{
	CMDXMLNode* nodePtr = iPrevSiblingPtr;
	while((nodePtr != NULL) && nodePtr->iElementType != iElementType)
		{
		nodePtr = nodePtr->iPrevSiblingPtr;
		}
	return nodePtr;
	}

EXPORT_C CMDXMLNode* CMDXMLNode::NextSameTypeSibling()
//
// @return Returns a pointer to the next sibling node of the same type if any,
// oherwise returns NULL
//
	{
	CMDXMLNode* nodePtr = iNextSiblingPtr;
	while((nodePtr != NULL) && nodePtr->iElementType != iElementType)
		{
		nodePtr = nodePtr->iNextSiblingPtr;
		}
	return nodePtr;
	}

EXPORT_C TInt CMDXMLNode::RemoveChild(CMDXMLNode* aChildToRemove)
//
// Removes a child from the list of child nodes.  The child node is not deleted - that is the responsibility of the caller
// @param aChildToRemove Pointer to child to remove from the list
// @return Returns KERRNone if sucessful or KErrNotFound if the referenced child node is not found
//
	{
	TInt retVal=KErrNone;		
	
	if(aChildToRemove == NULL)
		{
		retVal = KErrNotFound;
		}
	else if( !iCanHaveChildren )
		{
		retVal = KErrXMLInvalidChild;
		}
	else if( aChildToRemove->iParentPtr != this )
		{
		retVal = KErrNotFound;
		}
	else
		{
		if(iFirstChildPtr == NULL)
			{
			retVal = KErrNotFound;
			}
		else 
			{
			if( aChildToRemove == iFirstChildPtr)
				{
				if( aChildToRemove == iLastChildPtr )
					{ // Only child so just zero pointers
					iFirstChildPtr = NULL;
					iLastChildPtr = NULL;
					}
				else
					{ // First but not only child
					iFirstChildPtr->iNextSiblingPtr->iPrevSiblingPtr = NULL;
					iFirstChildPtr = iFirstChildPtr->iNextSiblingPtr;
					}
				}
			else if( aChildToRemove == iLastChildPtr )
				{ // Last but not only child
				iLastChildPtr->iPrevSiblingPtr->iNextSiblingPtr = NULL;
				iLastChildPtr = iLastChildPtr->iPrevSiblingPtr;
				}
			else
				{ // Not first or last so somewhere in the list
				CMDXMLNode* nodeBefore = iFirstChildPtr;
				while((nodeBefore->iNextSiblingPtr != NULL) && 
					  (nodeBefore->iNextSiblingPtr != aChildToRemove))
					{
					nodeBefore = nodeBefore->iNextSiblingPtr;
					}
				if( nodeBefore->iNextSiblingPtr != aChildToRemove )
					{
					retVal = KErrNotFound;
					}
				else
					{
					nodeBefore->iNextSiblingPtr = aChildToRemove->iNextSiblingPtr;
					aChildToRemove->iNextSiblingPtr->iPrevSiblingPtr = nodeBefore;
					}
				}
			}
		}//end if

	if( retVal == KErrNone )
		{ // Having cleared this node off the list, clear its own pointers
		aChildToRemove->iPrevSiblingPtr = NULL;
		aChildToRemove->iNextSiblingPtr = NULL;
		aChildToRemove->iParentPtr = NULL;
		}
	return retVal;
	}

EXPORT_C TInt CMDXMLNode::InsertBefore(CMDXMLNode* aInsertBeforeChild, CMDXMLNode* aChildToInsert)
//
// Inserts a new child node at a specific point in the child list.
// @param aInsertBeforeChild Pointer to the element before which the new child should be inserted (NULL to insert at the start of the list)
// @param aChildToInsert Pointer to the new child node to insert.
// @return Returns KErrNone if successful, KErrXMLInvalidChild if the node cannot have children or KErrNotFound if it cannot fnd the child before which to insert
//
	{
	TInt retVal = KErrNone;	
	
	if(aChildToInsert == NULL)
		{
		retVal = KErrNotSupported;
		}
	else if( !iCanHaveChildren )
		{
		retVal = KErrXMLInvalidChild ;
		}
	else if(iFirstChildPtr == NULL && aInsertBeforeChild != NULL)
		{
		retVal = KErrNotFound;
		}
	else if((aInsertBeforeChild == NULL) || (aInsertBeforeChild == iFirstChildPtr))
		{ // Insert at start of list
		aChildToInsert->iParentPtr = this;
		if(iFirstChildPtr != NULL)
			{
			iFirstChildPtr->iPrevSiblingPtr = aChildToInsert;
			aChildToInsert->iNextSiblingPtr = iFirstChildPtr;
			}
		else
			{
			iLastChildPtr = aChildToInsert;
			aChildToInsert->iNextSiblingPtr = NULL;
			}
		iFirstChildPtr = aChildToInsert;
		}
	else
		{ // Find the insert before child as a check.
		CMDXMLNode* nodeBefore = iFirstChildPtr;
		while((nodeBefore->iNextSiblingPtr != NULL) && 
			  (nodeBefore->iNextSiblingPtr != aInsertBeforeChild))
			{
			nodeBefore = nodeBefore->iNextSiblingPtr;
			}
		if( nodeBefore->iNextSiblingPtr != aInsertBeforeChild )
			{
			retVal = KErrNotFound;
			}
		else
			{
			aChildToInsert->iParentPtr = this;
			aChildToInsert->iNextSiblingPtr = nodeBefore->iNextSiblingPtr;
			aChildToInsert->iPrevSiblingPtr = nodeBefore;
			nodeBefore->iNextSiblingPtr = aChildToInsert;
			aChildToInsert->iNextSiblingPtr->iPrevSiblingPtr = aChildToInsert;
			}
		}
	return retVal;
	}

EXPORT_C TInt CMDXMLNode::AppendChild(CMDXMLNode* aChildToInsert)
//
// Appends a new child at the end of the child list.
// @param aChildToInsert Pointer to the new child node to append.
// @return Returns KErrNone if successful or KErrXMLInvalidChild if the node cannot have children
//
	{
	TInt retVal = KErrNone;

	if(aChildToInsert == NULL)
		{
		retVal = KErrNotSupported;
		}
	else if( !iCanHaveChildren )
		{
		retVal = KErrXMLInvalidChild;
		}
	else
		{
		if(iFirstChildPtr == NULL)
			{
			iFirstChildPtr = aChildToInsert;
			}

		if(iLastChildPtr != NULL)
			{
			iLastChildPtr->iNextSiblingPtr = aChildToInsert;
			}

		aChildToInsert->iPrevSiblingPtr = iLastChildPtr;
		iLastChildPtr = aChildToInsert;
		aChildToInsert->iParentPtr = this;
		}
	return retVal;
	}

EXPORT_C TInt CMDXMLNode::ReplaceChild(CMDXMLNode* aChildToInsert, CMDXMLNode* aChildToReplace)
//
// Inserts a new child node while removing an existing one.  The old child is not deleted.
// @param aChildToInsert Pointer to the new child node to insert.
// @param aChildToReplace Pointer to the child node to be replaced.
// @return Returns KErrNone if successful, KErrXMLInvalidChild if the node cannot have children or KErrNotFound if it cannot fnd the child to replace.
//
	{
	TInt retVal = KErrNone;
	
	if(aChildToInsert == NULL)
		{
		retVal = KErrNotSupported;
		}
	else if(aChildToReplace == NULL)
		{
		retVal = KErrNotFound;
		}
	else if( !iCanHaveChildren )
		{
		retVal = KErrXMLInvalidChild ;
		}
	else
		{
		if((aChildToReplace == iFirstChildPtr) && (aChildToReplace == iLastChildPtr))
			{ // Replace only child
			iFirstChildPtr = aChildToInsert;
			iLastChildPtr = aChildToInsert;
			}
		else if(aChildToReplace == iFirstChildPtr)
			{ // Replace first but not only
			aChildToInsert->iNextSiblingPtr = iFirstChildPtr->iNextSiblingPtr;
			aChildToInsert->iNextSiblingPtr->iPrevSiblingPtr = aChildToInsert;
			iFirstChildPtr = aChildToInsert;
			}
		else if(aChildToReplace == iLastChildPtr)
			{ // Replace Last but not only
			aChildToInsert->iPrevSiblingPtr = iLastChildPtr->iPrevSiblingPtr;
			aChildToInsert->iPrevSiblingPtr->iNextSiblingPtr = aChildToInsert;
			iLastChildPtr = aChildToInsert;
			}
		else if(iFirstChildPtr != NULL)
			{ // Replace in the middle of the list
			CMDXMLNode* nodeBefore = iFirstChildPtr;
			while((nodeBefore->iNextSiblingPtr != NULL) && 
				  (nodeBefore->iNextSiblingPtr != aChildToReplace))
				{
				nodeBefore = nodeBefore->iNextSiblingPtr;
				}
			if( nodeBefore->iNextSiblingPtr != aChildToReplace )
				{
				retVal = KErrNotFound;
				}
			else
				{ // found so just cross link
				aChildToInsert->iNextSiblingPtr = aChildToReplace->iNextSiblingPtr;
				aChildToInsert->iPrevSiblingPtr = aChildToReplace->iPrevSiblingPtr;
				aChildToInsert->iPrevSiblingPtr->iNextSiblingPtr = aChildToInsert;
				aChildToInsert->iNextSiblingPtr->iPrevSiblingPtr = aChildToInsert;
				}
			}
		else
			{
			retVal = KErrNotFound;
			}
		}

	if( retVal == KErrNone )
		{ // Clear out the replaced node
		aChildToReplace->iPrevSiblingPtr = NULL;
		aChildToReplace->iNextSiblingPtr = NULL;
		aChildToReplace->iParentPtr = NULL;
		// Point the new child at its parent
		aChildToInsert->iParentPtr = this;
		}
	return retVal;
	}

// End Of File