--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/applayerprotocols/wapbase/wnode/CNODE.cpp Tue Feb 02 01:09:52 2010 +0200
@@ -0,0 +1,600 @@
+// Copyright (c) 1998-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:
+//
+
+#include <cnode.h>
+
+#ifndef __WAP_MONOLITHIC__
+// Its a standalone DLL
+
+#ifndef EKA2
+GLDEF_C TInt E32Dll(TDllReason /*aReason*/)
+ {
+ return(KErrNone);
+ }
+#endif
+
+#endif
+//
+// Node implementation
+//
+
+/** Allocates and constructs a new node.
+
+@return New node
+@param aType The type of the node
+@param aParent The parent of this node
+*/
+EXPORT_C CNode* CNode::NewL(TAny* aType,CNode* aParent)
+ {
+ return (new(ELeave) CNode(aType,aParent));
+ }
+
+CNode::CNode(TAny* aType,CNode* aParent)
+ : iType(aType), iParent(aParent), iValues(8), iTypes(8)
+ {}
+
+/** Destructor.
+
+Data (if owned by the object), child nodes and attributes are deleted.
+*/
+EXPORT_C CNode::~CNode()
+ {
+ iValues.ResetAndDestroy();
+ delete iDataValue;
+ DeleteAllChildNodes();
+ }
+
+/** Deletes a specified child node.
+
+@param aNode Node to delete
+*/
+EXPORT_C void CNode::DeleteChildNode(CNode* aNode)
+ {
+ __ASSERT_DEBUG(iChildList != NULL && aNode != NULL ,Panic(ENodeNoChildren));
+ __ASSERT_DEBUG(aNode != NULL ,Panic(ENodeBadArgument));
+ CArrayPtr<CNode> &childList = *iChildList;
+ TInt childListCount = iChildList->Count() - 1;
+ for(TInt childIter = childListCount;childIter >= 0;childIter--)
+ {
+ if(aNode == childList[childIter])
+ {
+ delete childList[childIter];
+ iChildList->Delete(childIter);
+ break;
+ }
+
+ }
+ }
+
+/** Deletes all the child nodes of this node.
+*/
+EXPORT_C void CNode::DeleteAllChildNodes()
+ {
+ if(iChildList != NULL)
+ {
+ iChildList->ResetAndDestroy();
+ delete iChildList;
+ iChildList = NULL;
+ }
+ }
+
+/** Creates a new child node.
+
+@return The new child node
+@param aType Node type
+*/
+EXPORT_C CNode& CNode::AppendNodeL(TAny* aType)
+ {
+ CNode* node = CNode::NewL(aType,this);
+ CleanupStack::PushL(node);
+ AppendNodeToThisNodeL(node);
+ CleanupStack::Pop();
+ return *node;
+ }
+
+/** Adds an existing node as a child.
+
+@param aNode Node to make a child
+*/
+EXPORT_C void CNode::AppendNodeToThisNodeL(CNode* aNode)
+ {
+ if(!iChildList)
+ iChildList = new (ELeave) CArrayPtrFlat<CNode>(KGranularity);
+ iChildList->AppendL(aNode);
+ }
+
+/** Gets the first child or the next child after a specified child.
+
+@return First or next child node
+@param aNode Child node or NULL to get the first child
+*/
+EXPORT_C CNode* CNode::NextChild(const CNode* aNode) const
+ {
+// __ASSERT_DEBUG(iChildList != NULL,Panic(ENodeNoChildren));
+ if(iChildList) //if there are any children
+ {
+ if(aNode == NULL) //if just want the first child
+ return (*iChildList)[0];
+ else
+ {
+ TInt index = FindChild(aNode);
+ __ASSERT_DEBUG(index != KErrNotFound,Panic(ENodeBadArgument));
+// __ASSERT_DEBUG(!((index + 1) >= iChildList->Count()),Panic(ENodeBadArgument));
+ if(index == KErrNotFound || ((index+1) >= iChildList->Count()) )
+ return NULL;
+ else
+ return (*iChildList)[index + 1];
+ }
+ }
+ return NULL;
+ }
+
+TInt CNode::FindChild(const CNode* aNode) const
+ {
+ __ASSERT_DEBUG(aNode != NULL, Panic(ENodeBadArgument));
+ __ASSERT_DEBUG(iChildList != NULL,Panic(ENodeNoChildren));
+ TInt count = iChildList->Count();
+ for(TInt childIter = 0;childIter < count; childIter++)
+ {
+ if(aNode == (*iChildList)[childIter])
+ return childIter;
+ }
+ return KErrNotFound;
+ }
+
+/** Gets the previous child before a specified child.
+
+@return Previous child node
+@param aNode Child node
+*/
+EXPORT_C CNode* CNode::PrevChild(const CNode& aNode) const
+ {
+ __ASSERT_DEBUG(iChildList != NULL,Panic(ENodeNoChildren));
+ if(iChildList) //if there are any children
+ {
+ TInt index = FindChild(&aNode);
+ __ASSERT_DEBUG(index != KErrNotFound && index != 0,Panic(ENodeBadArgument));
+ return (*iChildList)[index - 1];
+ }
+ else
+ return NULL;
+ }
+
+/** Gets the parent of this node.
+
+@return Parent
+*/
+EXPORT_C CNode* CNode::Parent() const
+ {
+ return iParent;
+ }
+
+/** Changes the parent of the node.
+
+The node is removed from the childlist of its current parent.
+
+@param aParent New parent
+*/
+EXPORT_C void CNode::ReparentL(CNode* aParent)
+ {
+// __ASSERT_DEBUG(iParent != NULL && iParent->iChildList != NULL,Panic(ENodeNoChildren));
+ if( iParent != NULL && iParent->iChildList != NULL )
+ {
+ for(TInt ChildIter = 0;ChildIter < iParent->iChildList->Count(); ChildIter++)
+ {
+ if(this == (*iParent->iChildList)[ChildIter])
+ {
+ iParent->iChildList->Delete(ChildIter);
+ break;
+ }
+ }
+ }
+ if (aParent)
+ {
+ aParent->AppendNodeToThisNodeL(this);
+ iParent = aParent;
+ }
+ }
+
+/** Gets the next sibling node.
+
+This asks for the next child of its parent.
+
+@return Next sibling node
+*/
+EXPORT_C CNode* CNode::NextSibling() const
+ {
+ __ASSERT_DEBUG(iParent != NULL,Panic(ENodeNoChildren));
+ if(iParent)
+ return Parent()->NextChild(this);
+ else
+ return NULL;
+ }
+
+/** Gets the previous sibling node.
+
+This asks for the previous child of its parent.
+
+@return Previous sibling node
+*/
+EXPORT_C CNode* CNode::PrevSibling() const
+ {
+ __ASSERT_DEBUG(iParent != NULL,Panic(ENodeNoChildren));
+ if(iParent)
+ return Parent()->PrevChild(*this);
+ else
+ return NULL;
+ }
+
+/** Gets the number of children of this node.
+
+@return Number of children of this node
+*/
+EXPORT_C TInt CNode::NumberImmediateChildren() const
+ {
+ if(iChildList)
+ return iChildList->Count();
+ else
+ return 0;
+ }
+
+/** Gets the absolute root node of the tree.
+
+@return Root node
+*/
+EXPORT_C const CNode& CNode::Root() const
+ {
+ const CNode* node = this;
+ while(node->Parent() != NULL)
+ node = node->Parent();
+ return *node;
+ }
+
+/** Sets the node data.
+
+The object will delete the data in its destructor.
+
+@param aData Node data
+*/
+EXPORT_C void CNode::SetDataL(HBufC16* aData)
+ {
+ delete iDataValue;
+ iDataValue=NULL;
+ iDataValue = new(ELeave) CDataDelete(aData);
+ }
+
+HBufC16* CNode::SetupDeletableOrNonDeleteableDataLC()
+ {
+ __ASSERT_DEBUG(iDataValue != NULL ,Panic(ENoData));
+ HBufC16* aData = iDataValue->SetData(NULL);
+ CleanupStack::PushL(aData); // **** eeek !
+ delete iDataValue;
+ return aData;
+ }
+
+/** Sets the object not to delete the node data in its destructor.
+
+Note that the function internally reallocates memory. If it leaves, the data is lost.
+ */
+EXPORT_C void CNode::SetDataNoDeleteL()
+ {
+ HBufC16* aData = SetupDeletableOrNonDeleteableDataLC();
+ iDataValue = new (ELeave) CDataNoDelete(aData);
+ CleanupStack::Pop();
+ }
+
+/** Sets the object to delete the node data in its destructor.
+
+Note that the function internally reallocates memory. If it leaves, the data is lost. */
+EXPORT_C void CNode::ClearSetDataNoDeleteL()
+ {
+ HBufC16* aData = SetupDeletableOrNonDeleteableDataLC();
+ iDataValue = new (ELeave) CDataDelete(aData);
+ CleanupStack::Pop();
+ }
+
+/** Sets the node data to be taken from a specified file.
+
+If the data is deleted, the referenced file is also deleted.
+
+@param aFileDataLocationNowNodeOwns Name of the file containing the data
+*/
+EXPORT_C void CNode::SetFileDataL(HBufC16* aFileDataLocationNowNodeOwns)
+ {
+ delete iDataValue;
+ iDataValue = NULL;
+ iDataValue = new(ELeave) CFileDataDelete(aFileDataLocationNowNodeOwns);
+ }
+
+/** Resets the node data to a specified pointer.
+
+Existing data owned by the node is deleted.
+
+@param aData Root node
+*/
+EXPORT_C void CNode::ResetDataPointer(HBufC16* aData)
+ {
+ if (iDataValue)
+ iDataValue->ResetDataPointer(aData);
+ }
+
+/** Gets the node data.
+
+@return Node data or NULL if no data is set
+*/
+EXPORT_C HBufC16* CNode::Data() const
+ {
+ if(iDataValue)
+ return iDataValue->Data();
+ else
+ return NULL;
+ }
+
+/** Adds an attribute.
+
+The node takes ownership of aAttributeValue.
+
+@param aAttributeType Attribute type
+@param aAttributeValue Attribute value
+*/
+EXPORT_C void CNode::AddAttributeL(TAny* aAttributeType, CBase* aAttributeValue)
+ {
+ TInt count;
+ if((count=iValues.Count())>0)
+ {
+ const TInt32* typesPtr=iTypesBasePtr;
+ for(TInt ii=0;ii<count;ii++)
+ {
+ if(*typesPtr==(TInt32)aAttributeType)
+ {
+ delete iValues[ii];
+ iValues[ii]=aAttributeValue;
+ return;
+ }
+ typesPtr++;
+ }
+ }
+ iTypes.AppendL(aAttributeType);
+ TRAPD(err,iValues.AppendL(aAttributeValue));
+ if(err)
+ iTypes.Delete(iTypes.Count()-1);
+ AdjustBasePointers();
+ User::LeaveIfError(err);
+ }
+
+void CNode::AdjustBasePointers()
+ {
+ if(iValues.Count())
+ iTypesBasePtr=(TInt32*)iTypes.CArrayFixBase::At(0);
+ else
+ iTypesBasePtr=NULL;
+ }
+
+/** Sets node data and adds an attribute.
+
+The node takes ownership of aDataand aAttributeValue.
+Existing node data owned by the node is deleted.
+
+@param aData Node data
+@param aAttributeType Attribute type
+@param aAttributeValue Attribute value
+*/
+EXPORT_C void CNode::AddDataAndAttributeL(HBufC16 *aData, TAny* aAttributeType, CBase* aAttributeValue)
+ {
+ __ASSERT_DEBUG(aData != NULL, Panic(ENodeBadArgument));
+
+ delete iDataValue;
+ iDataValue = NULL;
+ iDataValue = new(ELeave) CDataDelete(aData);
+
+ AddAttributeL(aAttributeType,aAttributeValue);
+ }
+
+/** Gets a child node by index.
+
+@return Child node
+@param aByIndex Index of the child node
+*/
+EXPORT_C CNode* CNode::Child(TInt aByIndex) const
+ {
+ __ASSERT_DEBUG(iChildList != NULL , Panic(ENodeNoChildren));
+ __ASSERT_DEBUG(aByIndex < iChildList->Count() && aByIndex >= 0, Panic(ENodeBadArgument));
+ return ((*iChildList)[aByIndex]);
+ }
+
+/** Gets an attribute value for a specified attribute type.
+
+@return Attribute value
+@param aAttributeType Attribute type
+*/
+EXPORT_C CBase* CNode::Attribute(TAny* aAttributeType) const
+ {
+ TInt count;
+ if((count=iValues.Count())>0)
+ {
+ const TInt32* typesPtr=iTypesBasePtr;
+ for(TInt ii=0;ii<count;ii++)
+ {
+ if(*typesPtr==(TInt32)aAttributeType)
+ return iValues[ii];
+ typesPtr++;
+ }
+ }
+ return NULL;
+ }
+
+/** Tests if an attribute of a specified type exists.
+
+@return True if the attribute exists, otherwise false
+@param aAttributeType Attribute type
+*/
+EXPORT_C TBool CNode::AttributeExists(TAny* aAttributeType) const
+ {
+ TInt count;
+ if((count=iValues.Count())>0)
+ {
+ const TInt32* typesPtr=iTypesBasePtr;
+ for(TInt ii=0;ii<count;ii++)
+ {
+ if(*typesPtr==(TInt32)aAttributeType)
+ return ETrue;
+ typesPtr++;
+ }
+ }
+ return EFalse;
+ }
+
+/** Deletes an attribute of a specified type.
+
+Note that the attribute value will be deleted.
+
+@param aAttributeType Attribute type
+*/
+EXPORT_C void CNode::DeleteAttribute(TAny* aAttributeType)
+ {
+ TInt count;
+ if((count=iValues.Count())>0)
+ {
+ const TInt32* typesPtr=iTypesBasePtr;
+ for(TInt ii=0;ii<count;ii++)
+ {
+ if(*typesPtr==(TInt32)aAttributeType)
+ { // delete attribute value
+ delete iValues[ii];
+ iValues.Delete(ii);
+ iTypes.Delete(ii);
+ AdjustBasePointers();
+ break;
+ }
+ typesPtr++;
+ }
+ }
+ }
+
+/** Delete all node attributes.
+
+Note that attribute values will be deleted.
+*/
+EXPORT_C void CNode::DeleteAllAttributes()
+ {
+ iValues.ResetAndDestroy();
+ iTypes.Reset();
+ AdjustBasePointers();
+ }
+
+/** Removes an attribute of a specified type, but does not delete it.
+
+The caller is now responsible for the destruction of the attribute value.
+
+@param aAttributeType Attribute type
+*/
+EXPORT_C void CNode::RemoveAttributeNoDelete(TAny* aAttributeType)
+ {
+ TInt count;
+ if((count=iValues.Count())>0)
+ {
+ const TInt32* typesPtr=iTypesBasePtr;
+ for(TInt ii=0;ii<count;ii++)
+ {
+ if(*typesPtr==(TInt32)aAttributeType)
+ { // do not delete the pointer in iValues
+ iValues.Delete(ii);
+ iTypes.Delete(ii);
+ AdjustBasePointers();
+ break;
+ }
+ typesPtr++;
+ }
+ }
+ }
+
+/** Gets the number of attributes of this node.
+
+@return Number of attributes of this node
+*/
+EXPORT_C TInt CNode::AttributeCount() const
+ {
+ return iValues.Count();
+ }
+
+/** Gets the attribute value of an attribute at a specified index.
+
+@return Attribute value
+@param aIndex Attribute index
+*/
+EXPORT_C CBase* CNode::AttributeByIndex(TInt aIndex) const
+ {
+ if(iValues.Count())
+ return iValues[aIndex];
+ return NULL;
+ }
+
+/** Gets the attribute value and type of an attribute at a specified index..
+
+@return Attribute value
+@param aIndex Attribute index
+@param aType On return, the attribute type
+*/
+EXPORT_C CBase* CNode::AttributeByIndex(TInt aIndex,TAny*& aType) const
+ {
+ if(iValues.Count())
+ {
+ aType=iTypes[aIndex];
+ return iValues[aIndex];
+ }
+ return NULL;
+ }
+
+/** Gets the attribute value of an attribute at a specified index
+
+@return Attribute value
+@param aIndex Attribute index
+*/
+EXPORT_C TAny* CNode::AttributeTypeByIndex(TInt aIndex) const
+ {
+ if(iValues.Count())
+ return iTypes[aIndex];
+ return NULL;
+ }
+
+/** Gets the node type.
+
+@return Node type
+*/
+EXPORT_C TAny* CNode::Type() const
+ {
+ return iType;
+ }
+
+/** Sets the node type.
+
+@param aType Node type
+*/
+EXPORT_C void CNode::SetType(TAny* aType)
+ {
+ iType = aType;
+ }
+
+void CNode::Reserved1()
+// Reserved for future expansion
+ {
+ User::Panic(_L("Reserved"),KErrNotSupported);
+ }
+
+void CNode::Reserved1() const
+// Reserved for future expansion
+ {
+ User::Panic(_L("Reserved"),KErrNotSupported);
+ }