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

// DBMS server proxy cursor

// 

//

#include "SD_STD.H"

const TDbBlobId KUnknownBlobId=~0u;

// Class HDbsColumns

class HDbsColumns

	{

public:

	static HDbsColumns* NewL(TInt aCount);

	inline void Set(const TUint8* aPtr);

	inline TPtr8 Ptr();

	inline TInt Count() const;

	inline TDbColType Type(TDbColNo aCol) const;

	void Check(TDbColNo aCol) const;

private:

	inline HDbsColumns(TInt aCount);

private:

	TInt iCount;

	TUint8 iType[1];

	};

inline HDbsColumns::HDbsColumns(TInt aCount)

	:iCount(aCount)

	{}

inline void HDbsColumns::Set(const TUint8* aPtr)

	{Mem::Copy(iType,aPtr,iCount);}

inline TPtr8 HDbsColumns::Ptr()

	{return TPtr8(iType,iCount);}

inline TInt HDbsColumns::Count() const

	{return iCount;}

inline TDbColType HDbsColumns::Type(TDbColNo aCol) const

	{__DEBUG(Check(aCol));return TDbColType(iType[aCol-1]);}

HDbsColumns* HDbsColumns::NewL(TInt aCount)

	{

	return new(User::AllocL(_FOFF(HDbsColumns,iType[aCount]))) HDbsColumns(aCount);

	}

void HDbsColumns::Check(TDbColNo aColNo) const

	{

	__ASSERT_ALWAYS(aColNo>0&&aColNo<=iCount,Panic(EDbsInvalidColumn));

	}

// Class CDbsCursor

CDbsCursor::CDbsCursor()

	:iState(EAtBeginning)

	{}

CDbsCursor* CDbsCursor::NewL(const RDbsObject& aDbs,TDbsFunction aFunction,TIpcArgs& aArgs)

	{

	CDbsCursor* self=new(ELeave) CDbsCursor;

	CleanupStack::PushL(self);

	self->ConstructL(aDbs,aFunction,aArgs);

	CleanupStack::Pop();

	return self;

	}

void CDbsCursor::ConstructL(const RDbsObject& aDbs,TDbsFunction aFunction,TIpcArgs& aArgs)

//

// construct a cursor from the supplied parameters

// Retrieve the column types, in one pass if possible

//

	{

	TPckgBuf<TDbsColumns> cols;

	aArgs.Set(3,&cols);

	iObject.OpenL(aDbs,aFunction,aArgs);

	iColumns=HDbsColumns::NewL(cols().iCount);

	if (cols().iCount<=cols().EMax)

		iColumns->Set(cols().iData);	// we have the column types

	else

		{	// too many for the fixed buffer, make a second call to get the columns

		TPtr8 ptr=iColumns->Ptr();

		aArgs.Set(3,&ptr);

		iObject.SendReceiveL(EDbsCursorColumnTypes,aArgs);

		}

	}

CDbsCursor::~CDbsCursor()

	{

	iObject.Close();

	delete iColumns;

	iRow.Close();

	}

TDbColType CDbsCursor::Type(TDbColNo aCol) const

	{

	iColumns->Check(aCol);

	return iColumns->Type(aCol);

	}

void CDbsCursor::Reset()

	{

	iState=EAtBeginning;

	iObject.SendReceive(EDbsCursorReset);

	}

TBool CDbsCursor::EvaluateL()

	{

	iState=EUnknown;

	return iObject.SendReceiveL(EDbsCursorEvaluate);

	}

void CDbsCursor::Evaluate(TRequestStatus& aStatus)

	{

	iState=EUnknown;

	iObject.SendReceive(EDbsCursorEvaluate,aStatus);

	}

TBool CDbsCursor::Unevaluated()

	{

	return iObject.SendReceive(EDbsCursorUnevaluated);

	}

void CDbsCursor::SetIndexL(const TDesC* anIndex)

	{

	iObject.SendReceiveL(EDbsCursorSetIndex,TIpcArgs(anIndex));

	iState=EAtBeginning;

	}

TBool CDbsCursor::SeekL(const TDbLookupKey& aKey,RDbTable::TComparison aComparison)

	{

	TPtrC8 key(TDbsParam::PrepareLC(aKey));

	iState=EUnknown;

	TBool found=iObject.SendReceiveL(EDbsCursorSeek,TIpcArgs(&key,key.Length(),aComparison));

	CleanupStack::PopAndDestroy();	// key

	if (found)

		iState=EAtRow;

	return found;

	}

TBool CDbsCursor::AtBeginning()

	{

	if (iState==EUnknown && iObject.SendReceive(EDbsCursorAtBeginning)>0)

		iState=EAtBeginning;

	return iState==EAtBeginning;

	}

TBool CDbsCursor::AtEnd()

	{

	if (iState==EUnknown && iObject.SendReceive(EDbsCursorAtEnd)>0)

		iState=EAtEnd;

	return iState==EAtEnd;

	}

TBool CDbsCursor::AtRow()

	{

	if (iState==EUnknown && iObject.SendReceive(EDbsCursorAtRow)>0)

		iState=EAtRow;

	return iState>=EAtRow;

	}

TInt CDbsCursor::CountL(RDbRowSet::TAccuracy aAccuracy)

//

// valid response is >=0 + undefined (==-1)

// server returns +1 for non-error conditions

//

	{

	return iObject.SendReceiveL(EDbsCursorCount,TIpcArgs(aAccuracy))-1;

	}

TBool CDbsCursor::GotoL(RDbRowSet::TPosition aPosition)

	{

	TBool atrow=RetrieveL(EDbsCursorGotoPos,aPosition);

	if (atrow)

		iState=ERetrieve;

	else

		{

		switch (aPosition)

			{

		default:

			__ASSERT(0);

		case RDbRowSet::EEnd:

		case RDbRowSet::EFirst:

		case RDbRowSet::ENext:

			iState=EAtEnd;

			break;

		case RDbRowSet::EBeginning:

		case RDbRowSet::ELast:

		case RDbRowSet::EPrevious:

			iState=EAtBeginning;

			break;

			}

		}

	return atrow;

	}

void CDbsCursor::Bookmark(TDbBookmark::TMark& aMark)

	{

	TPckg<TDbBookmark::TMark> pckg(aMark);

	iObject.SendReceive(EDbsCursorBookmark,TIpcArgs(TIpcArgs::ENothing,TIpcArgs::ENothing,TIpcArgs::ENothing,&pckg));

	}

void CDbsCursor::GotoL(const TDbBookmark::TMark& aMark)

	{

	TPckgC<TDbBookmark::TMark> pckg(aMark);

	iState=EUnknown;

	iObject.SendReceiveL(EDbsCursorGotoBookmark,TIpcArgs(&pckg));

	}

LOCAL_C void CancelCursor(TAny* aPtr)

	{

	STATIC_CAST(CDbCursor*,aPtr)->Cancel();

	}

TBool CDbsCursor::RetrieveL(TDbsFunction aFunction,TInt aArg0)

//

// Read the row buffer

//

	{

	iState=EUnknown;

	TInt size;

	for (;;)

		{

		TInt max=iRow.MaxSize();

		TPtr8 row((TUint8*)iRow.First(),max);

		size=iObject.SendReceiveL(aFunction,TIpcArgs(aArg0,TIpcArgs::ENothing,max,&row))-1;

		if (size<0)

			return EFalse;		// no row to retrieve

		if (size<=max)

			break;

		// didn't fit! Grow the buffer

		if (aFunction!=EDbsCursorRetrieveRow)

			{

			CleanupStack::PushL(TCleanupItem(CancelCursor,this));	// in case this goes wrong!

			aFunction=EDbsCursorRetrieveRow;

			}

		iRow.GrowL(size);

		}

	iRow.SetSize(size);

	if (aFunction==EDbsCursorRetrieveRow)

		CleanupStack::Pop();

	return ETrue;

	}

void CDbsCursor::GetL()

	{

	if (iState!=ERetrieve)

		RetrieveL(EDbsCursorGet);

	iState=ERead;

	}

void CDbsCursor::InsertL(TInsert aClearRow)

	{

	RetrieveL(EDbsCursorInsert,aClearRow);

	iState=EWrite;

	iChangedBlob=EFalse;

	}

void CDbsCursor::UpdateL()

	{

	RetrieveL(EDbsCursorUpdate);

	iState=EWrite;

	iChangedBlob=EFalse;

	}

void CDbsCursor::Cancel()

	{

	if (iState==EUnknown || iState==EWrite)

		iObject.SendReceive(EDbsCursorCancel);

	}

void CDbsCursor::PutL()

	{

	TInt size=iRow.Size();

	TPtrC8 row((const TUint8*)iRow.First(),size);

	iObject.SendReceiveL(EDbsCursorPut,TIpcArgs(&row,size,iChangedBlob));// if iChangedBlob false, server can optimize put

	iState=ERead;		// we can still look at the row we put

	}

void CDbsCursor::DeleteL()

	{

	iState=EUnknown;

	iObject.SendReceiveL(EDbsCursorDelete);

	}

TInt CDbsCursor::ColumnCount()

	{

	return iColumns->Count();

	}

void CDbsCursor::ColumnsL(CDbColSet& aColSet)

//

// optimise the retreival of all columns

//

	{

	TIpcArgs m;

	RReadStream in(HDbsBuf::NewLC(iObject,EDbsCursorColumns,m));

	in>>aColSet;

	CleanupStack::PopAndDestroy();	// buffer

	}

void CDbsCursor::ColumnDef(TDbCol& aCol,TDbColNo aColNo)

	{

	TPckg<TDbCol> pckg(aCol);

	iColumns->Check(aColNo);

	iObject.SendReceive(EDbsCursorColumnDef,TIpcArgs(aColNo,TIpcArgs::ENothing,TIpcArgs::ENothing,&pckg));

	}

TDbColType CDbsCursor::ColumnType(TDbColNo aCol)

	{

	return Type(aCol);

	}

RDbRow* CDbsCursor::RowBuffer()

//

// Invoked by the server-- should not be called

//

	{

	__ASSERT(0);

	return 0;

	}

TDbColumnC CDbsCursor::ColumnC(TDbColNo aCol)

//

// check row is valid for extraction

//

	{

	__ASSERT_ALWAYS(iState>=ERead,Panic(EDbsNoRowData));

	return TDbColumnC(iRow,aCol);

	}

TDbColumn CDbsCursor::Column(TDbColNo aCol)

//

// check row is valid for writing

//

	{

	__ASSERT_ALWAYS(iState==EWrite,Panic(EDbsNotInUpdate));

	return TDbColumn(iRow,aCol);

	}

void CDbsCursor::ReplaceBlobL(TDbColumn& aCol)

//

// We no longer know what the shape of a blob is, mark it as "unknown"

//

	{

	iChangedBlob=ETrue;

	aCol.SetBlobL(KUnknownBlobId);

	}

void CDbsCursor::SetNullL(TDbColNo aCol)

//

// Make the column Null

//

	{

	TDbColumn col=Column(aCol);

	if (!TDbCol::IsLong(Type(aCol)))

		col.SetNull();

	else if (!TDbColumnC(col).IsNull())

		{

		ReplaceBlobL(col);

		iObject.SendReceiveL(EDbsCursorSetNull,TIpcArgs(aCol));

		}

	}

TInt CDbsCursor::ColumnSize(TDbColNo aCol)

	{

	TDbColumnC col(ColumnC(aCol));

	if (!TDbCol::IsLong(Type(aCol)))

		return col.Size();

	TInt size=col.Blob().Size();

	if (size>=0)

		return size;

	// unknown size, so ask the server

	return iObject.SendReceive(EDbsCursorColumnSize,TIpcArgs(aCol));

	}

MStreamBuf* CDbsCursor::ColumnSourceL(TDbColNo aCol)

	{

	TDbColumnC col(ColumnC(aCol));

	if (!TDbCol::IsLong(iColumns->Type(aCol)))

		return HDbsReadBuf::NewL(col.PtrC8());

	// blobs

	const TDbBlob& blob=col.Blob();

	if (blob.IsInline())

		return HDbsReadBuf::NewL(blob.PtrC8());

	// get it from the server

	TIpcArgs args(aCol);

	return HDbsBuf::NewL(iObject,EDbsCursorColumnSource,args);

	}

MStreamBuf* CDbsCursor::ColumnSinkL(TDbColNo aCol)

	{

	TDbColumn col(Column(aCol));

	ReplaceBlobL(col);

	TIpcArgs args(aCol);

	return HDbsBuf::NewL(iObject,EDbsCursorColumnSink,args);

	}

CDbRowConstraint* CDbsCursor::OpenConstraintL(const TDbQuery& aQuery)

	{

	const TDesC& des = aQuery.Query();

	CDbsConstraint* c=new(ELeave) CDbsConstraint();

	CleanupStack::PushL(c);

	c->iObject.OpenL(iObject,EDbsCursorOpenConstraint,TIpcArgs(&des,aQuery.Comparison()));

	CleanupStack::Pop();

	return c;

	}

TBool CDbsCursor::MatchL(CDbRowConstraint& aConstraint)

	{

	TInt handle = STATIC_CAST(CDbsConstraint&,aConstraint).iObject.Handle();

	return iObject.SendReceiveL(EDbsCursorMatch,TIpcArgs(handle));

	}

TInt CDbsCursor::FindL(RDbRowSet::TDirection aDirection,const TDbQuery& aCriteria)

//

// Server returns result-KErrNotFound, to ensure non-leaving on not found

//

	{

	const TDesC& des = aCriteria.Query();

	iState=EUnknown;

	TInt f=iObject.SendReceiveL(EDbsCursorFind,TIpcArgs(&des,aCriteria.Comparison(),aDirection))+KErrNotFound;

	if (f>=0)

		iState=EAtRow;

	return f;

	}

// Class CDbsConstraint

CDbsConstraint::~CDbsConstraint()

	{

	iObject.Close();

	}