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