diff -r 4ea6f81c838a -r 0e9bb658ef58 widgetmodel/alfwidgetmodel/src/alfvarianttype.cpp --- /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 +#include +#include +#include +#include +#include +#include +//#include "alf/alfperf.h" +#include +#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 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 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 clone( new( EMM ) AlfContainer() ); + auto_ptr 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 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 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 mArray[aIndex]->mData; + } + } + + +// --------------------------------------------------------------------------- +// Description : Clones the map +// --------------------------------------------------------------------------- +// +OSN_EXPORT IAlfMap* AlfMap::clone() + { + try + { + //ALF_PERF_START( perfdata, "AlfContainer-Clone-Cloning Map") + auto_ptr clone( new(EMM) AlfMap() ); + auto_ptr 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 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 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 currentData( mBranchData->mCurrentData->clone() ); + auto_ptr 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