// 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;

 	}