/*

* 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 "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 TAiwGenericParam and CAiwGenericParamList.

*

*/

// INCLUDES

#include <s32mem.h>

#include "AiwGenericParam.h"

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.

 */

inline void TAiwGenericParam::Destroy()

    {

    iValue.Destroy();

    }

/**

 * Copies aParam to this parameter. Takes an own copy of the value held in 

 * aParam.

 */

void TAiwGenericParam::CopyLC(const TAiwGenericParam& aParam)

    {

    // Take a copy of value

    iValue.SetL(aParam.iValue);

    // Copy semantic id

    iSemanticId = aParam.iSemanticId;

    CleanupStack::PushL(*this);

    __ASSERT_DEBUG(*this==aParam, Panic(EPanicPostCond_CopyLC));

    }

/**

 * Returns a cleanup item that will call Destroy to this object when 

 * PopAndDestroy'ed.

 */

TAiwGenericParam::operator TCleanupItem()

    {

    return TCleanupItem(&CleanupDestroy,this);

    }

/**

 * Callback for operator TCleanupItem().

 */

void TAiwGenericParam::CleanupDestroy(TAny* aObj)

    {

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

    }

/**

 * Internalizes this parameter from aStream.

 */

void TAiwGenericParam::InternalizeL(RReadStream& aStream)

    {

    /*const TInt version =*/ aStream.ReadInt8L();

    const TGenericParamId id = 

        static_cast<TGenericParamId>(aStream.ReadInt32L());

    iValue.InternalizeL(aStream);

    iSemanticId = id;

    }

/**

 * Externalizes this parameter to aStream.

 */

void TAiwGenericParam::ExternalizeL(RWriteStream& aStream) const

    {

    aStream.WriteInt8L(KVersion);

    aStream.WriteInt32L(iSemanticId);

    iValue.ExternalizeL(aStream);

    }

/**

 * Returns the maximum externalized size of this parameter.

 */

TInt TAiwGenericParam::Size() const

    {

    TInt size = sizeof (TInt8); // version

    size += sizeof (TInt32); // semantic ID

    size += iValue.Size();

    return size;

    }

EXPORT_C TBool operator==(const TAiwGenericParam& aLhs, 

    const TAiwGenericParam& aRhs)

    {

    return 

        ((aLhs.SemanticId() == aRhs.SemanticId()) && 

        (aLhs.Value() == aRhs.Value()));

    }

////////////////////////////////////////////////////////////

// CAiwGenericParamList

inline CAiwGenericParamList::CAiwGenericParamList()

    {

    }

EXPORT_C CAiwGenericParamList* CAiwGenericParamList::NewL()

    {

    CAiwGenericParamList *self = NewLC();

    CleanupStack::Pop();

    return self;

    }

EXPORT_C CAiwGenericParamList* CAiwGenericParamList::NewL(RReadStream& aReadStream)

    {

    CAiwGenericParamList *self = NewLC(aReadStream);

    CleanupStack::Pop();

    return self;

    }

EXPORT_C CAiwGenericParamList* CAiwGenericParamList::NewLC()

    {

    CAiwGenericParamList *self = new( ELeave ) CAiwGenericParamList();

    CleanupStack::PushL( self );

    return self;

    }

EXPORT_C CAiwGenericParamList* CAiwGenericParamList::NewLC(RReadStream& aReadStream)

    {

    CAiwGenericParamList *self = new( ELeave ) CAiwGenericParamList();

    CleanupStack::PushL( self );

    self->AppendL(aReadStream);

    return self;

    }

CAiwGenericParamList::~CAiwGenericParamList()

    {

    for (TInt i = iParameters.Count()-1; i >= 0; --i)

        {

        // Can use Destroy because the parameters cannot be accessed anymore

        iParameters[i].Destroy();

        }

    iParameters.Close();

    }

EXPORT_C TInt CAiwGenericParamList::Count() const

    {

    return iParameters.Count();

    }

EXPORT_C TInt CAiwGenericParamList::Count(TGenericParamId aSemanticId, 

    TVariantTypeId aDataType) const

    {

    TInt result = 0;

    const TInt count = iParameters.Count();

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

        {

        const TAiwGenericParam& param = iParameters[i];

        if (param.SemanticId() == aSemanticId)

            {

            if (aDataType==EVariantTypeAny || param.Value().TypeId()==aDataType)

                {

                result++;                   

                }

            }

        }       

    return result;     

    }

EXPORT_C const TAiwGenericParam& CAiwGenericParamList::operator[](TInt aIndex) const

    {

    return iParameters[aIndex];

    }

EXPORT_C void CAiwGenericParamList::AppendL(const TAiwGenericParam& aParam)

    {

    TAiwGenericParam newParam;

    newParam.CopyLC(aParam);

    User::LeaveIfError(iParameters.Append(newParam));

    CleanupStack::Pop(&newParam);

    __ASSERT_DEBUG((*this)[Count()-1]==aParam, Panic(EPanicPostCond_AppendL));

    }

EXPORT_C TBool CAiwGenericParamList::Remove(TInt aSemanticId)

    {

    const TInt count = iParameters.Count();

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

        {

        const TAiwGenericParam& param = iParameters[i];

        if (param.SemanticId() == aSemanticId)

            {

            iParameters.Remove(i);

            return ETrue;

            }

        }

    return EFalse;

    }

EXPORT_C void CAiwGenericParamList::Reset()

    {

    for (TInt i = iParameters.Count()-1; i >= 0; --i)

        {

        // Can use Destroy because the parameters cannot be accessed anymore

        iParameters[i].Destroy();

        iParameters.Remove(i);

        }

    __ASSERT_DEBUG(Count()==0, Panic(EPanicPostCond_Reset));

    }

EXPORT_C const TAiwGenericParam* CAiwGenericParamList::FindFirst(

    TInt &aIndex, 

    TGenericParamId aSemanticId, 

    TVariantTypeId aDataType) const

    {

    if (aIndex >= 0)

        {

        const TInt count = iParameters.Count();

        for (TInt i = aIndex; i < count; ++i)

            {

            const TAiwGenericParam& param = iParameters[i];

            if (param.SemanticId() == aSemanticId)

                {

                if (aDataType==EVariantTypeAny || param.Value().TypeId()==aDataType)

                    {

                    aIndex = i;

                    return &param;

                    }

                }

            }

        }

    aIndex = KErrNotFound;

    return NULL;

    }

EXPORT_C const TAiwGenericParam* CAiwGenericParamList::FindNext(

    TInt &aIndex, 

    TGenericParamId aSemanticId,

    TVariantTypeId aDataType) const

    {

    if (aIndex < 0)

        {

        aIndex = KErrNotFound;

        return NULL;

        }

    TInt index = aIndex+1;

    const TAiwGenericParam* result = FindFirst(index, aSemanticId, aDataType);

    aIndex = index;

    return result;

    }

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

    {

    aStream.WriteInt8L(KVersion);

    const TInt count = iParameters.Count();

    aStream.WriteInt32L(count);

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

        {

        iParameters[i].ExternalizeL(aStream);

        }

    }

EXPORT_C TInt CAiwGenericParamList::Size() const

    {

    TInt size = sizeof (TInt8); // version

    size += sizeof (TInt32);  // param count

    const TInt count = iParameters.Count();

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

        {

        size += iParameters[i].Size();

        }

    return size;

    }

/**

 * Appends parameters to this list from aStream.

 */

void CAiwGenericParamList::AppendL(RReadStream& aReadStream)

    {

    /*const TInt version =*/ aReadStream.ReadInt8L();

    TInt count = aReadStream.ReadInt32L();

    while (count--)

        {

        TAiwGenericParam param;

        CleanupStack::PushL(param);

        param.InternalizeL(aReadStream);

        User::LeaveIfError(iParameters.Append(param));

        CleanupStack::Pop(&param);

        }

    }

EXPORT_C void CAiwGenericParamList::InternalizeL(RReadStream& aStream)

    {

    AppendL(aStream);

    }

EXPORT_C HBufC8* CAiwGenericParamList::PackForServerL(TIpcArgs& aArgs)

    {   

    TInt i;

    TInt rfileCount = 0;

    RFile fhandle;

    HBufC8* buf = HBufC8::NewLC(Size() + iParameters.Count());

    TPtr8 des = buf->Des();

    RDesWriteStream outstrm(des);    

    //outstrm.Open(des);

    CleanupClosePushL(outstrm);

    outstrm.WriteInt16L(iParameters.Count());   

    for (i = 0; i < iParameters.Count(); i++)

        {       

        if (iParameters[i].Value().TypeId() == EVariantTypeFileHandle)

            {

            if (rfileCount == 0)

                {

                outstrm.WriteInt8L(iParameters[i].Value().TypeId());

                outstrm.WriteInt32L(iParameters[i].SemanticId());

                if (iParameters[i].Value().Get(fhandle))

                    {

                    rfileCount++;

                    }

                }

            }

        else

            {

            outstrm.WriteInt8L(iParameters[i].Value().TypeId());

            iParameters[i].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

    return buf;

    }

EXPORT_C void CAiwGenericParamList::UnpackFromClientL(const RMessage2& aMsg)

    {

    TInt8 type;

    TInt i;

    TAiwGenericParam 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 (i = 0; i < count; i++)

        {

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

        TAiwVariant variant(file);

        AppendL(TAiwGenericParam(handleId, variant));               

        }

    CleanupStack::PopAndDestroy(); // buf       

    }

EXPORT_C void CAiwGenericParamList::AppendL(const CAiwGenericParamList& aList)

    {

    for (TInt i = 0; i < aList.iParameters.Count(); i++)

        {

        AppendL(aList.iParameters[i]);

        }

    }

// End of file