/*
* Copyright (c) 2005 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: This class is used to start searches for landmarks or landmark 
*  categories in a local landmark database.
*
*
*/


// INCLUDE FILES
#include    <epos_cposlmlocaldatabase.h>
#include    <epos_cposlmlocaldbaccess.h>
#include    <EPos_CPosLmSearchCriteria.h>
#include    <EPos_LandmarksErrors.h>
#include    "EPos_CPosLmLocalSearch.h"
#include    "EPos_CPosLmLocalSearchIterator.h"
#include    "EPos_CPosLmLocalSearchOperation.h"
#include    "EPos_CPosLmLocalSearchHandler.h"

// CONSTANTS

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

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

// -----------------------------------------------------------------------------
// CPosLmLocalSearch::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CPosLmLocalSearch::ConstructL(
    TAny* aDatabase)
    {
    iDb = reinterpret_cast<CPosLmLocalDatabase*>(aDatabase);
    }

// -----------------------------------------------------------------------------
// CPosLmLocalSearch::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CPosLmLocalSearch* CPosLmLocalSearch::NewL(
    TAny* aDatabase)
    {
    CPosLmLocalSearch* self = new (ELeave) CPosLmLocalSearch();
    CleanupStack::PushL(self);
    self->ConstructL(aDatabase);
    CleanupStack::Pop();
    return self;
    }

// Destructor
CPosLmLocalSearch::~CPosLmLocalSearch()
    {
    if (iSearchOperation)
        {
        iSearchOperation->HandleLocalSearchDeleted();
        }

    if (iOwnsSearchHandler)
        {
        delete iSearchHandler;
        }
    }

// -----------------------------------------------------------------------------
// CPosLmLocalSearch::SearchCompleted
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosLmLocalSearch::SearchCompleted()
    {
    // Take back ownership of iSearchHandler when operation has completed.
    iOwnsSearchHandler = ETrue;

    iSearchOperation = NULL;
    }

// -----------------------------------------------------------------------------
// CPosLmLocalSearch::StartLandmarkSearchL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CPosLmOperation* CPosLmLocalSearch::StartLandmarkSearchL(
    const CPosLmSearchCriteria& aCriteria,
    TBool aSearchOnlyPreviousMatches)
    {
    TPosLmLocalSortPref sortPref;

    StartSearchL(ETrue, aCriteria, sortPref, aSearchOnlyPreviousMatches);

    return iSearchOperation;
    }

// -----------------------------------------------------------------------------
// CPosLmLocalSearch::StartLandmarkSearchL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CPosLmOperation*  CPosLmLocalSearch::StartLandmarkSearchL(
    const CPosLmSearchCriteria& aCriteria,
    const TPosLmSortPref& aSortPref,
    TBool aSearchOnlyPreviousMatches)
    {
    if (aSortPref.LandmarkAttributeToSortBy() != CPosLandmark::ELandmarkName)
        {
        User::Leave(KErrNotSupported);
        }

    TPosLmLocalSortPref sortPref(aSortPref);

    StartSearchL(ETrue, aCriteria, sortPref, aSearchOnlyPreviousMatches);

    return iSearchOperation;
    }

// -----------------------------------------------------------------------------
// CPosLmLocalSearch::StartCategorySearchL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CPosLmOperation*  CPosLmLocalSearch::StartCategorySearchL(
    const CPosLmSearchCriteria& aCriteria,
    CPosLmCategoryManager::TCategorySortPref aSortPref,
    TBool aSearchOnlyPreviousMatches)
    {
    __ASSERT_ALWAYS(
        aSortPref >= CPosLmCategoryManager::ECategorySortOrderNone &&
        aSortPref <= CPosLmCategoryManager::ECategorySortOrderNameDescending,
        Panic(KPosLandmarksClientPanic, EPosInvalidEnumValue));

    TPosLmLocalSortPref sortPref(aSortPref);

    StartSearchL(EFalse, aCriteria, sortPref, aSearchOnlyPreviousMatches);

    return iSearchOperation;
    }

// -----------------------------------------------------------------------------
// CPosLmLocalSearch::NumOfMatches
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TUint CPosLmLocalSearch::NumOfMatches() const
    {
    TUint numOfMatches = 0;

    if (iSearchHandler)
        {
        numOfMatches = iSearchHandler->Matches().Count();
        }

    return numOfMatches;
    }

// -----------------------------------------------------------------------------
// CPosLmLocalSearch::MatchIteratorL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
CPosLmItemIterator* CPosLmLocalSearch::MatchIteratorL()
    {
    if (!iSearchHandler)
        {
        return CPosLmLocalSearchIterator::NewL();
        }

    return CPosLmLocalSearchIterator::NewL(iSearchHandler->Matches());
    }

// -----------------------------------------------------------------------------
// CPosLmLocalSearch::SetDisplayData
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosLmLocalSearch::SetDisplayData(CPosLmDisplayData& aData)
    {
    __ASSERT_ALWAYS(!iSearchOperation,
                    Panic(KPosLandmarksClientPanic, EPosSearchOperationInUse));

    // Set display data reference
    iDisplayData = &aData;
    }

// -----------------------------------------------------------------------------
// CPosLmLocalSearch::UnsetDisplayData
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosLmLocalSearch::UnsetDisplayData()
    {
    __ASSERT_ALWAYS(!iSearchOperation,
                    Panic(KPosLandmarksClientPanic, EPosSearchOperationInUse));

    // Set display data reference to null
    iDisplayData = NULL;
    }

// -----------------------------------------------------------------------------
// CPosLmLocalSearch::StartSearchL
//
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CPosLmLocalSearch::StartSearchL(
    TBool aSearchForLandmarks,
    const CPosLmSearchCriteria& aCriteria,
    const TPosLmLocalSortPref& aSortPref,
    TBool aSearchOnlyPreviousMatches)
    {
    if (iSearchOperation)
        {
        User::Leave(KErrInUse);
        }

    if (!iSearchHandler && aSearchOnlyPreviousMatches)
        {
        User::Leave(KErrArgument);
        }

    if (aCriteria.CriteriaType() == CPosLmSearchCriteria::ECriteriaIdList)
        {
        User::Leave(KErrArgument);
        }

    if (!aSearchForLandmarks &&
        aCriteria.CriteriaType() == CPosLmSearchCriteria::ECriteriaComposite)
        {
        User::Leave(KErrNotSupported);
        }

    // Get previous matches before deleting the previous search handler.
    RArray<TPosLmItemId> previousMatches;
    if (aSearchOnlyPreviousMatches)
        {
        CleanupClosePushL(previousMatches);
        iSearchHandler->GetMatchesL(previousMatches);

        if (previousMatches.Count() == 0)
            {
            User::Leave(KErrArgument);
            }
        }

    delete iSearchHandler;
    iSearchHandler = NULL;

    // Create the proper searchHandler
    iSearchHandler = CPosLmLocalSearchHandler::CreateHandlerL(
        *iDb, aCriteria, aSortPref,
        iDisplayData, MaxNumOfMatches());

    iOwnsSearchHandler = ETrue;

    if ((aSearchForLandmarks && !iSearchHandler->IsValidForLandmarkSearch()) ||
        (!aSearchForLandmarks && !iSearchHandler->IsValidForCategorySearch()))
        {
        User::Leave(KErrArgument);
        }

    // Set previous matches
    if (aSearchOnlyPreviousMatches)
        {
        iSearchHandler->SetPreviousMatchesToSearchL(previousMatches);
        CleanupStack::PopAndDestroy(&previousMatches);
        }

    // Create the search operation
    iSearchOperation = CPosLmLocalSearchOperation::NewL(
        iDb, this, iSearchHandler);

    iOwnsSearchHandler = EFalse;
    }

//  End of File