/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:       Implementation of class TLiwVariant.

*

*/

// INCLUDES

#ifdef _DEBUG

#include <e32svr.h>

#endif

#include "liwvariant.h"

#include "liwgenericparam.h" 

// ============================= LOCAL FUNCTIONS ===============================

using namespace LIW;

namespace {

// CONSTANTS

/// TLiwVariant streaming version

const TInt KVersion = 10;  // Version 1.0

const TInt KBufSizeMid = 128;

const TInt KBufSizeSmall = 64;

const TInt KBufSizeLarge = 8192;

// Debug helpers

#ifdef _DEBUG

enum TPanicCode

    {

    EPanicPostCond_Constructor = 1,

    EPanicPostCond_Reset,

    EPanicPostCond_Set_TInt32,

    EPanicPostCond_Set_TUid,

    EPanicPostCond_Set_TTime,

    EPanicPostCond_Set_TDesC,

    EPanicPostCond_CopyL,

    EPanicInvariant_InvalidDesCState,

    EPanicPostCond_Set_TDesC8,

    EPanicPreCond_DataSizeMismatch,

    EPanicPostCond_Set_TBool,

    EPanicPostCond_Set_TUint,

    EPanicPostCond_Set_TReal,

    EPanicPostCond_Set_TInt64

    };

void Panic(TPanicCode aCode)

    {

    _LIT(KPanicText, "TLiwVariant");

    User::Panic(KPanicText, aCode);

    }

#endif  // #ifdef _DEBUG

}  // namespace

_LIT8(KDummy, "Dummy"); // needed for BC-preserving hack to store info about ownership of container

/*

 * class CLiwContainer, class CLiwIterable, class CLiwList, class CLiwMap,

 * class CLiwDefaultList, class CLiwDefaultMap

 */

EXPORT_C void CLiwContainer::PushL() 

    {

    CleanupClosePushL(*this);

    }

EXPORT_C void CLiwContainer::ExternalizeL(RWriteStream&) const

    {

    User::Leave(KErrNotSupported);

    }

EXPORT_C TInt CLiwContainer::Size() const

    {

    return KErrNotSupported;

    }

EXPORT_C CLiwContainer::~CLiwContainer()

    {

   /*

    * Since CLiwContainer is based on reference count mechanism, it does not go with CleanupStack::PushL()

    *

    * LIW takes care of managing the memory in heap for CLiwContainer using the reference count logic

    * 

    * The container should not be destroyed until the reference count is ZERO.

    * If the reference count is not equal to ZERO, it means there are some more owners of that container

    * 

    * This panics if the reference count is not equal to ZERO, in DEBUG Mode only

    *

    * Hence it is recommended to use CleanupClosePushL for Container objects when using CleanupStack

    */

    __ASSERT_DEBUG(iRefCount == 0, User::Panic(_L("E32USER-CBase: 33"), 1));

    }

EXPORT_C void CLiwContainer::Close()

    {

    DecRef();

    }

EXPORT_C TBool CLiwIterable::operator==(CLiwIterable& aOther)

    {

    if (this == &aOther)

    return ETrue;

    Reset();

    aOther.Reset();

    TBool rval = ETrue;

    TLiwVariant variant1, variant2;

    TRAPD(error, {

    while (NextL(variant1)) 

	    {

	      if (!aOther.NextL(variant2) || (variant1 != variant2))

	        rval = EFalse;

	    }

    });

    if (rval && (error == KErrNone))

        {

        TRAP(error, (rval = !(aOther.NextL(variant2))));

        }

    variant1.Reset();

    variant2.Reset();

    return (error == KErrNone) ? rval : EFalse;

    }

EXPORT_C TBool CLiwList::operator==(const CLiwList& aOther) const

    {

    TInt count = Count();

    if (count != aOther.Count())

    return EFalse;

    TInt error = KErrNone;

    TBool retval = ETrue;

    TLiwVariant variant1, variant2;

    for (TInt index = 0; index < count; index++) {

    TRAP(error, {

      AtL(index, variant1); aOther.AtL(index, variant2);

    });

    if ((error != KErrNone) || (!(variant1 == variant2)))

        {

        retval = EFalse;

        break;

        }

    }

    variant1.Reset();

    variant2.Reset();

    return retval;

    }

EXPORT_C TBool CLiwMap::operator==(const CLiwMap& aOther) const

    {

    TInt count = Count();

    if (count != aOther.Count())

    return EFalse;

    TInt error = KErrNone;

    TBool retval = ETrue;

    TLiwVariant variant1, variant2;

    TBuf8<KBufSizeMid> buf1, buf2;

    for (TInt index = 0; index < count; index++)

        {

        TRAP(error, {

          AtL(index, buf1); aOther.AtL(index, buf2);

          retval = (FindL(buf1, variant1) && aOther.FindL(buf2, variant2));

        });

        if (error != KErrNone)

          retval = EFalse;

        if (!retval || (!(variant1 == variant2)))

            {

            retval = EFalse;

            break;

            }

        }

    variant1.Reset();

    variant2.Reset();

    return retval;

    }

EXPORT_C CLiwDefaultList* CLiwDefaultList::NewL()

    {

    CLiwGenericParamList* gl = CLiwGenericParamList::NewLC();

    CLiwDefaultList* tempList = new (ELeave) CLiwDefaultList(gl);

    CleanupStack::Pop(gl); // gl

    return tempList;

    }

EXPORT_C CLiwDefaultList* CLiwDefaultList::NewLC()

    {

    CLiwGenericParamList* gl = CLiwGenericParamList::NewLC();

    CLiwDefaultList* tempList = new (ELeave) CLiwDefaultList(gl);

    CleanupStack::Pop(gl); // gl

    CleanupClosePushL(*tempList);

    return tempList;

    }

EXPORT_C CLiwDefaultList* CLiwDefaultList::NewLC(RReadStream& aStream)

    {

    CLiwDefaultList* tempList = CLiwDefaultList::NewL();

    CleanupClosePushL(*tempList);

    tempList->iList->InternalizeL(aStream);

    return tempList;

    }

EXPORT_C void CLiwDefaultList::AppendL(const TLiwVariant& aValue)

    {

    iList->AppendL(TLiwGenericParam(EGenericParamUnspecified, aValue));

    }

EXPORT_C TBool CLiwDefaultList::AtL(TInt aIndex, TLiwVariant& aValue) const

    {

    if(0 <= aIndex && aIndex < iList->Count())

        {

        aValue.SetL((*iList)[aIndex].Value());

        return ETrue;   

        }

    else

        {

        return EFalse;    

        }

    }

EXPORT_C void CLiwDefaultList::Remove(TInt aIndex)

    {

    if(0 <= aIndex && aIndex < iList->Count())

        {

        iList->iParameters[aIndex].Destroy();

        iList->iParameters.Remove(aIndex);   

        }

    }

EXPORT_C TInt CLiwDefaultList::Count() const

    {

    return iList->Count();

    }

EXPORT_C void CLiwDefaultList::ExternalizeL(RWriteStream& aStream) const

    {

    iList->ExternalizeL(aStream);

    }

EXPORT_C TInt CLiwDefaultList::Size() const

    {

    return iList->Size();

    }

EXPORT_C CLiwDefaultList::~CLiwDefaultList()

    {

    delete iList;

    }

EXPORT_C CLiwDefaultMap* CLiwDefaultMap::NewL()

    {

    CLiwGenericParamList* gl = CLiwGenericParamList::NewLC();

    CLiwDefaultMap* tempMap = new (ELeave) CLiwDefaultMap(gl);

    CleanupStack::Pop(gl); // gl

    return tempMap;

    }

EXPORT_C CLiwDefaultMap* CLiwDefaultMap::NewLC()

    {

    CLiwGenericParamList* gl = CLiwGenericParamList::NewLC();

    CLiwDefaultMap* tempMap = new (ELeave) CLiwDefaultMap(gl);

    CleanupStack::Pop(gl); // gl

    CleanupClosePushL(*tempMap);

    return tempMap;

    }

EXPORT_C CLiwDefaultMap* CLiwDefaultMap::NewLC(RReadStream& aStream)

    {

    CLiwDefaultMap* tempMap = CLiwDefaultMap::NewL();

    CleanupClosePushL(*tempMap);

    tempMap->iMap->InternalizeL(aStream);

    return tempMap;

    }

EXPORT_C void CLiwDefaultMap::InsertL(const TDesC8& aKey, const TLiwVariant& aValue)

    {

    Remove(aKey);

    TLiwGenericParam mp;

    mp.SetNameAndValueL(aKey, aValue);

    iMap->AppendL(mp);

    mp.Reset();

    }

EXPORT_C TBool CLiwDefaultMap::FindL(const TDesC8& aKey, TLiwVariant& aValue) const

    {

    TInt pos = 0;

    const TLiwGenericParam* tempParam = iMap->FindFirst(pos, aKey);

    if (tempParam)

        {

        aValue.SetL(tempParam->Value());

        return ETrue;

        }

    else

        return EFalse;

    }

EXPORT_C TInt CLiwDefaultMap::Count() const

    {

    return iMap->Count();

    }

EXPORT_C TBool CLiwDefaultMap::AtL(TInt aIndex, TDes8& aKey) const

    {

    if(0 <= aIndex && aIndex < iMap->Count())

        {

        aKey = ((*iMap)[aIndex]).Name();

        return ETrue;   

        }

    else

        {

        return EFalse;  

        }

    }

EXPORT_C const TDesC8& CLiwDefaultMap::AtL(TInt aIndex) const

    {

    if(0 <= aIndex && aIndex < iMap->Count())

        {

        return ((*iMap)[aIndex]).Name();

        }

    else

        {

        User::LeaveIfError(KErrArgument);  

        return KNullDesC8;

        }

    }

EXPORT_C void CLiwDefaultMap::Remove(const TDesC8& aKey)

    {

    TInt pos = 0;

    iMap->FindFirst(pos, aKey);

    if (pos != KErrNotFound)

        {

        iMap->iParameters[pos].Destroy();

        iMap->iParameters.Remove(pos);

        }

    }

EXPORT_C void CLiwDefaultMap::ExternalizeL(RWriteStream& aStream) const

    {

    iMap->ExternalizeL(aStream);

    }

EXPORT_C TInt CLiwDefaultMap::Size() const

    {

    return iMap->Size();

    }

EXPORT_C CLiwDefaultMap::~CLiwDefaultMap()

    {

    delete iMap;

    }

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

#ifdef _DEBUG

void TLiwVariant::__DbgTestInvariant() const

    {

    if (iTypeId==EVariantTypeDesC && iData.iBufC)

        {

        __ASSERT_ALWAYS(iData.iBufC->Ptr() == iPtrC.Ptr(), 

            Panic(EPanicInvariant_InvalidDesCState));

        }

    }

#endif  // #ifdef _DEBUG

EXPORT_C void TLiwVariant::PushL()

    {

    CleanupStack::PushL( TCleanupItem( TLiwVariant::VariantCleanup , this) );

    }

EXPORT_C void TLiwVariant::VariantCleanup( TAny* aObj )

    {

    static_cast<TLiwVariant*>(aObj)->Destroy();

    }

inline void TLiwVariant::SInt64::InternalizeL(RReadStream& aStream)

    {

    TInt32 low = aStream.ReadInt32L();

    iHigh = aStream.ReadInt32L();

    iLow = low;

    }

inline void TLiwVariant::SInt64::ExternalizeL(RWriteStream& aStream) const

    {

    aStream.WriteInt32L(iLow);

    aStream.WriteInt32L(iHigh);

    }

inline void TLiwVariant::SInt64::Set(const TInt64& aTInt64)

    {

    iLow = I64LOW(aTInt64);

    iHigh = I64HIGH(aTInt64);

    }

inline TLiwVariant::SInt64::operator TInt64() const

    {

    return MAKE_TINT64(iHigh,iLow);

    }

inline TBool TLiwVariant::SInt64::operator==(const SInt64& aRhs) const

    {

    return (iHigh==aRhs.iHigh && iLow==aRhs.iLow);

    }

EXPORT_C TLiwVariant::TLiwVariant(const TLiwVariant& aSrc) :

    iTypeId(aSrc.iTypeId), iData(aSrc.iData), iPtrC(), iPtrC8()

    {

    if (iTypeId == EVariantTypeDesC)

        {

        iPtrC.Set(aSrc.iPtrC);

        // Do not take ownership of data

        iData.iBufC = NULL;

        }

    else if ( iTypeId == EVariantTypeDesC8 )

        {

        iPtrC8.Set( aSrc.iPtrC8 );

        // Do not take ownership of data

        iData.iBufC8 = NULL;

        }

    }

EXPORT_C TLiwVariant& TLiwVariant::operator=(const TLiwVariant& aSrc)

    {

    // Check self-assignment first.

    if (this == &aSrc)

        {

        return *this;

        }

    Reset(); 

    iTypeId = aSrc.iTypeId;

    iData = aSrc.iData;

    if (iTypeId == EVariantTypeDesC)

        {

        iPtrC.Set(aSrc.iPtrC);

        // Do not take ownership of data

        iData.iBufC = NULL;

        }

    else if ( iTypeId == EVariantTypeDesC8 )

        {

        iPtrC8.Set( aSrc.iPtrC8 );

        // Do not take ownership of data

        iData.iBufC8 = NULL;

        }

    return *this;

    }

EXPORT_C TBool TLiwVariant::Get(TInt32& aValue) const

    {

    __TEST_INVARIANT;

    if (iTypeId == EVariantTypeTInt32)

        {

        aValue = iData.iInt32;

        return ETrue;

        }

    else if (iTypeId == EVariantTypeTReal)

	    {

	    aValue = (TInt32)iData.iReal;

	    return ETrue;

	    }

	else if (iTypeId == EVariantTypeDesC8)  //string to real conversion

		{

		TLex8 parseString(iPtrC8);

		TInt err = parseString.Val(aValue);

		if(err == KErrNone)

			return ETrue;

		}

	else if (iTypeId == EVariantTypeDesC)  //string to real conversion

		{

		TLex16 parseString(iPtrC);

		TInt err = parseString.Val(aValue);

		if(err == KErrNone)

			return ETrue;		

		}

	else if (iTypeId == EVariantTypeTUint) //TUint to int conversion

	    {

	    aValue = (TInt32)iData.iUint;

	    return ETrue;

	    }

	else if (iTypeId == EVariantTypeTInt64) //TInt64 to TInt32 conversion

	    {

	    aValue = (TInt32)iData.iLong; //Warning : Results in loss of data sometimes

	    return ETrue;

	    }

	return EFalse;

    }

EXPORT_C TBool TLiwVariant::Get(TInt64& aValue) const

    {

    __TEST_INVARIANT;

    if (iTypeId == EVariantTypeTInt64)

        {

        aValue = iData.iLong;

        return ETrue;

        }

    else if (iTypeId == EVariantTypeTInt32)

        {