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

#include "presentitygroupcontenteventimp.h"
#include "presentitygroupmemberinfoimp.h"
#include "ximpidentityimp.h"
#include "ximpdatasubscriptionstateimp.h"
#include "ximpobjecthelpers.h"
#include <s32strm.h>


// ---------------------------------------------------------------------------
// CPresentityGroupContentEventImp::NewLC()
// ---------------------------------------------------------------------------
//
EXPORT_C CPresentityGroupContentEventImp* CPresentityGroupContentEventImp::NewLC(
        CXIMPIdentityImp& aGroupId,
        RPrGrpMemInfoImpArray* aAdded,
        RPrGrpMemInfoImpArray* aUpdated,
        RPrGrpMemInfoImpArray* aRemoved,
        CXIMPDataSubscriptionStateImp* aState
        )
    {
    CPresentityGroupContentEventImp* self = new( ELeave ) CPresentityGroupContentEventImp();
    CleanupStack::PushL( self );
    self->ConstructL( aGroupId, aAdded, aUpdated, aRemoved, aState );
    return self;
    }

// ---------------------------------------------------------------------------
// CPresentityGroupContentEventImp::NewLC()
// ---------------------------------------------------------------------------
//
EXPORT_C CPresentityGroupContentEventImp* CPresentityGroupContentEventImp::NewLC(
        CXIMPIdentityImp& aGroupId,
        RPrGrpMemInfoImpArray* aAdded,
        RPrGrpMemInfoImpArray* aUpdated,
        RPrGrpMemInfoImpArray* aRemoved,
        RPrGrpMemInfoImpArray* aCurrent,
        CXIMPDataSubscriptionStateImp* aState
        )
    {
    CPresentityGroupContentEventImp* self = new( ELeave ) CPresentityGroupContentEventImp();
    CleanupStack::PushL( self );
    if( aCurrent )
        {
        self->ConstructL( aGroupId, aAdded, aUpdated, aRemoved, aCurrent, aState );
        }
    else
        {
        self->ConstructL( aGroupId, aAdded, aUpdated, aRemoved, aState );
        }
    return self;
    }
// ---------------------------------------------------------------------------
// CPresentityGroupContentEventImp::NewL()
// ---------------------------------------------------------------------------
//
EXPORT_C CPresentityGroupContentEventImp* CPresentityGroupContentEventImp::NewL(
        CXIMPIdentityImp& aGroupId,
        RPrGrpMemInfoImpArray* aAdded,
        RPrGrpMemInfoImpArray* aUpdated,
        RPrGrpMemInfoImpArray* aRemoved,
        RPrGrpMemInfoImpArray* aCurrent,
        CXIMPDataSubscriptionStateImp* aState
        )
    {
    CPresentityGroupContentEventImp* self = 
        NewLC( aGroupId, aAdded, aUpdated, aRemoved, aCurrent, aState );
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// CPresentityGroupContentEventImp::NewFromStreamLC()
// ---------------------------------------------------------------------------
//
CXIMPApiEventBase* CPresentityGroupContentEventImp::NewFromStreamLC( RReadStream& aStream )
    {
    CPresentityGroupContentEventImp* self = new( ELeave ) CPresentityGroupContentEventImp();
    CleanupStack::PushL( self );
    self->ConstructL( aStream );
    return self;
    }

// ---------------------------------------------------------------------------
// CPresentityGroupContentEventImp::~CPresentityGroupContentEventImp()
// ---------------------------------------------------------------------------
//
CPresentityGroupContentEventImp::~CPresentityGroupContentEventImp()
    {
    delete iGroupId;

    if( iConstructedFromStream )
        {
        delete iAddedMembers;
        delete iUpdatedMembers;
        delete iRemovedMembers;
        delete iCurrentMembers;
        iCurrentMembers = NULL;  // must be null to skip double deletion below
        }

    if ( iOwnsCurrentMembersArray )
        {
        delete iCurrentMembers;
        }

    delete iSubscriptionState;
    }

// ---------------------------------------------------------------------------
// CPresentityGroupContentEventImp::CPresentityGroupContentEventImp()
// ---------------------------------------------------------------------------
//
CPresentityGroupContentEventImp::CPresentityGroupContentEventImp()
    {
    }


// ---------------------------------------------------------------------------
// CPresentityGroupContentEventImp::ConstructL()
// ---------------------------------------------------------------------------
//
void CPresentityGroupContentEventImp::ConstructL(
        CXIMPIdentityImp& aGroupId,
        RPrGrpMemInfoImpArray* aAdded,
        RPrGrpMemInfoImpArray* aUpdated,
        RPrGrpMemInfoImpArray* aRemoved,
        CXIMPDataSubscriptionStateImp* aState
         )
    {
    iGroupId = TXIMPObjectCloner< CXIMPIdentityImp >::CloneL( aGroupId );
    iAddedMembers = aAdded;
    iUpdatedMembers = aUpdated;
    iRemovedMembers = aRemoved;

    iCurrentMembers = new ( ELeave ) RPrGrpMemInfoImpArray;
    iOwnsCurrentMembersArray = ETrue;
    
    iSubscriptionState = aState;
    }

// ---------------------------------------------------------------------------
// CPresentityGroupContentEventImp::ConstructL()
// ---------------------------------------------------------------------------
//
void CPresentityGroupContentEventImp::ConstructL(
        CXIMPIdentityImp& aGroupId,
        RPrGrpMemInfoImpArray* aAdded,
        RPrGrpMemInfoImpArray* aUpdated,
        RPrGrpMemInfoImpArray* aRemoved,
        RPrGrpMemInfoImpArray* aCurrent,
        CXIMPDataSubscriptionStateImp* aState )
    {
    iGroupId = TXIMPObjectCloner< CXIMPIdentityImp >::CloneL( aGroupId );
    iAddedMembers = aAdded;
    iUpdatedMembers = aUpdated;
    iRemovedMembers = aRemoved;
    iCurrentMembers = aCurrent;

    iSubscriptionState = aState;
    }

// ---------------------------------------------------------------------------
// CPresentityGroupContentEventImp::ConstructL()
// ---------------------------------------------------------------------------
//
void CPresentityGroupContentEventImp::ConstructL( RReadStream& aStream )
    {
    iConstructedFromStream = ETrue;
    iAddedMembers = new ( ELeave ) RPrGrpMemInfoImpArray;
    iUpdatedMembers = new ( ELeave ) RPrGrpMemInfoImpArray;
    iRemovedMembers = new ( ELeave ) RPrGrpMemInfoImpArray;
    iCurrentMembers = new ( ELeave ) RPrGrpMemInfoImpArray;

    iGroupId = CXIMPIdentityImp::NewLC();
    CleanupStack::Pop( 1 ); // iGroupId

    iGroupId->InternalizeL( aStream );
    FillArrayFromStreamL( *iAddedMembers, aStream );
    FillArrayFromStreamL( *iUpdatedMembers, aStream );
    FillArrayFromStreamL( *iRemovedMembers, aStream );
    FillArrayFromStreamL( *iCurrentMembers, aStream );


    iSubscriptionState = CXIMPDataSubscriptionStateImp::NewL();
    iSubscriptionState->InternalizeL( aStream );
    }

// ---------------------------------------------------------------------------
// Implement supported interface access.
// ---------------------------------------------------------------------------
//
XIMPIMP_IF_BASE_GET_INTERFACE_BEGIN( CPresentityGroupContentEventImp,
                                     MPresentityGroupContentEvent )
    XIMPIMP_IF_BASE_GET_CLASS( CXIMPApiEventBase, this )
XIMPIMP_IF_BASE_GET_INTERFACE_END()

XIMPIMP_IF_BASE_GET_CONST_INTERFACE_BEGIN( CPresentityGroupContentEventImp,
                                           MPresentityGroupContentEvent )
    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( CPresentityGroupContentEventImp,
                                      MPresentityGroupContentEvent )


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

    TBool same = ETrue;

    TBool x = 0 == GroupId().Identity().Compare( tmp->GroupId().Identity() );
    same &= x;

    x = CompareArrays( iAddedMembers, tmp->iAddedMembers );
    same &= x;

    x = CompareArrays( iUpdatedMembers, tmp->iUpdatedMembers );
    same &= x;

    x = CompareArrays( iRemovedMembers, tmp->iRemovedMembers );
    same &= x;

    x = CompareArrays( iCurrentMembers, tmp->iCurrentMembers );
    same &= x;

    x = iSubscriptionState->EqualsContent( *tmp->iSubscriptionState );
    same &= x;

    return same;
    }

// ---------------------------------------------------------------------------
// CPresentityGroupContentEventImp::CompareArrays
// ---------------------------------------------------------------------------
//
TBool CPresentityGroupContentEventImp::CompareArrays(
        RPrGrpMemInfoImpArray* aA, RPrGrpMemInfoImpArray* aB )
    {
    TBool same = ETrue;

    TBool x;
    x = aA->Count() == aB->Count();   // counts must match
    same &= x;

    if ( ! same )
        {
        // don't bother checking further if counts mismatch
        return same;
        }

    // now check whole array, arrays have equal length
    for ( TInt i = 0; i < aA->Count(); i++ )
        {
        x = 0 == ( (*aA)[ i ]->IdentityImp().Compare(
                    (*aB)[ i ]->IdentityImp() ) );
        same &= x;

        x = 0 == ( (*aA)[ i ]->GroupMemberDisplayName().Compare(
                    (*aB)[ i ]->GroupMemberDisplayName() ) );
        same &= x;
        }

    return same;
    }

// ---------------------------------------------------------------------------
// From class CXIMPApiEventBase.
// CPresentityGroupContentEventImp::ExternalizeL()
// ---------------------------------------------------------------------------
//
void CPresentityGroupContentEventImp::ExternalizeL( RWriteStream& aStream ) const
    {
    iGroupId->ExternalizeL( aStream );
    WriteArrayToStreamL( *iAddedMembers, aStream );
    WriteArrayToStreamL( *iUpdatedMembers, aStream );
    WriteArrayToStreamL( *iRemovedMembers, aStream );
    WriteArrayToStreamL( *iCurrentMembers, aStream );

    iSubscriptionState->ExternalizeL( aStream );
    }


// ---------------------------------------------------------------------------
// From class MPresentityGroupContentEvent.
// CPresentityGroupContentEventImp::GroupId()
// ---------------------------------------------------------------------------
//
const MXIMPIdentity& CPresentityGroupContentEventImp::GroupId() const
    {
    return *iGroupId;
    }

// ---------------------------------------------------------------------------
// From class MPresentityGroupContentEvent.
// CPresentityGroupContentEventImp::NewMembersCount()
// ---------------------------------------------------------------------------
//
TInt CPresentityGroupContentEventImp::NewMembersCount() const
    {
    return iAddedMembers->Count();
    }

// ---------------------------------------------------------------------------
// From class MPresentityGroupContentEvent.
// CPresentityGroupContentEventImp::NewMember()
// ---------------------------------------------------------------------------
//
const MPresentityGroupMemberInfo& 
    CPresentityGroupContentEventImp::NewMember( TInt aIndex ) const
    {
    return *(*iAddedMembers)[ aIndex ];
    }

// ---------------------------------------------------------------------------
// From class MPresentityGroupContentEvent.
// CPresentityGroupContentEventImp::UpdatedMembersCount()
// ---------------------------------------------------------------------------
//
TInt CPresentityGroupContentEventImp::UpdatedMembersCount() const
    {
    return iUpdatedMembers->Count();
    }

// ---------------------------------------------------------------------------
// From class MPresentityGroupContentEvent.
// CPresentityGroupContentEventImp::UpdatedMember()
// ---------------------------------------------------------------------------
//
const MPresentityGroupMemberInfo& 
    CPresentityGroupContentEventImp::UpdatedMember( TInt aIndex ) const
    {
    return *(*iUpdatedMembers)[ aIndex ];
    }

// ---------------------------------------------------------------------------
// From class MPresentityGroupContentEvent.
// CPresentityGroupContentEventImp::DisappearedMembersCount()
// ---------------------------------------------------------------------------
//
TInt CPresentityGroupContentEventImp::DisappearedMembersCount() const
    {
    return iRemovedMembers->Count();
    }

// ---------------------------------------------------------------------------
// From class MPresentityGroupContentEvent.
// CPresentityGroupContentEventImp::DisappearedMember()
// ---------------------------------------------------------------------------
//
const MPresentityGroupMemberInfo& 
    CPresentityGroupContentEventImp::DisappearedMember( TInt aIndex ) const
    {
    return *(*iRemovedMembers)[ aIndex ];
    }

// ---------------------------------------------------------------------------
// From class MPresentityGroupContentEvent.
// CPresentityGroupContentEventImp::CurrentMembersCount()
// ---------------------------------------------------------------------------
//
TInt CPresentityGroupContentEventImp::CurrentMembersCount() const
    {
    return iCurrentMembers->Count();
    }

// ---------------------------------------------------------------------------
// From class MPresentityGroupContentEvent.
// CPresentityGroupContentEventImp::CurrentMember()
// ---------------------------------------------------------------------------
//
const MPresentityGroupMemberInfo& 
    CPresentityGroupContentEventImp::CurrentMember( TInt aIndex ) const
    {
    return *(*iCurrentMembers)[ aIndex ];
    }

// ---------------------------------------------------------------------------
// From class MPresentityGroupContentEvent.
// CPresentityGroupContentEventImp::Status()
// ---------------------------------------------------------------------------
//
const MXIMPDataSubscriptionState&
    CPresentityGroupContentEventImp::DataSubscriptionState() const
    {
    return *iSubscriptionState;
    }


// ---------------------------------------------------------------------------
// CPresentityGroupContentEventImp::WriteArrayToStreamL()
// ---------------------------------------------------------------------------
//
void CPresentityGroupContentEventImp::WriteArrayToStreamL(
        RPrGrpMemInfoImpArray& aArray, RWriteStream& aStream ) const
    {
    TInt count = aArray.Count();
    aStream.WriteInt32L( count );
        {
        for( TInt a = 0; a < count; ++a )
            {
            aArray[ a ]->ExternalizeL( aStream );
            }
        }
    }

// ---------------------------------------------------------------------------
// CPresentityGroupContentEventImp::FillArrayFromStreamL
// ---------------------------------------------------------------------------
//
void CPresentityGroupContentEventImp::FillArrayFromStreamL(
        RPrGrpMemInfoImpArray& aArray,
        RReadStream& aStream )
    {
    TInt count = aStream.ReadInt32L();
    for( TInt a = 0; a < count; ++a )
        {
        // the stream MUST be in order (since it was externalized by this class)
        CPresentityGroupMemberInfoImp* newInfo = CPresentityGroupMemberInfoImp::NewLC();
        newInfo->InternalizeL( aStream );
        aArray.AppendL( newInfo );
        CleanupStack::Pop(); // newInfo
        }
    }

// End of file