/****************************************************************************

**

** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (developer.feedback@nokia.com)

**

** This file is part of the HbCore module of the UI Extensions for Mobile.

**

** GNU Lesser General Public License Usage

** This file may be used under the terms of the GNU Lesser General Public

** License version 2.1 as published by the Free Software Foundation and

** appearing in the file LICENSE.LGPL included in the packaging of this file.

** Please review the following information to ensure the GNU Lesser General

** Public License version 2.1 requirements will be met:

** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at developer.feedback@nokia.com.

**

****************************************************************************/

#include "hbsymbianvariant.h"

{

public:

    CHbSymbianVariantPrivate();

    ~CHbSymbianVariantPrivate();

    void InitializeDataL(const TAny* aData, CHbSymbianVariant::TType aDataType);

    void ResetData();

    void* Data();

public:

    struct Data {

        union BasicData {

        TInt i;

        TUint u;

        TReal r;

        TAny* ptr;

        } iBasicData;

    } iData;

    CHbSymbianVariant::TType iType;

    TBool iNull;

};

CHbSymbianVariantPrivate::CHbSymbianVariantPrivate() : iType(CHbSymbianVariant::EInt), iNull(ETrue)

{

    iData.iBasicData.i = 0;

}

CHbSymbianVariantPrivate::~CHbSymbianVariantPrivate()

{

    ResetData();

};

void CHbSymbianVariantPrivate::InitializeDataL(const TAny* aData, CHbSymbianVariant::TType aDataType)

{

    switch(aDataType) {

        case CHbSymbianVariant::EInt: {

            iData.iBasicData.i = *reinterpret_cast<const TInt*>(aData);

            break;

        }

        case CHbSymbianVariant::EBool: {

            iData.iBasicData.i = *reinterpret_cast<const TBool*>(aData);

            break;

        }

        case CHbSymbianVariant::EUint: {

            iData.iBasicData.u = *reinterpret_cast<const TUint*>(aData);

            break;

        }

        case CHbSymbianVariant::EReal: {

            iData.iBasicData.r = *reinterpret_cast<const TReal*>(aData);

            break;

        }

        case CHbSymbianVariant::EChar: {

            const TChar* chPtr = reinterpret_cast<const TChar*>(aData);

            TChar* ch = new TChar(*chPtr);

            iData.iBasicData.ptr = ch;

            break;

        }

        case CHbSymbianVariant::ERect: {

            const TRect* rectPtr = reinterpret_cast<const TRect*>(aData);

            TRect* rect = new TRect(rectPtr->iTl, rectPtr->iBr);

            iData.iBasicData.ptr = rect;

            break;

        }

        case CHbSymbianVariant::EDes: {

            const TDesC* desPtr = reinterpret_cast<const TDesC*>(aData);

            HBufC* buf = desPtr->Alloc();

            iData.iBasicData.ptr = buf;

            break;

        }

        case CHbSymbianVariant::EPoint: {

            const TPoint* pointPtr = reinterpret_cast<const TPoint*>(aData);

            TPoint* point = new TPoint(pointPtr->iX, pointPtr->iY);

            iData.iBasicData.ptr = point;

            break;

        }

        case CHbSymbianVariant::ESize: {

            const TSize* sizePtr = reinterpret_cast<const TSize*>(aData);

            TSize* size = new TSize(sizePtr->iWidth, sizePtr->iHeight);

            iData.iBasicData.ptr = size;

            break;

        }

        case CHbSymbianVariant::EBinary: {

            const TDesC8* binPtr = reinterpret_cast<const TDesC8*>(aData);

            HBufC8* binBuf = binPtr->Alloc();

            iData.iBasicData.ptr = binBuf;

            break;

        }

        case CHbSymbianVariant::EDesArray: {

            const MDesCArray* arrayPtr = reinterpret_cast<const MDesCArray*>(aData);

            TInt count = arrayPtr->MdcaCount();

                array->AppendL(arrayPtr->MdcaPoint(i));

            }

            iData.iBasicData.ptr = array;

            break;

        }

        case CHbSymbianVariant::EVariantMap: {

            const CHbSymbianVariantMap* mapPtr = 

                reinterpret_cast<const CHbSymbianVariantMap*>(aData);

            CHbSymbianVariantMap* copy = CHbSymbianVariantMap::NewL();

            CleanupStack::PushL(copy);

            MDesCArray& keys = mapPtr->Keys();

            TInt count = keys.MdcaCount();

                TPtrC ptr = keys.MdcaPoint(i);

                const CHbSymbianVariant* var = mapPtr->Get(ptr);

                copy->Add(ptr, CHbSymbianVariant::NewL(var->Data(), var->Type()));

            }

            iData.iBasicData.ptr = copy;

            CleanupStack::Pop(copy);

            break;

        }

        default: {

            break;

        }

    }

    iType = aDataType;

    iNull = EFalse;

}

void CHbSymbianVariantPrivate::ResetData()

{

    switch(iType) {

        case CHbSymbianVariant::EInt:

        case CHbSymbianVariant::EBool:

        case CHbSymbianVariant::EUint:

        case CHbSymbianVariant::EReal:

            // no need to destroy anything

            break;

        case CHbSymbianVariant::EChar: {

            TChar* del_ptr = static_cast<TChar*>(iData.iBasicData.ptr);

            delete del_ptr;

            iData.iBasicData.ptr = NULL;

            break;

            }

        case CHbSymbianVariant::EDes: {

            TDesC* del_ptr = static_cast<TDesC*>(iData.iBasicData.ptr);

            delete del_ptr;

            iData.iBasicData.ptr = NULL;

            break;

            }

        case CHbSymbianVariant::ERect: {

            TRect* del_ptr = static_cast<TRect*>(iData.iBasicData.ptr);

            delete del_ptr;

            iData.iBasicData.ptr = NULL;

            break;

            }

        case CHbSymbianVariant::EPoint: {

            TPoint* del_ptr = static_cast<TPoint*>(iData.iBasicData.ptr);

            delete del_ptr;

            iData.iBasicData.ptr = NULL;

            break;

            }

        case CHbSymbianVariant::ESize: {

            TSize* del_ptr = static_cast<TSize*>(iData.iBasicData.ptr);

            delete del_ptr;

            iData.iBasicData.ptr = NULL;

            break;

            }

        case CHbSymbianVariant::EBinary: {

            TDesC8* del_ptr = static_cast<TDesC8*>(iData.iBasicData.ptr);

            delete del_ptr;

            iData.iBasicData.ptr = NULL;

            break;

            }

        case CHbSymbianVariant::EDesArray: {

            CDesC16ArrayFlat* del_ptr = static_cast<CDesC16ArrayFlat*>(iData.iBasicData.ptr);

            delete del_ptr;

            iData.iBasicData.ptr = NULL;

            break; // dynamic data

            }

        default:

            break;

    };

}

void* CHbSymbianVariantPrivate::Data() {

    void* return_value;

    switch(iType) {

    case CHbSymbianVariant::EInt:

        return_value = &iData.iBasicData.i;

        break;

    case CHbSymbianVariant::EBool:

        return_value = &iData.iBasicData.i;

        break;

    case CHbSymbianVariant::EUint:

        return_value = &iData.iBasicData.u;

        break;

    case CHbSymbianVariant::EReal:

        return_value = &iData.iBasicData.r;

        break;

    case CHbSymbianVariant::EChar:

    case CHbSymbianVariant::EDes:

    case CHbSymbianVariant::ERect:

    case CHbSymbianVariant::EPoint:

    case CHbSymbianVariant::ESize:

    case CHbSymbianVariant::EBinary:

    case CHbSymbianVariant::EDesArray:

    case CHbSymbianVariant::EVariantMap:

        return_value = iData.iBasicData.ptr;

        break; // dynamic data

    default:

        return_value = NULL;

        break;

    }

    return return_value;

};

/*!

 */

/*!

   \enum CHbSymbianVariant::TType

*/

/*!

*/

/*!

*/

/*!

*/

/*!

*/

/*!

*/

/*!

*/

/*!

*/

/*!

*/

/*!

*/

/*!

*/

/*!

*/

/*!

*/

 /*!

*/

/*!

*/

EXPORT_C CHbSymbianVariant* CHbSymbianVariant::NewL(const TAny* aData, TType aDataType)

{

    CHbSymbianVariant* variant = new (ELeave) CHbSymbianVariant(aData, aDataType);

    CleanupStack::PushL(variant);

    variant->ConstructL(aData, aDataType);

    CleanupStack::Pop(variant); //variant

    return variant;

}

*/

EXPORT_C CHbSymbianVariant::TType CHbSymbianVariant::Type() const

{

    return d->iType;

}

/*!

*/

EXPORT_C TAny* CHbSymbianVariant::Data() const

{

    return d->Data();

}

/*!

*/

EXPORT_C void CHbSymbianVariant::SetData(TAny* aData, TType aDataType)

{

    if(d) {

        d->ResetData();

        d->InitializeDataL(aData, aDataType);

    }

}

/*!

*/

EXPORT_C TBool CHbSymbianVariant::IsValid() const

{

    if(d && !(d->iNull))

        return ETrue;

    else

        return EFalse;

}

EXPORT_C CHbSymbianVariant::~CHbSymbianVariant()

{

    delete d;

    d = 0;

}

CHbSymbianVariant::CHbSymbianVariant(const TAny* /* aData */, TType /* aDataType */) : d(0)

{

}

void CHbSymbianVariant::ConstructL(const TAny* aData, TType aDataType)

{

    d = new (ELeave) CHbSymbianVariantPrivate;

    d->InitializeDataL(aData, aDataType);

}

{

public:

    CHbSymbianVariantMapPrivate():iKeyArray(NULL),iVariantArray() {

        iKeyArray = new CDesC16ArrayFlat(16);

    };

    ~CHbSymbianVariantMapPrivate(){

        delete iKeyArray;

        iKeyArray = NULL;

        iVariantArray.ResetAndDestroy();

        iVariantArray.Close();

    };

public:

    CDesC16Array* iKeyArray;

    RPointerArray<CHbSymbianVariant> iVariantArray;

};

/*!

*/

/*!

 */

EXPORT_C CHbSymbianVariantMap* CHbSymbianVariantMap::NewL()

{

    CHbSymbianVariantMap* map = new (ELeave) CHbSymbianVariantMap();

    CleanupStack::PushL(map);

    map->ConstructL();

    CleanupStack::Pop(map); // map

    return map;

}

EXPORT_C CHbSymbianVariantMap::~CHbSymbianVariantMap()

{

    delete d;

    d = 0;

}

/*!

 */

EXPORT_C TInt CHbSymbianVariantMap::Add(const TDesC& aKey, CHbSymbianVariant* aVariant)

{

    TInt pos = KErrNotFound;

        // for some reason directly deleting the pointer and

        // assigning a new one to position does not work

        CHbSymbianVariant* remove = d->iVariantArray[pos];

        d->iVariantArray.Remove(pos);

        d->iVariantArray.Insert(aVariant, pos);

        delete remove;

        remove = 0;

    }

    // new key-value pair

    else {

        result = KErrNone;

        TRAP(result, d->iKeyArray->AppendL(aKey));

            result = d->iVariantArray.Append(aVariant);

                d->iKeyArray->Delete(d->iKeyArray->MdcaCount()-1);

            }

        }

    }

    return result;

}