diff -r 000000000000 -r 99ef825efeca languageinterworkingfw/servicehandler/src/liwgenericparam.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/languageinterworkingfw/servicehandler/src/liwgenericparam.cpp	Mon Mar 30 12:51:20 2009 +0300
@@ -0,0 +1,575 @@
+/*
+* 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 TLiwGenericParam and CLiwGenericParamList.
+*
+*/
+
+
+
+
+
+
+
+// INCLUDES
+#include <s32mem.h>
+#include "liwgenericparam.h"
+using namespace LIW;
+namespace {
+
+// CONSTANTS
+// Protect against possible data format changes
+const TInt KVersion = 10;  // Version 1.0
+
+enum TPanicCode
+    {
+    EPanicPostCond_CopyLC = 1,
+    EPanicPostCond_AppendL,
+    EPanicPostCond_Reset
+    };
+
+
+// ============================= LOCAL FUNCTIONS ===============================
+
+#ifdef _DEBUG
+void Panic(TPanicCode aCode)
+    {
+    _LIT(KPanicText, "GenericParam");
+    User::Panic(KPanicText, aCode);
+    }
+#endif
+
+}
+
+
+const TInt KRFsSlot = 2;
+const TInt KRFileSlot = 3;
+
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+/**
+ * Releases any dynamic data owned by this parameter.
+ */
+void TLiwGenericParam::Destroy()
+    {
+    if (iSemanticId != EGenericParamNameAsStringTransient)
+        {
+        delete iReserved;
+        iReserved = NULL;   
+        }
+    iValue.Destroy();
+    }
+
+/**
+ * Copies aParam to this parameter. Takes an own copy of the value held in 
+ * aParam.
+ */
+void TLiwGenericParam::CopyLC(const TLiwGenericParam& aParam)
+    {
+    // Take a copy of value
+    iValue.SetL(aParam.iValue);
+    // Copy semantic id
+    iSemanticId = aParam.iSemanticId;
+    // Copy name  
+    if (iSemanticId == EGenericParamNameAsString) {
+      delete iReserved;
+      iReserved = NULL;
+      iReserved = ((HBufC8*)aParam.iReserved)->AllocL();
+    }
+    else if (iSemanticId == EGenericParamNameAsStringTransient) {
+      delete iReserved;
+      iReserved = NULL;
+      iReserved = ((TDesC8*)aParam.iReserved)->AllocL();
+      iSemanticId = EGenericParamNameAsString;
+    }
+    CleanupStack::PushL(*this);
+
+    //__ASSERT_DEBUG(*this==aParam, Panic(EPanicPostCond_CopyLC));
+    }
+
+
+EXPORT_C void TLiwGenericParam::PushL()
+	{
+	CleanupStack::PushL( TCleanupItem( TLiwGenericParam::ParamCleanup , this) ); 
+	}
+
+EXPORT_C void TLiwGenericParam::ParamCleanup( TAny* aObj )
+    {
+    static_cast<TLiwGenericParam*>(aObj)->Destroy();
+    }
+
+/**
+ * Returns a cleanup item that will call Destroy to this object when 
+ * PopAndDestroy'ed.
+ */
+TLiwGenericParam::operator TCleanupItem()
+    {
+    return TCleanupItem(&CleanupDestroy,this);
+    }
+
+/**
+ * Callback for operator TCleanupItem().
+ */
+void TLiwGenericParam::CleanupDestroy(TAny* aObj)
+    {
+    static_cast<TLiwGenericParam*>(aObj)->Destroy();
+    }
+/**
+ * Internalizes this parameter from aStream.
+ */
+void TLiwGenericParam::InternalizeL(RReadStream& aStream)
+    {
+    /*const TInt version =*/ aStream.ReadInt8L();
+    const TGenericParamId id = 
+        static_cast<TGenericParamId>(aStream.ReadInt32L());
+    if (id == EGenericParamNameAsString)
+      {
+        TInt len = aStream.ReadInt32L();
+        delete iReserved;
+        iReserved = NULL;
+        iReserved = HBufC8::NewL(aStream, len);
+      }
+    iValue.InternalizeL(aStream);
+    iSemanticId = id;
+    }
+
+/**
+ * Externalizes this parameter to aStream.
+ */
+void TLiwGenericParam::ExternalizeL(RWriteStream& aStream) const
+    {
+    aStream.WriteInt8L(KVersion);
+    aStream.WriteInt32L(iSemanticId);
+    if (iSemanticId == EGenericParamNameAsString)
+      {
+        aStream.WriteInt32L(((HBufC8*)iReserved)->Length());
+        aStream << (*((HBufC8*)iReserved));
+      }
+    iValue.ExternalizeL(aStream);
+    }
+
+/**
+ * Returns the maximum externalized size of this parameter.
+ */
+TInt TLiwGenericParam::Size() const
+    {
+    TInt size = sizeof (TInt8); // version
+    size += sizeof (TInt32); // semantic ID
+    if (iSemanticId == EGenericParamNameAsString)
+      {
+        size += sizeof (TInt32); // name length
+        //size += 1;   // header written by operator<<
+        if(((HBufC8*)iReserved)->Size()>=64)
+        	{
+           	size += 2;
+        	}
+        else
+        	{
+        	size += 1;
+           	}
+        	
+        size += ((HBufC8*)iReserved)->Size();
+      }
+    size += iValue.Size();
+    return size;
+    }
+
+EXPORT_C TBool operator==(const TLiwGenericParam& aLhs, 
+    const TLiwGenericParam& aRhs)
+    {
+      if (((aLhs.SemanticId() == EGenericParamNameAsString) ||
+           (aLhs.SemanticId() == EGenericParamNameAsStringTransient)) &&
+          ((aRhs.SemanticId() == EGenericParamNameAsString) ||
+           (aRhs.SemanticId() == EGenericParamNameAsStringTransient)))
+        return ((aLhs.Name() == aRhs.Name()) && (aLhs.Value() == aRhs.Value()));
+      else
+        return 
+          ((aLhs.SemanticId() == aRhs.SemanticId()) && 
+           (aLhs.Value() == aRhs.Value()));
+    }
+
+
+// CLiwGenericParamList
+
+inline CLiwGenericParamList::CLiwGenericParamList()
+    {
+    }
+
+EXPORT_C CLiwGenericParamList* CLiwGenericParamList::NewL()
+    {
+    CLiwGenericParamList *self = NewLC();
+    CleanupStack::Pop(self);
+    return self;
+    }
+
+EXPORT_C CLiwGenericParamList* CLiwGenericParamList::NewL(RReadStream& aReadStream)
+    {
+    CLiwGenericParamList *self = NewLC(aReadStream);
+    CleanupStack::Pop(self);
+    return self;
+    }
+
+EXPORT_C CLiwGenericParamList* CLiwGenericParamList::NewLC()
+    {
+    CLiwGenericParamList *self = new( ELeave ) CLiwGenericParamList();
+    CleanupStack::PushL( self );
+    return self;
+    }
+
+EXPORT_C CLiwGenericParamList* CLiwGenericParamList::NewLC(RReadStream& aReadStream)
+    {
+    CLiwGenericParamList *self = new( ELeave ) CLiwGenericParamList();
+    CleanupStack::PushL( self );
+    self->AppendL(aReadStream);
+    return self;
+    }
+
+CLiwGenericParamList::~CLiwGenericParamList()
+    {
+    for (TInt index = iParameters.Count()-1; index >= 0; --index)
+        {
+        // Can use Destroy because the parameters cannot be accessed anymore
+        iParameters[index].Destroy();
+        }
+    iParameters.Close();
+    }
+
+EXPORT_C TInt CLiwGenericParamList::Count() const
+    {
+    return iParameters.Count();
+    }
+    
+EXPORT_C TInt CLiwGenericParamList::Count(TGenericParamId aSemanticId, 
+    TVariantTypeId aDataType) const
+    {
+    TInt result = 0;
+    const TInt count = iParameters.Count();
+
+    for (TInt index = 0; index < count; index++)
+        {
+        const TLiwGenericParam& param = iParameters[index];
+        if (param.SemanticId() == aSemanticId)
+            {
+            if (aDataType==EVariantTypeAny || param.Value().TypeId()==aDataType)
+                {
+                result++;                   
+                }
+            }
+        }       
+    return result;     
+    }
+
+
+EXPORT_C const TLiwGenericParam& CLiwGenericParamList::operator[](TInt aIndex) const
+    {
+        return iParameters[aIndex]; 
+    }
+
+EXPORT_C void CLiwGenericParamList::AtL(TInt aIndex, TLiwGenericParam& aParam) const
+    {
+    aParam.CopyLC(iParameters[aIndex]); 
+    CleanupStack::Pop(&aParam);   
+    }
+
+EXPORT_C void CLiwGenericParamList::AppendL(const TLiwGenericParam& aParam)
+    {
+    TLiwGenericParam newParam;
+    newParam.CopyLC(aParam);
+    User::LeaveIfError(iParameters.Append(newParam));
+    CleanupStack::Pop(&newParam);
+
+    //__ASSERT_DEBUG((*this)[Count()-1]==aParam, Panic(EPanicPostCond_AppendL));
+    }
+
+
+EXPORT_C TBool CLiwGenericParamList::Remove(TInt aSemanticId)
+    {
+    const TInt count = iParameters.Count();
+    for (TInt index = 0; index < count; ++index)
+        {
+        const TLiwGenericParam& param = iParameters[index];
+        if (param.SemanticId() == aSemanticId)
+            {
+            iParameters.Remove(index);
+            return ETrue;
+            }
+        }
+
+    return EFalse;
+    }
+
+EXPORT_C void CLiwGenericParamList::Remove(const TDesC8& aName)
+    {
+    TInt start = 0;
+    FindFirst(start, aName);
+    while (start != KErrNotFound)
+        {
+        // Can use Destroy because the parameters cannot be accessed anymore
+        iParameters[start].Destroy();
+        iParameters.Remove(start);
+        start = 0;   
+        FindFirst(start, aName);
+        }
+    }
+    
+EXPORT_C void CLiwGenericParamList::Reset()
+    {
+    for (TInt index = iParameters.Count()-1; index >= 0; --index)
+        {
+        // Can use Destroy because the parameters cannot be accessed anymore
+        iParameters[index].Destroy();
+        iParameters.Remove(index);
+        }
+
+    __ASSERT_DEBUG(Count()==0, Panic(EPanicPostCond_Reset));
+    }
+
+EXPORT_C const TLiwGenericParam* CLiwGenericParamList::FindFirst(
+    TInt &aIndex, 
+    TGenericParamId aSemanticId, 
+    TVariantTypeId aDataType) const
+    {
+    if (aIndex >= 0)
+        {
+        const TInt count = iParameters.Count();
+        for (TInt index = aIndex; index < count; ++index)
+            {
+            const TLiwGenericParam& param = iParameters[index];
+            if (param.SemanticId() == aSemanticId)
+                {
+                if (aDataType==EVariantTypeAny || param.Value().TypeId()==aDataType)
+                    {
+                    aIndex = index;
+                    return &param;
+                    }
+                }
+            }
+        }
+    aIndex = KErrNotFound;
+    return NULL;
+    }
+
+EXPORT_C const TLiwGenericParam* CLiwGenericParamList::FindNext(
+    TInt &aIndex, 
+    TGenericParamId aSemanticId,
+    TVariantTypeId aDataType) const
+    {
+    if (aIndex < 0)
+        {
+        aIndex = KErrNotFound;
+        return NULL;
+        }
+
+    TInt index = aIndex+1;
+    const TLiwGenericParam* result = FindFirst(index, aSemanticId, aDataType);
+    aIndex = index;
+    return result;
+    }
+
+EXPORT_C const TLiwGenericParam* CLiwGenericParamList::FindNext(
+    TInt &aIndex, 
+    const TDesC8& aName,
+    TVariantTypeId aDataType) const
+    {
+    if (aIndex < 0)
+        {
+        aIndex = KErrNotFound;
+        return NULL;
+        }
+
+    TInt index = aIndex+1;
+    const TLiwGenericParam* result = FindFirst(index, aName, aDataType);
+    aIndex = index;
+    return result;
+    }
+
+EXPORT_C const TLiwGenericParam* CLiwGenericParamList::FindFirst 
+        (TInt &aIndex, const TDesC8& aName, 
+        TVariantTypeId aDataType) const
+    {
+    if (aIndex >= 0)
+        {
+        const TInt count = iParameters.Count();
+        for (TInt index = aIndex; index < count; ++index)
+            {
+            const TLiwGenericParam& param = iParameters[index];
+            if ((param.SemanticId() == EGenericParamNameAsString) &&
+                (param.Name() == aName))
+                {
+                if (aDataType==EVariantTypeAny || param.Value().TypeId()==aDataType)
+                    {
+                    aIndex = index;
+                    return &param;
+                    }
+                }
+            }
+        }
+    aIndex = KErrNotFound;
+    return NULL;
+    }
+
+EXPORT_C void CLiwGenericParamList::ExternalizeL(RWriteStream& aStream) const
+    {
+    aStream.WriteInt8L(KVersion);
+    const TInt count = iParameters.Count();
+    aStream.WriteInt32L(count);
+    for (TInt index = 0; index < count; ++index)
+        {
+        iParameters[index].ExternalizeL(aStream);
+        }
+    }
+
+EXPORT_C TInt CLiwGenericParamList::Size() const
+    {
+    TInt size = sizeof (TInt8); // version
+    size += sizeof (TInt32);  // param count
+    const TInt count = iParameters.Count();
+    for (TInt index = 0; index < count; ++index)
+        {
+        size += iParameters[index].Size();
+        }
+    return size;
+    }
+
+/**
+ * Appends parameters to this list from aStream.
+ */
+void CLiwGenericParamList::AppendL(RReadStream& aReadStream)
+    {
+    /*const TInt version =*/ aReadStream.ReadInt8L();
+    
+    TInt count = aReadStream.ReadInt32L();
+    while (count--)
+        {
+        TLiwGenericParam param;
+        CleanupStack::PushL(param);
+        param.InternalizeL(aReadStream);
+        User::LeaveIfError(iParameters.Append(param));
+        CleanupStack::Pop(&param);
+        }
+    }
+
+
+
+EXPORT_C void CLiwGenericParamList::InternalizeL(RReadStream& aStream)
+    {
+    AppendL(aStream);
+    }
+
+
+EXPORT_C HBufC8* CLiwGenericParamList::PackForServerL(TIpcArgs& aArgs)
+    {   
+    TInt index;
+    TInt rfileCount = 0;
+    RFile fhandle;
+
+    HBufC8* buf = HBufC8::NewLC(Size() + iParameters.Count());
+    TPtr8 des = buf->Des();
+    RDesWriteStream outstrm(des);    
+    CleanupClosePushL(outstrm);
+
+    outstrm.WriteInt16L(iParameters.Count());   
+
+    for (index = 0; index < iParameters.Count(); index++)
+        {       
+        if (iParameters[index].Value().TypeId() == EVariantTypeFileHandle)
+            {
+            if (rfileCount == 0)
+                {
+                outstrm.WriteInt8L(iParameters[index].Value().TypeId());
+                outstrm.WriteInt32L(iParameters[index].SemanticId());
+                if (iParameters[index].Value().Get(fhandle))
+                    {
+                    rfileCount++;
+                    }
+                }
+            }
+        else
+            {
+            outstrm.WriteInt8L(iParameters[index].Value().TypeId());
+            iParameters[index].ExternalizeL( outstrm );
+            }
+        }
+        
+    outstrm.CommitL();  
+    CleanupStack::PopAndDestroy(&outstrm);
+                        
+    aArgs.Set(0, buf);
+    aArgs.Set(1, des.MaxLength());    
+        
+    if (rfileCount)
+        {
+        fhandle.TransferToServer(aArgs, KRFsSlot, KRFileSlot);      
+        }   
+
+    CleanupStack::Pop(buf);    // buf
+
+    return buf;
+    }
+
+
+EXPORT_C void CLiwGenericParamList::UnpackFromClientL(const RMessage2& aMsg)
+    {
+    TInt8 type;
+    TInt index;
+    TLiwGenericParam param; 
+    TGenericParamId handleId = EGenericParamUnspecified;
+    TInt numFileHandles = 0;
+
+    HBufC8* buf = HBufC8::NewLC(aMsg.Int1());
+    TPtr8 ptr(buf->Des());
+    aMsg.ReadL(0, ptr);
+    RDesReadStream instrm(buf->Des());
+
+    const TInt16 count = instrm.ReadInt16L();
+    for (index = 0; index < count; index++)
+        {
+        type = instrm.ReadInt8L();
+        if (type == EVariantTypeFileHandle)
+            {
+            if (numFileHandles == 0)
+                {
+                handleId = (TGenericParamId)instrm.ReadInt32L();
+                numFileHandles++;
+                }
+            }
+        else
+            {
+            param.InternalizeL(instrm);
+            AppendL(param);
+            param.Reset();
+            }
+        }
+
+    if (numFileHandles)
+        {
+        RFile file;
+        file.AdoptFromClient(aMsg, KRFsSlot, KRFileSlot);
+        TLiwVariant variant(file);
+        AppendL(TLiwGenericParam(handleId, variant));               
+        }
+        
+    CleanupStack::PopAndDestroy(buf); // buf       
+    }
+    
+
+EXPORT_C void CLiwGenericParamList::AppendL(const CLiwGenericParamList& aList)
+    {
+    for (TInt index = 0; index < aList.iParameters.Count(); index++)
+        {
+        AppendL(aList.iParameters[index]);
+        }
+    }
+
+// End of file