--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/languageinterworkingfw/servicehandler/src/liwvariant.cpp Mon Mar 30 12:51:20 2009 +0300
@@ -0,0 +1,1767 @@
+/*
+* 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)
+ {
+ 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;
+ }
+ return EFalse;
+ }
+
+EXPORT_C TBool TLiwVariant::Get(TReal& aValue) const
+ {
+ __TEST_INVARIANT;
+ if (iTypeId == EVariantTypeTReal)
+ {
+ aValue = iData.iReal;
+ return ETrue;
+ }
+ else if(iTypeId == EVariantTypeTInt32)
+ {
+ aValue = iData.iInt32;
+ return ETrue;
+ }
+ else if (iTypeId == EVariantTypeDesC8) //string to integer conversion
+ {
+ TLex8 parseString(iPtrC8);
+ TInt err = parseString.Val(aValue);
+ if(err == KErrNone)
+ return ETrue;
+ }
+ else if (iTypeId == EVariantTypeDesC) //string to integer conversion
+ {
+ TLex16 parseString(iPtrC);
+ TInt err = parseString.Val(aValue);
+ if(err == KErrNone)
+ return ETrue;
+ }
+ else if (iTypeId == EVariantTypeTUint) //TUint to real conversion
+ {
+ aValue = iData.iUint;
+ return ETrue;
+ }
+ else if(iTypeId == EVariantTypeTInt64)
+ {
+ aValue = iData.iLong; //Warning : Results in loss of data
+ return ETrue;
+ }
+ return EFalse;
+ }
+EXPORT_C TBool TLiwVariant::Get(TBool& aValue) const
+ {
+ __TEST_INVARIANT;
+ if (iTypeId == EVariantTypeTBool)
+ {
+ aValue = iData.iBool;
+ return ETrue;
+ }
+ return EFalse;
+ }
+
+EXPORT_C TBool TLiwVariant::Get(TUint& aValue) const
+ {
+ __TEST_INVARIANT;
+ if (iTypeId == EVariantTypeTUint)
+ {
+ aValue = iData.iUint;
+ return ETrue;
+ }
+ else if (iTypeId == EVariantTypeTReal) //real to TUint conversion
+ {
+ aValue = static_cast<TUint>(iData.iReal);
+ return ETrue;
+ }
+ else if(iTypeId == EVariantTypeTInt32) // TInt32 to TUint conversion
+ {
+ aValue = static_cast<TUint>(iData.iInt32);
+ return ETrue;
+ }
+ else if (iTypeId == EVariantTypeDesC8) //desc8 to TUint conversion
+ {
+ TLex8 parseString(iPtrC8);
+ TInt err = parseString.Val(aValue);
+ if(err == KErrNone)
+ return ETrue;
+ }
+ else if (iTypeId == EVariantTypeDesC) //desc16 to TUint conversion
+ {
+ TLex16 parseString(iPtrC);
+ TInt err = parseString.Val(aValue);
+ if(err == KErrNone)
+ return ETrue;
+ }
+ else if(iTypeId == EVariantTypeTInt64) // TInt32 to TUint conversion
+ {
+ aValue = static_cast<TUint>(iData.iLong); //Warning : Results in loss of data
+ return ETrue;
+ }
+ return EFalse;
+ }
+
+EXPORT_C TBool TLiwVariant::Get(TUid& aValue) const
+ {
+ __TEST_INVARIANT;
+ if (iTypeId == EVariantTypeTUid)
+ {
+ aValue = TUid::Uid(iData.iInt32);
+ return ETrue;
+ }
+ return EFalse;
+ }
+
+EXPORT_C TBool TLiwVariant::Get(TPtrC& aValue) const
+ {
+ __TEST_INVARIANT;
+ if (iTypeId == EVariantTypeDesC)
+ {
+ aValue.Set(iPtrC);
+ return ETrue;
+ }
+ return EFalse;
+ }
+
+EXPORT_C TBool TLiwVariant::Get(TTime& aValue) const
+ {
+ __TEST_INVARIANT;
+ if (iTypeId == EVariantTypeTTime)
+ {
+ aValue = TTime(iData.iInt64);
+ return ETrue;
+ }
+ return EFalse;
+ }
+
+
+EXPORT_C TBool TLiwVariant::Get(TPtrC8& aValue) const
+ {
+ __TEST_INVARIANT;
+ if (iTypeId == EVariantTypeDesC8)
+ {
+ aValue.Set(iPtrC8);
+ return ETrue;
+ }
+
+ return EFalse;
+ }
+
+EXPORT_C TBool TLiwVariant::Get(TDes& aValue) const
+ {
+ __TEST_INVARIANT;
+ if (iTypeId == EVariantTypeDesC)
+ {
+ aValue.Copy(iPtrC);
+ return ETrue;
+ }
+ else if (iTypeId == EVariantTypeDesC8)
+ {
+ aValue.Copy(iPtrC8);
+ return ETrue;
+ }
+ else if (iTypeId == EVariantTypeTReal) //real to TDes conversion
+ {
+ const TRealFormat realFormat;
+ aValue.Num(iData.iReal,realFormat);
+ return ETrue;
+ }
+ else if(iTypeId == EVariantTypeTInt32) // TInt32 to TDes conversion
+ {
+ aValue.Num(iData.iInt32);
+ return ETrue;
+ }
+ else if(iTypeId == EVariantTypeTUint) // TInt32 to TDes conversion
+ {
+ aValue.Num(iData.iUint,EDecimal);
+ return ETrue;
+ }
+ else if(iTypeId == EVariantTypeTInt64) // TInt32 to TDes conversion
+ {
+ aValue.Num(iData.iLong);
+ return ETrue;
+ }
+ return EFalse;
+ }
+
+
+EXPORT_C TBool TLiwVariant::Get(TDes8& aValue) const
+ {
+ __TEST_INVARIANT;
+ if (iTypeId == EVariantTypeDesC8)
+ {
+ aValue.Copy(iPtrC8);
+ return ETrue;
+ }
+ else if (iTypeId == EVariantTypeDesC)
+ {
+ aValue.Copy(iPtrC);
+ return ETrue;
+ }
+ else if (iTypeId == EVariantTypeTReal) //real to TDes8 conversion
+ {
+ const TRealFormat realFormat;
+ aValue.Num(iData.iReal,realFormat);
+ return ETrue;
+ }
+ else if(iTypeId == EVariantTypeTInt32) // TInt32 to TDes8 conversion
+ {
+ aValue.Num(iData.iInt32);
+ return ETrue;
+ }
+ else if(iTypeId == EVariantTypeTUint) // TInt32 to TDes conversion
+ {
+ aValue.Num(iData.iUint,EDecimal);
+ return ETrue;
+ }
+ else if(iTypeId == EVariantTypeTInt64) // TInt32 to TDes8 conversion
+ {
+ aValue.Num(iData.iLong);
+ return ETrue;
+ }
+ return EFalse;
+ }
+
+
+EXPORT_C TBool TLiwVariant::Get(RFile& aValue) const
+ {
+ __TEST_INVARIANT;
+ if (iTypeId == EVariantTypeFileHandle)
+ {
+ aValue = *((RFile*)&iData.iInt64);
+ return ETrue;
+ }
+
+ return EFalse;
+ }
+
+EXPORT_C TBool TLiwVariant::Get(CLiwList& aValue) const
+ {
+ __TEST_INVARIANT;
+ if (iTypeId == EVariantTypeList)
+ {
+ TInt pos = 0;
+ TLiwVariant tempVarient;
+ tempVarient.PushL();
+ // Overwrite the list
+ if(0 != aValue.Count())
+ {
+ // make the list Empty
+ for (pos = aValue.Count() - 1; pos >= 0 ; pos--)
+ aValue.Remove(pos);
+ }
+ // Copy List varient by varient
+ for (pos = 0; pos < iData.iList->Count(); pos++)
+ {
+ iData.iList->AtL(pos, tempVarient);
+ aValue.AppendL(tempVarient);
+ }
+ CleanupStack::Pop(&tempVarient);
+ tempVarient.Reset();
+ return ETrue;
+ }
+
+ return EFalse;
+ }
+
+EXPORT_C TBool TLiwVariant::Get(CLiwMap& aValue) const
+ {
+ __TEST_INVARIANT;
+ if (iTypeId == EVariantTypeMap)
+ {
+ TInt pos = 0;
+ TLiwVariant tempVarient;
+ tempVarient.PushL();
+ // Overwrite the Map
+ if(0 != aValue.Count())
+ {
+ // make the Map Empty
+ for (pos = aValue.Count() - 1; pos >= 0 ; pos--)
+ {
+ TBuf8<KBufSizeSmall> mapKey;
+ aValue.AtL(pos, mapKey);
+ aValue.Remove(mapKey);
+ }
+ }
+ // Copy Map varient by varient
+ for (pos = 0; pos < iData.iMap->Count(); pos++)
+ {
+ TBuf8<KBufSizeSmall> mapKey;
+ iData.iMap->AtL(pos, mapKey);
+ iData.iMap->FindL(mapKey, tempVarient);
+ aValue.InsertL(mapKey, tempVarient);
+ }
+ CleanupStack::Pop(&tempVarient);
+ tempVarient.Reset();
+ return ETrue;
+ }
+
+ return EFalse;
+ }
+EXPORT_C TReal TLiwVariant::AsTReal() const
+ {
+ TReal value = 0;
+ Get(value);
+ return value;
+ }
+
+EXPORT_C TInt32 TLiwVariant::AsTInt32() const
+ {
+ TInt32 value = 0;
+ Get(value);
+ return value;
+ }
+
+EXPORT_C TInt64 TLiwVariant::AsTInt64() const
+ {
+ TInt64 value = 0;
+ Get(value);
+ return value;
+ }
+
+EXPORT_C CLiwBuffer* TLiwVariant::AsBuffer() const
+ {
+ __TEST_INVARIANT;
+ if (iTypeId == EVariantTypeBuffer)
+ {
+ return iData.iBuffer;
+ }
+
+ return NULL;
+ }
+
+EXPORT_C TBool TLiwVariant::AsTBool() const
+ {
+ TBool value = 0;
+ Get(value);
+ return value;
+ }
+
+EXPORT_C TBool TLiwVariant::AsTUint() const
+ {
+ TUint value = 0;
+ Get(value);
+ return value;
+ }
+
+EXPORT_C TUid TLiwVariant::AsTUid() const
+ {
+ __TEST_INVARIANT;
+ TUid value = {0};
+ Get(value);
+ return value;
+ }
+
+EXPORT_C TPtrC TLiwVariant::AsDes() const
+ {
+ __TEST_INVARIANT;
+ TPtrC value;
+ Get(value);
+ return value;
+ }
+
+EXPORT_C TTime TLiwVariant::AsTTime() const
+ {
+ __TEST_INVARIANT;
+ TTime value(Time::NullTTime());
+ Get(value);
+ return value;
+ }
+
+
+EXPORT_C TPtrC8 TLiwVariant::AsData() const
+ {
+ __TEST_INVARIANT;
+ TPtrC8 value;
+ Get(value);
+ return value;
+ }
+
+
+EXPORT_C RFile TLiwVariant::AsFileHandle() const
+ {
+ __TEST_INVARIANT;
+ RFile value;
+ Get(value);
+ return value;
+ }
+
+EXPORT_C const CLiwList* TLiwVariant::AsList() const
+ {
+ __TEST_INVARIANT;
+ return (iTypeId == EVariantTypeList) ? iData.iList : NULL;
+ }
+
+EXPORT_C const CLiwMap* TLiwVariant::AsMap() const
+ {
+ __TEST_INVARIANT;
+ return (iTypeId == EVariantTypeMap) ? iData.iMap : NULL;
+ }
+
+EXPORT_C MLiwInterface* TLiwVariant::AsInterface() const
+ {
+ __TEST_INVARIANT;
+ return (iTypeId == EVariantTypeInterface) ? iData.iSession : NULL;
+ }
+
+EXPORT_C CLiwIterable* TLiwVariant::AsIterable() const
+ {
+ __TEST_INVARIANT;
+ return (iTypeId == EVariantTypeIterable) ? iData.iIterable : NULL;
+ }
+
+EXPORT_C void TLiwVariant::Reset()
+ {
+ __TEST_INVARIANT;
+
+ if (iTypeId == EVariantTypeDesC)
+ {
+ // Delete any owned buffer
+ delete iData.iBufC;
+ iData.iBufC = NULL;
+ }
+ else if (iTypeId == EVariantTypeDesC8)
+ {
+ delete iData.iBufC8;
+ iData.iBufC8 = NULL;
+ }
+ else if (iTypeId == EVariantTypeList)
+ {
+ if (iPtrC8.Compare(KDummy) == 0)
+ {
+ iData.iList->DecRef();
+ iData.iList = NULL;
+ iPtrC8.Set(TPtrC8());
+ }
+ }
+ else if (iTypeId == EVariantTypeMap)
+ {
+ if (iPtrC8.Compare(KDummy) == 0)
+ {
+ iData.iMap->DecRef();
+ iData.iMap = NULL;
+ iPtrC8.Set(TPtrC8());
+ }
+ }
+ else if (iTypeId == EVariantTypeIterable)
+ {
+ if (iPtrC8.Compare(KDummy) == 0)
+ {
+ iData.iIterable->DecRef();
+ iData.iIterable = NULL;
+ iPtrC8.Set(TPtrC8());
+ }
+ }
+ else if (iTypeId == EVariantTypeBuffer)
+ {
+ if (iPtrC8.Compare(KDummy) == 0)
+ {
+ iData.iBuffer->DecRef();
+ iData.iBuffer = NULL;
+ iPtrC8.Set(TPtrC8());
+ }
+ }
+ // No need to clear other data, because Get methods wont't do anything if type
+ // is Null.
+ iTypeId = EVariantTypeNull;
+
+ __ASSERT_DEBUG(IsEmpty(), Panic(EPanicPostCond_Reset));
+ __TEST_INVARIANT;
+ }
+
+EXPORT_C void TLiwVariant::Set(TInt32 aValue)
+ {
+ __TEST_INVARIANT;
+
+ Reset();
+ iTypeId = EVariantTypeTInt32;
+ iData.iInt32 = aValue;
+
+ __ASSERT_DEBUG(this->AsTInt32()==aValue, Panic(EPanicPostCond_Set_TInt32));
+ __TEST_INVARIANT;
+ }
+
+EXPORT_C void TLiwVariant::Set(TInt64 aValue)
+ {
+ __TEST_INVARIANT;
+
+ Reset();
+ iTypeId = EVariantTypeTInt64;
+ iData.iLong = aValue;
+
+ __ASSERT_DEBUG(this->AsTInt64()==aValue, Panic(EPanicPostCond_Set_TInt64));
+ __TEST_INVARIANT;
+ }
+
+EXPORT_C void TLiwVariant::Set(TReal aValue)
+ {
+ __TEST_INVARIANT;
+
+ Reset();
+ iTypeId = EVariantTypeTReal;
+ iData.iReal = aValue;
+
+ __ASSERT_DEBUG(this->AsTReal()==aValue, Panic(EPanicPostCond_Set_TReal));
+ __TEST_INVARIANT;
+ }
+EXPORT_C void TLiwVariant::Set(const CLiwBuffer* aValue)
+ {
+ __TEST_INVARIANT;
+
+ Reset();
+ iTypeId = EVariantTypeBuffer;
+ iData.iBuffer = (CLiwBuffer*)aValue;
+
+ __TEST_INVARIANT;
+ }
+
+EXPORT_C void TLiwVariant::Set(TBool aValue)
+ {
+ __TEST_INVARIANT;
+
+ Reset();
+ iTypeId = EVariantTypeTBool;
+ iData.iBool = aValue;
+
+ __ASSERT_DEBUG(this->AsTBool()==aValue, Panic(EPanicPostCond_Set_TBool));
+ __TEST_INVARIANT;
+ }
+
+EXPORT_C void TLiwVariant::Set(TUint aValue)
+ {
+ __TEST_INVARIANT;
+
+ Reset();
+ iTypeId = EVariantTypeTUint;
+ iData.iUint = aValue;
+
+ __ASSERT_DEBUG(this->AsTUint()==aValue, Panic(EPanicPostCond_Set_TUint));
+ __TEST_INVARIANT;
+ }
+
+EXPORT_C void TLiwVariant::Set(const TUid& aValue)
+ {
+ __TEST_INVARIANT;
+
+ Reset();
+ iTypeId = EVariantTypeTUid;
+ iData.iInt32 = aValue.iUid;
+
+ __ASSERT_DEBUG(this->AsTUid()==aValue, Panic(EPanicPostCond_Set_TUid));
+ __TEST_INVARIANT;
+ }
+
+EXPORT_C void TLiwVariant::Set(const TTime& aValue)
+ {
+ __TEST_INVARIANT;
+
+ Reset();
+ iTypeId = EVariantTypeTTime;
+ iData.iInt64.Set(aValue.Int64());
+
+ __ASSERT_DEBUG(this->AsTTime()==aValue, Panic(EPanicPostCond_Set_TTime));
+ __TEST_INVARIANT;
+ }
+
+EXPORT_C void TLiwVariant::Set(const TDesC& aValue)
+ {
+ __TEST_INVARIANT;
+
+ Reset();
+ iTypeId = EVariantTypeDesC;
+ iData.iBufC = NULL; // not owned
+ iPtrC.Set(aValue);
+
+ __ASSERT_DEBUG(this->AsDes()==aValue, Panic(EPanicPostCond_Set_TDesC));
+ __TEST_INVARIANT;
+ }
+
+
+
+EXPORT_C void TLiwVariant::Set(const TDesC8& aValue)
+ {
+ __TEST_INVARIANT;
+
+ Reset();
+ iTypeId = EVariantTypeDesC8;
+ iData.iBufC8 = NULL; // not owned
+ iPtrC8.Set(aValue);
+
+ __ASSERT_DEBUG(this->AsData()==aValue, Panic(EPanicPostCond_Set_TDesC));
+ __TEST_INVARIANT;
+ }
+
+
+
+EXPORT_C void TLiwVariant::Set(const RFile& aValue)
+ {
+ __TEST_INVARIANT;
+ __ASSERT_DEBUG(sizeof(SInt64) == sizeof(RFile), Panic(EPanicPreCond_DataSizeMismatch));
+
+ Reset();
+ iTypeId = EVariantTypeFileHandle;
+ *((RFile*)&iData.iInt64) = aValue;
+
+ __TEST_INVARIANT;
+ }
+
+EXPORT_C void TLiwVariant::Set(const CLiwList* aValue)
+ {
+ __TEST_INVARIANT;
+
+ Reset();
+ iTypeId = EVariantTypeList;
+ iData.iList = (CLiwList*)aValue;
+
+ __TEST_INVARIANT;
+ }
+
+EXPORT_C void TLiwVariant::Set(const CLiwMap* aValue)
+ {
+ __TEST_INVARIANT;
+
+ Reset();
+ iTypeId = EVariantTypeMap;
+ iData.iMap = (CLiwMap*)aValue;
+
+ __TEST_INVARIANT;
+ }
+
+EXPORT_C void TLiwVariant::Set(const MLiwInterface* aValue)
+ {
+ __TEST_INVARIANT;
+
+ Reset();
+ iTypeId = EVariantTypeInterface;
+ iData.iSession = (MLiwInterface*)aValue;
+
+ __TEST_INVARIANT;
+ }
+
+EXPORT_C void TLiwVariant::Set(const CLiwIterable* aValue)
+ {
+ __TEST_INVARIANT;
+
+ Reset();
+ iTypeId = EVariantTypeIterable;
+ iData.iIterable = (CLiwIterable*)aValue;
+
+ __TEST_INVARIANT;
+ }
+
+EXPORT_C void TLiwVariant::SetL(const TLiwVariant& aValue)
+ {
+ __TEST_INVARIANT;
+
+ if (aValue.iTypeId == EVariantTypeDesC)
+ {
+ // Take an own copy of the string value
+ HBufC* buf = aValue.iPtrC.AllocL();
+ Reset();
+ iTypeId = EVariantTypeDesC;
+ iData.iBufC = buf;
+ iPtrC.Set(*iData.iBufC);
+ }
+ else if (aValue.iTypeId == EVariantTypeDesC8)
+ {
+ // Take an own copy of the data
+ HBufC8* buf = aValue.iPtrC8.AllocL();
+ Reset();
+ iTypeId = EVariantTypeDesC8;
+ iData.iBufC8 = buf;
+ iPtrC8.Set(*iData.iBufC8);
+ }
+ else if (aValue.iTypeId == EVariantTypeList)
+ {
+ // Take an own copy of the data by increasing the reference count
+ Reset();
+ iTypeId = EVariantTypeList;
+ iData.iList = aValue.iData.iList;
+ iData.iList->IncRef();
+ iPtrC8.Set(KDummy); // hack: mark owned
+ }
+ else if (aValue.iTypeId == EVariantTypeMap)
+ {
+ // Take an own copy of the data by increasing the reference count
+ Reset();
+ iTypeId = EVariantTypeMap;
+ iData.iMap = aValue.iData.iMap;
+ iData.iMap->IncRef();
+ iPtrC8.Set(KDummy); // hack: mark owned
+ }
+ else if (aValue.iTypeId == EVariantTypeIterable)
+ {
+ // Take an own copy of the data by increasing the reference count
+ Reset();
+ iTypeId = EVariantTypeIterable;
+ iData.iIterable = aValue.iData.iIterable;
+ iData.iIterable->IncRef();
+ iPtrC8.Set(KDummy); // hack: mark owned
+ }
+ else if (aValue.iTypeId == EVariantTypeBuffer)
+ {
+ Reset();
+ iTypeId = EVariantTypeBuffer;
+ iData.iBuffer = aValue.iData.iBuffer;
+ iData.iBuffer->IncRef();
+ iPtrC8.Set(KDummy); // hack: mark owned
+ }
+ else
+ {
+ Reset();
+ iTypeId = aValue.iTypeId;
+ // Copy the data union as one block
+ iData = aValue.iData;
+ }
+
+ //__ASSERT_DEBUG(*this == aValue, Panic(EPanicPostCond_CopyL));
+ __TEST_INVARIANT;
+ }
+
+void TLiwVariant::Destroy()
+ {
+ __TEST_INVARIANT;
+
+ if (iTypeId == EVariantTypeDesC)
+ {
+ // Delete any owned buffer
+ delete iData.iBufC;
+ iData.iBufC = NULL;
+ }
+ else if (iTypeId == EVariantTypeDesC8)
+ {
+ delete iData.iBufC8;
+ iData.iBufC8 = NULL;
+ }
+ else if (iTypeId == EVariantTypeList)
+ {
+ if (iPtrC8.Compare(KDummy) == 0)
+ {
+ iData.iList->DecRef();
+ iData.iList = NULL;
+ iPtrC8.Set(TPtrC8());
+ }
+ }
+ else if (iTypeId == EVariantTypeMap)
+ {
+ if (iPtrC8.Compare(KDummy) == 0)
+ {
+ iData.iMap->DecRef();
+ iData.iMap = NULL;
+ iPtrC8.Set(TPtrC8());
+ }
+ }
+ else if (iTypeId == EVariantTypeIterable)
+ {
+ if (iPtrC8.Compare(KDummy) == 0)
+ {
+ iData.iIterable->DecRef();
+ iData.iIterable = NULL;
+ iPtrC8.Set(TPtrC8());
+ }
+ }
+ else if (iTypeId == EVariantTypeBuffer)
+ {
+ if (iPtrC8.Compare(KDummy) == 0)
+ {
+ iData.iBuffer->DecRef();
+ iData.iBuffer = NULL;
+ iPtrC8.Set(TPtrC8());
+ }
+ }
+ }
+
+void TLiwVariant::InternalizeL(RReadStream& aStream)
+ {
+ __TEST_INVARIANT;
+
+ aStream.ReadInt8L(); // version
+ // if older version adapt to changes (who knows if
+ // parameters would be also persistent...)
+
+ const TUint8 typeId = aStream.ReadUint8L();
+ switch (typeId)
+ {
+ case EVariantTypeNull:
+ {
+ Reset();
+ break;
+ }
+ case EVariantTypeTInt32: // FALLTHROUGH
+ case EVariantTypeTUid:
+ case EVariantTypeTBool:
+ case EVariantTypeTUint:
+ {
+ TInt32 value = aStream.ReadInt32L();
+ Reset();
+ iTypeId = typeId;
+ iData.iInt32 = value;
+ break;
+ }
+ case EVariantTypeTInt64:
+ {
+ TInt64 value = aStream.ReadReal64L();
+ Reset();
+ iTypeId = typeId;
+ iData.iLong = value;
+ break;
+ }
+ case EVariantTypeFileHandle: // FALLTHROUGH
+ case EVariantTypeTTime:
+ case EVariantTypeTReal:
+ {
+ SInt64 value;
+ value.InternalizeL(aStream);
+ Reset();
+ iTypeId = typeId;
+ iData.iInt64 = value;
+ break;
+ }
+ case EVariantTypeDesC:
+ {
+ const TInt len = aStream.ReadInt32L();
+ HBufC* buf = HBufC::NewL(aStream,len);
+ Reset();
+ iTypeId = typeId;
+ iData.iBufC = buf;
+ iPtrC.Set(*iData.iBufC);
+ break;
+ }
+ case EVariantTypeDesC8:
+ {
+ const TInt len = aStream.ReadInt32L();
+ HBufC8* buf = HBufC8::NewL(aStream,len);
+ Reset();
+ iTypeId = typeId;
+ iData.iBufC8 = buf;
+ iPtrC8.Set(*iData.iBufC8);
+ break;
+ }
+ case EVariantTypeList:
+ {
+ CLiwList* list = CLiwDefaultList::NewLC(aStream);
+ Reset();
+ iTypeId = EVariantTypeList;
+ iData.iList = list;
+ iPtrC8.Set(KDummy); // hack: mark owned
+ CleanupStack::Pop(list); // list
+ break;
+ }
+ case EVariantTypeMap:
+ {
+ CLiwMap* map = CLiwDefaultMap::NewLC(aStream);
+ Reset();
+ iTypeId = EVariantTypeMap;
+ iData.iMap = map;
+ iPtrC8.Set(KDummy); // hack: mark owned
+ CleanupStack::Pop(map); // map
+ break;
+ }
+ default:
+ {
+ // Corrupted data stream.
+#ifdef _DEBUG
+ RDebug::Print(_L("***ERROR TLiwVariant::InternalizeL"));
+#endif
+ User::Leave(KErrCorrupt);
+ return;
+ }
+ }
+
+ __TEST_INVARIANT;
+ }
+
+void TLiwVariant::ExternalizeL(RWriteStream& aStream) const
+ {
+ __TEST_INVARIANT;
+
+ aStream.WriteInt8L(KVersion);
+ // if older version adapt to changes (who knows if parameters would be also persistent...)
+
+ aStream.WriteUint8L(iTypeId);
+ switch (iTypeId)
+ {
+ case EVariantTypeTInt32: // FALLTHROUGH
+ case EVariantTypeTUid:
+ case EVariantTypeTBool:
+ case EVariantTypeTUint:
+ {
+ aStream.WriteInt32L(iData.iInt32);
+ break;
+ }
+ case EVariantTypeTInt64:
+ {
+ aStream.WriteReal64L(iData.iLong);
+ break;
+ }
+ case EVariantTypeFileHandle: // FALLTHROUGH
+ case EVariantTypeTTime:
+ case EVariantTypeTReal:
+ {
+ iData.iInt64.ExternalizeL(aStream);
+ break;
+ }
+ case EVariantTypeDesC:
+ {
+ aStream.WriteInt32L(iPtrC.Length());
+ aStream << iPtrC;
+ break;
+ }
+ case EVariantTypeDesC8:
+ {
+ aStream.WriteInt32L(iPtrC8.Length());
+ aStream << iPtrC8;
+ break;
+ }
+ case EVariantTypeList:
+ {
+ iData.iList->ExternalizeL(aStream);
+ break;
+ }
+ case EVariantTypeMap:
+ {
+ iData.iMap->ExternalizeL(aStream);
+ break;
+ }
+ case EVariantTypeInterface:
+ {
+ _LIT(KMsg, "TLiwVariant: type Interface not externizable");
+ User::Panic(KMsg, 1);
+ break;
+ }
+ default:
+ break;
+ }
+
+ __TEST_INVARIANT;
+ }
+
+TInt TLiwVariant::Size() const
+ {
+ __TEST_INVARIANT;
+
+ TInt size = sizeof (TInt8); // version
+ size += sizeof (TUint8); // iTypeId
+ switch (iTypeId)
+ {
+ case EVariantTypeTInt32: // FALLTHROUGH
+ case EVariantTypeTUid:
+ case EVariantTypeTBool:
+ case EVariantTypeTUint:
+ {
+ size += sizeof (TInt32);
+ break;
+ }
+ case EVariantTypeFileHandle: // FALLTHROUGH
+ case EVariantTypeTTime:
+ case EVariantTypeTReal:
+ case EVariantTypeTInt64:
+ {
+ size += sizeof (TInt64);
+ break;
+ }
+ case EVariantTypeDesC:
+ {
+ size += sizeof (TInt32); // length
+ //size += 1; // the externalization method used adds a header byte
+ if(iPtrC.Size() >= KBufSizeLarge)
+ {
+ size += 4;
+ }
+ else if(iPtrC.Size() >= KBufSizeSmall)
+ {
+ size += 2;
+ }
+ else
+ {
+ size += 1;
+ }
+ size += iPtrC.Size();
+ break;
+ }
+ case EVariantTypeDesC8:
+ {
+ size += sizeof (TInt32); // length
+ //size += 1; // the externalization method used adds a header byte
+ if(iPtrC8.Size() >= KBufSizeLarge)
+ {
+ size += 4;
+ }
+
+ else if(iPtrC8.Size() >= KBufSizeSmall)
+ {
+ size += 2;
+ }
+ else
+ {
+ size += 1;
+ }
+ size += iPtrC8.Size();
+ break;
+ }
+ case EVariantTypeList:
+ {
+ size += iData.iList->Size();
+ break;
+ }
+ case EVariantTypeMap:
+ {
+ size += iData.iMap->Size();
+ break;
+ }
+ default:
+ break;
+ }
+ return size;
+ }
+
+// ============================ EXTERNAL FUNCTIONS ===============================
+
+EXPORT_C TBool operator==(const TLiwVariant& aLhs, const TLiwVariant& aRhs)
+ {
+ if (aLhs.iTypeId == aRhs.iTypeId)
+ {
+ switch (aLhs.iTypeId)
+ {
+ case EVariantTypeNull:
+ {
+ // Null equals Null
+ return ETrue;
+ }
+ case EVariantTypeTInt32: // FALLTHROUGH
+ case EVariantTypeTUid:
+ case EVariantTypeTBool:
+ case EVariantTypeTUint:
+ {
+ return (aLhs.iData.iInt32 == aRhs.iData.iInt32);
+ }
+ case EVariantTypeTInt64:
+ {
+ return (aLhs.iData.iLong == aRhs.iData.iLong);
+ }
+ case EVariantTypeDesC:
+ {
+ return (aLhs.iPtrC == aRhs.iPtrC);
+ }
+ case EVariantTypeDesC8:
+ {
+ return (aLhs.iPtrC8 == aRhs.iPtrC8);
+ }
+ case EVariantTypeFileHandle: // FALLTHROUGH
+ case EVariantTypeTTime:
+ case EVariantTypeTReal:
+ {
+ return (aLhs.iData.iInt64 == aRhs.iData.iInt64);
+ }
+ case EVariantTypeList:
+ {
+ return (*(aLhs.iData.iList) == *(aRhs.iData.iList));
+ }
+ case EVariantTypeMap:
+ {
+ return (*(aLhs.iData.iMap) == *(aRhs.iData.iMap));
+ }
+ case EVariantTypeInterface:
+ {
+ return (aLhs.iData.iSession == aRhs.iData.iSession);
+ }
+ case EVariantTypeIterable:
+ {
+ return (*(aLhs.iData.iIterable) == *(aRhs.iData.iIterable));
+ }
+ case EVariantTypeBuffer:
+ {
+ return (aLhs.iData.iBuffer == aRhs.iData.iBuffer);
+ }
+ default:
+ {
+ break;
+ }
+ }
+ }
+ return EFalse;
+ }
+
+#ifdef _DEBUG
+EXPORT_C void Dump(const TLiwVariant& aVariant)
+ {
+ switch (aVariant.TypeId())
+ {
+ case EVariantTypeNull:
+ {
+ RDebug::Print(_L(" TLiwVariant::Dump = Null"));
+ break;
+ }
+ case EVariantTypeTInt32:
+ {
+ RDebug::Print(_L(" TLiwVariant::Dump(TInt32) = %d"), aVariant.AsTInt32());
+ break;
+ }
+ case EVariantTypeTInt64:
+ {
+ RDebug::Print(_L(" TLiwVariant::Dump(TInt64) = %d"), aVariant.AsTInt64());
+ break;
+ }
+ case EVariantTypeTReal:
+ {
+ RDebug::Print(_L(" TLiwVariant::Dump(TReal) = %d"), aVariant.AsTReal());
+ break;
+ }
+ case EVariantTypeTBool:
+ {
+ RDebug::Print(_L(" TLiwVariant::Dump(TBool) = %d"), aVariant.AsTBool());
+ break;
+ }
+ case EVariantTypeTUint:
+ {
+ RDebug::Print(_L(" TLiwVariant::Dump(TUint) = %d"), aVariant.AsTUint());
+ break;
+ }
+
+ case EVariantTypeTUid:
+ {
+ const TUidName& uidName = aVariant.AsTUid().Name();
+ RDebug::Print(_L(" TLiwVariant::Dump(TUid) = %S"), &uidName);
+ break;
+ }
+ case EVariantTypeDesC:
+ {
+ TPtrC des = aVariant.AsDes();
+ RDebug::Print(_L(" TLiwVariant::Dump(TBufC) = %S"), &des);
+ break;
+ }
+ case EVariantTypeDesC8:
+ {
+ TPtrC8 des = aVariant.AsData();
+ RDebug::Print(_L(" TLiwVariant::Dump(TBufC8) = %S"), &des);
+ break;
+ }
+ case EVariantTypeTTime:
+ {
+ TDateTime dt = aVariant.AsTTime().DateTime();
+ RDebug::Print(_L(" TLiwVariant::Dump(TTime): day=%d,mon=%d,year=%d,hh=%d,mm=%d,ss=%d"),
+ dt.Day()+1, dt.Month()+1, dt.Year(),
+ dt.Hour(),dt.Minute(), dt.Second());
+ break;
+ }
+ case EVariantTypeFileHandle:
+ {
+ RDebug::Print(_L(" TLiwVariant::Dump(RFile): Value is file handle."));
+ break;
+ }
+ case EVariantTypeList:
+ {
+ const CLiwList* tempList = aVariant.AsList();
+ TInt count = tempList->Count();
+ TLiwVariant tempVariant;
+ tempVariant.PushL();
+ RDebug::Print(_L(" TLiwVariant::Dump(List[%d]):"), count);
+ for (TInt index = 0; index < count; index++)
+ {
+ TRAPD(error, {tempList->AtL(index, tempVariant);});
+ if(error != KErrNone)
+ RDebug::Print(_L("TLiwVariant::Dump ERROR: %d"), error);
+ Dump(tempVariant);
+ }
+ CleanupStack::Pop(&tempVariant);
+ tempVariant.Reset();
+ RDebug::Print(_L(" TLiwVariant::Dump List END"));
+ break;
+ }
+ case EVariantTypeIterable:
+ {
+ CLiwIterable* tempItr = aVariant.AsIterable();
+ TLiwVariant tempVariant;
+ RDebug::Print(_L(" TLiwVariant::Dump(Iterable):"));
+ tempItr->Reset();
+ TRAPD(errno, {
+ while (tempItr->NextL(tempVariant)) {
+ Dump(tempVariant);
+ }
+ });
+ if(errno != KErrNone)
+ RDebug::Print(_L("TLiwVariant::Dump ERROR: %d"), errno);
+ tempVariant.Reset();
+ RDebug::Print(_L(" TLiwVariant::Dump Iterable END"));
+ break;
+ }
+ case EVariantTypeMap:
+ {
+ const CLiwMap* tempMap = aVariant.AsMap();
+ TInt count = tempMap->Count();
+ TLiwVariant tempVariant;
+ RDebug::Print(_L(" TLiwVariant::Dump(Map):"));
+ for (TInt index = 0; index < count; index++) {
+ TBuf8<KBufSizeMid> key;
+ TRAPD(error, {tempMap->AtL(index, key);});
+ RDebug::Print(_L(" key=%S, value= "), &key);
+ TRAP(error, {tempMap->FindL(key, tempVariant);});
+ Dump(tempVariant);
+ }
+ tempVariant.Reset();
+ RDebug::Print(_L(" TLiwVariant::Dump Map END"));
+ break;
+ }
+ case EVariantTypeInterface:
+ {
+ RDebug::Print(_L(" TLiwVariant::Dump(Interface): Value is interface pointer."));
+ break;
+ }
+ default:
+ {
+ RDebug::Print(_L(" *** TLiwVariant::Dump(Unknown) ***"));
+ break;
+ }
+ }
+ }
+#else
+EXPORT_C void Dump(const TLiwVariant& /*aVariant*/)
+ {
+ }
+
+#endif // ifdef _DEBUG