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

TInt RFrame16Buf::Offset(TStreamPos aBase,TStreamPos aPos)

	{

	TInt off=aPos-aBase;

	__ASSERT_DEBUG(off>=0,Panic(EStreamPosInvalid));

	TInt n=off/(KFrameFullLength16+KSizeFrameDes16);

		// number of full frames from base

	off-=n<<KShiftFrameDes16;

		// target offset in frame coordinates

	TInt over=off-(n<<KShiftFrameLength16)-KFrameFullLength16;

		// adjust for overshoot into the frame descriptor

	__ASSERT_DEBUG(over>=-KFrameFullLength16&&over<TInt(KSizeFrameDes16),User::Invariant());

	if (over>0)

		off-=over;

	return off;

	}

TStreamPos RFrame16Buf::Position(TStreamPos aBase,TInt anOffset)

	{

	return aBase+(anOffset+(anOffset>>KShiftFrameLength16<<KShiftFrameDes16));

	}

RFrame16Buf::RFrame16Buf(TStreamPos aBase)

	: iBase(aBase),iHost(NULL),iExt(KFrameNonexistent16)

	{

	__ASSERT_DEBUG(aBase>=KStreamBeginning+KSizeFrameDes16,Panic(EStreamPosInvalid));

	}

TInt RFrame16Buf::ExtendL(TStreamExchange& aHost,TInt anExtent,TInt aMode)

	{

	__ASSERT_DEBUG(anExtent>=0,Panic(EStreamExtentNegative));

	__ASSERT_DEBUG((KMaskFrameType16&aMode)!=EFrameContinuation16,Panic(EStreamTypeInvalid));

	TFrameDes16 des[2]={0,TFrameDes16(KMaskFrameType16&aMode|KFrameOpen16)};

	TUint8* ptr=(TUint8*)&des[1];

	TInt len=KSizeFrameDes16;

	TStreamPos pos=Position(anExtent);

	TInt off=anExtent;

	anExtent&=KMaskFrameLength16;

	if (anExtent==0)

		pos-=KSizeFrameDes16;

	else

		{

		anExtent=KFrameFullLength16-anExtent;

		if (anExtent>KSizeFrameDes16)

			off+=KSizeFrameDes16;

		else

			{

			ptr-=anExtent;

			len+=anExtent;

			off+=anExtent;

			}

		}

//

	TStreamMark mark(pos);

	mark.WriteL(aHost,ptr,len); // platform dependency

	mark.Withdraw(aHost);

	Set(aHost,off,0,aMode);

	return off;

	}

void RFrame16Buf::OpenL(TStreamExchange& aHost,TInt anOffset,TInt aMode)

	{

	__ASSERT_DEBUG(anOffset>=0,Panic(EStreamOffsetNegative));

	__ASSERT_DEBUG((KMaskFrameType16&aMode)!=EFrameContinuation16,Panic(EStreamTypeInvalid));

	TStreamMark mark(Position(anOffset)-KSizeFrameDes16);

	TFrameDes16 des;

	TInt frame=mark.ReadL(aHost,&des,KSizeFrameDes16);

		// platform dependency

	mark.Withdraw(aHost);

	__ASSERT_DEBUG(frame>=0&&frame<=KSizeFrameDes16,Panic(EStreamReadInBreach));

	if (frame<KSizeFrameDes16)

		__LEAVE(KErrEof);

//

	frame=des;

	if ((frame^aMode)&KMaskFrameType16)

		__LEAVE(KErrCorrupt);

//

	TInt in=anOffset&KMaskFrameLength16;

	frame&=KMaskFrameLength16;

	if (frame==KFrameOpen16)

		frame=KFrameFullLength16-in;

	if (in+frame>KFrameFullLength16)

		__LEAVE(KErrCorrupt);

//

	Set(aHost,anOffset,anOffset+frame,aMode);

	}

void RFrame16Buf::Set(TStreamExchange& aHost,TInt anOffset,TInt anExtent,TInt aMode)

	{

	__ASSERT_DEBUG(anOffset>=0||anOffset==anExtent,Panic(EStreamOffsetNegative));

	__ASSERT_DEBUG(anExtent>=0||anOffset==anExtent,Panic(EStreamExtentNegative));

	iHost=&aHost;

	iOff=anOffset;

	iExt=anExtent;

	TInt lim;

	if (anOffset<0)

		lim=anExtent;

	else

		{

		TStreamPos start=Position(anOffset);

		if (aMode&ERead)

			iRMark=start;

		else

			iRMark.Clear();

		if (aMode&EWrite)

			iWMark=start;

		else

			iWMark.Clear();

		lim=(anOffset&~KMaskFrameLength16)+KFrameFullLength16;

		if (anExtent>0&&lim>anExtent)

			lim=anExtent;

		}

	iRAvail=iWAvail=lim-anOffset;

	iRLim=iWLim=lim;

	iMode=aMode;

	}

void RFrame16Buf::CommitL()

	{

	__ASSERT_DEBUG(!IsCommitted(),Panic(EStreamCommitted));

	TInt ext=Host().SizeL()-Base().Offset();

	if (ext<0)

		__LEAVE(KErrCorrupt);

//

	TInt n=ext/(KFrameFullLength16+KSizeFrameDes16);

		// number of full frames from base

	ext-=n<<KShiftFrameDes16;

		// end in frame coordinates

	TInt off=Offset();

	if (ext==off)

		{ // committing an empty stream

		iOff=iExt=KFrameNonexistent16;

		return;

		}

//

	TInt frame=ext-(n<<KShiftFrameLength16);

		// size of final frame (remainder of the division above)

	__ASSERT_DEBUG(frame>=0&&frame<KFrameFullLength16+KSizeFrameDes16,User::Invariant());

	if (ext<off||frame==0||frame>KFrameFullLength16)

		__LEAVE(KErrCorrupt); // bad offset, empty frame or partial frame descriptor

//

	if (frame<KFrameFullLength16)

		{

		TFrameDes16 des;

		if ((off^ext)&~KMaskFrameLength16)

			{ // in a different frame from the one we started in

			off=ext&~KMaskFrameLength16;

			des=TFrameDes16(EFrameContinuation16|frame);

			}

		else

			{

			frame-=off&KMaskFrameLength16;

			__ASSERT_DEBUG(frame>0&&frame<KFrameFullLength16,User::Invariant());

			des=TFrameDes16(iMode&KMaskFrameType16|frame);

			}

		TStreamMark mark(Position(off)-KSizeFrameDes16);

		mark.WriteL(Host(),&des,KSizeFrameDes16);

		mark.Withdraw(Host());

		}

	iExt=ext;

	}

void RFrame16Buf::DoRelease()

	{

	if (iHost!=NULL)

		{

		iRMark.Withdraw(*iHost);

		iWMark.Withdraw(*iHost);

		iHost=NULL;

		iExt=KFrameNonexistent16;

		}

	}

void RFrame16Buf::DoSynchL()

	{

	if (IsCommitted())

		return;

//

	CommitL();

	}

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

	{

	__ASSERT_DEBUG(aMaxLength>=0,Panic(EStreamReadLengthNegative));

	__ASSERT_DEBUG(aMaxLength>0,Panic(EStreamReadNoTransfer));

	TInt left=aMaxLength;

	TInt avail=iRAvail;

	if (avail==0)

		goto underflow; // we'd used up the whole frame

//

	do

		{

		__ASSERT_DEBUG(left>0&&avail>0,User::Invariant());

		{

		TInt len=iRMark.ReadL(Host(),aPtr,Min(left,avail));

		__ASSERT_DEBUG(len>=0&&len<=left&&len<=avail,Panic(EStreamReadInBreach));

		iRAvail=avail-=len;

		left-=len;

		if (left==0)

			return aMaxLength; // that's it

//

		aPtr=(TUint8*)aPtr+len;

		}

		if (avail>0)

			{ // we've run out of host 

			if ((Extent()&KMaskFrameLength16)==KFrameOpen16)

				break; // all's well, provided we're open-ended

//

			iRMark.Withdraw(Host());

			__LEAVE(KErrCorrupt);

			}

//

	underflow:

		avail=UnderflowL();

		} while (avail>0);

	return aMaxLength-left;

	}

TInt RFrame16Buf::DoReadL(TDes8& aDes,TInt aMaxLength,TRequestStatus& aStatus)

//

// Read up to aMaxLength bytes asynchronously.

//

	{

//#pragma message( __FILE__ " : 'RFrame16Buf::DoReadL(TDes8&,TInt,TRequestStatus&)' not implemented" )

	__ASSERT_DEBUG(aMaxLength<=aDes.MaxLength(),Panic(EStreamReadBeyondEnd));

	aDes.SetLength(DoReadL((TUint8*)aDes.Ptr(),aMaxLength));

	TRequestStatus* stat=&aStatus;

	User::RequestComplete(stat,KErrNone);

	return aMaxLength;

	}

TStreamTransfer RFrame16Buf::DoReadL(MStreamInput& anInput,TStreamTransfer aTransfer)

	{

	__ASSERT_DEBUG(aTransfer>0,Panic(EStreamReadNoTransfer));

	if (iRAvail>0)

		{

		TInt len=iRMark.ReadL(Host(),anInput,aTransfer[iRAvail]);

		aTransfer-=len;

		iRAvail-=len;

		}

	if (aTransfer>0)

		return anInput.ReadFromL(*this,aTransfer);

//

	return aTransfer;

	}

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

	{

	__ASSERT_DEBUG(aLength>=0,Panic(EStreamWriteLengthNegative));

	__ASSERT_DEBUG(aLength>0,Panic(EStreamWriteNoTransfer));

	TInt avail=iWAvail;

	if (avail==0)

		goto overflow; // we'd used up the whole frame

//

	for (;;)

		{

		__ASSERT_DEBUG(aLength>0&&avail>0,User::Invariant());

		{

		TInt len=Min(aLength,avail);

		iWMark.WriteL(Host(),aPtr,len);

		iWAvail=avail-len;

		aLength-=len;

		if (aLength==0)

			return; // won't worry about the next frame just yet

//

		aPtr=(TUint8*)aPtr+len;

		}

	overflow:

		OverflowL();

		avail=iWAvail;

		};

	}

TInt RFrame16Buf::DoWriteL(const TDesC8& aDes,TInt aMaxLength,TRequestStatus& aStatus)

//

// Write up to aMaxLength bytes asynchronously.

//

	{

//#pragma message( __FILE__ " : 'RFrame16Buf::DoWriteL(const TDesC8&,TInt,TRequestStatus&)' not implemented" )

	__ASSERT_DEBUG(aMaxLength<=aDes.Length(),Panic(EStreamWriteBeyondEnd));

	DoWriteL(aDes.Ptr(),aMaxLength);

	TRequestStatus* stat=&aStatus;

	User::RequestComplete(stat,KErrNone);

	return aMaxLength;

	}

TStreamTransfer RFrame16Buf::DoWriteL(MStreamOutput& anOutput,TStreamTransfer aTransfer)

	{

	__ASSERT_DEBUG(aTransfer>0,Panic(EStreamWriteNoTransfer));

	if (iWAvail>0)

		{

		TInt len=iWMark.WriteL(Host(),anOutput,aTransfer[iWAvail]);

		aTransfer-=len;

		iWAvail-=len;

		}

	if (aTransfer>0)

		return anOutput.WriteToL(*this,aTransfer);

//

	return aTransfer;

	}

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

//

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

//

	{

	switch (aLocation)

		{

	case EStreamBeginning:

		anOffset+=Offset();

		break;

	case EStreamMark:

		if (aMark==ERead)

			anOffset+=iRLim-iRAvail;

		else

			{

			__ASSERT_ALWAYS(aMark==EWrite,Panic(EStreamMarkInvalid));

			anOffset+=iWLim-iWAvail;

			}

		break;

	case EStreamEnd:

		anOffset+=EndL();

		break;

	default:

		Panic(EStreamLocationInvalid);

		break;

		}

	TInt r=KErrNone;

	if (anOffset<Offset())

		{

		anOffset=Offset();

		r=KErrEof;

		}

	else if (anOffset>=0&&!ReachL(anOffset))

		{

		__ASSERT_DEBUG(Extent()!=0,User::Invariant());

		anOffset=Extent();

		r=KErrEof;

		}

//

	if (aMark&&anOffset>=0)

		{

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

		TInt in=anOffset&KMaskFrameLength16;

		TInt off=anOffset-in;

		__ASSERT_DEBUG(Extent()==0||anOffset<=Extent(),User::Invariant());

		if (in==0&&off>Offset()&&(Extent()==0||off==Extent()))

			{ // positioning at the start of a frame that may not exist

			in=KFrameFullLength16;

			off-=in;

			}

		TStreamPos pos=Base()+(off+(off>>KShiftFrameLength16<<KShiftFrameDes16))+in;

		TInt lim=off+KFrameFullLength16;

		if (Extent()>0&&lim>Extent())

			lim=Extent();

		TInt left=lim-anOffset;

		__ASSERT_DEBUG(left>=0&&left<=KFrameFullLength16,User::Invariant());

//

		if (aMark&ERead)

			{

			if (iMode&ERead)

				iRMark.SeekL(Host(),pos);

			iRAvail=left;

			iRLim=lim;

			}

		if (aMark&EWrite)

			{

			if (iMode&EWrite)

				iWMark.SeekL(Host(),pos);

			iWAvail=left;

			iWLim=lim;

			}

		}

	__LEAVE_IF_ERROR(r);

	return TStreamPos(anOffset-Offset());

	}

TInt RFrame16Buf::UnderflowL()

	{

	__ASSERT_DEBUG(iRAvail==0,User::Invariant());

	if ((iRLim&KMaskFrameLength16)!=KFrameOpen16)

		{

		__ASSERT_DEBUG(iExt==iRLim,User::Invariant());

		return 0; // we've used up the closing, partial frame

		}

//

	__ASSERT_DEBUG(iRLim>0&&(iExt>0&&iRLim<=iExt||iExt==0),User::Invariant());

		// let's see if there's a continuation frame

	TFrameDes16 des;

	TInt frame=iRMark.ReadL(Host(),&des,KSizeFrameDes16);

		// platform dependency

	__ASSERT_DEBUG(frame>=0&&frame<=KSizeFrameDes16,Panic(EStreamReadInBreach));

	if (frame==KSizeFrameDes16)

		{

		frame=des;

		if ((frame&KMaskFrameType16)==EFrameContinuation16)

			{ // we have a continuation frame, prepare ourselves for it

			frame&=KMaskFrameLength16;

			if (frame==KFrameOpen16)

				frame=KFrameFullLength16;

			iRAvail=frame;

			TInt lim=iRLim;

			iRLim=lim+frame;

			if (iExt==lim)

				iExt=iRLim;

			return frame;

			}

		iRMark.SeekL(Host(),-KSizeFrameDes16);

		frame=0;

		}

//

	if (frame>0||iRLim<iExt)

		{ // we'd definitely seen a continuation frame here before

		iRMark.Withdraw(Host());

		__LEAVE(KErrCorrupt);

		}

	return 0;

	}

void RFrame16Buf::OverflowL()

	{

	__ASSERT_DEBUG(iWAvail==0,User::Invariant());

	if ((iWLim&KMaskFrameLength16)!=KFrameOpen16)

		{ // filled the closing, partial frame

		__ASSERT_DEBUG(iExt==iWLim,User::Invariant());

	overflow:

		iWMark.Withdraw(Host());

		__LEAVE(KErrOverflow);

		}

//

	__ASSERT_DEBUG(iWLim>0&&(iExt>0&&iWLim<=iExt||iExt==0),User::Invariant());

	if (iWLim==iExt)

		{ // let's see if this carries on

		TFrameDes16 des;

		TInt frame=iWMark.ReadL(Host(),&des,KSizeFrameDes16);

			// platform dependency

		__ASSERT_DEBUG(frame>=0&&frame<=KSizeFrameDes16,Panic(EStreamReadInBreach));

		if (frame==0)

			iExt=0; // end-of-host, let's start extending

		else

			{

			if (frame==KSizeFrameDes16)

				{

				frame=des;

				if ((frame&KMaskFrameType16)==EFrameContinuation16)

					{ // there's more, set up for the next frame

					frame&=KMaskFrameLength16;

					if (frame==KFrameOpen16)

						frame=KFrameFullLength16;

					iWAvail=frame;

					iExt=iWLim+=frame;

					return;

					}

				goto overflow;

				}

//

			iWMark.Withdraw(Host());

			__LEAVE(KErrCorrupt);

			}

		}

//

	__ASSERT_DEBUG(iWLim<iExt||iExt==0,User::Invariant());

		// calculate the frame descriptor to be written

	TInt frame=iExt&KMaskFrameLength16;

	if (iWLim<iExt-frame)

		frame=KFrameOpen16;

	TFrameDes16 des=TFrameDes16(EFrameContinuation16|frame);

	if (frame==KFrameOpen16)

		frame=KFrameFullLength16;

	iWMark.WriteL(Host(),&des,KSizeFrameDes16);

		// platform dependency

	iWAvail=frame;

	iWLim+=frame;

	}

TBool RFrame16Buf::ReachL(TInt anOffset)

	{

	if (iExt<=0)

		return iExt==0;

//

	TStreamMark mark(Base());

	TInt frame=(iExt+(iExt>>KShiftFrameLength16<<KShiftFrameDes16))-KSizeFrameDes16;

	while (iExt<anOffset)

		{

		if ((iExt&KMaskFrameLength16)!=KFrameOpen16)

			{

			mark.Withdraw(Host());

			return EFalse;

			}

//

		TFrameDes16 des;

		mark.SeekL(Host(),EStreamMark,frame);

		frame=mark.ReadL(Host(),&des,KSizeFrameDes16);

			// platform dependency

		__ASSERT_DEBUG(frame>=0&&frame<=KSizeFrameDes16,Panic(EStreamReadInBreach));

		if (frame==KSizeFrameDes16)

			{

			frame=des;

			if ((frame&KMaskFrameType16)==EFrameContinuation16)

				{ // we have a continuation frame, boost upper

				frame&=KMaskFrameLength16;

				if (frame==KFrameOpen16)

					frame=KFrameFullLength16;

				iExt+=frame;

				continue;

				}

			frame=0;

			}

//

		mark.Withdraw(Host());

		if (frame>0)

			__LEAVE(KErrCorrupt);