/*

* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:   Impelements Variants for widgetmodel data.

*

*/

//INCLUDES

#include <alf/ialfmodelbase.h>

#include <osn/ustring.h>

#include <osn/alfptrvector.h>

#include <alf/alfvarianttype.h>

#include <osn/osncommon.h>

#include <osn/ustring.h>

#include <alf/alfexceptions.h>

//#include "alf/alfperf.h"

#include <osn/osnnew.h>

#include "alfsort.h"

using osncore::UString;

using osncore::AlfPtrVector;

using std::auto_ptr;

// Forward declared inside the Alf namespace

namespace Alf

    {

    union UData

        {

        bool    mBool;                                // Boolean

        int     mInt;                                // 32-bit integer

        uint    mUint;                                // 32-bit unsigned integer

        double  mReal;                                // 64-bit real

        UString*  mString;        

        Alf::IAlfModelBase* mBasePtr;               

        };

//Internal class used to store the VariantData type

//These classes are not exposed.

class AlfVariantDataImpl

{

public:

    //Default Constructor

    AlfVariantDataImpl()

    {

        mData.mString = NULL;

    }

    //Destructor

    ~AlfVariantDataImpl()

    {

        if(mType == IAlfVariantType::EString)

        {

            if(mData.mString)

            {

                delete mData.mString;

                mData.mString = NULL;

            }

        }

        if(mType == IAlfVariantType::ECustomData)

        {

            if(mData.mBasePtr)

            {

                delete mData.mBasePtr;

                mData.mBasePtr = NULL;

            }

        }        

    }

    //Union that actually stores the variant Data

    uint8 mType;

    UData mData;    

};    

//Internal class used to store the Conatiner Data type

//These classes are not exposed.

class AlfContainerDataImpl 

{

public:    

    //Default Constructor

    AlfContainerDataImpl()

    {

        mArray.setAutoDelete();

    }

    //Destructor

    ~AlfContainerDataImpl()

    {

        mArray.clear();

    }

    AlfPtrVector<IAlfVariantType> mArray;

};

//Internal class used to store the Conatiner Data type

//These classes are not exposed.

class MapItem

{

public:

    //Default  Constructor

    MapItem():mData(0),mName(0)

    {

    }

    //Destructor

    ~MapItem()

    {

        if(mData)

        {

            delete mData;

            mData = NULL;

        }

        if(mName)

        {

            delete mName;

            mName = NULL;

        }

    }

    IAlfVariantType*    mData;

    UString*         mName;

};

//Internal class used to store the Branch Data type

//These classes are not exposed.

class AlfMapDataImpl

{

public:

    AlfMapDataImpl()

    {

    }

    ~AlfMapDataImpl()

    {

        mArray.clear();

    }

    //Array to hold the Map Item

    AlfPtrVector<MapItem> mArray;

};    

//owned

class AlfBranchDataImpl 

{

public:

    AlfBranchDataImpl():mCurrentData(0),mChildData(0)

    {

    }

    ~AlfBranchDataImpl()

    {

        if(mCurrentData)

        {    

            delete mCurrentData;

            mCurrentData=NULL;    

        }

        if(mChildData)

        {

            delete mChildData;

            mChildData=NULL;    

        }    

    }    

    IAlfMap* mCurrentData;

    IAlfMap* mChildData;    

};

////////////////////// AlfVariantType //////////////////////

// ---------------------------------------------------------------------------

// Description :Initialize the VarianType with an Unsigned 8 bit Integer Value 

// ---------------------------------------------------------------------------

//

void AlfVariantType::construct(Type aType)

    {   

    mVarData.reset( new (EMM) AlfVariantDataImpl() );

    mVarData->mType = aType;    

    }

OSN_EXPORT AlfVariantType::AlfVariantType() 

    {    

    mVarData.reset( new (EMM) AlfVariantDataImpl() );

    }

// ---------------------------------------------------------------------------

// Description : Parameterized Constructor for an Integer

// ---------------------------------------------------------------------------

//    

OSN_EXPORT AlfVariantType::AlfVariantType(IAlfModelBase* aValue)

    {

    construct(ECustomData);

    mVarData->mData.mBasePtr = aValue;

    }

// ---------------------------------------------------------------------------

// Description : Parameterized Constructor for an Integer

// ---------------------------------------------------------------------------

//    

OSN_EXPORT AlfVariantType::AlfVariantType(const UString& aValue)

    {

    construct(EString);

    mVarData->mData.mString = new(EMM) UString(aValue);

    }

// ---------------------------------------------------------------------------

// Description : Parameterized Constructor for an Integer value

// ---------------------------------------------------------------------------

//    

OSN_EXPORT AlfVariantType::AlfVariantType(const int& aValue)

    {

    construct(EInt);

    mVarData->mData.mInt  = aValue;    

    }

// ---------------------------------------------------------------------------

// Description : Parameterized Constructor for an Unsigned Int  value

// ---------------------------------------------------------------------------

//    

OSN_EXPORT AlfVariantType::AlfVariantType(const uint& aValue)

    {

    construct(EUint);

    mVarData->mData.mUint = aValue;      

    }

// ---------------------------------------------------------------------------

// Description : Parameterized Constructor for an Double value

// ---------------------------------------------------------------------------

//    

OSN_EXPORT AlfVariantType::AlfVariantType(const double& aValue)

    {

    construct(EReal);

    mVarData->mData.mReal  = aValue;

    }

// ---------------------------------------------------------------------------

// Description : Parameterized Constructor for an Bool  value

// ---------------------------------------------------------------------------

//    

OSN_EXPORT AlfVariantType::AlfVariantType(const bool& aValue)

    {

    construct(EBool);

    mVarData->mData.mBool  = aValue;        

    }

// ---------------------------------------------------------------------------

// Description : Class Destructor

// ---------------------------------------------------------------------------

//

OSN_EXPORT AlfVariantType::~AlfVariantType()

    {

    }

// ---------------------------------------------------------------------------

// Description : Sets  Data to be stored in the Variant Data Type

// ---------------------------------------------------------------------------

// 

OSN_EXPORT void AlfVariantType::set(IAlfVariantType& aValue)

    {

	if( mVarData->mType == EString)

		{

		delete mVarData->mData.mString;

        mVarData->mData.mString = 0;

		}

    // Set the type

    mVarData->mType = aValue.type();

    // Copy/create the new data

    if (aValue.type() == EBool)

        {

        mVarData->mData.mBool = aValue.boolean();

        }

    else if (aValue.type() <= EInt)

        {

        mVarData->mData.mInt = aValue.integer();

        }

    else if (aValue.type() <= EUint)

        {

        mVarData->mData.mUint = aValue.uinteger();

        }

    else if (aValue.type() <= EReal)

        {

        mVarData->mData.mReal = aValue.real();

        }

    else if (aValue.type() == EString)

        {

        mVarData->mData.mString = new (EMM) UString(aValue.string());

        }

    else if (aValue.type() == ECustomData)

        {

        mVarData->mData.mBasePtr = aValue.customData();

        }        

    else

        {

        ALF_THROW(AlfDataException,EInvalidVariantDataType,"AlfVariantType")

        }         

    }

// ---------------------------------------------------------------------------

// Description : Gets the Type of the Variant Data Type

// ---------------------------------------------------------------------------

//

OSN_EXPORT IAlfVariantType::Type AlfVariantType::type() const

    {

    return (Type)mVarData->mType;

    }

// ---------------------------------------------------------------------------

// Description : Returns the Boolean value if the data type in the variant 

//                 structure  is a bool 

// ---------------------------------------------------------------------------

//

OSN_EXPORT bool AlfVariantType::boolean() const

    {

    if (type() != EBool)

        {

        ALF_THROW(AlfDataException,EInvalidVariantDataType,"AlfVariantType")

        }

    return mVarData->mData.mBool;

    }

// ---------------------------------------------------------------------------

// Description : Returns the int value if the data type in the variant 

//                 structure  is a int 

// ---------------------------------------------------------------------------

//

OSN_EXPORT int AlfVariantType::integer() const

    {

    if (type() != EInt && type() != EUint) // Signed-unsigned conversion allowed

        {

        ALF_THROW(AlfDataException,EInvalidVariantDataType,"AlfVariantType")

        }

    return mVarData->mData.mInt;

    }

// ---------------------------------------------------------------------------

// Description : Returns the Unsigned value if the data type in the variant 

//                 structure  is a unsigned int 

// ---------------------------------------------------------------------------

//

OSN_EXPORT uint AlfVariantType::uinteger() const

    {

    if (type() != EInt && type() != EUint) // Signed-unsigned conversion allowed

        {

        ALF_THROW(AlfDataException,EInvalidVariantDataType,"AlfVariantType")

        }

    return mVarData->mData.mUint;

    }

// ---------------------------------------------------------------------------

// Description : Returns the Real value if the data type in the variant 

//                 structure  is a Real data

// ---------------------------------------------------------------------------

//

OSN_EXPORT double AlfVariantType::real() const

    {

    if (type() != EReal)

        {

        ALF_THROW(AlfDataException,EInvalidVariantDataType,"AlfVariantType")

        }

    return mVarData->mData.mReal;

    }

// ---------------------------------------------------------------------------

// Description : Returns the Descriptor value if the data type in the variant 

//                 structure  is a string data

// ---------------------------------------------------------------------------

//

OSN_EXPORT const UString& AlfVariantType::string() const

    {

    if (type() != EString)

        {

        ALF_THROW(AlfDataException,EInvalidVariantDataType,"AlfVariantType")

        }

    return *mVarData->mData.mString;

    }

// ---------------------------------------------------------------------------

// Description : Returns the Container if the data type in the variant 

//                 structure  is a collection

// ---------------------------------------------------------------------------

//

OSN_EXPORT IAlfContainer*    AlfVariantType::container() 

    {

    ALF_THROW(AlfDataException,EInvalidVariantDataType,"AlfVariantType")

    }

// ---------------------------------------------------------------------------

// Description : Returns the Map if the data type in the variant 

//                 structure  is a map

// ---------------------------------------------------------------------------

//

OSN_EXPORT IAlfMap*    AlfVariantType::map() 

    {

    ALF_THROW(AlfDataException,EInvalidVariantDataType,"AlfVariantType")

    }

// ---------------------------------------------------------------------------

// Description : Returns the Branch if the data type in the variant 

//                 structure  is a map

// ---------------------------------------------------------------------------

//

OSN_EXPORT IAlfBranch*    AlfVariantType::branch() 

    {

    ALF_THROW(AlfDataException,EInvalidVariantDataType,"AlfVariantType")

    }

// ---------------------------------------------------------------------------

// Description : Returns the User Defined Data Pointer if the data type in the variant 

//                 structure  is IAlfModelBase

// ---------------------------------------------------------------------------

//

OSN_EXPORT IAlfModelBase*    AlfVariantType::customData() 

    {

    if (type() != ECustomData)

        {

        ALF_THROW(AlfDataException,EInvalidVariantDataType,"AlfVariantType")

        }

    return mVarData->mData.mBasePtr;

    }

// ---------------------------------------------------------------------------

// Description : Returns true, if objects are equal, false otherwise.

// ---------------------------------------------------------------------------

//    

OSN_EXPORT bool AlfVariantType::operator==(const IAlfVariantType &aOther) const

    {

    // Set the type

    bool equals = false;

    if (type() == aOther.type() )

        {

        switch( type() )

            {

            case EBool:

                equals = ( bool() == aOther.boolean() );

                break;

            case EInt:

                equals = ( int() == aOther.integer() );

                break;

            case EUint:

                equals = ( uint() == aOther.uinteger() );

                break;

            case EReal:

                equals = ( real() == aOther.real() );

                break;

            case EString:

                equals = ( string() == aOther.string() );

                break;

            case ECustomData: //not known how to compare.

                break;

            default:

                ALF_THROW(AlfDataException,EInvalidVariantDataType,"AlfVariantType")

            }

        }

    return equals;

    }

////////////////////// AlfContainer //////////////////////

// ============================ MEMBER FUNCTIONS ===============================

// ---------------------------------------------------------------------------

// Description : Default Constructor for the Container Data Type

// ---------------------------------------------------------------------------

//    

OSN_EXPORT AlfContainer::AlfContainer()

    {

    construct();

    }

// ---------------------------------------------------------------------------

// Description : Default Construtor

// ---------------------------------------------------------------------------

//

void AlfContainer::construct() 

    {

    mContainerData.reset( new( EMM ) AlfContainerDataImpl() );

    }

// ---------------------------------------------------------------------------

// Description : Class Destructor

// ---------------------------------------------------------------------------

//

OSN_EXPORT AlfContainer::~AlfContainer()

    {

    }

// ---------------------------------------------------------------------------

// Description : Adds an AlfVariantType into the container

// ---------------------------------------------------------------------------

//

OSN_EXPORT void AlfContainer::addItem(IAlfVariantType* aData)

    {

    mContainerData->mArray.resize(mContainerData->mArray.count()+1);