/*
* 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:  MPresenceDocument API object implementation.
*
*/

#include "presenceinfoimp.h"
#include "personpresenceinfoimp.h"
#include "servicepresenceinfoimp.h"
#include "devicepresenceinfoimp.h"
#include "presenceapidataobjfactory.h"
#include "presencetypehelpers.h"
#include "ximpobjecthelpers.h"
#include "presenceinfofilterimp.h"

// ============================ MEMBER FUNCTIONS =============================

// ---------------------------------------------------------------------------
// CPresenceInfoImp::NewLC()
// ---------------------------------------------------------------------------
//
EXPORT_C CPresenceInfoImp* CPresenceInfoImp::NewLC()
    {
    CPresenceInfoImp* self = new( ELeave ) CPresenceInfoImp;
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }


// ---------------------------------------------------------------------------
// CPresenceInfoImp::NewL()
// ---------------------------------------------------------------------------
//
EXPORT_C CPresenceInfoImp* CPresenceInfoImp::NewL()
    {
    CPresenceInfoImp* self = NewLC();
    CleanupStack::Pop( self );
    return self;
    }


// ---------------------------------------------------------------------------
// CPresenceInfoImp::~CPresenceInfoImp()
// ---------------------------------------------------------------------------
//
CPresenceInfoImp::~CPresenceInfoImp()
    {
    delete iPersonPresence;
    iServicePresences.ResetAndDestroy();
    iDevicePresences.ResetAndDestroy();
    }

// ---------------------------------------------------------------------------
// CPresenceInfoImp::CPresenceInfoImp()
// ---------------------------------------------------------------------------
//
CPresenceInfoImp::CPresenceInfoImp()
    {
    }


// ---------------------------------------------------------------------------
// CPresenceInfoImp::ConstructL()
// ---------------------------------------------------------------------------
//
void CPresenceInfoImp::ConstructL()
    {
    iPersonPresence = CPersonPresenceInfoImp::NewLC();
    CleanupStack::Pop( iPersonPresence );
    }

// ---------------------------------------------------------------------------
// CPresenceInfoImp::NewFromStreamLC()
// ---------------------------------------------------------------------------
//
XIMPIMP_IMPLEMENT_DATAOBJ_NEWFROMSTREAM( CPresenceInfoImp )


// ---------------------------------------------------------------------------
// Implement supported interface access.
// ---------------------------------------------------------------------------
//
XIMPIMP_IF_BASE_GET_INTERFACE_BEGIN( CPresenceInfoImp, 
                                     MPresenceInfo )
XIMPIMP_IF_BASE_GET_INTERFACE_END()


XIMPIMP_IF_BASE_GET_CONST_INTERFACE_BEGIN( CPresenceInfoImp, 
                                           MPresenceInfo )
XIMPIMP_IF_BASE_GET_INTERFACE_END()

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

    TBool same = ETrue;
    TBool x = iPersonPresence->EqualsContent( *tmp->iPersonPresence );
    same &= x;
    
    x = TXIMPEqualsContent< CServicePresenceInfoImp >::Array( iServicePresences, tmp->iServicePresences );
    same &= x;

    x = TXIMPEqualsContent< CDevicePresenceInfoImp >::Array( iDevicePresences, tmp->iDevicePresences );
    same &= x;
    
    return same;
    }

// ---------------------------------------------------------------------------
// CPresenceInfoImp::ExternalizeL()
// ---------------------------------------------------------------------------
//
EXPORT_C void CPresenceInfoImp::ExternalizeL( RWriteStream& aStream ) const
    {
    iPersonPresence->ExternalizeL( aStream );

    CPresenceApiDataObjFactory::ExternalizeL< CServicePresenceInfoImp >
        ( aStream, iServicePresences );

    CPresenceApiDataObjFactory::ExternalizeL< CDevicePresenceInfoImp >
        ( aStream, iDevicePresences );
    }


// ---------------------------------------------------------------------------
// CPresenceInfoImp::InternalizeL()
// ---------------------------------------------------------------------------
//
EXPORT_C void CPresenceInfoImp::InternalizeL( RReadStream& aStream )
    {
    CPersonPresenceInfoImp* tmp = CPersonPresenceInfoImp::NewLC();
    tmp->InternalizeL( aStream );
    delete iPersonPresence;
    iPersonPresence = tmp;
    CleanupStack::Pop( tmp );

    iServicePresences.ResetAndDestroy();
    CPresenceApiDataObjFactory::InternalizeL< CServicePresenceInfoImp >
        ( aStream, iServicePresences );
    
    iDevicePresences.ResetAndDestroy();
    CPresenceApiDataObjFactory::InternalizeL< CDevicePresenceInfoImp >
        ( aStream, iDevicePresences );
    }
    

// ---------------------------------------------------------------------------
// From MPresenceInfo class.
// CPresenceInfoImp::PersonPresence()
// ---------------------------------------------------------------------------
//
const MPersonPresenceInfo* CPresenceInfoImp::PersonPresence() const
    {
    return iPersonPresence;
    }
    
// ---------------------------------------------------------------------------
// From MPresenceInfo class.
// CPresenceInfoImp::PersonPresence()
// ---------------------------------------------------------------------------
//
MPersonPresenceInfo* CPresenceInfoImp::PersonPresence()
    {
    return iPersonPresence;
    }    


// ---------------------------------------------------------------------------
// From MPresenceInfo class.
// CPresenceInfoImp::SetPersonPresenceL()
// ---------------------------------------------------------------------------
//
void CPresenceInfoImp::SetPersonPresenceL( 
    MPersonPresenceInfo* aPersonPresence )
    {
    User::LeaveIfError( aPersonPresence == NULL ? KErrArgument : KErrNone );

    CPersonPresenceInfoImp* personPresenceImp =
    TXIMPGetImpClassOrPanic< CPersonPresenceInfoImp >::From( *aPersonPresence );
    
    delete iPersonPresence;
    iPersonPresence = personPresenceImp;
    }


// ---------------------------------------------------------------------------
// From MPresenceInfo class.
// CPresenceInfoImp::ServicePresenceCount()
// ---------------------------------------------------------------------------
//
TInt CPresenceInfoImp::ServicePresenceCount() const
    {
    return iServicePresences.Count();
    }
    

// ---------------------------------------------------------------------------
// From MPresenceInfo class.
// CPresenceInfoImp::ServicePresenceAt()
// ---------------------------------------------------------------------------
//
const MServicePresenceInfo& CPresenceInfoImp::ServicePresenceAt(
    TInt aIndex ) const
    {
    return *iServicePresences[ aIndex ];    
    }


// ---------------------------------------------------------------------------
// From MPresenceInfo class.
// CPresenceInfoImp::LookupServicePresenceByServiceType()
// ---------------------------------------------------------------------------
//
void CPresenceInfoImp::LookupServicePresenceByServiceType( 
    MServicePresenceInfo*& aServicePresence,
    const TDesC8& aMatch ) const
    {
    TInt start = KErrNotFound;

    // search from start
    if ( aServicePresence )
        {
        TBool found = EFalse;
        for ( TInt i = 0; ( i < iServicePresences.Count() ) && ( ! found ); i++ )
            {
            CXIMPApiDataObjBase* gotObj = TXIMPGetImpClassOrPanic< CXIMPApiDataObjBase >::From( *aServicePresence );
            CXIMPApiDataObjBase* obj = iServicePresences[ i ];
            if ( &(gotObj->Base()) == &(obj->Base()) )
                {
                found = ETrue;
                start = i;
                }
            }
        }

    start = start == KErrNotFound ? 0 : start;
    aServicePresence = NULL;

    for ( TInt i = start; i < iServicePresences.Count(); i++ )
        {
        CServicePresenceInfoImp* srvInfo = iServicePresences[ i ];

        if ( KErrNotFound != srvInfo->ServiceType().MatchF( aMatch ) )
            {
            // found match, return it
            aServicePresence = srvInfo;
            return;
            }
        }
    }


// ---------------------------------------------------------------------------
// From MPresenceInfo class.
// CPresenceInfoImp::AddServicePresenceL()
// ---------------------------------------------------------------------------
//
void CPresenceInfoImp::AddServicePresenceL( 
    MServicePresenceInfo* aServicePresence )
    {
    User::LeaveIfError( aServicePresence == NULL ? KErrArgument : KErrNone );
    
    CServicePresenceInfoImp* servicePresenceImp =
    TXIMPGetImpClassOrPanic< CServicePresenceInfoImp >::From( *aServicePresence );

    iServicePresences.AppendL( servicePresenceImp );
    }


// ---------------------------------------------------------------------------
// From MPresenceInfo class.
// CPresenceInfoImp::DevicePresenceCount()
// ---------------------------------------------------------------------------
//
TInt CPresenceInfoImp::DevicePresenceCount() const
    {
    return iDevicePresences.Count();
    }


// ---------------------------------------------------------------------------
// From MPresenceInfo class.
// CPresenceInfoImp::DevicePresenceAt()
// ---------------------------------------------------------------------------
//
const MDevicePresenceInfo& CPresenceInfoImp::DevicePresenceAt(
    TInt aIndex ) const
    {
    return *iDevicePresences[ aIndex ];
    }
        

// ---------------------------------------------------------------------------
// From MPresenceInfo class.
// CPresenceInfoImp::AddDevicePresenceL()
// ---------------------------------------------------------------------------
//
void CPresenceInfoImp::AddDevicePresenceL( 
    MDevicePresenceInfo* aDevicePresence )
    {
    User::LeaveIfError( aDevicePresence == NULL ? KErrArgument : KErrNone );

    CDevicePresenceInfoImp* devicePresenceImp =
    TXIMPGetImpClassOrPanic< CDevicePresenceInfoImp >::From( *aDevicePresence );

    iDevicePresences.AppendL( devicePresenceImp );
    }

// ---------------------------------------------------------------------------
// CPresenceInfoImp::FilteredInfoLC()
// ---------------------------------------------------------------------------
//
EXPORT_C CPresenceInfoImp* CPresenceInfoImp::FilteredInfoLC(
        const CPresenceInfoFilterImp& aFilter ) const
    {
    CPresenceInfoImp* info = TXIMPObjectCloner< CPresenceInfoImp >::CloneLC( *this );

    // the info imps know how to filter themselves
    info->iPersonPresence->FilterWithL( aFilter );

    for ( TInt i = 0; i < iServicePresences.Count(); i++ )
        {
        info->iServicePresences[ i ]->FilterWithL( aFilter );
        }
    
    for ( TInt i = 0; i < iDevicePresences.Count(); i++ )
        {
        info->iDevicePresences[ i ]->FilterWithL( aFilter );
        }

    return info;
    }


// End of file