--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/widgetmodel/alfwidgetmodel/src/alfvarianttype.cpp Wed Sep 01 12:23:18 2010 +0100
@@ -0,0 +1,1646 @@
+/*
+* Copyright (c) 2006 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: Impelements Variants for widgetmodel data.
+*
+*/
+
+
+
+//INCLUDES
+
+
+#include <alf/ialfmodelbase.h>
+#include <osn/ustring.h>
+#include <osn/alfptrvector.h>
+#include <alf/alfvarianttype.h>
+#include <osn/osncommon.h>
+#include <osn/ustring.h>
+#include <alf/alfexceptions.h>
+//#include "alf/alfperf.h"
+#include <osn/osnnew.h>
+#include "alfsort.h"
+
+using osncore::UString;
+using osncore::AlfPtrVector;
+
+using std::auto_ptr;
+
+
+// Forward declared inside the Alf namespace
+namespace Alf
+ {
+
+ union UData
+ {
+ bool mBool; // Boolean
+ int mInt; // 32-bit integer
+ uint mUint; // 32-bit unsigned integer
+ double mReal; // 64-bit real
+ UString* mString;
+ Alf::IAlfModelBase* mBasePtr;
+ };
+
+
+
+//Internal class used to store the VariantData type
+//These classes are not exposed.
+class AlfVariantDataImpl
+{
+public:
+ //Default Constructor
+ AlfVariantDataImpl()
+ {
+ mData.mString = NULL;
+ }
+ //Destructor
+ ~AlfVariantDataImpl()
+ {
+ if(mType == IAlfVariantType::EString)
+ {
+ if(mData.mString)
+ {
+ delete mData.mString;
+ mData.mString = NULL;
+ }
+ }
+ if(mType == IAlfVariantType::ECustomData)
+ {
+ if(mData.mBasePtr)
+ {
+ delete mData.mBasePtr;
+ mData.mBasePtr = NULL;
+ }
+ }
+
+ }
+ //Union that actually stores the variant Data
+ uint8 mType;
+ UData mData;
+};
+
+
+//Internal class used to store the Conatiner Data type
+//These classes are not exposed.
+class AlfContainerDataImpl
+{
+public:
+ //Default Constructor
+ AlfContainerDataImpl()
+ {
+ mArray.setAutoDelete();
+ }
+ //Destructor
+ ~AlfContainerDataImpl()
+ {
+ mArray.clear();
+ }
+ AlfPtrVector<IAlfVariantType> mArray;
+
+};
+
+
+
+//Internal class used to store the Conatiner Data type
+//These classes are not exposed.
+class MapItem
+{
+public:
+ //Default Constructor
+ MapItem():mData(0),mName(0)
+ {
+
+ }
+ //Destructor
+ ~MapItem()
+ {
+ if(mData)
+ {
+ delete mData;
+ mData = NULL;
+ }
+ if(mName)
+ {
+ delete mName;
+ mName = NULL;
+ }
+ }
+ IAlfVariantType* mData;
+ UString* mName;
+};
+
+//Internal class used to store the Branch Data type
+//These classes are not exposed.
+class AlfMapDataImpl
+{
+public:
+ AlfMapDataImpl()
+ {
+
+ }
+ ~AlfMapDataImpl()
+ {
+
+ mArray.clear();
+ }
+ //Array to hold the Map Item
+ AlfPtrVector<MapItem> mArray;
+};
+
+//owned
+class AlfBranchDataImpl
+{
+public:
+ AlfBranchDataImpl():mCurrentData(0),mChildData(0)
+ {
+
+ }
+ ~AlfBranchDataImpl()
+ {
+ if(mCurrentData)
+ {
+ delete mCurrentData;
+ mCurrentData=NULL;
+ }
+
+ if(mChildData)
+ {
+ delete mChildData;
+ mChildData=NULL;
+ }
+ }
+ IAlfMap* mCurrentData;
+ IAlfMap* mChildData;
+};
+
+
+////////////////////// AlfVariantType //////////////////////
+
+// ---------------------------------------------------------------------------
+// Description :Initialize the VarianType with an Unsigned 8 bit Integer Value
+// ---------------------------------------------------------------------------
+//
+
+void AlfVariantType::construct(Type aType)
+ {
+ mVarData.reset( new (EMM) AlfVariantDataImpl() );
+ mVarData->mType = aType;
+ }
+
+OSN_EXPORT AlfVariantType::AlfVariantType()
+ {
+ mVarData.reset( new (EMM) AlfVariantDataImpl() );
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Parameterized Constructor for an Integer
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT AlfVariantType::AlfVariantType(IAlfModelBase* aValue)
+ {
+ construct(ECustomData);
+ mVarData->mData.mBasePtr = aValue;
+ }
+
+
+// ---------------------------------------------------------------------------
+// Description : Parameterized Constructor for an Integer
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT AlfVariantType::AlfVariantType(const UString& aValue)
+ {
+ construct(EString);
+ mVarData->mData.mString = new(EMM) UString(aValue);
+ }
+
+
+
+// ---------------------------------------------------------------------------
+// Description : Parameterized Constructor for an Integer value
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT AlfVariantType::AlfVariantType(const int& aValue)
+ {
+ construct(EInt);
+ mVarData->mData.mInt = aValue;
+ }
+
+
+// ---------------------------------------------------------------------------
+// Description : Parameterized Constructor for an Unsigned Int value
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT AlfVariantType::AlfVariantType(const uint& aValue)
+ {
+ construct(EUint);
+ mVarData->mData.mUint = aValue;
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Parameterized Constructor for an Double value
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT AlfVariantType::AlfVariantType(const double& aValue)
+ {
+ construct(EReal);
+ mVarData->mData.mReal = aValue;
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Parameterized Constructor for an Bool value
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT AlfVariantType::AlfVariantType(const bool& aValue)
+ {
+ construct(EBool);
+ mVarData->mData.mBool = aValue;
+ }
+
+
+// ---------------------------------------------------------------------------
+// Description : Class Destructor
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT AlfVariantType::~AlfVariantType()
+ {
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Sets Data to be stored in the Variant Data Type
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT void AlfVariantType::set(IAlfVariantType& aValue)
+ {
+ if( mVarData->mType == EString)
+ {
+ delete mVarData->mData.mString;
+ mVarData->mData.mString = 0;
+ }
+
+ // Set the type
+ mVarData->mType = aValue.type();
+
+ // Copy/create the new data
+ if (aValue.type() == EBool)
+ {
+ mVarData->mData.mBool = aValue.boolean();
+ }
+ else if (aValue.type() <= EInt)
+ {
+ mVarData->mData.mInt = aValue.integer();
+ }
+ else if (aValue.type() <= EUint)
+ {
+ mVarData->mData.mUint = aValue.uinteger();
+ }
+ else if (aValue.type() <= EReal)
+ {
+ mVarData->mData.mReal = aValue.real();
+ }
+ else if (aValue.type() == EString)
+ {
+ mVarData->mData.mString = new (EMM) UString(aValue.string());
+ }
+ else if (aValue.type() == ECustomData)
+ {
+ mVarData->mData.mBasePtr = aValue.customData();
+ }
+ else
+ {
+ ALF_THROW(AlfDataException,EInvalidVariantDataType,"AlfVariantType")
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Gets the Type of the Variant Data Type
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfVariantType::Type AlfVariantType::type() const
+ {
+ return (Type)mVarData->mType;
+ }
+
+
+// ---------------------------------------------------------------------------
+// Description : Returns the Boolean value if the data type in the variant
+// structure is a bool
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT bool AlfVariantType::boolean() const
+ {
+ if (type() != EBool)
+ {
+ ALF_THROW(AlfDataException,EInvalidVariantDataType,"AlfVariantType")
+ }
+ return mVarData->mData.mBool;
+ }
+
+
+// ---------------------------------------------------------------------------
+// Description : Returns the int value if the data type in the variant
+// structure is a int
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT int AlfVariantType::integer() const
+ {
+ if (type() != EInt && type() != EUint) // Signed-unsigned conversion allowed
+ {
+ ALF_THROW(AlfDataException,EInvalidVariantDataType,"AlfVariantType")
+ }
+ return mVarData->mData.mInt;
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns the Unsigned value if the data type in the variant
+// structure is a unsigned int
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT uint AlfVariantType::uinteger() const
+ {
+ if (type() != EInt && type() != EUint) // Signed-unsigned conversion allowed
+ {
+ ALF_THROW(AlfDataException,EInvalidVariantDataType,"AlfVariantType")
+ }
+ return mVarData->mData.mUint;
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns the Real value if the data type in the variant
+// structure is a Real data
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT double AlfVariantType::real() const
+ {
+ if (type() != EReal)
+ {
+ ALF_THROW(AlfDataException,EInvalidVariantDataType,"AlfVariantType")
+ }
+ return mVarData->mData.mReal;
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns the Descriptor value if the data type in the variant
+// structure is a string data
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT const UString& AlfVariantType::string() const
+ {
+ if (type() != EString)
+ {
+ ALF_THROW(AlfDataException,EInvalidVariantDataType,"AlfVariantType")
+ }
+ return *mVarData->mData.mString;
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns the Container if the data type in the variant
+// structure is a collection
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfContainer* AlfVariantType::container()
+ {
+ ALF_THROW(AlfDataException,EInvalidVariantDataType,"AlfVariantType")
+ }
+
+
+// ---------------------------------------------------------------------------
+// Description : Returns the Map if the data type in the variant
+// structure is a map
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfMap* AlfVariantType::map()
+ {
+ ALF_THROW(AlfDataException,EInvalidVariantDataType,"AlfVariantType")
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns the Branch if the data type in the variant
+// structure is a map
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfBranch* AlfVariantType::branch()
+ {
+ ALF_THROW(AlfDataException,EInvalidVariantDataType,"AlfVariantType")
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns the User Defined Data Pointer if the data type in the variant
+// structure is IAlfModelBase
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfModelBase* AlfVariantType::customData()
+ {
+ if (type() != ECustomData)
+ {
+ ALF_THROW(AlfDataException,EInvalidVariantDataType,"AlfVariantType")
+ }
+ return mVarData->mData.mBasePtr;
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns true, if objects are equal, false otherwise.
+// ---------------------------------------------------------------------------
+//
+
+OSN_EXPORT bool AlfVariantType::operator==(const IAlfVariantType &aOther) const
+ {
+ // Set the type
+ bool equals = false;
+ if (type() == aOther.type() )
+ {
+ switch( type() )
+ {
+ case EBool:
+ equals = ( bool() == aOther.boolean() );
+ break;
+ case EInt:
+ equals = ( int() == aOther.integer() );
+ break;
+ case EUint:
+ equals = ( uint() == aOther.uinteger() );
+ break;
+ case EReal:
+ equals = ( real() == aOther.real() );
+ break;
+ case EString:
+ equals = ( string() == aOther.string() );
+ break;
+ case ECustomData: //not known how to compare.
+ break;
+ default:
+ ALF_THROW(AlfDataException,EInvalidVariantDataType,"AlfVariantType")
+
+ }
+ }
+
+ return equals;
+ }
+
+////////////////////// AlfContainer //////////////////////
+
+
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+
+// ---------------------------------------------------------------------------
+// Description : Default Constructor for the Container Data Type
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT AlfContainer::AlfContainer()
+ {
+ construct();
+ }
+
+
+// ---------------------------------------------------------------------------
+// Description : Default Construtor
+// ---------------------------------------------------------------------------
+//
+void AlfContainer::construct()
+ {
+ mContainerData.reset( new( EMM ) AlfContainerDataImpl() );
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Class Destructor
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT AlfContainer::~AlfContainer()
+ {
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Adds an AlfVariantType into the container
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT void AlfContainer::addItem(IAlfVariantType* aData)
+ {
+ mContainerData->mArray.resize(mContainerData->mArray.count()+1);
+ mContainerData->mArray.insert(mContainerData->mArray.count(),aData);
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Adds an AlfVariantType into the container
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT void AlfContainer::addItem(uint aIndex, IAlfVariantType* aData)
+ {
+ if( aIndex > mContainerData->mArray.count() )
+ {
+ ALF_THROW(AlfDataException,EInvalidArrayIndex,"AlfContainer")
+ }
+ else
+ {
+ mContainerData->mArray.resize(mContainerData->mArray.count()+1);
+ mContainerData->mArray.insert(aIndex, aData);
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Gets the Size of the container
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT int AlfContainer::count()
+ {
+ return mContainerData->mArray.count();
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Gets the Item at a given index in the container
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfVariantType* AlfContainer::item(uint aIndex)
+ {
+ uint cmpIndex =0; //To remove RVCT compiler warning
+ if(aIndex < mContainerData->mArray.count() && aIndex >= cmpIndex )
+ {
+ return mContainerData->mArray[aIndex];
+ }
+ else
+ {
+ return NULL;
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Clones the existing conatiner and returns a new COntainer
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfContainer* AlfContainer::clone()
+ {
+ try
+ {
+ //ALF_PERF_START( perfdata, "AlfContainer-Clone-Cloning Container")
+ auto_ptr<AlfContainer> clone( new( EMM ) AlfContainer() );
+ auto_ptr<IAlfVariantType> childData;
+
+ for ( int i = 0; i < mContainerData->mArray.count(); ++i )
+ {
+ if( mContainerData->mArray[i]->type()== IAlfVariantType::EInt )
+ {
+ childData.reset( new(EMM) AlfVariantType(mContainerData->mArray[i]->integer()) );
+ }
+ else if( mContainerData->mArray[i]->type()== IAlfVariantType::EUint )
+ {
+ childData.reset( new(EMM) AlfVariantType(mContainerData->mArray[i]->uinteger()) );
+ }
+ else if(mContainerData->mArray[i]->type()== IAlfVariantType::EBool)
+ {
+ childData.reset( new (EMM) AlfVariantType(mContainerData->mArray[i]->boolean()) );
+ }
+ else if( mContainerData->mArray[i]->type()== IAlfVariantType::EReal )
+ {
+ childData.reset( new(EMM) AlfVariantType(mContainerData->mArray[i]->real()) );
+ }
+ else if( mContainerData->mArray[i]->type()== IAlfVariantType::EString )
+ {
+ childData.reset( new(EMM) AlfVariantType(mContainerData->mArray[i]->string()) );
+ }
+ else if( mContainerData->mArray[i]->type()== IAlfVariantType::EMap )
+ {
+ childData.reset( (IAlfMap*)(mContainerData->mArray[i]->map())->clone() );
+ }
+ else if( mContainerData->mArray[i]->type()== IAlfVariantType::EContainer )
+ {
+ childData.reset( (IAlfContainer*)(mContainerData->mArray[i]->container())->clone() );
+ }
+ else if ( mContainerData->mArray[i]->type()== IAlfVariantType::EBranch )
+ {
+ childData.reset( mContainerData->mArray[i]->branch()->clone() );
+ }
+ else
+ {
+ ALF_THROW(AlfDataException,EInvalidVariantDataType,"AlfContainer")
+ }
+ clone->mContainerData->mArray.resize( clone->mContainerData->mArray.count() + 1 );
+ clone->mContainerData->mArray.insert( clone->mContainerData->mArray.count(), childData.get() );
+ childData.release(); // ownership was transferred.
+ }
+ //ALF_PERF_STOP( perfdata, "AlfContainer-Clone-Cloning Container")
+ return clone.release();
+ }
+ catch(...)
+ {
+ ALF_THROW(AlfDataException,EInvalidContainerOperation,"AlfContainer")
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Sorts the container using user defined callback method
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT void AlfContainer::sort( const IAlfSortFunction& aSortFunction )
+ {
+ IAlfVariantType** d = mContainerData->mArray.data();
+ AlfSort::sort( d, mContainerData->mArray.count(), aSortFunction );
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Sets Data to be stored in the Variant Data Type
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT void AlfContainer::set(IAlfVariantType& /*aValue*/)
+ {
+ ALF_THROW(AlfDataException,EInvalidContainerOperation,"AlfContainer")
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Gets the Type of the Variant Data Type
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfVariantType::Type AlfContainer::type() const
+ {
+ return IAlfVariantType::EContainer;
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns the Boolean value if the data type in the variant
+// structure is a bool
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT bool AlfContainer::boolean() const
+ {
+ ALF_THROW(AlfDataException,EInvalidContainerOperation,"AlfContainer")
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns the int value if the data type in the variant
+// structure is a int
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT int AlfContainer::integer() const
+ {
+ ALF_THROW(AlfDataException,EInvalidContainerOperation,"AlfContainer")
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns the Unsigned value if the data type in the variant
+// structure is a unsigned int
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT uint AlfContainer::uinteger() const
+ {
+ ALF_THROW(AlfDataException,EInvalidContainerOperation,"AlfContainer")
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns the Real value if the data type in the variant
+// structure is a Real data
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT double AlfContainer::real() const
+ {
+ ALF_THROW(AlfDataException,EInvalidContainerOperation,"AlfContainer")
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns the Descriptor value if the data type in the variant
+// structure is a string data
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT const UString& AlfContainer::string() const
+ {
+ ALF_THROW(AlfDataException,EInvalidContainerOperation,"AlfContainer");
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns the Container if the data type in the variant
+// structure is a collection
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfContainer* AlfContainer::container()
+ {
+ return this;
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns the Map if the data type in the variant
+// structure is a map
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfMap* AlfContainer::map()
+ {
+ ALF_THROW(AlfDataException,EInvalidContainerOperation,"AlfContainer")
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns the Branch if the data type in the variant
+// structure is a map
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfBranch* AlfContainer::branch()
+ {
+ ALF_THROW(AlfDataException,EInvalidContainerOperation,"AlfContainer")
+ }
+
+
+// ---------------------------------------------------------------------------
+// Description : Returns the User Defined Data Pointer if the data type in the variant
+// structure is IAlfModelBase
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfModelBase* AlfContainer::customData()
+ {
+ ALF_THROW(AlfDataException,EInvalidContainerOperation,"AlfContainer")
+ }
+////////////////////// AlfContainer //////////////////////
+
+
+
+
+// ---------------------------------------------------------------------------
+// Description : Remove a item from the Container
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT void AlfContainer::removeItem(uint aIndex)
+ {
+ uint cmpIndex=0;
+ if(aIndex >= mContainerData->mArray.count() || (aIndex < cmpIndex))
+ {
+ ALF_THROW(AlfDataException,EInvalidArrayIndex,"AlfContainer")
+ }
+
+ mContainerData->mArray.remove(aIndex);
+ }
+
+
+// ---------------------------------------------------------------------------
+// Description : Clears the contents of the Container
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT void AlfContainer::clear()
+{
+ mContainerData->mArray.clear();
+}
+
+
+// ---------------------------------------------------------------------------
+// Description : Replaces the items of the container at a given index with the new data
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT void AlfContainer::replaceItem(uint aIndex, IAlfVariantType* aNewData )
+ {
+ if((aIndex < mContainerData->mArray.count()) && aNewData)
+ {
+ try
+ {
+ mContainerData->mArray.remove(aIndex);
+ mContainerData->mArray.insert(aIndex,aNewData);
+ }
+ catch(...)
+ {
+ ALF_THROW(AlfDataException,EInvalidContainerOperation,"AlfContainer")
+ }
+ }
+ else
+ ALF_THROW(AlfDataException,EInvalidArrayIndex,"AlfContainer")
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns true, if objects are equal, false otherwise.
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT bool AlfContainer::operator==(const IAlfVariantType &/*aOther*/) const
+ {
+ ALF_THROW(AlfDataException,EInvalidContainerOperation,"AlfContainer")
+ }
+
+
+////////////////////// AlfMap //////////////////////
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+
+
+// ---------------------------------------------------------------------------
+// Description : 1st Phase Constructor. Leaves the object onto the cleanup stack
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT AlfMap::AlfMap()
+ {
+ construct();
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Map Constructor
+// ---------------------------------------------------------------------------
+//
+void AlfMap::construct()
+ {
+ mMapDataImpl.reset( new (EMM) AlfMapDataImpl() );
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Sets Data to be stored in the Variant Data Type
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT void AlfMap::set(IAlfVariantType& aValue)
+ {
+ (void)aValue;
+ ALF_THROW(AlfDataException,EInvalidMapOperation,"AlfMap")
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Gets the Type of the Variant Data Type
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfVariantType::Type AlfMap::type() const
+ {
+ return IAlfVariantType::EMap;
+ }
+
+
+// ---------------------------------------------------------------------------
+// Description : Returns the Boolean value if the data type in the variant
+// structure is a bool
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT bool AlfMap::boolean() const
+ {
+ ALF_THROW(AlfDataException,EInvalidMapOperation,"AlfMap")
+ }
+
+
+// ---------------------------------------------------------------------------
+// Description : Returns the int value if the data type in the variant
+// structure is a int
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT int AlfMap::integer() const
+ {
+ ALF_THROW(AlfDataException,EInvalidMapOperation,"AlfMap")
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns the Unsigned value if the data type in the variant
+// structure is a unsigned int
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT uint AlfMap::uinteger() const
+ {
+ ALF_THROW(AlfDataException,EInvalidMapOperation,"AlfMap")
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns the Real value if the data type in the variant
+// structure is a Real data
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT double AlfMap::real() const
+ {
+ ALF_THROW(AlfDataException,EInvalidMapOperation,"AlfMap")
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns the Descriptor value if the data type in the variant
+// structure is a string data
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT const UString& AlfMap::string() const
+ {
+ ALF_THROW(AlfDataException,EInvalidMapOperation,"AlfMap")
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns the Container if the data type in the variant
+// structure is a collection
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfContainer* AlfMap::container()
+ {
+ ALF_THROW(AlfDataException,EInvalidMapOperation,"AlfMap")
+ }
+
+
+// ---------------------------------------------------------------------------
+// Description : Returns the Map if the data type in the variant
+// structure is a map
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfMap* AlfMap::map()
+ {
+ return this;
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns the Branch if the data type in the variant
+// structure is a map
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfBranch* AlfMap::branch()
+ {
+ ALF_THROW(AlfDataException,EInvalidMapOperation,"AlfMap")
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns the User Defined Data Pointer if the data type in the variant
+// structure is IAlfModelBase
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfModelBase* AlfMap::customData()
+ {
+ ALF_THROW(AlfDataException,EInvalidMapOperation,"AlfMap")
+ }
+
+////////////////////// AlfContainer //////////////////////
+
+
+
+
+
+// ---------------------------------------------------------------------------
+// Description : Map Destructor
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT AlfMap::~AlfMap()
+ {
+ }
+
+
+// ---------------------------------------------------------------------------
+// Description : APi to get the name of the data item in the map
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT const UString& AlfMap::name(uint aIndex) const
+ {
+ uint cmpIndex=0;
+ if( aIndex >= mMapDataImpl->mArray.count() || (aIndex < cmpIndex))
+ {
+ ALF_THROW(AlfDataException,EInvalidArrayIndex,"AlfMap")
+ }
+ return *mMapDataImpl->mArray[aIndex]->mName;
+ }
+
+
+// ---------------------------------------------------------------------------
+// Description : APi to add an VariantData into the map
+// ---------------------------------------------------------------------------
+//
+void AlfMap::addItem(IAlfVariantType* aData, const UString &aName)
+ {
+ auto_ptr<MapItem> item( new( EMM ) MapItem() );
+
+ item->mName = new( EMM ) UString( aName );
+
+ mMapDataImpl->mArray.resize( mMapDataImpl->mArray.count() + 1 );
+ mMapDataImpl->mArray.insert( mMapDataImpl->mArray.count(), item.get() );
+
+ // Take the ownership only if there was no exception.
+ // Otherwise the client is resp. of cleaning up the object.
+ item->mData = aData;
+ item.release();
+ }
+
+// ---------------------------------------------------------------------------
+// Description : APi to add an VariantData into the map
+// ---------------------------------------------------------------------------
+//
+void AlfMap::addItem(uint aIndex, IAlfVariantType* aData, const UString& aName)
+ {
+ if( aIndex > mMapDataImpl->mArray.count() )
+ {
+ ALF_THROW(AlfDataException,EInvalidArrayIndex,"AlfMap")
+ }
+ else
+ {
+ auto_ptr<MapItem> item( new( EMM ) MapItem() );
+
+ item->mName = new( EMM ) UString( aName );
+
+ mMapDataImpl->mArray.resize( mMapDataImpl->mArray.count() + 1 );
+ mMapDataImpl->mArray.insert( aIndex, item.get() );
+
+ // Take the ownership only if there was no exception.
+ // Otherwise the client is resp. of cleaning up the object.
+ item->mData = aData;
+ item.release();
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// Description : Gets the size of the map
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT int AlfMap::count() const
+ {
+ return mMapDataImpl->mArray.count();
+ }
+
+
+// ---------------------------------------------------------------------------
+// Description : Gets the Element at a given index
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfVariantType* AlfMap::item(uint aIndex)
+ {
+ uint cmpIndex=0;
+ if( aIndex >= mMapDataImpl->mArray.count() || aIndex <cmpIndex )
+ {
+ return NULL;
+ }
+ else
+ {
+ return mMapDataImpl->mArray[aIndex]->mData;
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// Description : Clones the map
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfMap* AlfMap::clone()
+ {
+ try
+ {
+ //ALF_PERF_START( perfdata, "AlfContainer-Clone-Cloning Map")
+ auto_ptr<AlfMap> clone( new(EMM) AlfMap() );
+ auto_ptr<MapItem> cloneItem;
+
+ for (int i = 0; i < mMapDataImpl->mArray.count(); ++i)
+ {
+ cloneItem.reset( new(EMM) MapItem() );
+ if( !(mMapDataImpl->mArray[i]->mName->getUtf8() == ""))
+ {
+ cloneItem->mName = new(EMM) UString(*(mMapDataImpl->mArray[i]->mName));
+ }
+ if(mMapDataImpl->mArray[i]->mData->type()== IAlfVariantType::EInt)
+ {
+ cloneItem->mData = new(EMM) AlfVariantType(mMapDataImpl->mArray[i]->mData->integer());
+ }
+ else if(mMapDataImpl->mArray[i]->mData->type()== IAlfVariantType::EUint)
+ {
+ cloneItem->mData = new(EMM) AlfVariantType(mMapDataImpl->mArray[i]->mData->uinteger());
+ }
+ else if(mMapDataImpl->mArray[i]->mData->type()== IAlfVariantType::EBool)
+ {
+ cloneItem->mData = new (EMM)AlfVariantType(mMapDataImpl->mArray[i]->mData->boolean());
+ }
+ else if(mMapDataImpl->mArray[i]->mData->type()== IAlfVariantType::EReal)
+ {
+ cloneItem->mData = new(EMM) AlfVariantType(mMapDataImpl->mArray[i]->mData->real());
+ }
+ else if(mMapDataImpl->mArray[i]->mData->type()== IAlfVariantType::EString)
+ {
+ cloneItem->mData = new(EMM) AlfVariantType(mMapDataImpl->mArray[i]->mData->string());
+ }
+ else if(mMapDataImpl->mArray[i]->mData->type()== IAlfVariantType::EMap)
+ {
+ cloneItem->mData = (IAlfMap*)(mMapDataImpl->mArray[i]->mData->map())->clone();
+ }
+ else if(mMapDataImpl->mArray[i]->mData->type()== IAlfVariantType::EContainer)
+ {
+ cloneItem->mData = (IAlfContainer*)(mMapDataImpl->mArray[i]->mData->container())->clone();
+ }
+ else if (mMapDataImpl->mArray[i]->mData->type()== IAlfVariantType::EBranch)
+ {
+ cloneItem->mData = mMapDataImpl->mArray[i]->mData->branch()->clone();
+ }
+ else
+ {
+ ALF_THROW(AlfDataException,EInvalidVariantDataType,"AlfMap")
+ }
+
+ clone->mMapDataImpl->mArray.resize(clone->mMapDataImpl->mArray.count()+1);
+ clone->mMapDataImpl->mArray.insert(clone->mMapDataImpl->mArray.count(),cloneItem.get() );
+ cloneItem.release();
+ }
+ //ALF_PERF_STOP( perfdata, "AlfContainer-Clone-Cloning Map")
+
+ return clone.release();
+ }
+ catch(...)
+ {
+ ALF_THROW(AlfDataException,EInvalidMapOperation,"AlfMap")
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// Description : Gets the map item with the given name
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfVariantType* AlfMap::item(const UString &aName)
+ {
+ for (int i = 0; i < mMapDataImpl->mArray.count(); ++i)
+ {
+ if ( *mMapDataImpl->mArray[i]->mName == aName)
+ {
+ return mMapDataImpl->mArray[i]->mData;
+ }
+ }
+ return NULL;
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Gets the index of the map item with the given name
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT int AlfMap::itemIndex(const UString &aName)
+ {
+ for (int i = 0; i < mMapDataImpl->mArray.count(); ++i)
+ {
+ if ( *mMapDataImpl->mArray[i]->mName == aName)
+ {
+ return i;
+ }
+ }
+ return -1;
+ }
+
+
+// ---------------------------------------------------------------------------
+// Description : Remove a item from the Map at a given index
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT void AlfMap::removeItem(uint aIndex)
+ {
+ try
+ {
+ uint cmpIndex =0;
+ if(aIndex < mMapDataImpl->mArray.count() && aIndex>= cmpIndex )
+ {
+ mMapDataImpl->mArray.remove(aIndex);
+ }
+ }
+ catch(...)
+ {
+ ALF_THROW(AlfDataException,EInvalidMapOperation,"AlfMap")
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// Description : Clears the contents of the Map
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT void AlfMap::clear()
+ {
+ mMapDataImpl->mArray.clear();
+ }
+
+
+// ---------------------------------------------------------------------------
+// Description : Replaces the items of the container at a given index with the new data
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT void AlfMap::replaceItem(uint aIndex, IAlfVariantType* aNewData )
+ {
+ try
+ {
+ uint cmpIndex =0;
+ if ( aIndex < mMapDataImpl->mArray.count()&& aIndex >= cmpIndex )
+ {
+ auto_ptr<MapItem> newData( new( EMM ) MapItem() );
+ newData.get()->mData = aNewData;
+ newData.get()->mName = new( EMM ) UString(
+ *( mMapDataImpl->mArray[aIndex]->mName ) );
+
+ mMapDataImpl->mArray.remove(aIndex);
+ mMapDataImpl->mArray.insert(aIndex,newData.get());
+
+ newData.release(); // ownership transferred away
+ }
+ }
+ catch(...)
+ {
+ ALF_THROW(AlfDataException,EInvalidMapOperation,"AlfMap")
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// Description : Replaces the items of the container at a given index with the Given name
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT void AlfMap::replaceItem(const UString &aName,IAlfVariantType* aNewData)
+ {
+
+ try
+ {
+ for (int i = 0; i < mMapDataImpl->mArray.count(); ++i)
+ {
+ if ( *mMapDataImpl->mArray[i]->mName == aName)
+ {
+ auto_ptr<MapItem> newData( new( EMM ) MapItem() );
+
+ newData.get()->mData = aNewData;
+ newData.get()->mName = new( EMM ) UString(*(mMapDataImpl->mArray[i]->mName));
+
+ mMapDataImpl->mArray.remove(i);
+ mMapDataImpl->mArray.insert(i,newData.get());
+
+ newData.release(); // ownership transferred away
+ break;
+ }
+ }
+ }
+ catch(...)
+ {
+ ALF_THROW(AlfDataException,EInvalidMapOperation,"AlfMap")
+ //aNewData might not have been deleted. In case of this exception the user should delete the variant data passed
+ }
+
+ }
+
+
+// ---------------------------------------------------------------------------
+// Description : Remove a item from the Map with a given name
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT void AlfMap::removeItem(const UString &aName)
+ {
+ try
+ {
+ for(int i=0; i< mMapDataImpl->mArray.count();i++)
+ {
+ if ( *mMapDataImpl->mArray[i]->mName == aName)
+ {
+ mMapDataImpl->mArray.remove(i);
+ break;
+ }
+ }
+ }
+ catch(...)
+ {
+ ALF_THROW(AlfDataException,EInvalidMapOperation,"AlfMap")
+ }
+
+ }
+
+////////////////////// AlfBranch //////////////////////
+
+// ---------------------------------------------------------------------------
+// Description : 2nd Phase Constructor
+// ---------------------------------------------------------------------------
+//
+void AlfBranch::construct( IAlfMap* aData, IAlfMap* aChildData)
+ {
+ mBranchData.reset( new( EMM ) AlfBranchDataImpl() );
+
+ // Take the ownership of the parameter objects
+ mBranchData->mCurrentData = aData;
+ mBranchData->mChildData = aChildData;
+ // No throwing code after the ownership has been transferred,
+ // it would result to double deletion crash.
+
+ }
+
+// ---------------------------------------------------------------------------
+// Description : 1st Phase Constructor. Leaves the object onto the cleanup stack
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT AlfBranch::AlfBranch(IAlfMap* aData, IAlfMap* aChildData)
+ {
+ construct( aData, aChildData );
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Default Construtor
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT AlfBranch::AlfBranch()
+ {
+ mBranchData.reset( new(EMM) AlfBranchDataImpl() );
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Map Destructor
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT AlfBranch::~AlfBranch()
+ {
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Sorts the branch using user defined callback method
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT void AlfBranch::sort( const IAlfSortFunction& aSortFunction )
+ {
+ try
+ {
+ for (int i = 0; i < mBranchData->mChildData->count(); ++i)
+ {
+ if (mBranchData->mChildData->item(i)->type() == EContainer)
+ {
+ IAlfContainer* container =
+ mBranchData->mChildData->item(i)->container();
+ container->sort(aSortFunction);
+ }
+ }
+ }
+ catch(...)
+ {
+ ALF_THROW(AlfDataException,EInvalidMapOperation,"AlfMap")
+ }
+ }
+// ---------------------------------------------------------------------------
+// Description : returns the data for this branch as a IAlfMap interface
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfMap* AlfBranch::data()
+ {
+ return mBranchData->mCurrentData;
+ }
+
+
+// ---------------------------------------------------------------------------
+// Description : Set the data for this branch
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT void AlfBranch::setData( IAlfMap* aData )
+ {
+ delete mBranchData->mCurrentData;
+ mBranchData->mCurrentData = aData;
+ }
+
+// ---------------------------------------------------------------------------
+// Description : returns the child data at the given index
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfVariantType* AlfBranch::childData(int aIndex)
+ {
+ if(aIndex <0 || mBranchData->mChildData->count() <=0)
+ return NULL;
+
+ int count = 0;
+
+ // Start counting from the first child (item number 1)
+ for (int i = 0; i < mBranchData->mChildData->count(); ++i)
+ {
+
+ if ( mBranchData->mChildData->item(i)->type() == IAlfVariantType::EMap || mBranchData->mChildData->item(i)->type() == IAlfVariantType::EBranch )
+ {
+ // Map contains the data for a single child
+
+ if(count == aIndex)
+ {
+ return mBranchData->mChildData->item(aIndex);
+ }
+ count++;
+ }
+
+ if (mBranchData->mChildData->item(i)->type() == IAlfVariantType::EContainer)
+ {
+ IAlfContainer* container = mBranchData->mChildData->item(i)->container();
+ for ( int j = 0; j < container->count(); ++j )
+ {
+ // Container contains data for multiple children
+
+ if(count == aIndex)
+ {
+ return mBranchData->mChildData->item(i)->container()->item(aIndex);
+ }
+ count ++;
+ }
+ }
+ }
+
+ return NULL;
+ }
+
+
+
+// ---------------------------------------------------------------------------
+// Description : returns the child name at the given index
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT const UString& AlfBranch::childName(int aIndex)
+ {
+
+ int count = 0;
+
+ // Start counting from the first child (item number 1)
+ for (int i = 0; i < mBranchData->mChildData->count(); ++i)
+ {
+
+ if ( mBranchData->mChildData->item(i)->type() == IAlfVariantType::EMap || mBranchData->mChildData->item(i)->type() == IAlfVariantType::EBranch )
+ {
+ // Map contains the data for a single child
+
+ if(count == aIndex)
+ {
+ return mBranchData->mChildData->name(i);
+ }
+ count++;
+ }
+ if (mBranchData->mChildData->item(i)->type() == IAlfVariantType::EContainer)
+ {
+ IAlfContainer* container = mBranchData->mChildData->item(i)->container();
+
+ if(aIndex >= count && aIndex < (count + container->count()) )
+ {
+ return mBranchData->mChildData->name(i);
+ }
+ count+= container->count();
+
+ }
+ }
+ UString* ret(0);
+ return *ret;
+ }
+
+
+
+// ---------------------------------------------------------------------------
+// Description : returns the Data for all childs
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfMap* AlfBranch::childData()
+ {
+ return mBranchData->mChildData;
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Set the data for children of this branch
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT void AlfBranch::setChildData( IAlfMap* aChildData )
+ {
+ delete mBranchData->mChildData;
+ mBranchData->mChildData = aChildData;
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Api to get the Number of children of a branch
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT uint AlfBranch::childrenCount()
+ {
+
+ uint count = 0;
+
+ // Start counting from the first child (item number 1)
+ for (int i = 0; i < mBranchData->mChildData->count(); ++i)
+ {
+ if ( mBranchData->mChildData->item(i)->type() == IAlfVariantType::EMap ||
+ mBranchData->mChildData->item(i)->type() == IAlfVariantType::EBranch )
+ {
+ // Map contains the data for a single child
+ count++;
+ }
+ if (mBranchData->mChildData->item(i)->type() == IAlfVariantType::EContainer)
+ {
+ // Container contains data for multiple children
+ count += mBranchData->mChildData->item(i)->container()->count();
+ }
+ }
+
+ return count;
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Sets Data to be stored in the Variant Data Type
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT void AlfBranch::set(IAlfVariantType& aValue)
+ {
+ (void)aValue;
+ ALF_THROW(AlfDataException,EInvalidBranchOperation,"AlfBranch")
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Gets the Type of the Variant Data Type
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfVariantType::Type AlfBranch::type() const
+ {
+ return IAlfVariantType::EBranch;
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns the Boolean value if the data type in the variant
+// structure is a bool
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT bool AlfBranch::boolean() const
+ {
+ ALF_THROW(AlfDataException,EInvalidBranchOperation,"AlfBranch")
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns the int value if the data type in the variant
+// structure is a int
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT int AlfBranch::integer() const
+ {
+ ALF_THROW(AlfDataException,EInvalidBranchOperation,"AlfBranch")
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns the Unsigned value if the data type in the variant
+// structure is a unsigned int
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT uint AlfBranch::uinteger() const
+ {
+ ALF_THROW(AlfDataException,EInvalidBranchOperation,"AlfBranch")
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns the Real value if the data type in the variant
+// structure is a Real data
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT double AlfBranch::real() const
+ {
+ ALF_THROW(AlfDataException,EInvalidBranchOperation,"AlfBranch")
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns the Descriptor value if the data type in the variant
+// structure is a string data
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT const UString& AlfBranch::string() const
+ {
+ ALF_THROW(AlfDataException,EInvalidBranchOperation,"AlfBranch")
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns the Container if the data type in the variant
+// structure is a collection
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfContainer* AlfBranch::container()
+ {
+ ALF_THROW(AlfDataException,EInvalidBranchOperation,"AlfBranch")
+ }
+
+
+// ---------------------------------------------------------------------------
+// Description : Returns the Map if the data type in the variant
+// structure is a map
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfMap* AlfBranch::map()
+ {
+ ALF_THROW(AlfDataException,EInvalidBranchOperation,"AlfBranch")
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns the Branch if the data type in the variant
+// structure is a map
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfBranch* AlfBranch::branch()
+ {
+ return this;
+ }
+
+
+// ---------------------------------------------------------------------------
+// Description : Returns the User Defined Data Pointer if the data type in the variant
+// structure is IAlfModelBase
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfModelBase* AlfBranch::customData()
+ {
+ ALF_THROW(AlfDataException,EInvalidBranchOperation,"AlfBranch")
+ }
+// ---------------------------------------------------------------------------
+// Description : Clones the branch
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT IAlfBranch* AlfBranch::clone()
+ {
+ try
+ {
+ auto_ptr<IAlfMap> currentData( mBranchData->mCurrentData->clone() );
+ auto_ptr<IAlfMap> childData( mBranchData->mChildData->clone() );
+ IAlfBranch* clone = new(EMM) AlfBranch( currentData.get(), childData.get() );
+ currentData.release(); // ownership transferred away
+ childData.release(); // ownership transferred away
+
+ return clone;
+ }
+ catch(...)
+ {
+ ALF_THROW(AlfDataException,EInvalidBranchOperation,"AlfBranch")
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Description : Returns true, if objects are equal, false otherwise.
+// ---------------------------------------------------------------------------
+//
+OSN_EXPORT bool AlfBranch::operator==(const IAlfVariantType &/*aOther*/) const
+ {
+ ALF_THROW(AlfDataException,EInvalidBranchOperation,"AlfBranch")
+ }
+
+} // namespace Alf