--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/syncmlfw/dm/dmutils/src/nsmldmtreedtd.cpp Thu Dec 17 09:07:52 2009 +0200
@@ -0,0 +1,1560 @@
+/*
+* 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()
+ {
+ delete 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();
+ newNode->iParent= aParent;
+ 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();
+
+ //EDDFAdapterUid tag
+ tag = aReader.ReadUint8L();
+ aNode->iImplUid = aReader.ReadUint32L();
+ tag = aReader.ReadUint8L();
+
+ //EDDFHostServerId tag
+ tag = aReader.ReadUint8L();
+ aNode->iHostServerId = aReader.ReadUint8L();
+ tag = aReader.ReadUint8L();
+
+ // nodename tag
+ tag = aReader.ReadUint8L();
+
+ // read nodename length
+ TUint8 len = aReader.ReadUint8L();
+ if ( len != 0 )
+ {
+ data = HBufC8::NewLC( len );
+ TPtr8 dataPtr = data->Des();
+ // ..and nodename
+ aReader.ReadL(dataPtr, len);
+ aNode->iNodeName.DataL(dataPtr);
+ CleanupStack::PopAndDestroy();
+ }
+
+ // end nodename
+ tag = aReader.ReadUint8L();
+
+ // read next tag
+ tag = aReader.ReadUint8L();
+ __ASSERT_DEBUG( tag == EDDFDFProperties,
+ User::Panic(_L("ParseNodeWBXMLL: wrong tag: "),tag));
+
+ // Path is not added to data
+ ParseDFPropertiesWBXMLL( aReader, aNode );
+
+
+ if ( aNode->iNodeListPtr == NULL )
+ {
+ aNode->iNodeListPtr = new (ELeave) CNSmlDmNodeList();
+ tag = ParseNodeListWBXMLL(aReader, aNode->iNodeListPtr, aNode);
+ }
+
+ if (tag == EDDFValue )
+ {
+ // value length
+ len = aReader.ReadUint8L();
+ // value data
+ data = HBufC8::NewLC( len );
+ TPtr8 dataPtr = data->Des();
+ aReader.ReadL(dataPtr, len);
+ // store the data
+ aNode->iValue->DataL(dataPtr);
+ // end value tag
+ tag = aReader.ReadUint8L();
+ CleanupStack::PopAndDestroy(); // data
+ }
+ }
+
+// ===========================================================================
+// CNSmlDmMgmtTree
+// ===========================================================================
+
+// ---------------------------------------------------------------------------
+// CNSmlDmMgmtTree::NewL()
+// ---------------------------------------------------------------------------
+EXPORT_C CNSmlDmMgmtTree* CNSmlDmMgmtTree::NewL()
+ {
+ CNSmlDmMgmtTree* self = new (ELeave) CNSmlDmMgmtTree();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop();
+ return self;
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmMgmtTree::ConstructL()
+// ---------------------------------------------------------------------------
+void CNSmlDmMgmtTree::ConstructL()
+ {
+ iNodeListPtr = 0;
+ iVerDTD.DataL ( KNSmlDmTreeDTDVersion );
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmMgmtTree::CNSmlDmMgmtTree()
+// ---------------------------------------------------------------------------
+CNSmlDmMgmtTree::CNSmlDmMgmtTree()
+ {
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNSmlDmMgmtTree::~CNSmlDmMgmtTree()
+// ---------------------------------------------------------------------------
+CNSmlDmMgmtTree::~CNSmlDmMgmtTree()
+ {
+ CNSmlDmNodeList* ptr = iNodeListPtr;
+ while(iNodeListPtr!=0)
+ {
+ delete iNodeListPtr->iNode;
+ iNodeListPtr = iNodeListPtr->iNext;
+ delete ptr;
+ ptr = iNodeListPtr;
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNSmlDmMgmtTree::SetAccessTypesL( TSmlDmAccessTypes aAccessTypes )
+// set accestypes for root node
+// ---------------------------------------------------------------------------
+void CNSmlDmMgmtTree::SetAccessTypesL( TSmlDmAccessTypes /*aAccessTypes*/ )
+ {
+ //root node cannot be changed
+ }
+
+
+
+// ---------------------------------------------------------------------------
+// CNSmlDmMgmtTree::SetDefaultValueL( const TDesC8& aDefaultValue )
+// ---------------------------------------------------------------------------
+void CNSmlDmMgmtTree::SetDefaultValueL( const TDesC8& /*aDefaultValue*/ )
+ {
+ //root node cannot be changed
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNSmlDmMgmtTree::SetDescriptionL( const TDesC8& aDescription )
+// ---------------------------------------------------------------------------
+void CNSmlDmMgmtTree::SetDescriptionL( const TDesC8& /*aDescription*/ )
+ {
+ //root node cannot be changed
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+void CNSmlDmMgmtTree::SetDFFormatL( TDFFormat /*aFormat*/ )
+ {
+ //root node cannot be changed
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmMgmtTree::SetOccurenceL( TOccurence aOccurence )
+// ---------------------------------------------------------------------------
+void CNSmlDmMgmtTree::SetOccurenceL( TOccurence /*aOccurence*/ )
+ {
+ //root node cannot be changed
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmMgmtTree::SetScopeL( TScope aScope )
+// ---------------------------------------------------------------------------
+void CNSmlDmMgmtTree::SetScopeL( TScope /*aScope*/ )
+ {
+ //root node cannot be changed
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNSmlDmMgmtTree::SetDFTitleL( const TDesC8& aTitle )
+// ---------------------------------------------------------------------------
+void CNSmlDmMgmtTree::SetDFTitleL( const TDesC8& /*aTitle*/ )
+ {
+ //root node cannot be changed
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNSmlDmMgmtTree::AddDFTypeMimeTypeL( const TDesC8& aMimeType )
+// ---------------------------------------------------------------------------
+void CNSmlDmMgmtTree::AddDFTypeMimeTypeL( const TDesC8& /*aMimeType*/ )
+ {
+ //root node cannot be changed
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNSmlDmMgmtTree::SetAsObjectGroup()
+// ---------------------------------------------------------------------------
+void CNSmlDmMgmtTree::SetAsObjectGroup()
+ {
+ //root node cannot be changed
+ }
+
+
+
+// ---------------------------------------------------------------------------
+// CNSmlDmMgmtTree::AddChildObjectL(const TDesC8& aNodeName)
+// add child under root node
+// ---------------------------------------------------------------------------
+MSmlDmDDFObject& CNSmlDmMgmtTree::AddChildObjectL(const TDesC8& aNodeName)
+ {
+ CNSmlDmNode* newNode;
+
+ if(iNodeListPtr==0)
+ {
+ newNode = new (ELeave) CNSmlDmNode();
+ CleanupStack::PushL(newNode);
+ iNodeListPtr = new (ELeave) CNSmlDmNodeList();
+ CleanupStack::Pop(); // newNode
+ iNodeListPtr->iNext = 0;
+ iNodeListPtr->iNode = newNode;
+ newNode->iStaticLevel=ETrue;
+ newNode->iNodeName.DataL(aNodeName);
+ }
+ else
+ {
+ CNSmlDmNodeList* tmpNode = iNodeListPtr;
+ CNSmlDmNodeList* tmpNodePrev = iNodeListPtr;
+ TBool found=EFalse;
+
+ //check if 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
+ {
+ //create new node
+ tmpNodePrev->iNext = new (ELeave) CNSmlDmNodeList();
+ newNode = new (ELeave) CNSmlDmNode();
+ tmpNode = tmpNodePrev->iNext;
+ tmpNode->iNext = 0;
+ tmpNode->iNode = newNode;
+ newNode->iStaticLevel=ETrue;
+ newNode->iNodeName.DataL(aNodeName);
+ }
+ }
+ return *newNode;
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmMgmtTree::AddChildObjectGroupL()
+// add child under root node
+// ---------------------------------------------------------------------------
+
+MSmlDmDDFObject& CNSmlDmMgmtTree::AddChildObjectGroupL()
+ {
+ User::Leave(KErrAccessDenied);
+ CNSmlDmNode* newNode=0;
+ return *newNode;
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmMgmtTree::GenerateXMLL(CBufBase& aObject)
+// Generate xml from ddf structure
+// ---------------------------------------------------------------------------
+EXPORT_C void CNSmlDmMgmtTree::GenerateXMLL(CBufBase& aObject)
+ {
+ CBufBase* man = CBufFlat::NewL(8);
+ CleanupStack::PushL(man);
+ CBufBase* mod = CBufFlat::NewL(8);
+ CleanupStack::PushL(mod);
+
+ aObject.InsertL(aObject.Size(),KNSmlDDFMgmtTree);
+ aObject.InsertL(aObject.Size(),KNSmlDDFVerDTD);
+ aObject.InsertL(aObject.Size(),iVerDTD.iContent, iVerDTD.iLength );
+ aObject.InsertL(aObject.Size(),KNSmlDDFVerDTDEnd);
+
+ //man
+ aObject.InsertL(aObject.Size(),KNSmlDDFMan);
+ aObject.InsertL(aObject.Size(),man->Ptr(0));
+ aObject.InsertL(aObject.Size(),KNSmlDDFManEnd);
+
+ //mod
+ aObject.InsertL(aObject.Size(),KNSmlDDFMod);
+ aObject.InsertL(aObject.Size(),mod->Ptr(0));
+ aObject.InsertL(aObject.Size(),KNSmlDDFModEnd);
+ CleanupStack::PopAndDestroy(2); //man,mod
+
+ if(iNodeListPtr!=0)
+ {
+ iNodeListPtr->GenerateNodeListL(aObject);
+ }
+ aObject.InsertL(aObject.Size(),KNSmlDDFMgmtTreeEnd);
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmMgmtTree::GenerateWBXMLL(CBufBase& aObject)
+// Generate wbxml from ddf structure
+// ---------------------------------------------------------------------------
+EXPORT_C void CNSmlDmMgmtTree::GenerateWBXMLL(RWriteStream& aStream)
+ {
+ aStream.WriteUint8L(EDDFMgmtTree);
+ aStream.WriteUint8L(EDDFVerDTD);
+ aStream.WriteUint8L(iVerDTD.iLength);
+ aStream.WriteL(static_cast<TUint8*>(iVerDTD.iContent), iVerDTD.iLength);
+ aStream.WriteUint8L(EDDFVerDTDEnd);
+
+ if(iNodeListPtr!=0)
+ {
+ iNodeListPtr->GenerateNodeListWBXMLL(aStream);
+ }
+
+ aStream.WriteUint8L(EDDFMgmtTreeEnd);
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmMgmtTree::ParseWBXMLL(CBufBase& aObject)
+// Parse wbxml to ddf structure
+// ---------------------------------------------------------------------------
+EXPORT_C void CNSmlDmMgmtTree::ParseWBXMLL(RReadStream& aReader)
+ {
+ //Mgmttree; ignore
+ aReader.ReadUint8L();
+ //VerDTD; ignore
+ aReader.ReadUint8L();
+ // verDTD length
+ TInt len = aReader.ReadUint8L();
+ // ..and value
+ //TDes8& aDes
+ HBufC8* verData = HBufC8::NewLC( len );
+ TPtr8 verDataPtr = verData->Des();
+ aReader.ReadL(verDataPtr, len);
+ //Append the verDTD to new DDF
+ CleanupStack::PopAndDestroy(); //verData
+ // end verDTD, ignore
+ aReader.ReadUint8L();
+
+
+ CNSmlDmNodeList* nodeListPtr;
+ TBool first=EFalse;
+
+ if(iNodeListPtr==0)
+ {
+ iNodeListPtr = new (ELeave) CNSmlDmNodeList();
+ nodeListPtr=iNodeListPtr;
+ first=ETrue;
+ }
+ else
+ {
+ nodeListPtr=iNodeListPtr;
+ while(nodeListPtr->iNext)
+ {
+ nodeListPtr=nodeListPtr->iNext;
+ }
+ nodeListPtr->iNext = new (ELeave) CNSmlDmNodeList();
+ }
+ if(first)
+ {
+ iNodeListPtr->ParseNodeListWBXMLL(aReader,iNodeListPtr, NULL );
+ }
+ else
+ {
+ iNodeListPtr->ParseNodeListWBXMLL(aReader,nodeListPtr->iNext, NULL );
+ }
+ }
+
+
+
+// ---------------------------------------------------------------------------
+// CNSmlDmMgmtTree::SetUid(TUint32 aUid)
+// Sets adapter uid to tree
+// ---------------------------------------------------------------------------
+EXPORT_C void CNSmlDmMgmtTree::SetAdapterUid(TUint32 aUid)
+ {
+ SetUidToNewItems(iNodeListPtr,aUid);
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmMgmtTree::SetServerId(TUint8 aServerId)
+// Sets host server id (host session id) to tree
+// ---------------------------------------------------------------------------
+EXPORT_C void CNSmlDmMgmtTree::SetServerId(TUint8 aServerId)
+ {
+ SetServerIdToNewItems(iNodeListPtr,aServerId);
+ }
+
+
+
+// ---------------------------------------------------------------------------
+// TNSmlDmDDFFormatt CNSmlDmDDF::FindNameFromNodeListL()
+// Recursive function for searching certain uri segment from ddf structure.
+// ---------------------------------------------------------------------------
+EXPORT_C TNSmlDmDDFFormat CNSmlDmMgmtTree::FindNameFromNodeListL(
+ const TDesC8& aURI,CNSmlDmNodeList*& aFinalPtr)
+ {
+ TNSmlDmDDFFormat ret = ENSmlDmDDFNotFound;
+
+ CNSmlDmNodeList* nodeListPtr = iNodeListPtr;
+ TInt numOfUriSegs=NSmlDmURI::NumOfURISegs(aURI);
+
+ TInt level=1;
+
+
+ while(nodeListPtr!=0)
+ {
+ TPtrC8 nodeNamePtr =
+ TPtrC8((TUint8*)nodeListPtr->iNode->iNodeName.iContent,
+ nodeListPtr->iNode->iNodeName.iLength);
+
+
+ //check if we are in correct level
+ if(level>=numOfUriSegs)
+ {
+ if( nodeNamePtr.Compare(NSmlDmURI::URISeg(aURI,level)) == 0 ||
+ nodeNamePtr.Length()==0)
+ {
+ if(nodeListPtr->iNode->iNodeListPtr!=0)
+ {
+ ret = ENSmlDmDDFNode;
+ }
+ else
+ {
+ ret = ENSmlDmDDFLeaf;
+ }
+ aFinalPtr = nodeListPtr;
+ break;
+ }
+ else
+ {
+ nodeListPtr = nodeListPtr->iNext;
+ }
+ }
+ else
+ {
+ //not yet in final level, if correct nodename found, this function is called recursively
+ if( nodeNamePtr.Compare(NSmlDmURI::URISeg(aURI,level)) == 0 ||
+ nodeNamePtr.Length()==0)
+ {
+ nodeListPtr=nodeListPtr->iNode->iNodeListPtr;
+ level++;
+ }
+ else
+ {
+ nodeListPtr = nodeListPtr->iNext;
+ }
+ }
+ } // end while
+
+ return ret;
+ }
+
+
+// ---------------------------------------------------------------------------
+// TBool CNSmlDmDDF::FindLoadedAdaptersL()
+// Finds the uids of allready loaded adapters
+// ---------------------------------------------------------------------------
+EXPORT_C TBool CNSmlDmMgmtTree::FindLoadedAdaptersL(
+ RArray<TUint32>& aLoadedAdapters,
+ CNSmlDmNodeList* aNodeListPtr)
+ {
+ CNSmlDmNodeList* nodeListPtr;
+ if(aNodeListPtr)
+ {
+ nodeListPtr = aNodeListPtr;
+ }
+ else
+ {
+ nodeListPtr = iNodeListPtr;
+ }
+ while(nodeListPtr!=0)
+ {
+ if(nodeListPtr->iNode)
+ {
+ if(nodeListPtr->iNode->iImplUid)
+ {
+ TBool found(EFalse);
+ for(TInt i = 0;i<aLoadedAdapters.Count();i++)
+ {
+ if(aLoadedAdapters[i]==nodeListPtr->iNode->iImplUid)
+ {
+ found = ETrue;
+ break;
+ }
+ }
+ if(!found)
+ {
+ aLoadedAdapters.AppendL(nodeListPtr->iNode->iImplUid);
+ }
+ }
+ if(nodeListPtr->iNode->iNodeListPtr)
+ {
+ FindLoadedAdaptersL(aLoadedAdapters,
+ nodeListPtr->iNode->iNodeListPtr);
+ }
+ }
+ nodeListPtr=nodeListPtr->iNext;
+ } // end while
+ return EFalse;
+ }
+
+
+
+
+// ---------------------------------------------------------------------------
+// CNSmlDmMgmtTree::SetUidToNewItems
+// Set adapter id to new items in tree
+// ---------------------------------------------------------------------------
+TBool CNSmlDmMgmtTree::SetUidToNewItems ( CNSmlDmNodeList* aNodeListPtr,
+ TUint32 aUid)
+ {
+ CNSmlDmNodeList* nodeListPtr = aNodeListPtr;
+ while ( nodeListPtr )
+ {
+ if ( nodeListPtr->iNode->iStaticLevel)
+ {
+ if(nodeListPtr->iNode->iParent)
+ {
+ nodeListPtr->iNode->iParent->iImplUid=0;
+ }
+ if(nodeListPtr->iNode->iImplUid==0 )
+ {
+ nodeListPtr->iNode->iImplUid = aUid;
+ SetUidToNewItems ( nodeListPtr->iNode->iNodeListPtr, aUid );
+ }
+ }
+ nodeListPtr =nodeListPtr->iNext;
+ }
+ return EFalse;
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmMgmtTree::SetServerIdToNewItems
+// Set session id to new items in tree
+// ---------------------------------------------------------------------------
+TBool CNSmlDmMgmtTree::SetServerIdToNewItems ( CNSmlDmNodeList* aNodeListPtr,
+ TUint8 aServerId)
+ {
+ CNSmlDmNodeList* nodeListPtr = aNodeListPtr;
+ while ( nodeListPtr )
+ {
+ if ( nodeListPtr->iNode->iStaticLevel )
+ {
+ if(nodeListPtr->iNode->iParent)
+ {
+ nodeListPtr->iNode->iParent->iHostServerId=0;
+ }
+ if(nodeListPtr->iNode->iHostServerId==0 )
+ {
+ nodeListPtr->iNode->iHostServerId = aServerId;
+ SetServerIdToNewItems ( nodeListPtr->iNode->iNodeListPtr, aServerId );
+ }
+ }
+ nodeListPtr = nodeListPtr->iNext;
+ }
+ return EFalse;
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmMgmtTree::NodeListPtr()
+// ---------------------------------------------------------------------------
+EXPORT_C CNSmlDmNodeList* CNSmlDmMgmtTree::NodeListPtr()
+ {
+ return iNodeListPtr;
+ }
+
+
+// ===========================================================================
+// CNSmlDmDFProperties
+// ===========================================================================
+
+// ---------------------------------------------------------------------------
+// CNSmlDmDFProperties::CNSmlDmDFProperties()
+// ---------------------------------------------------------------------------
+CNSmlDmDFProperties::CNSmlDmDFProperties()
+ {
+ iOccurrence = MSmlDmDDFObject::EOne;
+ iScope = MSmlDmDDFObject::EDynamic;
+ iDFFormat = MSmlDmDDFObject::ENode;
+ iAccessTypes = 0;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNSmlDmDFProperties::~CNSmlDmDFProperties()
+// ---------------------------------------------------------------------------
+CNSmlDmDFProperties::~CNSmlDmDFProperties()
+ {
+ delete iDefaultValue;
+ delete iDescription;
+ delete iDFTitle;
+ delete iDFType;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNSmlDmDFProperties::GenerateDFPropertiesL(CBufBase& aObject)
+// generate xml from df properties
+// ---------------------------------------------------------------------------
+void CNSmlDmDFProperties::GenerateDFPropertiesL(CBufBase& aObject)
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFDFProperties);
+ aObject.InsertL(aObject.Size(),KNSmlDDFAccessType);
+ for(TUint8 i = 0; i<6;i++)
+ {
+ TUint8 acl = TUint8(0x1<<i);
+ if(acl&iAccessTypes)
+ {
+ switch (acl)
+ {
+ case TSmlDmAccessTypes::EAccessType_Add:
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFAccessTypeAdd);
+ break;
+ }
+ case TSmlDmAccessTypes::EAccessType_Copy:
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFAccessTypeCopy);
+ break;
+ }
+ case TSmlDmAccessTypes::EAccessType_Delete:
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFAccessTypeDelete);
+ break;
+ }
+ case TSmlDmAccessTypes::EAccessType_Exec:
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFAccessTypeExec);
+ break;
+ }
+ case TSmlDmAccessTypes::EAccessType_Get:
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFAccessTypeGet);
+ break;
+ }
+ case TSmlDmAccessTypes::EAccessType_Replace:
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFAccessTypeReplace);
+ break;
+ default:
+ User::Panic(KNSmlTreeDTDPanic,KErrArgument);
+ break;
+ }
+ } //end switch
+ } //end if(acl&AccessTypes)
+ }
+ aObject.InsertL(aObject.Size(),KNSmlDDFAccessTypeEnd);
+ FeatureManager::InitializeLibL();
+ GenerateDFPropsSubmethodL(aObject); // To reduce cyclomatic complexity
+ aObject.InsertL(aObject.Size(),KNSmlDDFOccurrence);
+ switch( iOccurrence )
+ {
+ case MSmlDmDDFObject::EOne:
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFOccurrenceOne);
+ break;
+ }
+ case MSmlDmDDFObject::EZeroOrOne:
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFOccurrenceZeroOrOne);
+ break;
+ }
+ case MSmlDmDDFObject::EZeroOrMore:
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFOccurrenceZeroOrMore);
+ break;
+ }
+ case MSmlDmDDFObject::EOneOrMore:
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFOccurrenceOneOrMore);
+ break;
+ }
+ case MSmlDmDDFObject::EZeroOrN:
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFOccurrenceZeroOrN);
+ break;
+ }
+ case MSmlDmDDFObject::EOneOrN:
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFOccurrenceOneOrN);
+ break;
+ default:
+ User::Panic(KNSmlTreeDTDPanic,KErrArgument);
+ break;
+ }
+ }
+ aObject.InsertL(aObject.Size(),KNSmlDDFOccurrenceEnd);
+ aObject.InsertL(aObject.Size(),KNSmlDDFScope);
+ switch( iScope )
+ {
+ case MSmlDmDDFObject::EPermanent:
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFScopePermanent);
+ break;
+ }
+ case MSmlDmDDFObject::EDynamic:
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFScopeDynamic);
+ break;
+ }
+ default:
+ User::Panic(KNSmlTreeDTDPanic,KErrArgument);
+ break;
+ }
+ aObject.InsertL(aObject.Size(),KNSmlDDFScopeEnd);
+ if(iDFTitle!=0)
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFDFTitle);
+ aObject.InsertL(aObject.Size(),iDFTitle->iContent,iDFTitle->iLength);
+ aObject.InsertL(aObject.Size(),KNSmlDDFDFTitleEnd);
+ }
+ if(iDFType!=0)
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFDFType);
+ aObject.InsertL(aObject.Size(),KNSmlDDFMIME);
+ aObject.InsertL(aObject.Size(),iDFType->iContent,iDFType->iLength);
+ aObject.InsertL(aObject.Size(),KNSmlDDFMIMEEnd);
+ aObject.InsertL(aObject.Size(),KNSmlDDFDFTypeEnd);
+ }
+
+ aObject.InsertL(aObject.Size(),KNSmlDDFDFPropertiesEnd);
+
+ FeatureManager::UnInitializeLib();
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmDFProperties::GenerateDFPropertiesWBXMLL(TPtr8& aObject)
+// generate wbxml from df properties
+// ---------------------------------------------------------------------------
+void CNSmlDmDFProperties::GenerateDFPropertiesWBXMLL(RWriteStream& aStream)
+ {
+ aStream.WriteUint8L(EDDFDFProperties);
+ aStream.WriteUint8L(EDDFAccessType);
+ aStream.WriteUint8L(iAccessTypes);
+ aStream.WriteUint8L(EDDFAccessTypeEnd);
+ if(iDefaultValue != 0)
+ {
+ aStream.WriteUint8L(EDDFDefaultValue);
+ aStream.WriteUint16L(iDefaultValue->iLength);
+ aStream.WriteL(static_cast<TUint8*>(iDefaultValue->iContent),
+ iDefaultValue->iLength);
+ aStream.WriteUint8L(EDDFDefaultValueEnd);
+ }
+ if(iDescription != 0)
+ {
+ aStream.WriteUint8L(EDDFDescription);
+ aStream.WriteUint16L(iDescription->iLength);
+ aStream.WriteL(static_cast<TUint8*>(iDescription->iContent),
+ iDescription->iLength);
+ aStream.WriteUint8L(EDDFDescriptionEnd);
+ }
+
+ aStream.WriteUint8L(EDDFDFFormat);
+ aStream.WriteUint8L(iDFFormat);
+
+ aStream.WriteUint8L(EDDFDFFormatEnd);
+ aStream.WriteUint8L(EDDFOccurrence);
+ aStream.WriteUint8L( iOccurrence );
+
+ aStream.WriteUint8L(EDDFOccurrenceEnd);
+ aStream.WriteUint8L(EDDFScope);
+ aStream.WriteUint8L( iScope );
+
+ aStream.WriteUint8L(EDDFScopeEnd);
+
+ if(iDFTitle!=0)
+ {
+ aStream.WriteUint8L(EDDFDFTitle);
+ aStream.WriteUint8L(iDFTitle->iLength);
+ aStream.WriteL(static_cast<TUint8*>(iDFTitle->iContent),
+ iDFTitle->iLength);
+
+ aStream.WriteUint8L(EDDFDFTitleEnd);
+ }
+ if(iDFType!=0)
+ {
+ aStream.WriteUint8L(EDDFDFType);
+ aStream.WriteUint8L(EDDFMIME);
+ aStream.WriteUint8L(iDFType->iLength);
+ aStream.WriteL(static_cast<TUint8*>(iDFType->iContent),
+ iDFType->iLength);
+ aStream.WriteUint8L(EDDFMIMEEnd);
+ aStream.WriteUint8L(EDDFDFTypeEnd);
+ }
+ aStream.WriteUint8L(EDDFDFPropertiesEnd);
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNSmlDmDFProperties::ParseDFPropertiesWBXMLL(RFileReadStream& reader)
+// Parses DF properties element to structure
+// ---------------------------------------------------------------------------
+void CNSmlDmNodeList::ParseDFPropertiesWBXMLL(RReadStream& aReader,
+ MSmlDmDDFObject* aNodePtr )
+ {
+ TInt len;
+ //Accesstypes
+ TUint tag = aReader.ReadUint8L();
+ // get the Accesstypes value
+ TSmlDmAccessTypes act;
+ tag = aReader.ReadUint8L();
+ Mem::Copy(&act, &tag, 1);
+ aNodePtr->SetAccessTypesL( act );
+ // Accesstypes End
+ tag = aReader.ReadUint8L();
+
+ // next tag
+ do
+ {
+ tag = aReader.ReadUint8L();
+
+ if(tag==EDDFDefaultValue)
+ {
+ len = aReader.ReadUint16L();
+ //value
+ HBufC8* data = HBufC8::NewLC( len );
+ TPtr8 dataPtr = data->Des();
+ aReader.ReadL(dataPtr, len);
+ aNodePtr->SetDefaultValueL(dataPtr);
+ CleanupStack::PopAndDestroy(1); //data
+ // end defaultvalue
+ tag = aReader.ReadUint8L();
+ }
+ else if(tag==EDDFDescription)
+ {
+ len = aReader.ReadUint16L();
+ //value
+ HBufC8* desData = HBufC8::NewLC( len );
+ TPtr8 desDataPtr = desData->Des();
+ aReader.ReadL(desDataPtr, len);
+ aNodePtr->SetDescriptionL(desDataPtr);
+ CleanupStack::PopAndDestroy(); //desData
+ // end description
+ tag = aReader.ReadUint8L();
+ }
+ else if(tag==EDDFDFFormat)
+ {
+ aNodePtr->SetDFFormatL(MSmlDmDDFObject::TDFFormat(aReader.ReadUint8L()));
+ // end format
+ tag = aReader.ReadUint8L();
+ }
+ }while ((tag == EDDFDefaultValueEnd) || (tag == EDDFDescriptionEnd));
+
+ //Occurrence
+ tag = aReader.ReadUint8L();
+ __ASSERT_DEBUG(tag == EDDFOccurrence,
+ User::Panic(_L("Tag not EDDFOccurrence, tag:"),tag));
+
+ aNodePtr->SetOccurenceL(MSmlDmDDFObject::TOccurence(aReader.ReadUint8L()));
+ // end occurrence
+ tag = aReader.ReadUint8L();
+
+ //Scope
+ tag = aReader.ReadUint8L();
+ aNodePtr->SetScopeL(MSmlDmDDFObject::TScope(aReader.ReadUint8L()));
+ // end occurrence
+ tag = aReader.ReadUint8L();
+
+ do
+ {
+ tag = aReader.ReadUint8L();
+
+ if(tag==EDDFDFTitle)
+ {
+ //length
+ len = aReader.ReadUint8L();
+ //value
+ HBufC8* titleData = HBufC8::NewLC( len );
+ TPtr8 titleDataPtr = titleData->Des();
+ aReader.ReadL(titleDataPtr, len);
+
+ aNodePtr->SetDFTitleL(titleDataPtr);
+ CleanupStack::PopAndDestroy(); //titleData, titleData16
+ // end description
+ tag = aReader.ReadUint8L();
+ }
+ else if(tag==EDDFDFType)
+ {
+ tag = aReader.ReadUint8L();
+ if ( tag == EDDFMIME )
+ {
+ //length
+ len = aReader.ReadUint8L();
+ //value
+ HBufC8* typeData = HBufC8::NewLC( len );
+ TPtr8 typeDataPtr = typeData->Des();
+ aReader.ReadL(typeDataPtr, len);
+
+ aNodePtr->AddDFTypeMimeTypeL(typeDataPtr);
+ CleanupStack::PopAndDestroy(); //data
+ //end MIMETYPE
+ tag = aReader.ReadUint8L();
+ }
+ // end DFType
+ tag = aReader.ReadUint8L();
+
+ }
+ else if(tag==EDDFDFPropertiesEnd)
+ {
+
+ }
+ }while ( tag != EDDFDFPropertiesEnd );
+ }
+
+
+// ===========================================================================
+// CNSmlDmRTProperties
+// ===========================================================================
+
+// ---------------------------------------------------------------------------
+// CNSmlDmRTProperties::CNSmlDmRTProperties()
+// ---------------------------------------------------------------------------
+CNSmlDmRTProperties::CNSmlDmRTProperties()
+ {
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmRTProperties::~CNSmlDmRTProperties()
+// ---------------------------------------------------------------------------
+CNSmlDmRTProperties::~CNSmlDmRTProperties()
+ {
+ delete iSize;
+ delete iTitle;
+ delete iTStamp;
+ delete iType;
+ delete iVerNo;
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmRTProperties::GenerateDFPropsSubmethodL(CBufBase& aObject)
+// ---------------------------------------------------------------------------
+void CNSmlDmDFProperties::GenerateDFPropsSubmethodL(CBufBase& aObject)
+ {
+ if(iDefaultValue != 0)
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFDefaultValue);
+ aObject.InsertL(aObject.Size(),iDefaultValue->iContent,
+ iDefaultValue->iLength);
+
+ aObject.InsertL(aObject.Size(),KNSmlDDFDefaultValueEnd);
+ }
+ if(iDescription != 0)
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFDescription);
+ aObject.InsertL(aObject.Size(),iDescription->iContent,
+ iDescription->iLength);
+
+ aObject.InsertL(aObject.Size(),KNSmlDDFDescriptionEnd);
+ }
+
+ aObject.InsertL(aObject.Size(),KNSmlDDFDFFormat);
+ switch( iDFFormat )
+ {
+ case MSmlDmDDFObject::EB64:
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFFormatB64);
+ break;
+ }
+ case MSmlDmDDFObject::EBool:
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFFormatBool);
+ break;
+ }
+ case MSmlDmDDFObject::EChr:
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFFormatChr);
+ break;
+ }
+ case MSmlDmDDFObject::EInt:
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFFormatInt);
+ break;
+ }
+ case MSmlDmDDFObject::ENode:
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFFormatNode);
+ break;
+ }
+ case MSmlDmDDFObject::ENull:
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFFormatNull);
+ break;
+ }
+ case MSmlDmDDFObject::EXml:
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFFormatXml);
+ break;
+ }
+ case MSmlDmDDFObject::EBin:
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFFormatBin);
+ break;
+ }
+
+ case MSmlDmDDFObject::EDate:
+ {
+ if(!FeatureManager::FeatureSupported( KFeatureIdSyncMlDm112 ))
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFFormatDate);
+ }
+ else
+ {
+ User::Panic(KNSmlTreeDTDPanic,KErrArgument);
+ }
+ break;
+ }
+ case MSmlDmDDFObject::ETime:
+ {
+ if(!FeatureManager::FeatureSupported( KFeatureIdSyncMlDm112 ))
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFFormatTime);
+ }
+ else
+ {
+ User::Panic(KNSmlTreeDTDPanic,KErrArgument);
+ }
+ break;
+ }
+ case MSmlDmDDFObject::EFloat:
+ {
+ if(!FeatureManager::FeatureSupported( KFeatureIdSyncMlDm112 ))
+ {
+ aObject.InsertL(aObject.Size(),KNSmlDDFFormatFloat);
+ }
+ else
+ {
+ User::Panic(KNSmlTreeDTDPanic,KErrArgument);
+ }
+ break;
+ }
+ default:
+ User::Panic(KNSmlTreeDTDPanic,KErrArgument);
+ break;
+ }
+ aObject.InsertL(aObject.Size(),KNSmlDDFDFFormatEnd);
+ }
+// End of file
+