// 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);
//
		return EFalse;
		}
	mark.Withdraw(Host());
	return ETrue;
	}

TInt RFrame16Buf::EndL()
	{
	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 frame=ext-(n<<KShiftFrameLength16);
		// size of final frame (remainder of the division above)
	__ASSERT_DEBUG(frame>=0&&frame<KFrameFullLength16+KSizeFrameDes16,User::Invariant());
	if (ext<Offset()||frame>KFrameFullLength16)
		__LEAVE(KErrCorrupt); // bad offset or partial frame descriptor
//
	if (!ReachL(ext))
		{
		__ASSERT_DEBUG(Extent()!=0,User::Invariant());
		return Extent();
		}
//
	return ext;
	}