/*

* Copyright (c) 2005 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:  DM Utilities

*

*/

#include "nsmldmtreedtd.h"

#include <nsmldmuri.h>

#include <s32file.h> 

#include <featmgr.h>

// ===========================================================================

// CNSmlDmPcdata

// ===========================================================================

// ---------------------------------------------------------------------------

// CNSmlDmPcdata::CNSmlDmPcdata()

// ---------------------------------------------------------------------------

CNSmlDmPcdata::CNSmlDmPcdata()

	{

	}

// ---------------------------------------------------------------------------

// CNSmlDmPcdata::~CNSmlDmPcdata()

// ---------------------------------------------------------------------------

CNSmlDmPcdata::~CNSmlDmPcdata()

	{

	FreeContent();

	}

// ---------------------------------------------------------------------------

// CNSmlDmPcdata::FreeContent()

// Free the content of pcdata element

// ---------------------------------------------------------------------------

void CNSmlDmPcdata::FreeContent()

	{

    User::Free(iContent);

    iContent = 0;

	}

// ---------------------------------------------------------------------------

// CNSmlDmPcdata::DataL()

// fill the pc data element

// ---------------------------------------------------------------------------

void CNSmlDmPcdata::DataL( const TDesC8& aData )

	{

	iLength = aData.Length();

	iContent = User::AllocL(iLength);

	Mem::Copy(iContent, aData.Ptr(), iLength);

	}

// ---------------------------------------------------------------------------

// CNSmlDmPcdata::Compare()

// compare content of pcdata element to aStr 

// ---------------------------------------------------------------------------

TBool CNSmlDmPcdata::Compare(const TUint8* aStr, TInt aLength)

	{

	if(iLength!=aLength)

		{

		return EFalse;

		}

	for(TInt i=0;i<iLength;i++)

		{

		if(((TUint8*)iContent)[i]!=aStr[i])

			{

			return EFalse;

			}

		}

	return ETrue;

	}

// ===========================================================================

// CNSmlDmNode

// ===========================================================================

// ---------------------------------------------------------------------------

// CNSmlDmNode::CNSmlDmNode()

// ---------------------------------------------------------------------------

CNSmlDmNode::CNSmlDmNode()

	{

	    iDFProperties.iCaseSense=ETrue;

	}

// ---------------------------------------------------------------------------

// CNSmlDmNode::~CNSmlDmNode()

// ---------------------------------------------------------------------------

CNSmlDmNode::~CNSmlDmNode()

	{

	delete iPath;

	delete iRTProperties;

	delete iValue;

	CNSmlDmNodeList* ptr = iNodeListPtr;

	while(iNodeListPtr!=0)

		{

		delete iNodeListPtr->iNode;

		iNodeListPtr = iNodeListPtr->iNext;

		delete ptr;

		ptr = iNodeListPtr; 

		}

	}

// ---------------------------------------------------------------------------

// CNSmlDmNode::SetAccessTypesL( TSmlDmAccessTypes aAccessTypes )

// set accestypes of node to ddf

// ---------------------------------------------------------------------------

void CNSmlDmNode::SetAccessTypesL( TSmlDmAccessTypes aAccessTypes )

	{

	iDFProperties.iAccessTypes = aAccessTypes.GetACL();

	}

// ---------------------------------------------------------------------------

// CNSmlDmNode::SetDefaultValueL( const TDesC8& aDefaultValue )

// Set default value of node to ddf

// ---------------------------------------------------------------------------

void CNSmlDmNode::SetDefaultValueL( const TDesC8& aDefaultValue )

	{

	if(iDFProperties.iDefaultValue!=0)

		{

		delete iDFProperties.iDefaultValue;

		iDFProperties.iDefaultValue=0;

		}

	iDFProperties.iDefaultValue = new (ELeave) CNSmlDmPcdata();

	iDFProperties.iDefaultValue->DataL(aDefaultValue);

	}

// ---------------------------------------------------------------------------

// CNSmlDmNode::SetDescriptionL( const TDesC8& aDescription )

// Set description of node to ddf

// ---------------------------------------------------------------------------

void CNSmlDmNode::SetDescriptionL( const TDesC8& aDescription )

	{

	if(iDFProperties.iDescription!=0)

		{

		delete iDFProperties.iDescription;

		iDFProperties.iDescription=0;

		}

	iDFProperties.iDescription = new (ELeave) CNSmlDmPcdata();

	iDFProperties.iDescription->DataL(aDescription);

	}

// ---------------------------------------------------------------------------

// CNSmlDmNode::SetDFFormatL( TDFFormat aFormat )

// set dfformat of node to ddf

// ---------------------------------------------------------------------------

void CNSmlDmNode::SetDFFormatL( TDFFormat aFormat )

	{

	iDFProperties.iDFFormat = aFormat;

	}

// ---------------------------------------------------------------------------

// CNSmlDmNode::SetOccurenceL( TOccurence aOccurence )

// set occurrence of node to ddf

// ---------------------------------------------------------------------------

void CNSmlDmNode::SetOccurenceL( TOccurence aOccurence )

	{

	iDFProperties.iOccurrence = aOccurence;

	}

void CNSmlDmNode::SetCaseSenseL( TBool aCaseSense )

    {

    iDFProperties.iCaseSense = aCaseSense;

	}

// ---------------------------------------------------------------------------

// CNSmlDmNode::SetScopeL( TScope aScope )

// set scope of node to ddf

// ---------------------------------------------------------------------------

void CNSmlDmNode::SetScopeL( TScope aScope )

	{

	iDFProperties.iScope = aScope;

	}

// ---------------------------------------------------------------------------

// CNSmlDmNode::SetDFTitleL( const TDesC8& aDescription )

// set dftitle of node to ddf

// ---------------------------------------------------------------------------

void CNSmlDmNode::SetDFTitleL( const TDesC8& /*aDescription*/ )

	{

	}

// ---------------------------------------------------------------------------

// CNSmlDmNode::AddDFTypeMimeTypeL( const TDesC8& aMimeType )

// set mimetype of node to ddf

// ---------------------------------------------------------------------------

void CNSmlDmNode::AddDFTypeMimeTypeL( const TDesC8& aMimeType )

	{

	if(iDFProperties.iDFType!=0)

		{

		delete iDFProperties.iDFType;

		iDFProperties.iDFType=0;

		}

	iDFProperties.iDFType = new (ELeave) CNSmlDmPcdata();

	iDFProperties.iDFType->DataL(aMimeType);

	}

// ---------------------------------------------------------------------------

// CNSmlDmNode::SetAsObjectGroup()

// se as object group, adapter level is the last objectgroup level

// ---------------------------------------------------------------------------

void CNSmlDmNode::SetAsObjectGroup()

	{

	}

// ---------------------------------------------------------------------------

// CNSmlDmNode::AddChildObjectL( const TDesC8& aNodeName )

// Add child object for the node

// ---------------------------------------------------------------------------

MSmlDmDDFObject& CNSmlDmNode::AddChildObjectL( const TDesC8& aNodeName )

	{

	CNSmlDmNode* newNode;

	if ( iNodeListPtr == 0 )

		{

		newNode = new (ELeave) CNSmlDmNode();

		CleanupStack::PushL(newNode);

		newNode->iParent = this;

		iNodeListPtr = new (ELeave) CNSmlDmNodeList();

		CleanupStack::Pop(); // newNode

		iNodeListPtr->iNext = 0;

		iNodeListPtr->iNode = newNode;

		if(iStaticLevel)

			{

			newNode->iStaticLevel=ETrue;

			}

		newNode->iNodeName.DataL(aNodeName);

		}

	else

		{

		CNSmlDmNodeList* tmpNode = iNodeListPtr;

		CNSmlDmNodeList* tmpNodePrev = iNodeListPtr;

		TBool found=EFalse;

		//check if same nodename already exists

		while(tmpNode!=0)

			{

			if(tmpNode->iNode->iNodeName.Compare( aNodeName.Ptr(),

				aNodeName.Length() ) )

				{

				found = ETrue;

				break;

				}

			tmpNodePrev = tmpNode;

			tmpNode = tmpNode->iNext;

			}

		if(found)

			{

			//nodename already exist, new node is not created and pointer

			//to existing is returned

			newNode = tmpNode->iNode;

			}

		else

			{

			tmpNodePrev->iNext = new (ELeave) CNSmlDmNodeList();

			newNode = new (ELeave) CNSmlDmNode();

			newNode->iParent = this;

			tmpNode = tmpNodePrev->iNext;

			tmpNode->iNext = 0;

			tmpNode->iNode = newNode;

			if(iStaticLevel)

				{

				newNode->iStaticLevel=ETrue;

				}

			newNode->iNodeName.DataL( aNodeName );

			}

		}

	return *newNode;	

	}

// ---------------------------------------------------------------------------

// CNSmlDmNode::AddChildObjectGroupL()

// Adds nameless child to node

// ---------------------------------------------------------------------------

MSmlDmDDFObject& CNSmlDmNode::AddChildObjectGroupL()

	{

	CNSmlDmNode* newNode = 0;

	if(iNodeListPtr==0)

		{

		newNode = new (ELeave) CNSmlDmNode();

		CleanupStack::PushL(newNode);

		newNode->iParent = this;

		iNodeListPtr = new (ELeave) CNSmlDmNodeList();

		iNodeListPtr->iNext = 0;

		iNodeListPtr->iNode = newNode;

		CleanupStack::Pop(); //newNode

		newNode->iNodeName.DataL(KNullDesC8);

		}

	else

		{

		User::Leave(KErrAlreadyExists);

		}

	return *newNode;

	}

// ===========================================================================

// CNSmlDmNodeList

// ===========================================================================

// ---------------------------------------------------------------------------

// CNSmlDmNodeList::CNSmlDmNodeList()

// ---------------------------------------------------------------------------

CNSmlDmNodeList::CNSmlDmNodeList()

	{

	}

// ---------------------------------------------------------------------------

// CNSmlDmNodeList::GetImplUid()

// return implementation uid of adapter

// ---------------------------------------------------------------------------

EXPORT_C void CNSmlDmNodeList::GetImplUid(TUint32& aImplUid,

	TUint8& aSessionId)

	{

	CNSmlDmNode* nodePtr = this->iNode;

	while(nodePtr!=0)

		{

		if(nodePtr->iImplUid!=0)

			{

			aImplUid=nodePtr->iImplUid;

			aSessionId=nodePtr->iHostServerId;

			return;

			}

		nodePtr=nodePtr->iParent;

		}

	aImplUid=0;

	aSessionId=0;

	}

// ---------------------------------------------------------------------------

// CNSmlDmNodeList::GenerateNodeListL(CBufBase& aObject)

// generate xml

// ---------------------------------------------------------------------------

void CNSmlDmNodeList::GenerateNodeListL(CBufBase& aObject)

	{

	CNSmlDmNodeList* listPtr = this;

	while(listPtr!=0)

		{

		CNSmlDmNode* nodePtr = listPtr->iNode;

		aObject.InsertL(aObject.Size(),KNSmlDDFNode);

		aObject.InsertL(aObject.Size(),KNSmlDDFNodeName);

		aObject.InsertL(aObject.Size(),nodePtr->iNodeName.iContent,

			nodePtr->iNodeName.iLength);

		aObject.InsertL(aObject.Size(),KNSmlDDFNodeNameEnd);

		if(nodePtr->iPath!=0)

			{

			aObject.InsertL(aObject.Size(),KNSmlDDFPath);

			aObject.InsertL(aObject.Size(),nodePtr->iPath->iContent,

				nodePtr->iPath->iLength);

			aObject.InsertL(aObject.Size(),KNSmlDDFPathEnd);

			}

		nodePtr->iDFProperties.GenerateDFPropertiesL(aObject);

		if(nodePtr->iNodeListPtr!=0)

			{

			nodePtr->iNodeListPtr->GenerateNodeListL(aObject);

			}

		else

			{

			if(nodePtr->iValue!=0)

				{

				aObject.InsertL(aObject.Size(),KNSmlDDFValue);

				aObject.InsertL(aObject.Size(),nodePtr->iValue->iContent,

					nodePtr->iValue->iLength);

				aObject.InsertL(aObject.Size(),KNSmlDDFValueEnd);

				}

			}

		aObject.InsertL(aObject.Size(),KNSmlDDFNodeEnd); 

		listPtr = listPtr->iNext;

		}

	}

// ---------------------------------------------------------------------------

// CNSmlDmNodeList::GenerateNodeListWBXMLL(TPtr8& aObject)

// generate wbxml

// ---------------------------------------------------------------------------

void CNSmlDmNodeList::GenerateNodeListWBXMLL(RWriteStream& aStream)

	{

	CNSmlDmNodeList* listPtr = this;

	while(listPtr!=0)

		{

		CNSmlDmNode* nodePtr = listPtr->iNode;

		aStream.WriteUint8L(EDDFNode);

		// Add the iObjectGroup field

		aStream.WriteUint8L(EDDFStaticLevel);

		aStream.WriteUint8L(nodePtr->iStaticLevel);

		aStream.WriteUint8L(EDDFStaticLevelEnd);

		aStream.WriteUint8L(EDDFAdapterUid);

		aStream.WriteUint32L(nodePtr->iImplUid);

		aStream.WriteUint8L(EDDFAdapterUidEnd);

		aStream.WriteUint8L(EDDFHostServerId);

		aStream.WriteUint8L(nodePtr->iHostServerId);

		aStream.WriteUint8L(EDDFHostServerIdEnd);

		aStream.WriteUint8L(EDDFNodeName);

		aStream.WriteUint8L(nodePtr->iNodeName.iLength);

		aStream.WriteL(static_cast<TUint8*>(nodePtr->iNodeName.iContent),

			nodePtr->iNodeName.iLength);

		aStream.WriteUint8L(EDDFNodeNameEnd);

		//Path is not added

		nodePtr->iDFProperties.GenerateDFPropertiesWBXMLL(aStream);

		if(nodePtr->iNodeListPtr!=0)

			{

			nodePtr->iNodeListPtr->GenerateNodeListWBXMLL(aStream);

			}

		else

			{

			if(nodePtr->iValue!=0)

				{

				aStream.WriteUint8L(EDDFValue);

				aStream.WriteUint8L(nodePtr->iValue->iLength);

				aStream.WriteL(static_cast<TUint8*>(nodePtr->iValue->iContent),

					nodePtr->iValue->iLength);

				aStream.WriteUint8L(TChar(EDDFValueEnd));

				}

			}

		aStream.WriteUint8L(EDDFNodeEnd); 

		listPtr = listPtr->iNext;

		}

	}

// ---------------------------------------------------------------------------

// CNSmlDmNodeList::ParseNodeListWBXMLL(TPtr8& aObject)

// Parse nodelist from wbxml to structure

// ---------------------------------------------------------------------------

TUint CNSmlDmNodeList::ParseNodeListWBXMLL(RReadStream& aReader,

	CNSmlDmNodeList*& aNodeListPtr, CNSmlDmNode* aParent)

	{

	CNSmlDmNode* newNode = NULL;

	TUint tag = 0;

	CNSmlDmNodeList* lastInList = NULL;

	// read node tag

	tag = aReader.ReadUint8L();

	if (tag == EDDFNode )

	    {

		newNode = new (ELeave) CNSmlDmNode();

		aNodeListPtr->iNode = newNode;

		lastInList=aNodeListPtr;

		ParseNodeWBXMLL( aReader, newNode );

		newNode = NULL;

		}

	else

		{

		delete aNodeListPtr;

		aNodeListPtr = NULL;

		return tag;

		}

	// read next tag ( EDDFNode | EDDFNodeEnd  )

	tag = aReader.ReadUint8L();

   	__ASSERT_DEBUG(((tag == EDDFNode) || (tag == EDDFNodeEnd)||

   		(tag == EDDFMgmtTreeEnd)),

   		User::Panic(_L("ParseNodeListWBXMLL: unknown tag: "),tag));

	while ( tag == EDDFNode)

		{

   		lastInList->iNext = new (ELeave) CNSmlDmNodeList();

   		lastInList=lastInList->iNext;

		newNode = new (ELeave) CNSmlDmNode();

	   	newNode->iParent= aParent;

	   	lastInList->iNode = newNode;

       	lastInList->ParseNodeWBXMLL( aReader, newNode );

      	// read next tag

    	tag = aReader.ReadUint8L();

		}

	return tag;

	}

// ---------------------------------------------------------------------------

// CNSmlDmNodeList::ParseNodeWBXMLL(TPtr8& aObject)

// Parse node from wbxml to structure

// ---------------------------------------------------------------------------

void CNSmlDmNodeList::ParseNodeWBXMLL(RReadStream& aReader,CNSmlDmNode* aNode )

	{

	HBufC8* data;

	TUint tag = 0;

   	//EDDFStaticLevel tag

  	tag = aReader.ReadUint8L();

    aNode->iStaticLevel = aReader.ReadUint8L();

   	tag = aReader.ReadUint8L();