/*
* Copyright (c) 2009 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:  MXIMPRequestCompleteEvent API object implementation.
*
*/


#include <s32strm.h>

#include "ximprequestcompleteeventimp.h"
#include "ximpstatusimp.h"
#include "ximpapidataobjfactory.h"
#include "ximpapidataobjbase.h"


// ---------------------------------------------------------------------------
// CXIMPRequestCompleteEventImp::NewL()
// ---------------------------------------------------------------------------
//
EXPORT_C CXIMPRequestCompleteEventImp* CXIMPRequestCompleteEventImp::NewL()
    {
    TXIMPRequestId nullId = TXIMPRequestId::Null();
    
    CXIMPRequestCompleteEventImp* self =
            new( ELeave ) CXIMPRequestCompleteEventImp( nullId );
    CleanupStack::PushL( self );
    self->ConstructL( KErrNone );
    CleanupStack::Pop( self );
    return self;
    }



// ---------------------------------------------------------------------------
// CXIMPRequestCompleteEventImp::NewLC()
// ---------------------------------------------------------------------------
//
EXPORT_C CXIMPRequestCompleteEventImp* CXIMPRequestCompleteEventImp::NewLC(
       TXIMPRequestId& aRequestId, TInt aDefaultErrorValue )
    {
    CXIMPRequestCompleteEventImp* self =
            new( ELeave ) CXIMPRequestCompleteEventImp( aRequestId );
    CleanupStack::PushL( self );
    self->ConstructL( aDefaultErrorValue );
    return self;
    }


// ---------------------------------------------------------------------------
// CXIMPRequestCompleteEventImp::NewLC()
// Instantiation method for event automation.
// ---------------------------------------------------------------------------
//
CXIMPApiEventBase*
    CXIMPRequestCompleteEventImp::NewFromStreamLC( RReadStream& aStream )
    {
    CXIMPRequestCompleteEventImp* self = new( ELeave ) CXIMPRequestCompleteEventImp;
    CleanupStack::PushL( self );
    self->ConstructL( aStream );
    return self;
    }


// ---------------------------------------------------------------------------
// CXIMPRequestCompleteEventImp::~CXIMPRequestCompleteEventImp()
// ---------------------------------------------------------------------------
//
CXIMPRequestCompleteEventImp::~CXIMPRequestCompleteEventImp()
    {
    delete iResult;

    // remove the owned objects
    for ( TInt i = 0; i < iParamArray.Count(); i++ )
        {
        SXIMPReqParam param = iParamArray[i];
        delete param.iParam;
        param.iParam = NULL;
        }
    iParamArray.Close();
    }


// ---------------------------------------------------------------------------
// CXIMPRequestCompleteEventImp::CXIMPRequestCompleteEventImp()
// ---------------------------------------------------------------------------
//
CXIMPRequestCompleteEventImp::CXIMPRequestCompleteEventImp()
    {
    }


// ---------------------------------------------------------------------------
// CXIMPRequestCompleteEventImp::CXIMPRequestCompleteEventImp()
// ---------------------------------------------------------------------------
//
CXIMPRequestCompleteEventImp::CXIMPRequestCompleteEventImp(
    TXIMPRequestId& aRequestId ) :
    iReqId( aRequestId )
    {
    }


// ---------------------------------------------------------------------------
// CXIMPRequestCompleteEventImp::ConstructL()
// ---------------------------------------------------------------------------
//
void CXIMPRequestCompleteEventImp::ConstructL( TInt aDefaultErrorValue )
    {
    iResult = CXIMPStatusImp::NewL();
    iResult->SetResultCode( aDefaultErrorValue );
    }


// ---------------------------------------------------------------------------
// CXIMPRequestCompleteEventImp::ConstructL()
// ---------------------------------------------------------------------------
//
void CXIMPRequestCompleteEventImp::ConstructL( RReadStream& aStream )
    {
    // normal params
    TPckgBuf< TXIMPRequestId > bufReqId;
    aStream.ReadL( bufReqId );
    iReqId = bufReqId();

    iResult = CXIMPStatusImp::NewL();
    iResult->InternalizeL( aStream );

    // the array with variable parameters
    XIMPApiDataObjFactory::InternalizeL( aStream, iParamArray );
    }

// ---------------------------------------------------------------------------
// Implement supported interface access.
// ---------------------------------------------------------------------------
//
XIMPIMP_IF_BASE_GET_INTERFACE_BEGIN( CXIMPRequestCompleteEventImp,
                                     MXIMPRequestCompleteEvent )
    XIMPIMP_IF_BASE_GET_CLASS( CXIMPApiEventBase, this )
XIMPIMP_IF_BASE_GET_INTERFACE_END()

XIMPIMP_IF_BASE_GET_CONST_INTERFACE_BEGIN( CXIMPRequestCompleteEventImp,
                                           MXIMPRequestCompleteEvent )
    XIMPIMP_IF_BASE_GET_CONST_CLASS( CXIMPApiEventBase, this )
XIMPIMP_IF_BASE_GET_INTERFACE_END()


// ---------------------------------------------------------------------------
// Implement methods from base event interface and base event class
// ---------------------------------------------------------------------------
//
XIMPIMP_IMPLEMENT_EVENT_BASE_METHODS( CXIMPRequestCompleteEventImp,
                                      MXIMPRequestCompleteEvent )

// ---------------------------------------------------------------------------
// CXIMPRequestCompleteEventImp::RequestId()
// ---------------------------------------------------------------------------
//
const TXIMPRequestId& CXIMPRequestCompleteEventImp::RequestId() const
    {
    return iReqId;
    }


// ---------------------------------------------------------------------------
// CXIMPRequestCompleteEventImp::CompletionResult()
// ---------------------------------------------------------------------------
//
const MXIMPStatus& CXIMPRequestCompleteEventImp::CompletionResult() const
    {
    return *iResult;
    }



// ---------------------------------------------------------------------------
// CXIMPRequestCompleteEventImp::LookupCompletionDataByType()
// ---------------------------------------------------------------------------
//
const MXIMPBase* CXIMPRequestCompleteEventImp::LookupCompletionDataByType(
    TInt32 aInterfaceId ) const
    {
    const TInt count = iParamArray.Count();
    for( TInt i = 0; i < count; i++ )
        {
        if( iParamArray[ i ].iParamType == aInterfaceId )
            {
            return &iParamArray[ i ].iParam->Base();
            }
        }

    return NULL;
    }




// ---------------------------------------------------------------------------
// CXIMPRequestCompleteEventImp::SetRequestId()
// ---------------------------------------------------------------------------
//
EXPORT_C void CXIMPRequestCompleteEventImp::SetRequestId( const TXIMPRequestId& aRequestId )
    {
    iReqId = aRequestId;
    }

// ---------------------------------------------------------------------------
// CXIMPRequestCompleteEventImp::EqualsContent
// ---------------------------------------------------------------------------
//
TBool CXIMPRequestCompleteEventImp::EqualsContent(
    const CXIMPApiEventBase& aOtherInstance ) const
    {
    const CXIMPRequestCompleteEventImp* tmp =
    TXIMPGetImpClassOrPanic< const CXIMPRequestCompleteEventImp >::From(
                                                        aOtherInstance.Base() );

    TBool same = ETrue;

    TBool x = ( iResult->ResultCode() == tmp->iResult->ResultCode() );
    same &= x;

    x = ( 0 == iResult->ProtocolResultDescription().Compare(
                tmp->iResult->ProtocolResultDescription() ) );
    same &= x;

    // check parameter arrays for equality
    TInt myCount = iParamArray.Count();
    TInt otherCount = tmp->iParamArray.Count();

    x = myCount == otherCount;
    same &= x;

    if ( x )
        {
        // don't do potentially expensive operation unless arrays are
        // have same number of elements

        for ( TInt i = 0; i < myCount; i++ )
            {
            // assumes the parameters are IN ORDER
            x = iParamArray[ i ].iParam->EqualsContent( *( tmp->iParamArray[ i ].iParam ) );
            same &= x;
            }
        }

    return same;
    }

// ---------------------------------------------------------------------------
// CXIMPRequestCompleteEventImp::ExternalizeL()
// ---------------------------------------------------------------------------
//
void CXIMPRequestCompleteEventImp::ExternalizeL( RWriteStream& aStream ) const
    {
    // normal params
    TPckgBuf< TXIMPRequestId > bufReqId( iReqId );
    aStream.WriteL( bufReqId );

    iResult->ExternalizeL( aStream );

    // the array with variable parameters
    XIMPApiDataObjFactory::ExternalizeL( aStream, iParamArray );
    }

// ---------------------------------------------------------------------------
// CXIMPRequestCompleteEventImp::AppendParamL
// ---------------------------------------------------------------------------
//
EXPORT_C void CXIMPRequestCompleteEventImp::AppendParamL( CXIMPApiDataObjBase* aObj )
    {
    SXIMPReqParam param;
    param.iParamType = aObj->Base().GetInterfaceId();
    param.iParam = aObj;
    iParamArray.AppendL( param );
    }


// ---------------------------------------------------------------------------
// CXIMPRequestCompleteEventImp::CompletionResultImp()
// ---------------------------------------------------------------------------
//
EXPORT_C CXIMPStatusImp& CXIMPRequestCompleteEventImp::CompletionResultImp()
    {
    return *iResult;
    }

// End of file