// 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 stream buffer classes

// 

//

#include "SD_STD.H"

HDbsBuf* HDbsBuf::NewLC(const RDbsObject& aObject,TDbsFunction aFunction,TIpcArgs& aArgs)

	{

	HDbsBuf* self=new(ELeave) HDbsBuf;

	self->PushL();

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

	return self;

	}

HDbsBuf* HDbsBuf::NewL(const RDbsObject& aObject,TDbsFunction aFunction,TIpcArgs& aArgs)

	{

	HDbsBuf* self=NewLC(aObject,aFunction,aArgs);

	CleanupStack::Pop();

	return self;

	}

void HDbsBuf::ConstructL(const RDbsObject& aObject,TDbsFunction aFunction,TIpcArgs& aArgs)

	{

	TPckg<TDbsStreamBuf> pckg(iBuf);

	aArgs.Set(3,&pckg);

	iIpc.OpenL(aObject,aFunction,aArgs);

	TUint8* base=iBuf.iData;

	// if reading we already have one buffer-full of data

	TInt avail=Max(0,Min(iBuf.iExt,KDbsStreamBufSize));

	SetBuf(ERead,base,base+avail);

	SetPos(ERead,avail);

	SetBuf(EWrite,base,base);

	SetPos(EWrite,0);

	}

TInt HDbsBuf::UnderflowL(TInt)

//

// Fill the buffer's read area.

//

	{

	// when handle is null there is no data to read from server

	if(!iIpc.Handle())

		return 0;

	__ASSERT(Avail(ERead)==0);

	TUint8* base=iBuf.iData;

	IpcWriteL(base,Lag(EWrite));

	SetBuf(EWrite,base,base);

//

	TInt len=IpcReadL(base,iBuf.ESize);

	SetBuf(ERead,base,base+len);

	return len;

	}

void HDbsBuf::OverflowL()

//

// Set up the buffer's write area.

//

	{

	__ASSERT(Avail(EWrite)==0);

	TUint8* base=iBuf.iData;

	MovePos(ERead,Lag(ERead));

	SetBuf(ERead,base,base);

//

	IpcWriteL(base,Lag(EWrite));

	SetBuf(EWrite,base,base+iBuf.ESize);

	}

void HDbsBuf::DoRelease()

	{

	delete this;

	}

void HDbsBuf::DoSynchL()

//

// Synchronise this buffer with its file, giving up on outstanding writes in case of failure.

//

	{

	TUint8* base=iBuf.iData;

	MovePos(ERead,Lag(ERead));

	TInt lag=Lag(EWrite);

	SetBuf(ERead|EWrite,base,base);

	iBuf.iExt=-1;

	IpcWriteL(base,lag);

	iIpc.SendReceiveL(EDbsStreamSynch);

	}

TInt HDbsBuf::DoReadL(TAny* aPtr,TInt aMaxLength)

//

// Read direct from ipc if asked to transfer more than a bufferful.

//

	{

	__ASSERT(aMaxLength>=0);

	__ASSERT(aMaxLength>0);

	TInt avail=Avail(ERead);

	__ASSERT(avail>=0&&Avail(EWrite)>=0);

	if (avail>0)

		{

		TInt len=Min(aMaxLength,avail);

		TUint8* ptr=Ptr(ERead);

		aPtr=Mem::Copy(aPtr,ptr,len);

		SetPtr(ERead,ptr+len);

		aMaxLength-=len;

		if (aMaxLength==0)

			return len; // that's it

		}

	__ASSERT(Avail(ERead)==0);

	if (aMaxLength<iBuf.ESize)

		return avail+TStreamBuf::DoReadL(aPtr,aMaxLength);

//

	// when handle is null there is no more data to read from server

	if(!iIpc.Handle())

		return avail;

	TUint8* base=iBuf.iData;

	IpcWriteL(base,Lag(EWrite));

	SetBuf(ERead|EWrite,base,base);

	return avail+IpcReadL(aPtr,aMaxLength);

	}

void HDbsBuf::DoWriteL(const TAny* aPtr,TInt aLength)

//

// Write direct to ipc if asked to transfer more than a bufferful.

//

	{

	__ASSERT(aLength>=0);

	__ASSERT(aLength>0);

	TInt avail=Avail(EWrite);

	__ASSERT(Avail(ERead)>=0&&avail>=0);

	if (avail>0)

		{

		TInt len=Min(aLength,avail);

		SetPtr(EWrite,Mem::Copy(Ptr(EWrite),aPtr,len));

		aLength-=len;

		if (aLength==0)

			return; // done

//

		aPtr=(TUint8*)aPtr+len;

		}

	__ASSERT(Avail(EWrite)==0);

	if (aLength<iBuf.ESize)

		TStreamBuf::DoWriteL(aPtr,aLength);

	else

		{

		TUint8* base=iBuf.iData;

		IpcWriteL(base,Lag(EWrite));

		MovePos(ERead,Lag(ERead));

		SetBuf(ERead|EWrite,base,base);

		IpcWriteL(aPtr,aLength);

		}

	}

TStreamPos HDbsBuf::DoSeekL(TMark aMark,TStreamLocation aLocation,TInt anOffset)

//

// Position the mark(s) indicated by aMark at anOffset from aLocation.

//

	{

	TUint8* base=iBuf.iData;

	TInt end=EndL();

//

	switch (aLocation)

		{

	case EStreamBeginning:

		break;

	case EStreamMark:

		switch (aMark)

			{

		case ERead:

			anOffset+=Mark(ERead);

			break;

		case EWrite:

			anOffset+=Mark(EWrite);

			break;

		default:

			Panic(EDbsStreamMarkInvalid);

			break;

			}

		break;

	case EStreamEnd:

		anOffset+=end;

		break;

	default:

		Panic(EDbsStreamLocationInvalid);

		break;

		}

	TInt r=KErrNone;

	if (anOffset<0)

		{

		anOffset=0;

		r=KErrEof;

		}

	else if (anOffset>end)

		{

		anOffset=end;

		r=KErrEof;

		}

//

	__ASSERT_ALWAYS(!(aMark&~(ERead|EWrite)),Panic(EDbsStreamMarkInvalid));

	if (aMark&ERead)

		{

		TInt lag=anOffset-Pos(ERead);

		if (lag>=base-End(ERead)&&lag<=0)

			SetPtr(ERead,End(ERead)+lag);

		else

			{

			SetPos(ERead,anOffset);

			SetBuf(ERead,base,base);

			}

		}

	if (aMark&EWrite&&anOffset!=Mark(EWrite))

		{

		IpcWriteL(base,Lag(EWrite));

		SetPos(EWrite,anOffset);

		SetBuf(EWrite,base,base);

		}

	__LEAVE_IF_ERROR(r);

	return TStreamPos(anOffset);

	}

TInt HDbsBuf::IpcReadL(TAny* aPtr,TInt aMaxLength)

//

// Read from the server at the current read position.

//

	{

	__ASSERT(aMaxLength>=0);

	if (aMaxLength==0)

		return 0;

//

	TPtr8 des((TUint8*)aPtr,aMaxLength);

	TInt pos=Pos(ERead);

	TInt len=iIpc.SendReceiveL(EDbsStreamRead,TIpcArgs(pos,&des,aMaxLength));

	pos+=len;

	if (len<aMaxLength)

		iBuf.iExt=pos; // end-of-file encountered

	SetPos(ERead,pos);

	return len;

	}

void HDbsBuf::IpcWriteL(const TAny* aPtr,TInt aLength)

//

// Write to the server at the current write position.

//

	{

	__ASSERT(aLength>=0);

	if (aLength==0)

		return;

//

	TPtrC8 ptr((TUint8*)aPtr,aLength);

	TInt ext=iBuf.iExt;

	iBuf.iExt=-1;

	TInt pos=Pos(EWrite);

	iIpc.SendReceiveL(EDbsStreamWrite,TIpcArgs(pos,&ptr));

	pos+=aLength;

	if (ext>=0&&pos>ext)

		iBuf.iExt=pos;

	SetPos(EWrite,pos);

	}

TInt HDbsBuf::EndL()

//

// Determine the end of the stream

//

	{

	TInt ext=iBuf.iExt;

	if (ext<0)

		iBuf.iExt=ext=iIpc.SendReceiveL(EDbsStreamSize);

	return Max(ext,Mark(EWrite));

	}

// Class HDbsReadBuf

inline HDbsReadBuf::HDbsReadBuf(const TDesC8& aDes)

	{

	TUint8* ptr=CONST_CAST(TUint8*,aDes.Ptr());

	Set(ptr,ptr+aDes.Length(),ERead);

	}

HDbsReadBuf* HDbsReadBuf::NewL(const TDesC8& aDes)

	{

	return new(ELeave) HDbsReadBuf(aDes);

	}

void HDbsReadBuf::DoRelease()

	{

	delete this;

	}

// Class HDbsStream

TInt HDbsStream::ReadL(const RMessage2& aMessage)

	{

	TInt pos=aMessage.Int0();

	if (pos!=iRPos)

		iHost.SeekL(iHost.ERead,EStreamBeginning,pos);

	iRPos=-1;

	TInt len=aMessage.Int2();

	pos+=len;

	TInt tfr=len;

	for (;;)

		{

		TUint8 buf[KDbsStreamIoSize];

		TInt read=iHost.ReadL(buf,Min(tfr,KDbsStreamIoSize));

		if (read==0)

			break;

		aMessage.WriteL(1,TPtrC8(buf,read),len-tfr);

		tfr-=read;

		if (tfr==0)

			break;

		if (read<KDbsStreamIoSize)

			break;

		}

	iRPos=pos-tfr;

	return len-tfr;

	}

void HDbsStream::WriteL(const RMessage2& aMessage)

	{

	TInt pos=aMessage.Int0();

	if (pos!=iWPos)

		iHost.SeekL(iHost.EWrite,EStreamBeginning,pos);

	iWPos=-1;

	TInt offset=0;

	TBuf8<KDbsStreamIoSize> buf;

	for (;;)

		{

		aMessage.ReadL(1,buf,offset);

		TInt len=buf.Length();

		if (len==0)

			break;

		iHost.WriteL(buf.Ptr(),len);

		offset+=len;

		if (len<KDbsStreamIoSize)

			break;

		}

	iWPos=pos+offset;

	}

// Class HBufBuf

void HBufBuf::DoRelease()

	{

	delete this;

	}

HBufBuf* HBufBuf::NewLC()

	{

	HBufBuf* self=new(ELeave) HBufBuf;

	self->PushL();

	self->iBuf=CBufSeg::NewL(EGranularity);

	self->Set(*self->iBuf,0,ERead|EWrite);

	return self;

	}