/*

* 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: Implementation of CPosLmNameIndex class

*

*

*/

#include <e32base.h>

#include <d32dbms.h>

#include <EPos_Landmarks.h>

#include <EPos_CPosLandmark.h>

#include <epos_cposlmlocaldbaccess.h>

#include <epos_landmarkdatabasestructure.h>

#include <epos_poslmlandmarkhandler.h>

#include <epos_cposlmdiskutilities.h>

#include <epos_poslmserverutility.h>

#include <epos_poslmlongtextcolhandler.h>

#include "EPos_PosLmDatabaseManager.h"

#include "epos_lmdebug.h"

#include "EPos_CPosLmNameIndex.h"

// ============================ LOCAL FUNCTIONS ===============================

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

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

// CLmNameIndex::CIndexItem

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

//

CPosLmNameIndex::CIndexItem::CIndexItem()

: iId ( KPosLmNullItemId )

    {

    }

CPosLmNameIndex::CIndexItem::CIndexItem( TPosLmItemId aId )

: iId ( aId )

    {

    }

CPosLmNameIndex::CIndexItem::CIndexItem( TPosLmItemId aId, HBufC* aName )

: iId ( aId ), iName( aName )

    {

    }

CPosLmNameIndex::CIndexItem::~CIndexItem()

    {

    delete iName;

    }

CPosLmNameIndex::CIndexItem* CPosLmNameIndex::CIndexItem::NewLC( TPosLmItemId aId, const TDesC& aName )

    {

    CIndexItem* self = new (ELeave) CIndexItem( aId );

    CleanupStack::PushL( self );

    self->iName = aName.AllocL();

    return self;

    }

CPosLmNameIndex::CIndexItem* CPosLmNameIndex::CIndexItem::NewLC( RReadStream& aIn )

    {

    TPosLmItemId id = aIn.ReadUint32L();

    TInt len = aIn.ReadUint32L();

    if ( id < 1 || len < 0 ) User::Leave( KErrCorrupt );

    HBufC* name = HBufC::NewLC( len );

    TPtr ptr = name->Des();

    aIn.ReadL( ptr, len );

    CIndexItem* self = new (ELeave) CIndexItem( id, name );

    CleanupStack::Pop( name );

    CleanupStack::PushL( self );

    return self;

    }

TPtrC CPosLmNameIndex::CIndexItem::Name() const

    {

    if ( iName )

        return *iName;

    else

        return KNullDesC();

    }

void CPosLmNameIndex::CIndexItem::ExternalizeL( RWriteStream& aOut ) const

    {

    aOut.WriteUint32L( iId );

    aOut.WriteUint32L( Name().Length() );

    aOut.WriteL( Name() );

    // state is not stored, it is used only for index verification

    }

TInt CPosLmNameIndex::CIndexItem::Size() const

    {

    return 

        sizeof( TUint32 )       // id size

        + sizeof( TUint32 )     // string length size

        + Name().Size();        // string size

    }

TInt CPosLmNameIndex::CIndexItem::CompareById( const CIndexItem& aLeft, const CIndexItem& aRight )

    {

    return aLeft.Id() - aRight.Id();

    }

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

// CPosLmNameIndex::TLmIndexNameKey

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

//

CPosLmNameIndex::TLmIndexNameKey::TLmIndexNameKey() :

    TKeyArrayFix( 0, ECmpCollated )

    {

    // the second parameter - comparison type - is used

    // by TKeyArrayFix::Compare()

    // the first parameter - offset of the key - is not used: 

    // overridden At() returns pointer to key not using offsets

    }

TAny* CPosLmNameIndex::TLmIndexNameKey::At( TInt anIndex ) const

    {

    TAny* any = TKeyArrayFix::At( anIndex );

    CIndexItem** ptr = static_cast<CIndexItem**>( any );

    return (*ptr)->NamePtr();

    }

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

// CPosLmNameIndex::TLmIndexIdKey

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

//

CPosLmNameIndex::TLmIndexIdKey::TLmIndexIdKey() :

    TKeyArrayFix( 0, ECmpTUint32 )

    {

    }

TAny* CPosLmNameIndex::TLmIndexIdKey::At( TInt anIndex ) const

    {

    TAny* any = TKeyArrayFix::At( anIndex );

    CIndexItem** ptr = static_cast<CIndexItem**>( any );

    return (*ptr)->IdPtr();

    }

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

// CPosLmNameIndex

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

//

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

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

//

CPosLmNameIndex::CPosLmNameIndex( CPosLmLocalDbAccess& aDbAccess )

:   iDbAccess( aDbAccess ), iStatus( KErrNotReady )

    {

    }

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

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

//

CPosLmNameIndex::~CPosLmNameIndex()

    {

    Reset();

    delete iArray;

    delete iKeyItem;

    }

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

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

//

void CPosLmNameIndex::Reset()

    {

    StopEvaluation();

    iArray->ResetAndDestroy();

    iDataSize = 0;

    iStatus = KErrNotReady;

    }

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

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

//

CPosLmNameIndex* CPosLmNameIndex::NewL( CPosLmLocalDbAccess& aDbAccess )

    {

    CPosLmNameIndex* self = NewLC( aDbAccess );

    CleanupStack::Pop( self );

    return self;

    }

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

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

//

CPosLmNameIndex* CPosLmNameIndex::NewLC( CPosLmLocalDbAccess& aDbAccess )

    {   

    CPosLmNameIndex* self = new (ELeave) CPosLmNameIndex( aDbAccess );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

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

//

void CPosLmNameIndex::ConstructL()

    {

    const TInt KGranularity = 100;

    iArray = new (ELeave) CArrayPtrSeg<CIndexItem>( KGranularity );

    iKeyItem = new (ELeave) CIndexItem;

    iDbAccess.GetDatabase( iDatabase );

    iTimeStamp.UniversalTime();

    TRAPD( err, LoadL() );

    if ( err )

        {

        // need to re-generate index

        iStatus = KErrNotReady;

        }

    else

    	{

    	//if no need to re-generate then set all the landmarks to valid state

    	for(int i =0; i < iArray->Count(); i++)

    	{

    		CIndexItem *item = iArray->At(i);

    		item->SetValid();

    	}

    	iStatus = KErrNone;

    	}

    }

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

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

//

TReal32 CPosLmNameIndex::Evaluate()

    {

    TReal32 progress = 1.0;

    if ( iStatus )

        {

        TRAPD( err, DoEvaluateL( progress ) );

        if ( err )

            {

            StopEvaluation();

            iStatus = err;

            }

        else if ( progress == 1.0 ) // evaluation completed

            {

            StopEvaluation();

            iStatus = KErrNone;

            }

        }

    return progress;

    }

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

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

//

void CPosLmNameIndex::StopEvaluation()

	{

	if ( iIsTableOpen )

		{

	    iTable.Close();

	    iIsTableOpen = EFalse;

		}

    iIdSortedArray.Reset();

    RemoveInvalidItems();

	}

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

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

//

void CPosLmNameIndex::DoEvaluateL( TReal32& aProgress )

    {

    const TInt KRowsPerStep( 100 );

    if ( !iIsTableOpen )

    	{

        TInt err = iTable.Open( iDatabase, KPosLmLandmarkTable, RDbRowSet::EReadOnly );

        User::LeaveIfError( err );

        iIsTableOpen = ETrue;

        if ( iTable.FirstL() )

            {

            //   Reset(); 

            // Don't reset what's loaded - try to check the index with

            // contents of the database and update accordingly. 

            // Reason: if changes are small (most probable case) this job 

            // is faster than rebuilding new index from scratch

            CreateByIdSortingL();

            iTablePosition = 0;

            iStatus = KErrNotReady;

            }

        else

            {

            // no records in the table

    	    iTable.Close();

    	    iIsTableOpen = EFalse;

            aProgress = 1.0;

            return;

            }

    	}

    TInt numRows = KRowsPerStep;

    while( !iTable.AtEnd() && numRows-- > 0 )

        {

        iTable.GetL();

        TPosLmItemId id = iTable.ColUint32( EPosLmLcLandmarkIdCol );

        HBufC* name = PosLmServerUtility::ReadFromLongTextColumnLC( 

        	iTable, EPosLmLcNameCol );

        // If the item already exists in the index, mark it as verified

        // otherwise - add to index

        CIndexItem* item = ItemById( id );

        // when comparing contents of the index with database

        // it is ok to use binary comparison 

        if ( !item || item->Name().Compare( *name ) != 0 ) 

            {

            // the ID has been removed or changed in database

            if ( item )

                {

                // the original item has been changed

                item->SetInvalid();

                }

			CleanupStack::Pop( name );//ownership of name is transferred in the call to DoInsertL	

            // add new item for this ID

            // here comparison must be done using collation

            CIndexItem* newItem = DoInsertL( id, name ); // takes onwership of name

            newItem->SetValid();

            TLinearOrder<CIndexItem> order( CIndexItem::CompareById );

            iIdSortedArray.InsertInOrder( newItem, order );

            }

        else

            {

            // this item already exists in the index

            item->SetValid();

            CleanupStack::PopAndDestroy( name );

            }

				    //coverity[check_return :FALSE]

    //coverity[unchecked_value :FALSE]

        iTable.NextL();

        iTablePosition++;

        }

    // return progress;

    TInt count = iTable.CountL();

    if ( count > 0 )

        {

        aProgress = TReal32( iTablePosition ) / TReal32( count );

        }

    else

        {

        aProgress = 1.0;

        }

    }

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

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

//

CArrayFixSeg<TPosLmItemId>* CPosLmNameIndex::GetSortedIdsLC() const

    {

    return GetSortedIdsLC( 0, Count() );

    }

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

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

//

CArrayFixSeg<TPosLmItemId>* CPosLmNameIndex::GetSortedIdsLC( TInt aFirst, TInt aCount ) const

    {

    if ( iStatus == KErrNone )

        {

        const TInt KGranularity( 512 );

        CArrayFixSeg<TPosLmItemId>* array = new (ELeave) CArrayFixSeg<TPosLmItemId>( KGranularity );

        CleanupStack::PushL( array );

        TInt first = Max( 0, aFirst );

        TInt last = Min( first + aCount, iArray->Count() );

        for ( TInt i = first; i < last; i++ )

            {

            CIndexItem* item = iArray->At(i);

            array->AppendL( item->Id() );

            }

        return array;

        }

    else

        {

        User::Leave( iStatus );

        return NULL;

        }

    }

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

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

//

TInt CPosLmNameIndex::GetSortedIds( 

    TInt aFirst, TInt aCount, 

    TPosLmItemId* aTarget, TInt& aReminder ) const

    {

    if ( aFirst < 0 || aCount < 0 || aTarget == NULL )

        return KErrArgument;

    if ( iStatus == KErrNone )

        {

        TInt first = Min( Max( aFirst, 0 ), iArray->Count() );

        TInt last = Max( 0, Min( aFirst + aCount, iArray->Count() ) );

        for ( TInt i = first; i < last; i++ )

            {

            CIndexItem* item = iArray->At( i );

            *(aTarget + i-first ) = item->Id();

            }

        aReminder = Count() - last;

        return last - first;

        }

    else

        {

        return iStatus;

        }

    }

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

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

//

void CPosLmNameIndex::InsertL( const CPosLandmark& aLandmark )

    {

    TPtrC name;

    aLandmark.GetLandmarkName( name );

    InsertL( aLandmark.LandmarkId(), name );

    }

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

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

//

void CPosLmNameIndex::InsertL( TPosLmItemId aLmid, const TDesC& aName )

    {

    HBufC* name = aName.AllocLC();

    CleanupStack::Pop( name );

    InsertL( aLmid, name );

    }

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

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

//

void CPosLmNameIndex::InsertL( TPosLmItemId aLmid, HBufC* aName )

    {

	//coverity[ alloc_fn : FALSE ]

   DoInsertL( aLmid, aName );

    }

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

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

//

CPosLmNameIndex::CIndexItem* CPosLmNameIndex::DoInsertL( TPosLmItemId aLmid, HBufC* aName )

    {

	CleanupStack::PushL( aName );//ownership of aName is transferred to this class

    if ( Find( aLmid ) >= 0 ) // finds valid item

        {

        User::Leave( KErrAlreadyExists ); // duplicate ID found

        }

    CIndexItem* landmark = new (ELeave) CIndexItem( aLmid, aName ); // takes ownership of aName

    CleanupStack::Pop( aName );

	CleanupStack::PushL( landmark );

    TLmIndexNameKey key;

    iArray->InsertIsqAllowDuplicatesL( landmark, key );

    CleanupStack::Pop( landmark );

    iDataSize += landmark->Size();

    if ( !iInTransaction )

        {

        landmark->SetValid();

        }

    // otherwise item remains in Temp state

    return landmark;

    }

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

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

//

void CPosLmNameIndex::AppendL( TPosLmItemId aLmid, HBufC* aName )

    {

	//Ownership of aName is transferred in this call

	CleanupStack::PushL( aName );

    CIndexItem* landmark = new (ELeave) CIndexItem( aLmid, aName );

    CleanupStack::Pop( aName );

    CleanupStack::PushL( landmark );

    AppendL( landmark );

    CleanupStack::Pop( landmark );

    }

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

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

//

void CPosLmNameIndex::AppendL( CIndexItem* aLandmark )

    {

    ASSERT( aLandmark );

    iArray->AppendL( aLandmark );

    iDataSize += aLandmark->Size();

    }

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

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

//

void CPosLmNameIndex::Remove( TPosLmItemId aLmid )

    {

    TInt index = Find( aLmid );

    if ( index >= 0 )

        {

        DoRemove( index );

        }

    }

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