/*

* Copyright (c) 2007 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:  Holds the contact information in memory. It maintains a 

*                master array of all contacts. It also has 10 pools corresponding

*                to each key id in the keyboard. Based on numeric key char of 

*                first char of firstname/ lastname a contact is added to one of the

*                pools. Implements MDataStoreObserver interface functions to

*                add/ remove contacts.

*

*/

// INCLUDE FILES

#include <MVPbkContactLink.h>

#include "FindUtilChineseECE.h"

#include "CPsData.h"

#include "CPcsCache.h"

#include "CPcsDebug.h"

#include "CWords.h"

#include "CPcsAlgorithm2Utils.h"

#include "CPcsAlgorithm2.h"

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

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

// CPcsCache::NewL

// Two Phase Construction

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

                           CPcsKeyMap& aKeyMap, TUint8 aUriId)

    {

    PRINT ( _L("Enter CPcsCache::NewL") );

    CPcsCache* instance = new (ELeave) CPcsCache();

    CleanupStack::PushL(instance);

    instance->ConstructL(aAlgorithm, aURI, aKeyMap, aUriId);

    CleanupStack::Pop(instance);

    PRINT ( _L("End CPcsCache::NewL") );

    return instance;

    }

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

// CPcsCache::CPcsCache

// Constructor

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

CPcsCache::CPcsCache()

    {

    PRINT ( _L("Enter CPcsCache::CPcsCache") );

    PRINT ( _L("End CPcsCache::CPcsCache") );

    }

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

// CPcsCache::ConstructL

// 2nd Phase Constructor

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

                           CPcsKeyMap& aKeyMap, TUint8 aUriId)

    {

    PRINT ( _L("Enter CPcsCache::ConstructL") );

    iAlgorithm = aAlgorithm;

    iURI = aURI.AllocL();

    iUriId = aUriId;

    //Update the caching status for this cache

    iCacheStatus = ECachingNotStarted;

        {

        }

    PRINT ( _L("End CPcsCache::ConstructL") );

    }

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

// CPcsCache::~CPcsCache

// Destructor

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

CPcsCache::~CPcsCache()

    {

    PRINT ( _L("Enter CPcsCache::~CPcsCache") );

    iDataFields.Reset();

    iSortOrder.Reset();

    iIndexOrder.Reset();

    PRINT ( _L("End CPcsCache::~CPcsCache") );

    }

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

// CPcsCache::GetContactsForKeyL

// Get list of pool elements specific to a pool

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

void CPcsCache::GetContactsForKeyL(TInt aKeyId, RPointerArray<CPcsPoolElement>& aData)

    {

    PRINT ( _L("Enter CPcsCache::GetContactsForKeyL") );

        {

        }

    PRINT ( _L("End CPcsCache::GetContactsForKeyL") );

    }

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

// CPcsCache::GetAllContentsL

// Get all data elements in this cache

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

void CPcsCache::GetAllContentsL(RPointerArray<CPsData>& aData)

    {

    PRINT ( _L("Enter CPcsCache::GetAllContentsL") );

        {

        aData.AppendL(value);

        }

    PRINT ( _L("End CPcsCache::GetAllContentsL") );

    }

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

// CPcsCache::AddToPool

// Adds a contact to cache

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

    {

    // Temp hash to remember the location of pool elements

    // First TInt  = Pool 

    // Second TInt = Location in the pool

    // Required for memory optimization so that more than one pool

    // element doesn't get added for the same data

    RHashMap<TInt, TInt> elementHash;

        {

        // Stores first key for each word

        // Recover the first character

            {

            }

            {

            CPcsPoolElement* element = NULL;

            // Check if an element already exists in the pool for this data

            TInt* loc = NULL;

            if (loc != NULL)

                {

                // Exists. Then recover ...

                element = tmpKeyMap[*loc];

                }

            if (element == NULL) // Pool element doesn't exist. Create new ...

                {

                element = CPcsPoolElement::NewL(aData);

                element->ClearDataMatchAttribute();

                element->SetDataMatch(dataIndex);

                // Insert to pool

                // Store the array index in the temp hash

                }

            else // Pool element exists. Just alter the data match attribute

                {

                element->SetDataMatch(dataIndex);

                }

            } // for 2 loop

        } // for 1 loop

    }

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

// CPcsCache::AddToCacheL

// 

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

void CPcsCache::AddToCacheL(CPsData& aData)

    {

    // Protect against duplicate items getting added

        {

        return;

        }

    // Include this element in the pool     

    AddToPoolL(poolMap, aData);

    // Include this element in master pool        

    }

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

// CPcsCache::RemoveContactL

// 

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

void CPcsCache::RemoveFromCacheL(TInt aItemId)

    {

    CPsData *data = NULL;

    if (poolMap == NULL)

        {

        return;

        }

    // Remove this element from pools

        {

        TBool present = GetPoolMap(*poolMap, keyIndex);

        if (!present)

            {

            continue;

            }

            {

            CPcsPoolElement *element = tmpKeyMap[arrayIndex];

            TInt id = element->GetPsData()->Id();

            if (id == aItemId)

                {

                data = element->GetPsData();

                delete element;

                }

            }

        }

    // Remove this element from master pool

        {

        TInt id = dataElement->Id();

        if (id == aItemId)

            {

            }

        }

    // Delete data 

    if (data)

        {

        delete data;

        data = NULL;

        }

    // Clear up cache information

    }

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

// CPcsCache::RemoveAllFromCacheL

// 

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

    {

        {

        }

    }

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

// CPcsCache::SetPoolMap

// 

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

    {

    }

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

// CPcsCache::GetPoolMap

// 

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

    {

    }

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

// CPcsCache::GetURI

// 

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

TDesC& CPcsCache::GetURI()

    {

    return (*iURI);

    }

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

// CPcsCache::SetDataFields

// 

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

void CPcsCache::SetDataFields(RArray<TInt>& aDataFields)

    {

        {

        iDataFields.Append(aDataFields[i]);

        }

    }

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

// CPcsCache::GetDataFields

// 

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

void CPcsCache::GetDataFields(RArray<TInt>& aDataFields)

    {

        {

        aDataFields.Append(iDataFields[i]);

        }

    }

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

// CPcsCache::UpdateCacheStatus

// 

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

void CPcsCache::UpdateCacheStatus(TInt aStatus)

    {

    iCacheStatus = aStatus;

    }

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

// CPcsCache::GetCacheStatus

// 

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

TInt CPcsCache::GetCacheStatus()

    {

    return iCacheStatus;

    }