/*

* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* which accompanies this distribution, and is available

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*   ?description_line

*

*/

//  INCLUDES

#include "FT_CPosTp11.h"

#include <EPos_CPosLandmarkDatabase.h> 

#include <EPos_CPosLMItemIterator.h> 

#include <EPos_CPosLandmark.h>

#include <EPos_TPosLMSortPref.h> 

//CONSTANTS

const TInt KNoCategoriesTp11  = 100;

const TInt KNoLandmarksTp11 = 100;     

_LIT(KCategoryIteratorNumOfItemsErr, "The iterator returns incorrect number of items");

_LIT(KCategoryIteratorIdErr, "A category id not in the database returned from the iterator");         

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

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

// CPosTp11::StartL

//

// (other items were commented in a header).

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

//

void CPosTp11::StartL()

    {  

    iLog->Log(_L("***** Testing CPosCategoryManager::CategoryIteratorL() and CPosCategoryManager::ReferencedCategoryIteratorL()***** "));

    RemoveDefaultDbL();

    RemoveAllLmDatabasesL();              

    iDatabase = CPosLandmarkDatabase::OpenL();        

    if (iDatabase->IsInitializingNeeded())

       {

        iLog->Log(_L("ExecuteAndDeleteLD(iDatabase->InitializeL())"));

       ExecuteAndDeleteLD(iDatabase->InitializeL());

       } 

    iLog->Log(_L("Default database opened and initialized "));       

    iCategoryManager = CPosLmCategoryManager::NewL(*iDatabase);

    ExecuteAndDeleteLD(iDatabase->CompactL());          

    MakeEmptyLmDatabaseL( *iDatabase, *iCategoryManager);        

    iLog->Log(_L("Deleting all landmarks and categories to create empty database Done"));

    AddCategoriesL();

    AddLandmarksL();   

    iLog->Log(_L("** 1: Testing CPosCategoryManager::CategoryIteratorL() (Iteration of categories)"));

    IterateCategoriesL();

    iLog->Log(_L("** 2: Testing CPosCategoryManager::ReferencedCategoryIteratorL() (Iteration of referenced categories)"));   

    IterateReferencedCategoriesL();

    iLog->Log(_L("** 3: Testing CPosCategoryManager::CategoryIteratorL() (Iteration of categories)"));    

    IterateSetOfCategoriesL();

	iLog->Log(_L("** 4: Testing CPosCategoryManager::CategoryIteratorL() (Iteration of Sorted categories)"));    

    IterateSortedCategoriesL();    

    iLog->Log(_L("** 5: Testing CPosCategoryManager::ReferencedCategoryIteratorL() (Iteration of Sorted referenced categories)"));    

    IterateReferencedSortedCategoriesL();    

    delete iDatabase;

    iDatabase = NULL;

    // Remove lm db

    RemoveDefaultDbL();    

    }

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

// CPosTp11::CloseTest

//

// (other items were commented in a header).

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

//

void CPosTp11::CloseTest()

    {

    iLog->Log(_L("CloseTest"));

    iCategories.ResetAndDestroy();

    iCategories.Close();

    iReferencedCategories.Close();

    iLandmarks.ResetAndDestroy();

    iLandmarks.Close();

    delete iDatabase;

    iDatabase = NULL;

    delete iCategoryManager; 

    iCategoryManager = NULL;      

    }

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

// CPosTp11::AddCategoriesL

//

// (other items were commented in a header).

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

//

void CPosTp11::AddCategoriesL()

    {    

    _LIT(KName, "CategoryTP11 - %d");

    TInt err=KErrLocked;

    for (TInt i=0; i<KNoCategoriesTp11; i++)

        {

        TBuf<100> categoryName;

        categoryName.Format(KName,i);

        CPosLandmarkCategory* lmc = CPosLandmarkCategory::NewLC();

        lmc->SetCategoryNameL(categoryName);

        err = KErrLocked;

        while (err == KErrLocked)

            {

            TRAP(err, iCategoryManager->AddCategoryL(*lmc));

            }

        iCategories.Append(lmc);       

        CleanupStack::Pop(lmc);

        }    

    iLog->Log(_L("Adding categories to database done "));

    }

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

// CPosTp11::AddLandmarksL

//

// (other items were commented in a header).

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

//

void CPosTp11::AddLandmarksL()

    {

    _LIT(KLmName, "LmTP11 - %d");

    TInt err = KErrLocked;

    for (TInt i=0; i<KNoLandmarksTp11; i++)

        {

        TBuf<100> lmName;

        lmName.Format(KLmName,i);

        CPosLandmark* landmark = CPosLandmark::NewLC();

        landmark->SetLandmarkNameL(lmName); 

        if (i % 2)

            {

            landmark->AddCategoryL(iCategories[i]->CategoryId());

            iReferencedCategories.Append(*iCategories[i]);

            }

        err = KErrLocked;

        while (err == KErrLocked)

            {

            TRAP(err, iDatabase->AddLandmarkL(*landmark));

            }

        iLandmarks.Append(landmark);

        CleanupStack::Pop(landmark);

        }

    iLog->Log(_L("Adding categories to landmarks and adding landmarks to database done "));

    }

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

// CPosTp11::IterateCategoriesL

//

// (other items were commented in a header).

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

//

void CPosTp11::IterateCategoriesL()

    {

    CPosLmItemIterator* iter = iCategoryManager->CategoryIteratorL();

    CleanupStack::PushL(iter);

    AssertTrueSecL(iter->NumOfItemsL() == (TUint)iCategories.Count(), KCategoryIteratorNumOfItemsErr);

    CheckIteratorItemsL(*iter);

    iter->Reset();

    CheckIteratorItemsL(*iter);

    CleanupStack::PopAndDestroy(iter);

    }

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

// CPosTp11::IterateReferencedCategoriesL

//

// (other items were commented in a header).

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

//

void CPosTp11::IterateReferencedCategoriesL()

    {

    CPosLmItemIterator* iter = iCategoryManager->ReferencedCategoryIteratorL();

    CleanupStack::PushL(iter);

    AssertTrueSecL(iter->NumOfItemsL() == (TUint)(iCategories.Count()/2), KCategoryIteratorNumOfItemsErr);

    CheckIteratorItemsL(*iter);

    iter->Reset();

    CheckIteratorItemsL(*iter);

    CleanupStack::PopAndDestroy(iter);

    }

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

// CPosTp11::CheckIteratorItemsL

//

// (other items were commented in a header).

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

//

void CPosTp11::CheckIteratorItemsL(CPosLmItemIterator& iter)

    {

    TPosLmItemId id = iter.NextL();

    while (id != KPosLmNullItemId)

        {

        CPosLandmarkCategory* source = InternalGet(id);

        AssertTrueSecL(source != NULL, KCategoryIteratorIdErr);

        CPosLandmarkCategory* target = iCategoryManager->ReadCategoryLC(id);

        CompareCategoriesL(*source, *target);

        CleanupStack::PopAndDestroy(target); 

        id = iter.NextL();

        }    

    }

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

// CPosTp11::IterateSetOfCategoriesL

//

// (other items were commented in a header).

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

//

void CPosTp11::IterateSetOfCategoriesL()

    {

    CPosLmItemIterator* iter = iCategoryManager->CategoryIteratorL();

    CleanupStack::PushL(iter);

    const TInt startIndex=11;

    const TInt numOfItems=34;

    RArray<TPosLmItemId> ids;

    CleanupClosePushL(ids);

    iter->GetItemIdsL(ids, startIndex, numOfItems);

    AssertTrueSecL(ids.Count() == numOfItems, KCategoryIteratorNumOfItemsErr);

    for (TInt i=0; i<numOfItems; i++)

        {

        CPosLandmarkCategory* source = InternalGet(ids[i]);

        AssertTrueSecL(source != NULL, KCategoryIteratorIdErr);

        CPosLandmarkCategory* target = iCategoryManager->ReadCategoryLC(ids[i]);

        CompareCategoriesL(*source, *target);

        CleanupStack::PopAndDestroy(target); 

        }

    CleanupStack::PopAndDestroy(2, iter);

    }

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

// InternalSort

//

// (other items were commented in a header).

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

//

TInt InternalSortL(const CPosLandmarkCategory& aSource, const CPosLandmarkCategory& aTarget)

    {

    TPtrC sourceName, targetName;

    User::LeaveIfError(aSource.GetCategoryName(sourceName));  

    User::LeaveIfError(aTarget.GetCategoryName(targetName));

    return sourceName.Compare(targetName);

    }

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

// CPosTp11::IterateSortedCategoriesL

//

// (other items were commented in a header).

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

//

void CPosTp11::IterateSortedCategoriesL()

    {

    TLinearOrder<CPosLandmarkCategory> order(InternalSortL);

    iCategories.Sort(order);

    CPosLmItemIterator* iter = iCategoryManager->CategoryIteratorL(

                                CPosLmCategoryManager::ECategorySortOrderNameDescending);

    CleanupStack::PushL(iter);

    AssertTrueSecL(iter->NumOfItemsL() == (TUint)iCategories.Count(), KCategoryIteratorNumOfItemsErr);

    TInt lastIndex=iCategories.Count()-1;

    for (TInt i=lastIndex; i>=0; i--)

        {

        CPosLandmarkCategory* target = iCategoryManager->ReadCategoryLC(iter->NextL());

        CompareCategoriesL(*iCategories[i], *target);

        CleanupStack::PopAndDestroy(target); 

        }

    CleanupStack::PopAndDestroy(iter);

    iter = iCategoryManager->CategoryIteratorL(

                                CPosLmCategoryManager::ECategorySortOrderNameAscending);

    CleanupStack::PushL(iter);

    for (TInt j=0; j < iCategories.Count(); j++)

        {

        CPosLandmarkCategory* target = iCategoryManager->ReadCategoryLC(iter->NextL());

        CompareCategoriesL(*iCategories[j], *target);

        CleanupStack::PopAndDestroy(target); 

        }

    CleanupStack::PopAndDestroy(iter);

    }

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

// CPosTp11::IterateReferencedSortedCategoriesL

//

// (other items were commented in a header).

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

//

void CPosTp11::IterateReferencedSortedCategoriesL()

    {

    TLinearOrder<CPosLandmarkCategory> order(InternalSortL);

    iReferencedCategories.Sort(order);

    CPosLmItemIterator* iter = iCategoryManager->ReferencedCategoryIteratorL(

                                CPosLmCategoryManager::ECategorySortOrderNameDescending);

    CleanupStack::PushL(iter);

    AssertTrueSecL(iter->NumOfItemsL() == (TUint)(iCategories.Count()/2), KCategoryIteratorNumOfItemsErr);

    TInt lastIndex=iReferencedCategories.Count()-1;

    for (TInt i=lastIndex; i>=0; i--)

        {

        CPosLandmarkCategory* target = iCategoryManager->ReadCategoryLC(iter->NextL());

        CompareCategoriesL(iReferencedCategories[i], *target);

        CleanupStack::PopAndDestroy(target); 

        }

    CleanupStack::PopAndDestroy(iter);

    iter = iCategoryManager->ReferencedCategoryIteratorL(

                                CPosLmCategoryManager::ECategorySortOrderNameAscending);

    CleanupStack::PushL(iter);

    for (TInt j=0; j < iReferencedCategories.Count(); j++)

        {

        CPosLandmarkCategory* target = iCategoryManager->ReadCategoryLC(iter->NextL());

        CompareCategoriesL(iReferencedCategories[j], *target);

        CleanupStack::PopAndDestroy(target); 

        }

    CleanupStack::PopAndDestroy(iter);

    }

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

// CPosT11::InternalGet

//

// (other items were commented in a header).

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

//

CPosLandmarkCategory* CPosTp11::InternalGet(TPosLmItemId id)

    {

    for (TInt i=0; i<iCategories.Count(); i++)

        {   

        if (iCategories[i]->CategoryId() == id)

            {

            return iCategories[i];

            }

        }

    return NULL;

    }

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

// CPosT11::CreateEmptyLmDatabaseL() 

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

//

void CPosTp11::MakeEmptyLmDatabaseL( CPosLandmarkDatabase& aLdb,

                                     CPosLmCategoryManager& aCatMgr )    

    {

    CPosLmOperation* operation1 = aLdb.RemoveAllLandmarksL();

    //Remove all landmarks from default db : Sync call     

    ExecuteAndDeleteLD( operation1 ); 

    RArray<TPosLmItemId> catArray;

    CleanupClosePushL( catArray );

    // Get all the categories from the database and delete them if necessary 

    CPosLmItemIterator* iter = aCatMgr.CategoryIteratorL();

    CleanupStack::PushL( iter );

    TUint count = iter->NumOfItemsL();

    if ( count > 0 )

        { // can only be called if there are some items

        iter->GetItemIdsL( catArray, 0, count );

        }

    // Remove all the categories here Sync call     

    ExecuteAndDeleteLD(aCatMgr.RemoveCategoriesL( catArray ));    

    CleanupStack::PopAndDestroy( 2 ); // catArray, iter

    }

//  End of File