/*

* 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;