diff -r 000000000000 -r 08ec8eefde2f persistentstorage/store/USTRM/US_FRAME.CPP
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/persistentstorage/store/USTRM/US_FRAME.CPP	Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,560 @@
+// 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;
+	}
+