// Copyright (c) 1998-2009 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:
//

#include "UT_STD.H"

// Class CDbReverseIterator

NONSHARABLE_CLASS(CDbReverseIter) : public CDbRecordIter
	{
public:
	CDbReverseIter(CDbRecordIter* anIterator);
	~CDbReverseIter();
private:
	TInt Count() const;
	TDbRecordId CurrentL();
	TBool GotoL(TDbPosition aPosition);
	TBool GotoL(TDbRecordId aRecordId,RDbTableRow& aBuffer);
	TBool SeekL(const TDbLookupKey& aKey,RDbTable::TComparison aComparison);
	TDeleted DoDeletedL(TDbPosition aPosition,TDbRecordId aRecordId,const RDbTableRow* aRow);
private:
	CDbRecordIter* iIter;
	};

CDbReverseIter::CDbReverseIter(CDbRecordIter* aIterator)
	: CDbRecordIter(aIterator->Host()),iIter(aIterator)
	{}

CDbReverseIter::~CDbReverseIter()
	{
	delete iIter;
	}

TInt CDbReverseIter::Count() const
	{
	return iIter->Count();
	}

TDbRecordId CDbReverseIter::CurrentL()
	{
	return iIter->CurrentL();
	}

TBool CDbReverseIter::GotoL(TDbPosition aPosition)
	{
	return iIter->GotoL(TDbPosition(EDbLast-aPosition));
	}

TBool CDbReverseIter::GotoL(TDbRecordId aRecord,RDbTableRow& aRow)
	{
	return iIter->GotoL(aRecord,aRow);
	}

TBool CDbReverseIter::SeekL(const TDbLookupKey& aKey,RDbTable::TComparison aComparison)
//
// Reverse the comparison
//
	{
	return iIter->SeekL(aKey,RDbTable::TComparison(RDbTable::EGreaterThan-aComparison));
	}

CDbReverseIter::TDeleted CDbReverseIter::DoDeletedL(TDbPosition aPosition,TDbRecordId aRecordId,const RDbTableRow* aRow)
//
// Need to invert the position.
//
	{
	return iIter->DoDeletedL(TDbPosition(EDbLast-aPosition),aRecordId,aRow);
	}

// Class CDbTableSource

CDbTableSource::CDbTableSource()
	{}

CDbTableSource::~CDbTableSource()
	{
	delete iIter;
	iRow.Close();
	}

void CDbTableSource::Construct(CDbTable* aTable)
//
// We own the table pass in
//
	{
	iIterMark.Construct(aTable->Generation());
	iRow.Open(aTable);
	}

void CDbTableSource::ReverseIteratorL()
//
// Plug in a reverse iterator adaptor for the iterator
//
	{
	iIter=new(ELeave) CDbReverseIter(iIter);
	}

TInt CDbTableSource::ColumnCount() const
	{
	return iRow.Table().Def().Columns().Count();
	}

const TDbColumnDef& CDbTableSource::ColumnDef(TDbColNo aCol) const
	{
	return iRow.Table().Def().Columns()[aCol];
	}

RDbRow* CDbTableSource::RowBuffer()
	{
	return &iRow;
	}

TDbColumn CDbTableSource::Column(TDbColNo aColNo)
	{
	return TDbColumn(iRow,aColNo);
	}

void CDbTableSource::Reset()
	{
	iReset=ETrue;
	}

TBool CDbTableSource::EvaluateL(TInt&,TDbRecordId&,TBool&)
	{
	return EFalse;
	}

TBool CDbTableSource::Unevaluated()
	{
	return EFalse;
	}

TInt CDbTableSource::CountL()
//
// Count the records
//
	{
	if (iReset)
		OpenIteratorL();
	return iIter->Count();
	}

void CDbTableSource::OpenIteratorL()
//
// Re-open the iterator after a reset
//
	{
	__ASSERT(iIter);
	if (iIter->Host().OpenL())
		__LEAVE(KErrCorrupt);
	iReset=EFalse;
	}

CDbTableSource::TGoto CDbTableSource::GotoL(TInt& aWork,TDbPosition aPosition,TDbRecordId& aRecordId)
//
// Move to the position specified. If out of synch, try to resynch the iterator
// using aRecordId
//
	{
	__ASSERT(iIter);
	TInt work=aWork;
	if (work<0)
		return EExhausted;
	aWork=work-EWorkToIterate;
	CDbRecordIter& iter=*iIter;
	if (iIterMark.Changed())
		{	// two possible resaons for this
		if (iReset)
			OpenIteratorL();
		if (aPosition==EDbNext || aPosition==EDbPrevious)
			{	// table modified
			if (aRecordId==KDbNullRecordId)
				return ESynchFailure;
			if (!iter.GotoL(aRecordId,iRow))
				{	// record has been deleted
				switch(iter.DeletedL(aPosition,aRecordId))
					{
				case CDbRecordIter::EAtRow:			// found it
					aRecordId=iter.CurrentL();
					return ESuccess;
				case CDbRecordIter::ENoRow:			// no more rows
					aRecordId=KDbNullRecordId;
					return ENoRow;
				case CDbRecordIter::ENotSupported:	// couldn't re-snych
					return ESynchFailure;
					}
				}
			}
		iIterMark.Mark();
		}
	if (iter.GotoL(aPosition))
		{
		aRecordId=iter.CurrentL();
		return ESuccess;
		}
	else
		{
		aRecordId=KDbNullRecordId;
		return ENoRow;
		}
	}

TBool CDbTableSource::SynchL(TDbRecordId aRecordId)
	{
	if (iReset)
		OpenIteratorL();
	TBool found=iIter->GotoL(aRecordId,iRow);
	iIterMark.Mark();
	return found;
	}

TBool CDbTableSource::GotoL(TDbRecordId aRecordId)
	{
	return iRow.Table().ExistsL(aRecordId) ? SynchL(aRecordId) : EFalse;
	}

void CDbTableSource::ReadRowL(TDbRecordId aRecordId)
	{
	iRow.ReadL(aRecordId);
	}

void CDbTableSource::NewRowL(TDbRecordId aCopyRecord)
	{
	if (iIter!=NULL&&iReset)
		OpenIteratorL();
	iRow.NewL(aCopyRecord);
	}

void CDbTableSource::PrepareToWriteRowL(TWrite aWrite)
	{
	__ASSERT(aWrite==EReplace||aWrite==EAppend);
	if (aWrite==EReplace)
		iRow.PrepareReplaceL();
	else
		iRow.PrepareAppendL();
	}

TDbRecordId CDbTableSource::WriteRowL(TWrite aWrite,TSynch aSynch)
	{
	__ASSERT(aWrite==EReplace||aWrite==EAppend);
	TDbRecordId id=aWrite==EReplace ? iRow.ReplaceL() : iRow.AppendL();
	if (aSynch==ESynch)
		{
		__DEBUG(TBool dbgchk=) SynchL(id);
		__ASSERT(dbgchk);
		}
	return id;
	}

CDbTableSource::TDelete CDbTableSource::DeleteRowL(TDbRecordId& aRecordId,TSynch aSynch)
//
// Remove the row from the table. Synchronise the iterator if required
// When not synchronising, the return value is not significant
//
	{
	// if the table has changed, we may need to re-synch the iterator before deleting
	// this is important if neighbouring rows have been deleted by another view
	if (aSynch==ESynch && iIterMark.Changed() && !SynchL(aRecordId))
		__LEAVE(KErrNotFound);		// it has been deleted already!
	iRow.DeleteL(aRecordId);
	if (aSynch==ESynch)
		{
		CDbRecordIter::TDeleted del=iIter->DeletedL(EDbNext,aRecordId,iRow);
		__ASSERT(del!=CDbRecordIter::ENotSupported);	// must always be able to synch with row data
		iIterMark.Mark();
		if (del==CDbRecordIter::EAtRow)
			{	// pass back the next record id
			aRecordId=iIter->CurrentL();
			return EDeletedAtNext;
			}
		}
	return EDeletedAtEnd;
	}

void CDbTableSource::SetIndexL(const TDesC* anIndex)
	{
	CDbRecordIter* iter=anIndex ? iRow.Table().IteratorL(*anIndex) : iRow.Table().IteratorL();
	delete iIter;
	iIter=iter;
	}

TBool CDbTableSource::SeekL(const TDbLookupKey& aKey,RDbTable::TComparison aComparison,TDbRecordId& aRecordId)
	{
	if (iReset)
		OpenIteratorL();
	CDbRecordIter& iter=*iIter;
	TBool atrow=iter.SeekL(aKey,aComparison);
	aRecordId=atrow ? iter.CurrentL() : KDbNullRecordId;
	iIterMark.Mark();
	return atrow;
	}

CSqlSearchCondition* CDbTableSource::ParseConstraintLC(const TDesC& aCondition)
	{
	CSqlSearchCondition* sc=Sql::ParseSearchConditionLC(aCondition);
	sc->BindL(iRow);
	return sc;
	}