diff -r 4526337fb576 -r 3eca7e70b1b8 widgetmodel/alfwidgetmodel/src/alfvarianttype.cpp --- a/widgetmodel/alfwidgetmodel/src/alfvarianttype.cpp Tue Feb 02 00:28:09 2010 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1646 +0,0 @@ -/* -* 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