/*

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

*

*/

#include "presencewatcherinfoimp.h"

#include "ximpidentityimp.h"

#include "ximprbufhelpers.h"

#include "ximpobjecthelpers.h"

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

// ---------------------------------------------------------------------------

// CPresenceWatcherInfoImp::NewLC()

// ---------------------------------------------------------------------------

//

EXPORT_C CPresenceWatcherInfoImp* CPresenceWatcherInfoImp::NewLC(

                            const MPresenceWatcherInfo::TWatcherType aType,

                            const MXIMPIdentity& aIdentity,

                            const TDesC16& aDisplayName )

    {

    CPresenceWatcherInfoImp* self = new( ELeave ) CPresenceWatcherInfoImp;

    CleanupStack::PushL( self );

    self->ConstructL( aType, aIdentity, aDisplayName );

    return self;

    }

// ---------------------------------------------------------------------------

// CPresenceWatcherInfoImp::NewLC()

// ---------------------------------------------------------------------------

//

EXPORT_C CPresenceWatcherInfoImp* CPresenceWatcherInfoImp::NewLC()

    {

    CPresenceWatcherInfoImp* self = new( ELeave ) CPresenceWatcherInfoImp;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// ---------------------------------------------------------------------------

// CPresenceWatcherInfoImp::NewL()

// ---------------------------------------------------------------------------

//

EXPORT_C CPresenceWatcherInfoImp* CPresenceWatcherInfoImp::NewL()

    {

    CPresenceWatcherInfoImp* self = NewLC();

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// CPresenceWatcherInfoImp::NewFromStreamLC()

// ---------------------------------------------------------------------------

//

XIMPIMP_IMPLEMENT_DATAOBJ_NEWFROMSTREAM( CPresenceWatcherInfoImp )

// ---------------------------------------------------------------------------

// Implement supported interface access.

// ---------------------------------------------------------------------------

//

XIMPIMP_IF_BASE_GET_INTERFACE_BEGIN( CPresenceWatcherInfoImp, 

                                     MPresenceWatcherInfo )

XIMPIMP_IF_BASE_GET_INTERFACE_END()

XIMPIMP_IF_BASE_GET_CONST_INTERFACE_BEGIN( CPresenceWatcherInfoImp, 

                                           MPresenceWatcherInfo )

XIMPIMP_IF_BASE_GET_INTERFACE_END()

// ---------------------------------------------------------------------------

// CPresenceWatcherInfoImp::~CPresenceWatcherInfoImp()

// ---------------------------------------------------------------------------

//

CPresenceWatcherInfoImp::~CPresenceWatcherInfoImp()

    {

    iDisplayName.Close();

    delete iIdentity;

    }

// ---------------------------------------------------------------------------

// CPresenceWatcherInfoImp::CPresenceWatcherInfoImp()

// ---------------------------------------------------------------------------

//

CPresenceWatcherInfoImp::CPresenceWatcherInfoImp()

    {

    }

// ---------------------------------------------------------------------------

// CPresenceWatcherInfoImp::ConstructL()

// ---------------------------------------------------------------------------

//

void CPresenceWatcherInfoImp::ConstructL()

    {

    iDisplayName.CreateL( 0 );

    iIdentity = CXIMPIdentityImp::NewLC();

    CleanupStack::Pop( iIdentity );

    }

// ---------------------------------------------------------------------------

// CPresenceWatcherInfoImp::ConstructL()

// ---------------------------------------------------------------------------

//

void CPresenceWatcherInfoImp::ConstructL(

                            const MPresenceWatcherInfo::TWatcherType aType,

                            const MXIMPIdentity& aIdentity,

                            const TDesC16& aDisplayName )

    {

    iType = aType;

    const CXIMPIdentityImp* sourceIdentity =

    TXIMPGetImpClassOrPanic< const CXIMPIdentityImp >::From( aIdentity );

    iIdentity = TXIMPObjectCloner< CXIMPIdentityImp >::CloneL( *sourceIdentity );

    iDisplayName.CreateL( aDisplayName );

    }

// ---------------------------------------------------------------------------

// CPresenceWatcherInfoImp::ExternalizeL()

// ---------------------------------------------------------------------------

//

void CPresenceWatcherInfoImp::ExternalizeL( RWriteStream& aStream ) const

    {

    aStream.WriteInt32L( iType );

    iIdentity->ExternalizeL( aStream );

    XIMPRBuf16Helper::ExternalizeL( iDisplayName, aStream );

    }

// ---------------------------------------------------------------------------

// CPresenceWatcherInfoImp::InternalizeL()

// ---------------------------------------------------------------------------

//

EXPORT_C void CPresenceWatcherInfoImp::InternalizeL( RReadStream& aStream )

    {

    iType = ( MPresenceWatcherInfo::TWatcherType ) aStream.ReadInt32L();

    iIdentity->InternalizeL( aStream );

    XIMPRBuf16Helper::InternalizeL( iDisplayName, aStream );

    }

// ---------------------------------------------------------------------------

// From MPresenceWatcherInfo class.

// CPresenceWatcherInfoImp::WatcherId()

// ---------------------------------------------------------------------------

//

const MXIMPIdentity& CPresenceWatcherInfoImp::WatcherId() const

    {

    return *iIdentity;

    }

// ---------------------------------------------------------------------------

// From MPresenceWatcherInfo class.

// CPresenceWatcherInfoImp::WatcherDisplayName()

// ---------------------------------------------------------------------------

//

const TDesC16& CPresenceWatcherInfoImp::WatcherDisplayName() const

    {

    return iDisplayName;

    }

// ---------------------------------------------------------------------------

// From MPresenceWatcherInfo class.

// CPresenceWatcherInfoImp::WatcherType()

// ---------------------------------------------------------------------------

//

MPresenceWatcherInfo::TWatcherType CPresenceWatcherInfoImp::WatcherType() const

    {

    return iType;

    }    

// ---------------------------------------------------------------------------

// From MPresenceWatcherInfo class.

// CPresenceWatcherInfoImp::SetWatcherIdL()

// ---------------------------------------------------------------------------

//

void CPresenceWatcherInfoImp::SetWatcherIdL( MXIMPIdentity* aIdentity )

    {

    User::LeaveIfError( aIdentity == NULL ? KErrArgument : KErrNone );

    CXIMPIdentityImp* identityImp =

    TXIMPGetImpClassOrPanic< CXIMPIdentityImp>::From( *aIdentity );

    delete iIdentity;

    iIdentity = identityImp; 

    }    

// ---------------------------------------------------------------------------

// From MPresenceWatcherInfo class.

// CPresenceWatcherInfoImp::SetWatcherDisplayNameL()

// ---------------------------------------------------------------------------

//

void CPresenceWatcherInfoImp::SetWatcherDisplayNameL( 

    const TDesC16& aDisplayName )

    {

    HBufC16* displayNameBuf = aDisplayName.AllocL();

    iDisplayName.Close();

    iDisplayName.Assign( displayNameBuf );

    }    

// ---------------------------------------------------------------------------

// From MPresenceWatcherInfo class.

// CPresenceWatcherInfoImp::SetWatcherTypeL()

// ---------------------------------------------------------------------------

//

void CPresenceWatcherInfoImp::SetWatcherTypeL( 

    MPresenceWatcherInfo::TWatcherType aType )

    {

    iType = aType;

    }    

// ---------------------------------------------------------------------------

// CPresenceWatcherInfoImp::SetIdentityL()

// ---------------------------------------------------------------------------

//

EXPORT_C void CPresenceWatcherInfoImp::SetIdentity( CXIMPIdentityImp* aIdentity )

    {

    delete iIdentity;

    iIdentity = aIdentity;

    }

// ---------------------------------------------------------------------------

// CPresenceWatcherInfoImp::SetIdentityL()

// ---------------------------------------------------------------------------

//

EXPORT_C void CPresenceWatcherInfoImp::SetDisplayName( HBufC16* aDisplayName )

    {

    iDisplayName.Close();

    iDisplayName.Assign( aDisplayName );

    }

// ---------------------------------------------------------------------------

// CPresenceWatcherInfoImp::GroupIdLinearOrder()

// ---------------------------------------------------------------------------

//

EXPORT_C TInt CPresenceWatcherInfoImp::IdLinearOrder(

        const CPresenceWatcherInfoImp& aA,

        const CPresenceWatcherInfoImp& aB )

    {

    return aA.IdentityImp().Compare( aB.IdentityImp() );

    }

// ---------------------------------------------------------------------------

// CPresenceWatcherInfoImp::Identity()

// ---------------------------------------------------------------------------

//

EXPORT_C const CXIMPIdentityImp& CPresenceWatcherInfoImp::IdentityImp() const

    {

    return *iIdentity;

    }

// ---------------------------------------------------------------------------

// CPresenceWatcherInfoImp::EqualsContent()

// ---------------------------------------------------------------------------

//

TBool CPresenceWatcherInfoImp::EqualsContent( 

    const CXIMPApiDataObjBase& aOtherInstance ) const

    {

    const CPresenceWatcherInfoImp* tmp =

    TXIMPGetImpClassOrPanic< const CPresenceWatcherInfoImp >::From( 

                                                        aOtherInstance.Base() );

    TBool same = ETrue;

    TBool x;

    x = iIdentity->EqualsContent( *( tmp->iIdentity ) );

    same &= x;

    x = 0 == iDisplayName.Compare( tmp->iDisplayName );

    same &= x;

    x = iType == iType;

    same &= x;

    // add more comparisons in a similar way...

    return same;

    }

// End of file