/*

* 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 collection.

*

*/

// INCLUDE FILES

#include <CPEngTrackedPresenceIDs2.h>

#include <CPEngTrackedPresenceID2.h>

#include <MPEngPresenceAttrModel2.h>

#include <E32Std.h>

#include "CPEngTrackedPresenceIDCollection.h"

#include "CPEngTrackedPresenceIDEntry.h"

#include "CPEngTrackedPresenceIDEntryLookUp.h"

#include "TPEngTrackedPresenceEntryFilter.h"

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

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

// CPEngTrackedPresenceIDCollection::NewL()

// Two-phased constructor.

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

//

CPEngTrackedPresenceIDCollection* CPEngTrackedPresenceIDCollection::NewL()

    {

    CPEngTrackedPresenceIDCollection* self = new ( ELeave ) CPEngTrackedPresenceIDCollection;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CPEngTrackedPresenceIDCollection::~CPEngTrackedPresenceIDCollection()

    {

    delete iInterface;

    delete iPresenceIdLookup;

    delete iEntryListFilter;

    // Ondra, remove all tracked Ids

    RemoveAllTrackedIds();

    }

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

// CPEngTrackedPresenceIDCollection::CPEngTrackedPresenceIDCollection

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CPEngTrackedPresenceIDCollection::CPEngTrackedPresenceIDCollection()

    {

    }

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

// CPEngTrackedPresenceIDCollection::ConstructL()

// Symbian OS constructor.

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

//

void CPEngTrackedPresenceIDCollection::ConstructL()

    {

    iInterface = new ( ELeave ) CPEngTrackedPresenceIDs2( *this );

    iPresenceIdLookup = CPEngTrackedPresenceIDEntryLookUp::NewL();

    iEntryListFilter = new ( ELeave ) TPEngTrackedPresenceEntryFilter( iTrackedIDs,

                                                                       EIncludedToList );

    }

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

// CPEngTrackedPresenceIDCollection::Interface()

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

//

CPEngTrackedPresenceIDs2& CPEngTrackedPresenceIDCollection::Interface()

    {

    return *iInterface;

    }

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

// CPEngTrackedPresenceIDCollection::TrackedPresenceIDsCount()

// Tracked presence IDs.

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

//

TInt CPEngTrackedPresenceIDCollection::TrackedPresenceIDsCount() const

    {

    return iTrackedIDs.Count();

    }

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

// CPEngTrackedPresenceIDCollection::FindTrackedPresenceID()

// Tracked presence IDs.

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

//

const CPEngTrackedPresenceIDEntry* CPEngTrackedPresenceIDCollection::FindTrackedPresenceID(

    const TDesC& aPresenceID ) const

    {

    TLinearOrder< CPEngTrackedPresenceIDEntry > order ( CPEngTrackedPresenceIDEntry::Compare );

    iPresenceIdLookup->SetLookupKey( aPresenceID );

    TInt index = iTrackedIDs.FindInOrder( iPresenceIdLookup, order );

    iPresenceIdLookup->Reset();

    const CPEngTrackedPresenceIDEntry* presenceID = NULL;

    if ( index != KErrNotFound )

        {

        presenceID = iTrackedIDs[ index ];

        }

    return presenceID;

    }

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

// CPEngTrackedPresenceIDCollection::TrackedPresenceID()

// Tracked presence IDs.

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

//

const CPEngTrackedPresenceIDEntry& CPEngTrackedPresenceIDCollection::TrackedPresenceID(

    TInt aIndex ) const

    {

    return *iTrackedIDs[ aIndex ];

    }

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

// CPEngTrackedPresenceIDCollection::NextTrackedPresenceID()

// Tracked presence IDs.

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

//

CPEngTrackedPresenceID2* CPEngTrackedPresenceIDCollection::NextTrackedPresenceID(

    TInt& aIterIx )

    {

    CPEngTrackedPresenceID2* idInterface = NULL;

    if ( iTrackedIDs.Count() > aIterIx )

        {

        idInterface = &iTrackedIDs[ aIterIx ]->Interface();

        aIterIx++;

        }

    return idInterface;

    }

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

// CPEngTrackedPresenceIDCollection::AddTrackedIdsL()

// Tracked presence IDs.

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

//

void CPEngTrackedPresenceIDCollection::AddTrackedIdsL( const MDesCArray& aPresenceIDs,

                                                       const TArray<TUint32>& aTypes )

    {

    __ASSERT_ALWAYS( aTypes.Count() > 0, User::Leave( KErrArgument ) );

    const TInt idCount = aPresenceIDs.MdcaCount();

    for ( TInt idIx = 0; idIx < idCount; idIx++ )

        {

        TPtrC presenceID( aPresenceIDs.MdcaPoint( idIx ) );

        TLinearOrder< CPEngTrackedPresenceIDEntry > order

        ( CPEngTrackedPresenceIDEntry::Compare );

        TInt entryIx = KErrNotFound;

        iPresenceIdLookup->SetLookupKey( presenceID );

        TInt entryExists = iTrackedIDs.FindInOrder( iPresenceIdLookup, entryIx, order );

        iPresenceIdLookup->Reset();

        if ( entryExists == KErrNotFound )

            {

            CPEngTrackedPresenceIDEntry* entry = CPEngTrackedPresenceIDEntry::NewLC(

                                                     presenceID,

                                                     aTypes,

                                                     ENotIncludedToList );

            User::LeaveIfError( iTrackedIDs.Insert( entry, entryIx ) );

            CleanupStack::Pop( entry );

            }

        else

            {

            CPEngTrackedPresenceIDEntry* entry = iTrackedIDs[ entryIx ];

            entry->AddTrackedAttributesL( aTypes );

            }

        }

    }

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

// CPEngTrackedPresenceIDCollection::RemoveTrackedIds()

// Tracked presence IDs.

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

//

void CPEngTrackedPresenceIDCollection::RemoveTrackedIds( const MDesCArray& aPresenceIDs )

    {

    const TInt idCount = aPresenceIDs.MdcaCount();

    for ( TInt idIx = 0; idIx < idCount; idIx++ )

        {

        TPtrC presenceID( aPresenceIDs.MdcaPoint( idIx ) );

        TLinearOrder< CPEngTrackedPresenceIDEntry > order

        ( CPEngTrackedPresenceIDEntry::Compare );

        TInt entryIx = KErrNotFound;

        iPresenceIdLookup->SetLookupKey( presenceID );

        TInt entryExists = iTrackedIDs.FindInOrder( iPresenceIdLookup, entryIx, order );

        iPresenceIdLookup->Reset();

        if ( entryExists == KErrNone )

            {

            delete iTrackedIDs[ entryIx ];

            iTrackedIDs.Remove( entryIx );

            }

        }

    }

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

// CPEngTrackedPresenceIDCollection::RemoveTrackedIds()

// Tracked presence IDs.

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

//

void CPEngTrackedPresenceIDCollection::RemoveTrackedIds( const TArray<TUint32>& aTypes )

    {

    //go from end to start ==> remove is safe

    for ( TInt entryIx = ( iTrackedIDs.Count() - 1 ) ; entryIx >= 0; entryIx-- )

        {

        CPEngTrackedPresenceIDEntry* entry = iTrackedIDs[ entryIx ];

        entry->RemoveTrackedAttributes( aTypes );

        if ( !entry->AttributesTracked() )

            {

            delete entry;

            iTrackedIDs.Remove( entryIx );

            }

        }

    }

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

// CPEngTrackedPresenceIDCollection::RemoveTrackedIds()

// Tracked presence IDs.

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

//

void CPEngTrackedPresenceIDCollection::RemoveTrackedIds( const MDesCArray& aPresenceIDs,

                                                         const TArray<TUint32>& aTypes )

    {

    const TInt idCount = aPresenceIDs.MdcaCount();

    for ( TInt idIx = 0; idIx < idCount; idIx++ )

        {

        TPtrC presenceID( aPresenceIDs.MdcaPoint( idIx ) );

        TLinearOrder< CPEngTrackedPresenceIDEntry > order

        ( CPEngTrackedPresenceIDEntry::Compare );

        TInt entryIx = KErrNotFound;

        iPresenceIdLookup->SetLookupKey( presenceID );

        TInt entryExists = iTrackedIDs.FindInOrder( iPresenceIdLookup, entryIx, order );

        iPresenceIdLookup->Reset();

        if ( entryExists == KErrNone )

            {

            CPEngTrackedPresenceIDEntry* entry = iTrackedIDs[ entryIx ];

            entry->RemoveTrackedAttributes( aTypes );

            if ( !entry->AttributesTracked() )

                {

                delete entry;

                iTrackedIDs.Remove( entryIx );

                }

            }

        }

    }

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

// CPEngTrackedPresenceIDCollection::RemoveTrackedIds()

// Tracked presence IDs.

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

//

void CPEngTrackedPresenceIDCollection::RemoveAllTrackedIds()

    {

    iTrackedIDs.ResetAndDestroy();

    }

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

// CPEngTrackedPresenceIDCollection::ResetPresenceChangeMarks()

// List of changed presences

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

//

void CPEngTrackedPresenceIDCollection::ResetPresenceChangeMarks()

    {

    const TInt entryCount = iTrackedIDs.Count();

    for ( TInt entryIx = 0; entryIx < entryCount; entryIx++ )

        {

        CPEngTrackedPresenceIDEntry* entry = iTrackedIDs[ entryIx ];

        entry->ResetChangeMarks();

        }

    }

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

// CPEngTrackedPresenceIDCollection::MarkPresenceChange()

// List of changed presences

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

//

void CPEngTrackedPresenceIDCollection::MarkPresenceChange( const TDesC& aPresenceID )

    {

    TLinearOrder< CPEngTrackedPresenceIDEntry > order

    ( CPEngTrackedPresenceIDEntry::Compare );

    TInt entryIx = KErrNotFound;

    iPresenceIdLookup->SetLookupKey( aPresenceID );

    TInt entryExists = iTrackedIDs.FindInOrder( iPresenceIdLookup, entryIx, order );

    iPresenceIdLookup->Reset();

    if ( entryExists == KErrNone )

        {

        iTrackedIDs[ entryIx ]->MarkAllAttributesChanged();

        }

    }

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

// CPEngTrackedPresenceIDCollection::NextChangeMarkedPresenceID()

// List of changed presences

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

//

CPEngTrackedPresenceID2* CPEngTrackedPresenceIDCollection::NextChangeMarkedPresenceID(

    TInt& aIterIx )

    {

    CPEngTrackedPresenceID2* idInterface = NULL;

    while ( aIterIx < iTrackedIDs.Count()  )

        {

        CPEngTrackedPresenceIDEntry* trackedId = iTrackedIDs[ aIterIx ];

        if ( trackedId->AttributesChanged() )

            {

            idInterface = &trackedId->Interface();

            aIterIx++;

            break;

            }

        aIterIx++;

        }

    return idInterface;

    }

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

// CPEngTrackedPresenceIDCollection::ResetFilteredList()

// Filtered list.

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

//

void CPEngTrackedPresenceIDCollection::ResetFilteredList()

    {

    const TInt entryCount = iTrackedIDs.Count();

    for ( TInt entryIx = 0; entryIx < entryCount; entryIx++ )

        {

        CPEngTrackedPresenceIDEntry* entry = iTrackedIDs[ entryIx ];

        entry->SetFilterFlag( ENotIncludedToList );

        }

    }

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

// CPEngTrackedPresenceIDCollection::IncludeToFilteredList()

// Filtered list.

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

//

void CPEngTrackedPresenceIDCollection::IncludeToFilteredList( TInt aIndex )

    {

    iTrackedIDs[ aIndex ]->SetFilterFlag( EIncludedToList );

    }

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

// CPEngTrackedPresenceIDCollection::FilteredList()

// Filtered list.

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

//

const MDesCArray& CPEngTrackedPresenceIDCollection::FilteredList() const

    {

    return *iEntryListFilter;

    }

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

// CPEngTrackedPresenceIDCollection::ResetTrackedEntriesIterators()

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

//

void CPEngTrackedPresenceIDCollection::ResetTrackedEntriesIterators()

    {

    const TInt trackedIDsCount = iTrackedIDs.Count();

    for ( TInt ii = 0; ii < trackedIDsCount; ii++ )

        {

        CPEngTrackedPresenceID2& idInterface = iTrackedIDs[ ii ]->Interface();

        idInterface.ResetTrackedIterator();

        idInterface.ResetChangedIterator();

        }

    }

//  End of File