// 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 "UM_STD.H"

EXPORT_C TMemBuf::TMemBuf()
	: iBase(NULL)
/** Constructs an empty object.

Call Set() before using the object. */
	{}

EXPORT_C void TMemBuf::Set(TUint8* aPtr,TUint8* anEnd,TInt aMode)
/** Sets up the stream to use the specified area of plain memory.

@param aPtr The start address for the area of plain memory that hosts the 
stream and that also acts as the intermediate buffer.
@param anEnd The end address for the area of plain memory that hosts the stream 
and that also acts as the intermediate buffer. The addressed byte is outside 
the memory area.
@param aMode The mode in which the stream is to be used. It can be used in 
either or both read and write modes, represented by ERead and EWrite.
@see MStreamBuf::TRead
@see MStreamBuf::TWrite */
	{
	if (aPtr==NULL && anEnd==NULL)
		aPtr=anEnd=(TUint8*)this;	// treat null data as seekable zero-length data
	iBase=aPtr;
	SetBuf(ERead,(aMode&ERead)?aPtr:NULL,anEnd);
	SetBuf(EWrite,(aMode&EWrite)?aPtr:NULL,anEnd);
	}

EXPORT_C TInt TMemBuf::UnderflowL(TInt)
//
// The read buffer is empty.
//
	{
	return 0;
	}

EXPORT_C void TMemBuf::OverflowL()
//
// Ran out of write buffer.
//
	{
	__LEAVE(KErrOverflow);
	}

EXPORT_C TStreamPos TMemBuf::DoSeekL(TMark aMark,TStreamLocation aLocation,TInt anOffset)
//
// Position the mark(s) indicated by aMark at anOffset from aLocation.
//
	{
	TUint8* ptr=0;
	switch (aLocation)
		{
	case EStreamBeginning:
		ptr=Base()+anOffset;
		break;
	case EStreamMark:
		ptr=Ptr(aMark)+anOffset;
		break;
	case EStreamEnd:
		ptr=End()+anOffset;
		break;
	default:
		Panic(EMemLocationInvalid);
		break;
		}
	TInt r=KErrNone;
	if (ptr>End())
		{
		ptr=End();
		r=KErrEof;
		}
	else if (ptr<Base())
		{
		ptr=Base();
		r=KErrEof;
		}
//
	SetPtr(aMark,ptr);
	__LEAVE_IF_ERROR(r);
	return TStreamPos(ptr-Base());
	}

EXPORT_C TDesBuf::TDesBuf()
	: iDes(NULL)
/** Constructs an empty object.

Call Set() before using the object. */
	{}

EXPORT_C void TDesBuf::Set(TDes8& aDes,TInt aMode)
/** Sets up the stream to use the specified descriptor.

@param aDes The descriptor that hosts the stream and that also acts as the 
intermediate buffer.
@param aMode The mode in which the buffer is to be used. It can be used in 
either or both read and write modes, represented by ERead and EWrite.
@see TDes8
@see MStreamBuf::TRead
@see MStreamBuf::TWrite */
	{
	iDes=&aDes;
	TUint8* ptr=(TUint8*)aDes.Ptr();
	SetBuf(ERead,(aMode&ERead)?ptr:NULL,ptr+aDes.Length());
	SetBuf(EWrite,(aMode&EWrite)?ptr:NULL,ptr+aDes.MaxLength());
	}

EXPORT_C TInt TDesBuf::UnderflowL(TInt)
//
// Check if there's any more to be read.
//
	{
	Consolidate();
	return Avail(ERead);
	}

EXPORT_C void TDesBuf::OverflowL()
//
// Ran out of write buffer.
//
	{
	__LEAVE(KErrOverflow);
	}

EXPORT_C void TDesBuf::DoSynchL()
//
// Synchronise descriptor and stream buffer.
//
	{
	Consolidate();
	}

EXPORT_C TStreamPos TDesBuf::DoSeekL(TMark aMark,TStreamLocation aLocation,TInt anOffset)
//
// Position the mark(s) indicated by aMark at anOffset from aLocation.
//
	{
	Consolidate();
	TUint8* ptr=0;
	switch (aLocation)
		{
	case EStreamBeginning:
		ptr=Base()+anOffset;
		break;
	case EStreamMark:
		ptr=Ptr(aMark)+anOffset;
		break;
	case EStreamEnd:
		ptr=End(ERead)+anOffset;
		break;
	default:
		Panic(EMemLocationInvalid);
		break;
		}
	TInt r=KErrNone;
	if (ptr>End(ERead))
		{
		ptr=End(ERead);
		r=KErrEof;
		}
	else if (ptr<Base())
		{
		ptr=Base();
		r=KErrEof;
		}
//
	SetPtr(aMark,ptr);
	__LEAVE_IF_ERROR(r);
	return TStreamPos(ptr-Base());
	}

void TDesBuf::Consolidate()
//
// Update the descriptor's length as well as the read limit.
//
	{
	TUint8* ptr=Ptr(EWrite);
	if (ptr==NULL)
		return;			// ERead only desbuf
	TUint8* base=Base();
	TInt len=Max(Des().Length(),ptr-base);
	Des().SetLength(len);
	SetEnd(ERead,base+len);
	}

EXPORT_C TBufBuf::TBufBuf()
	: iBuf(NULL)
/** Constructs an empty object.

Call Set() before using the object. */
	{}

EXPORT_C void TBufBuf::Set(CBufBase& aBuf,TInt aPos,TInt aMode)
/** Sets up the stream to use the specified dynamic buffer.

@param aBuf The dynamic buffer that hosts the stream and that also acts as 
the intermediate buffer.
@param aPos The offset within the dynamic buffer where the stream starts.
@param aMode The mode in which the stream is to be used. It can be used in 
either or both read and write modes, represented by ERead and EWrite. In addition, 
specify TBufBuf::EInsert to imply insert mode; specify TBufBuf::ETruncate 
to imply truncate mode. If neither TBufBuf::EInsert nor TBufBuf::ETruncate 
are specified, then overwrite mode is implied. Both TBufBuf::EInsert and TBufBuf::ETruncate 
imply EWrite.
@see CBufBase
@see MStreamBuf::TRead
@see MStreamBuf::TWrite */
	{
	iBuf=&aBuf;
	SetPos(ERead|EWrite,aPos);
	if (aMode&(ETruncate|EInsert))
		aMode|=EWrite; // truncate and insert imply write
	iMode=aMode;
	//Initialize base class data members.
	//The first Read/Write call will reinitialize them with non NULL values.
	TStreamBuf::SetBuf(iMode & (EWrite | ERead), NULL, NULL);
	}

EXPORT_C TInt TBufBuf::UnderflowL(TInt)
//
// Establish the buffer's read area.
//
	{
	__ASSERT_ALWAYS(iMode&ERead,Panic(EMemCannotRead));
	__ASSERT_DEBUG(Ptr(ERead)==End(ERead),User::Invariant());
	TInt pos=Pos(ERead);
	TPtr8 seg=Buf().Ptr(pos);
	TUint8* ptr=(TUint8*)seg.Ptr();
	TInt len=seg.Length();
	if (iMode&ETruncate)
		{
		TInt left=Pos(EWrite)-pos;
		__ASSERT_DEBUG(left>=0,User::Invariant());
		if (left<len)
			len=left;
		}
	SetBuf(ERead,ptr,ptr+len);
	SetPos(ERead,pos+len);
	return len;
	}

EXPORT_C void TBufBuf::OverflowL()
//
// Establish the buffer's write area.
//
	{
	__ASSERT_ALWAYS(iMode&EWrite,Panic(EMemCannotWrite));
	__ASSERT_DEBUG(Ptr(EWrite)==End(EWrite)&&Pos(EWrite)<Buf().Size(),User::Invariant());
	TInt pos=Pos(EWrite);
	TPtr8 seg=Buf().Ptr(pos);
	TUint8* ptr=(TUint8*)seg.Ptr();
	TInt len=seg.Length();
	SetBuf(EWrite,ptr,ptr+len);
	SetPos(EWrite,pos+len);
	}

EXPORT_C void TBufBuf::DoSynchL()
//
// Synchronise buffer and stream buffer and compress.
//
	{
	Consolidate();
	Buf().Compress();
	}

EXPORT_C void TBufBuf::DoWriteL(const TAny* aPtr,TInt aLength)
//
// Consume aLength bytes, taking care of any reallocation.
//
	{
	__ASSERT_ALWAYS(iMode&EWrite,Panic(EMemCannotWrite));
	__ASSERT_DEBUG(aLength>=0,Panic(EMemWriteLengthNegative));
	__ASSERT_DEBUG(aLength>0,Panic(EMemWriteNoTransfer));
	TInt len=(iMode&EInsert?0:Min(aLength,Buf().Size()-Mark(EWrite)));
	if (len>0)
		{
		TStreamBuf::DoWriteL(aPtr,len);
		aPtr=(TUint8*)aPtr+len;
		aLength-=len;
		}
	if (aLength>0)
		{
		Consolidate();
		TInt pos=Pos(EWrite);
		Buf().InsertL(pos,aPtr,aLength);
		if (Pos(ERead)>pos)
			MovePos(ERead,aLength);
		SetPos(EWrite,pos+aLength);
		}
	}

EXPORT_C TStreamPos TBufBuf::DoSeekL(TMark aMark,TStreamLocation aLocation,TInt anOffset)
//
// Position the mark(s) indicated by aMark at anOffset from aLocation.
//
	{
	Consolidate();
	TInt size=Buf().Size();
	switch (aLocation)
		{
	case EStreamBeginning:
		break;
	case EStreamMark:
		anOffset+=Pos(aMark);
		break;
	case EStreamEnd:
		anOffset+=size;
		break;
	default:
		Panic(EMemLocationInvalid);
		break;
		}
	TInt r=KErrNone;
	if (anOffset>size)
		{
		anOffset=size;
		r=KErrEof;
		}
	else if (anOffset<0)
		{
		anOffset=0;
		r=KErrEof;
		}
//
	SetPos(aMark,anOffset);
	__LEAVE_IF_ERROR(r);
	return TStreamPos(anOffset);
	}

void TBufBuf::Consolidate()
//
// Empty buffer areas and, in truncate mode, cut off at the current write position.
//
	{
	MovePos(ERead,-Avail(ERead));
	MovePos(EWrite,-Avail(EWrite));
	SetBuf(ERead|EWrite,NULL,NULL);
	if (iMode&ETruncate)
		{
		Buf().Delete(Pos(EWrite),Buf().Size()-Pos(EWrite));
		iMode&=~ETruncate;
		}
	}

void TBufBuf::SetPos(TMark aMark,TInt aPos)
//
// Set the buffer position for the mark(s) indicated by aMark
//
	{
	__ASSERT_ALWAYS(!(aMark&~(ERead|EWrite)),Panic(EMemMarkInvalid));
	if (aMark&ERead)
		SetPos(ERead,aPos);
	if (aMark&EWrite)
		SetPos(EWrite,aPos);
	}

TInt TBufBuf::Pos(TMark aMark) const
//
// Return the buffer position for the mark indicated by aMark.
//
	{
	if (aMark==ERead)
		return Pos(ERead);
//
	__ASSERT_ALWAYS(aMark==EWrite,Panic(EMemMarkInvalid));
	return Pos(EWrite);
	}