/*
* Copyright (c) 2004 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:  Tracked Presence ID entry.
*
*/

// INCLUDE FILES
#include "CPEngTrackedPresenceIDEntry.h"

#include <CPEngTrackedPresenceID2.h>
#include <MPEngPresenceAttrModel2.h>
#include <E32Std.h>



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

// -----------------------------------------------------------------------------
// CPEngTrackedPresenceIDEntry::NewLC()
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CPEngTrackedPresenceIDEntry* CPEngTrackedPresenceIDEntry::NewLC(
    const TDesC& aPresenceID,
    const TArray<TUint32>& aTypes,
    TInt aFilterFlag )
    {
    CPEngTrackedPresenceIDEntry* self = new ( ELeave ) CPEngTrackedPresenceIDEntry;
    CleanupStack::PushL( self );
    self->ConstructL( aPresenceID, aTypes, aFilterFlag );
    return self;
    }


// Destructor
CPEngTrackedPresenceIDEntry::~CPEngTrackedPresenceIDEntry()
    {
    delete iInterface;
    delete iPresenceID;
    iTrackedAttributes.Close();
    }


// -----------------------------------------------------------------------------
// CPEngTrackedPresenceIDEntry::CPEngTrackedPresenceIDEntry
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CPEngTrackedPresenceIDEntry::CPEngTrackedPresenceIDEntry()
        : iAttributesChanged( EFalse )
    {
    }


// -----------------------------------------------------------------------------
// CPEngTrackedPresenceIDEntry::ConstructL()
// Symbian OS constructor.
// -----------------------------------------------------------------------------
//
void CPEngTrackedPresenceIDEntry::ConstructL( const TDesC& aPresenceID,
                                              const TArray<TUint32>& aTypes,
                                              TInt aFilterFlag )
    {
    iFilterFlag =  aFilterFlag;
    iInterface = new ( ELeave ) CPEngTrackedPresenceID2( *this );
    iPresenceID = aPresenceID.AllocL();

    AddTrackedAttributesL( aTypes );
    }


// -----------------------------------------------------------------------------
// CPEngTrackedPresenceIDEntry::Interface()
// -----------------------------------------------------------------------------
//
CPEngTrackedPresenceID2& CPEngTrackedPresenceIDEntry::Interface()
    {
    return *iInterface;
    }


// -----------------------------------------------------------------------------
// CPEngTrackedPresenceIDEntry::PresenceID()
// Tracked presence ID.
// -----------------------------------------------------------------------------
//
TPtrC CPEngTrackedPresenceIDEntry::PresenceID() const
    {
    return *iPresenceID;
    }


// -----------------------------------------------------------------------------
// CPEngTrackedPresenceIDEntry::Compare()
// Tracked presence ID.
// -----------------------------------------------------------------------------
//
TInt CPEngTrackedPresenceIDEntry::Compare( const CPEngTrackedPresenceIDEntry& aLhs,
                                           const CPEngTrackedPresenceIDEntry& aRhs )
    {
    return aLhs.PresenceID().Compare( aRhs.PresenceID() );
    }



// -----------------------------------------------------------------------------
// CPEngTrackedPresenceIDEntry::IsOnlyTrackedAttribute()
// Tracked attributes.
// -----------------------------------------------------------------------------
//
TBool CPEngTrackedPresenceIDEntry::IsOnlyTrackedAttribute( TUint32 aType ) const
    {
    TBool result = EFalse;

    //Given attribute is only tracked attribute if
    // - there is just 1 tracked attribute
    // - and is is same as given
    if ( ( iTrackedAttributes.Count() == 1 ) &&
         ( iTrackedAttributes[ 0 ] == aType ) )
        {
        result = ETrue;
        }

    return result;
    }


// -----------------------------------------------------------------------------
// CPEngTrackedPresenceIDEntry::TrackedAttributes()
// Tracked attributes.
// -----------------------------------------------------------------------------
//
TBool CPEngTrackedPresenceIDEntry::AttributesTracked() const
    {
    return ( iTrackedAttributes.Count() != 0 );
    }



// -----------------------------------------------------------------------------
// CPEngTrackedPresenceIDEntry::AddTrackedAttributesL()
// Tracked attributes.
// -----------------------------------------------------------------------------
//
void CPEngTrackedPresenceIDEntry::AddTrackedAttributesL( const TArray<TUint32>& aTypes )
    {
    const TInt typeCount( aTypes.Count() );
    for ( TInt typeIx = 0; typeIx < typeCount; typeIx++ )
        {
        TUint32 attributeLookup( aTypes[ typeIx ] );

        TInt index = KErrNotFound;
        TInt result = iTrackedAttributes.FindInUnsignedKeyOrder( attributeLookup,
                                                                 index );
        if ( result == KErrNotFound )
            {
            User::LeaveIfError( iTrackedAttributes.Insert( attributeLookup, index ) );
            }
        }
    }



// -----------------------------------------------------------------------------
// CPEngTrackedPresenceIDEntry::RemoveTrackedAttributes()
// Tracked attributes.
// -----------------------------------------------------------------------------
//
void CPEngTrackedPresenceIDEntry::RemoveTrackedAttributes( const TArray<TUint32>& aTypes )
    {
    const TInt typeCount( aTypes.Count() );
    for ( TInt typeIx = 0; typeIx < typeCount; typeIx++ )
        {
        TUint32 attributeLookup( aTypes[ typeIx ] );

        TInt index = iTrackedAttributes.FindInUnsignedKeyOrder( attributeLookup );
        if ( index != KErrNotFound )
            {
            iTrackedAttributes.Remove( index );
            }
        }


    if ( iTrackedAttributes.Count() == 0 )
        {
        iAttributesChanged = EFalse;
        }
    }


// -----------------------------------------------------------------------------
// CPEngTrackedPresenceIDEntry::TrackedAttributes()
// Tracked attributes.
// -----------------------------------------------------------------------------
//
TArray<TUint32> CPEngTrackedPresenceIDEntry::TrackedAttributes() const
    {
    return TArray< TUint32 >( TrackedAttributesCount,
                              TrackedAttributeAt,
                              this );
    }


// -----------------------------------------------------------------------------
// CPEngTrackedPresenceIDEntry::NextTrackedAttribute()
// Tracked attributes.
// -----------------------------------------------------------------------------
//
TUint32 CPEngTrackedPresenceIDEntry::NextTrackedAttribute( TInt& aIterIx ) const
    {
    TUint32 attribute = KPEngNullAttributeType;

    if ( iTrackedAttributes.Count() > aIterIx )
        {
        attribute = iTrackedAttributes[ aIterIx ];
        aIterIx++;
        }

    return attribute;
    }



// -----------------------------------------------------------------------------
// CPEngTrackedPresenceIDEntry::SetFilterFlag()
// Filter flags.
// -----------------------------------------------------------------------------
//
void CPEngTrackedPresenceIDEntry::SetFilterFlag( TInt aFlag )
    {
    iFilterFlag = aFlag;
    }


// -----------------------------------------------------------------------------
// CPEngTrackedPresenceIDEntry::FilterFlag()
// Filter flags.
// -----------------------------------------------------------------------------
//
TInt CPEngTrackedPresenceIDEntry::FilterFlag() const
    {
    return iFilterFlag;
    }


void CPEngTrackedPresenceIDEntry::MarkAllAttributesChanged()
    {
    iAttributesChanged = ETrue;
    }


// -----------------------------------------------------------------------------
// CPEngTrackedPresenceIDEntry::ResetChangeMarks()
// Attribute change marks.
// -----------------------------------------------------------------------------
//
void CPEngTrackedPresenceIDEntry::ResetChangeMarks()
    {
    iAttributesChanged = EFalse;
    }


// -----------------------------------------------------------------------------
// CPEngTrackedPresenceIDEntry::AttributesChanged()
// Attribute change marks.
// -----------------------------------------------------------------------------
//
TBool CPEngTrackedPresenceIDEntry::AttributesChanged() const
    {
    return iAttributesChanged;
    }


// -----------------------------------------------------------------------------
// CPEngTrackedPresenceIDEntry::NextChangedAttribute()
// Attribute change marks.
// -----------------------------------------------------------------------------
//
TUint32 CPEngTrackedPresenceIDEntry::NextChangedAttribute( TInt& aIterIx ) const
    {
    if ( iAttributesChanged )
        {
        return NextTrackedAttribute( aIterIx );
        }


    return KPEngNullAttributeType;
    }


// -----------------------------------------------------------------------------
// CPEngTrackedPresenceIDEntry::TrackedAttributesCount()
// -----------------------------------------------------------------------------
//
TInt CPEngTrackedPresenceIDEntry::TrackedAttributesCount( const CBase* aThis )
    {
    const CPEngTrackedPresenceIDEntry* self =
        static_cast< const CPEngTrackedPresenceIDEntry* > ( aThis );

    return self->iTrackedAttributes.Count();
    }


// -----------------------------------------------------------------------------
// CPEngTrackedPresenceIDEntry::TrackedAttributeAt()
// -----------------------------------------------------------------------------
//
const TAny* CPEngTrackedPresenceIDEntry::TrackedAttributeAt( const CBase* aThis,
                                                             TInt aIndex )
    {
    const CPEngTrackedPresenceIDEntry* self =
        static_cast< const CPEngTrackedPresenceIDEntry* > ( aThis );

    return &self->iTrackedAttributes[ aIndex ];
    }


//  End of File