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

CDbBasicWindowStage::CDbBasicWindowStage(const TDbWindow& aWindow)

	: iWindow(aWindow), iRecords(EWindowArrayGranularity), iPos(-1)

	{

	__ASSERT(aWindow.Size()!=aWindow.ENone);

	}

TBool CDbBasicWindowStage::GetRecord(TDbRecordId& aRecordId)

	{

	if (TUint(iPos)>=TUint(iRecords.Count()))

		return EFalse;

	aRecordId=iRecords[iPos];

	return ETrue;

	}

void CDbBasicWindowStage::Reset()

//

// Reset the window to initial state

//

	{

	CDbDataStage::Reset();

	iRecords.Reset();

	iPos=-1;

	}

TBool CDbBasicWindowStage::EvaluateL(TInt& aWork,TDbRecordId& aRecordId,TBool& aAtRow)

//

// Do as much work as we can to make the window match the desired shape

//

	{

	TBool eval=CDbDataStage::EvaluateL(aWork,aRecordId,aAtRow);

	if (!eval)

		{

		eval=DoEvaluateL(aWork);

		aAtRow=GetRecord(aRecordId);

		}

	return eval;

	}

TInt CDbBasicWindowStage::CountL()

//

// Window'd views only report the evaluated records

//

	{

	return iRecords.Count();

	}

CDbBasicWindowStage::TGoto CDbBasicWindowStage::GotoL(TInt& /*aWork*/,TDbPosition aPosition,TDbRecordId& aRecordId)

	{

	switch (aPosition)

		{

	default:

		__ASSERT(0);

		break;

	case EDbFirst:

		iPos=0;

		break;

	case EDbLast:

		iPos=iRecords.Count()-1;

		break;

	case EDbNext:

		++iPos;

		break;

	case EDbPrevious:

		--iPos;

		break;

		}

	return GetRecord(aRecordId) ? ESuccess : ENoRow;

	}

TInt CDbBasicWindowStage::Find(TDbRecordId aRecordId,TInt& aPos)

	{

	TKeyArrayFix key(0,ECmpTUint32);

	return iRecords.Find(aRecordId,key,aPos);

	}

TBool CDbBasicWindowStage::GotoL(TDbRecordId aRecordId)

	{

	return Find(aRecordId,iPos)==0;

	}

void CDbBasicWindowStage::ReadRowL(TDbRecordId aRecordId)

	{

	TRAPD(r,CDbDataStage::ReadRowL(aRecordId));

	if (r==KErrNotFound)

		{

		TInt pos;

		if (Find(aRecordId,pos)==KErrNone)

			{

			iRecords.Delete(pos);

			if (pos<iPos)

				--iPos;

			}

		}

	__LEAVE_IF_ERROR(r);

	}

TDbRecordId CDbBasicWindowStage::WriteRowL(TWrite aWrite,TSynch aSynch)

	{

	TDbRecordId id=CDbDataStage::WriteRowL(aWrite,ENoSynch);

	if (aWrite==EAppend && iWindow.Size()==iWindow.EUnlimited)

		{

		iRecords.AppendL(id);

		if (aSynch==ESynch)

			iPos=iRecords.Count()-1;	// follow the append

		}

	return id;

	}

CDbBasicWindowStage::TDelete CDbBasicWindowStage::DeleteRowL(TDbRecordId& aRecordId,TSynch)

//

// Remove the row from the window if it is present

//

	{

	CDbDataStage::DeleteRowL(aRecordId,ENoSynch);

	if (GotoL(aRecordId))

		{

		iRecords.Delete(iPos);

		if (GetRecord(aRecordId))

			return EDeletedAtNext;

		}

	return EDeletedAtEnd;

	}

// Class CDbWindowStage

CDbWindowStage::CDbWindowStage(const TDbWindow& aWindow)

	: CDbBasicWindowStage(aWindow), iIterPos(EAtBeginning), iView(EBeginning)

	{}

void CDbWindowStage::Reset()

//

// Reset the window to initial state

//

	{

	CDbBasicWindowStage::Reset();

	iIterPos=EAtBeginning;

	iView=EBeginning;

	}

TInt CDbWindowStage::WhatToEvaluate()

//

// count of slots to fill, <0 at beginning, >0 at end. 0 none

//

	{

	if (iView==EAll)

		return 0;

	if (iWindow.Size()==iWindow.EUnlimited)

		return KMaxTInt;

	TInt space=iWindow.Size()-iRecords.Count();

	TInt lag=iPos-iWindow.PreferredPos();

	switch (iView)

		{

	default:

		__ASSERT(0);

	case EBeginning:

		return space+Max(lag,0);	// fill up and use forward lag if any

	case EEnd:

		return Min(lag,0)-space;	// fill up backwards and use rear lag if any

	case EMiddle:

		if (lag<0 && iIterPos==EAtBeginning)	// use iterator position if we can

			return lag;

		if (space+lag>0)

			return space+lag;

		if (lag<0)

			return lag;

		return 0;

		}

	}

TDbPosition CDbWindowStage::ResetIterToBeginningL()

	{

	for (TInt ii=iRecords.Count();--ii>=0;)

		{

		if (CDbDataStage::GotoL(iRecords[0]))

			return EDbPrevious;

// has been deleted, try the next one

		iRecords.Delete(0);

		if (iPos>0)

			--iPos;

		}

// no records to work with, start at the end

	return EDbLast;

	}

TDbPosition CDbWindowStage::ResetIterToEndL()

	{

	for (TInt ii=iRecords.Count();--ii>=0;)

		{

		if (CDbDataStage::GotoL(iRecords[ii]))

			return EDbNext;

// has been deleted, try the next one

		iRecords.Delete(ii);

		if (iPos>ii)

			--iPos;

		}

// no records to work with, start at the beginning

	return EDbFirst;

	}

TDbPosition CDbWindowStage::SetIteratorL(TInt anEval)

//

// Set the iterator for some work and return the first iterator direction

//

	{

	switch (iIterPos)

		{

	default:

		__ASSERT(0);

	case EAtBeginning:

		if (anEval<0)

			return EDbPrevious;

// turn around iterator to work at end

		iIterPos=EAtEnd;

		return ResetIterToEndL();

	case EAtEnd:

		if (anEval>0)

			return EDbNext;

// turn around iterator to work at beginning

		iIterPos=EAtBeginning;

		return ResetIterToBeginningL();

		}

	}

void CDbWindowStage::ExtendAtBeginningL(TInt aRecords,TDbPosition aFirst,TInt& aWork)

	{

	TDbRecordId id=iRecords.Count()>0 ? iRecords[0] : KDbNullRecordId;

	while (aRecords>0)

		{

		switch (CDbDataStage::GotoL(aWork,aFirst,id))

			{

		default:

			__ASSERT(0);

		case EExhausted:

			return;

		case ESuccess:

			if (iRecords.Count()==iWindow.Size())

				{	// drop last record

				iRecords.Delete(iRecords.Count()-1);

				if (iView==EEnd)

					iView=EMiddle;

				}

			iRecords.InsertL(0,id);

			++iPos;

			if (aFirst==EDbLast)

				aFirst=EDbPrevious;

			--aRecords;

			break;

		case ENoRow:	// no more data that way

			iView=iView==EEnd ? EAll : EBeginning;

			return;

		case ESynchFailure:	// have to do some work on the iterator now

			aFirst=ResetIterToBeginningL();

			break;

			}

		}

	}

void CDbWindowStage::ExtendAtEndL(TInt aRecords,TDbPosition aFirst,TInt& aWork)

	{

	TDbRecordId id=iRecords.Count()>0 ? iRecords[iRecords.Count()-1] : KDbNullRecordId;

	while (aRecords>0)

		{

		switch (CDbDataStage::GotoL(aWork,aFirst,id))

			{

		default:

			__ASSERT(0);

		case EExhausted:

			return;

		case ESuccess:

			if (iRecords.Count()==iWindow.Size())

				{	// drop first record

				iRecords.Delete(0);

				--iPos;

				if (iView==EBeginning)

					iView=EMiddle;

				}

			iRecords.AppendL(id);

			if (aFirst==EDbFirst)

				aFirst=EDbNext;

			--aRecords;

			break;

		case ENoRow:

			iView=iView==EBeginning ? EAll : EEnd;

			return;

		case ESynchFailure:

			aFirst=ResetIterToEndL();

			break;

			}

		}

	}

TBool CDbWindowStage::DoEvaluateL(TInt& aWork)

//

// Do as much work as we can to make the window match the desired shape

//

	{

	for (;;)

		{

		TInt eval=WhatToEvaluate();

		if (eval==0)

			return EFalse;

		if (aWork<=0)

			return ETrue;

		TDbPosition dir=SetIteratorL(eval);

		if (eval>0)

			ExtendAtEndL(eval,dir,aWork);

		else

			ExtendAtBeginningL(-eval,dir,aWork);

		}

	}

TBool CDbWindowStage::Unevaluated()

//

// Return whether it is worth Evaluating

//

	{

	return WhatToEvaluate()==0 ? CDbDataStage::Unevaluated() : ETrue;

	}