--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/persistentstorage/store/USTRM/US_IO.CPP	Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,301 @@
+// 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 TPtrInput::PushL(const TAny* aPtr,TInt aMaxLength)
+//
+// Accept the data, copying it to the buffer pointed to.
+//
+	{
+	__ASSERT_DEBUG(aMaxLength>=0,Panic(EStreamPushLengthNegative));
+	__ASSERT_DEBUG(aMaxLength>0,Panic(EStreamPushNoTransfer));
+	iPtr=Mem::Copy(iPtr,aPtr,aMaxLength);
+	return aMaxLength;
+	}
+
+TStreamTransfer TPtrInput::ReadFromL(MStreamBuf&,TStreamTransfer aTransfer)
+//
+// This input is passive.
+//
+	{
+	__ASSERT_DEBUG(aTransfer>0,Panic(EStreamReadNoTransfer));
+	return aTransfer;
+	}
+
+TInt TPtrOutput::PullL(TAny* aPtr,TInt aMaxLength)
+//
+// Produce data from the buffer pointed to.
+//
+	{
+	__ASSERT_DEBUG(aMaxLength>=0,Panic(EStreamPullLengthNegative));
+	__ASSERT_DEBUG(aMaxLength>0,Panic(EStreamPullNoTransfer));
+	Mem::Copy(aPtr,iPtr,aMaxLength);
+	iPtr+=aMaxLength;
+	return aMaxLength;
+	}
+
+TStreamTransfer TPtrOutput::WriteToL(MStreamBuf&,TStreamTransfer aTransfer)
+//
+// This output is passive.
+//
+	{
+	__ASSERT_DEBUG(aTransfer>0,Panic(EStreamWriteNoTransfer));
+	return aTransfer;
+	}
+
+TInt TNullInput::PushL(const TAny*,TInt aMaxLength)
+//
+// Accept and discard the data.
+//
+	{
+	__ASSERT_DEBUG(aMaxLength>=0,Panic(EStreamPushLengthNegative));
+	__ASSERT_DEBUG(aMaxLength>0,Panic(EStreamPushNoTransfer));
+	return aMaxLength;
+	}
+
+TStreamTransfer TNullInput::ReadFromL(MStreamBuf& aSource,TStreamTransfer aTransfer)
+//
+// Read and discard data from aSource using a temporary buffer.
+//
+	{
+	__ASSERT_DEBUG(aTransfer>0,Panic(EStreamReadNoTransfer));
+	do
+		{
+		TUint8 buf[KDefaultIoBufSize];
+		TInt len=aSource.ReadL(buf,aTransfer[sizeof(buf)]);
+		__ASSERT_DEBUG(len>=0&&len<=aTransfer[sizeof(buf)],Panic(EStreamReadInBreach));
+		if (len==0)
+			break;
+//
+		aTransfer-=len;
+		} while (aTransfer>0);
+	return aTransfer;
+	}
+
+TInt TSourceOutput::PullL(TAny* aPtr,TInt aMaxLength)
+//
+// Pull up to aMaxLength bytes of data from this output's source.
+//
+	{
+	__ASSERT_DEBUG(aMaxLength>=0,Panic(EStreamPullLengthNegative));
+	__ASSERT_DEBUG(aMaxLength>0,Panic(EStreamPullNoTransfer));
+	__ASSERT_DEBUG(iSrc!=NULL,User::Invariant());
+//
+	TPtrInput input(aPtr);
+	TInt len=iSrc->ReadL(input,aMaxLength);
+	__ASSERT_DEBUG(len>=0&&len<=aMaxLength,Panic(EStreamReadInBreach));
+	return len;
+	}
+
+TStreamTransfer TSourceOutput::WriteToL(MStreamBuf& aSink,TStreamTransfer aTransfer)
+//
+// Write data from this output's source to aSink using a temporary buffer.
+//
+	{
+	__ASSERT_DEBUG(aTransfer>0,Panic(EStreamWriteNoTransfer));
+	__ASSERT_DEBUG(iSrc!=NULL,User::Invariant());
+	do
+		{
+		TUint8 buf[KDefaultIoBufSize];
+		TInt len=iSrc->ReadL(buf,aTransfer[sizeof(buf)]);
+		__ASSERT_DEBUG(len>=0&&len<=aTransfer[sizeof(buf)],Panic(EStreamReadInBreach));
+		if (len==0)
+			break;
+//
+		aSink.WriteL(buf,len);
+		aTransfer-=len;
+		} while (aTransfer>0);
+	return aTransfer;
+	}
+
+TInt TFilterInput::PushL(const TAny* aPtr,TInt aMaxLength)
+//
+// Put up to aMaxLength bytes of data through the filter.
+//
+	{
+	__ASSERT_DEBUG(aMaxLength>=0,Panic(EStreamPushLengthNegative));
+	__ASSERT_DEBUG(aMaxLength>0,Panic(EStreamPushNoTransfer));
+	__ASSERT_DEBUG(!Eof(),Panic(EStreamReadInBreach));
+	__ASSERT_DEBUG(iFltr!=NULL&&iLeft>=0,User::Invariant());
+	if (Done())
+		return 0;
+//
+	const TUint8* from=(TUint8*)aPtr;
+	TInt len=iFltr->FilterL(iPtr,iLeft,from,from+aMaxLength);
+	__ASSERT_DEBUG(len>=0&&len<=iLeft,Panic(EStreamFilterInBreach));
+	__ASSERT_DEBUG(from>=(TUint8*)aPtr&&from<=(TUint8*)aPtr+aMaxLength,Panic(EStreamFilterInBreach));
+	__ASSERT_DEBUG(len==iLeft||from==(TUint8*)aPtr+aMaxLength,Panic(EStreamFilterInBreach));
+	iPtr+=len;
+	iLeft-=len;
+	return from-(TUint8*)aPtr;
+	}
+
+TStreamTransfer TFilterInput::ReadFromL(MStreamBuf& aSource,TStreamTransfer aTransfer)
+//
+// Put data read from aSource through the filter using a temporary buffer.
+//
+	{
+	__ASSERT_DEBUG(aTransfer>0,Panic(EStreamReadNoTransfer));
+	__ASSERT_DEBUG(iFltr!=NULL&&iLeft>=0,User::Invariant());
+	if (Done())
+		return aTransfer;
+//
+	TUint8 buf[KFilterIoBufSize];
+	TInt cap=aTransfer[Min(iFltr->Capacity(iLeft),sizeof(buf))];
+	const TUint8* end=buf+(cap==0?0:aSource.ReadL(buf,cap));
+	__ASSERT_DEBUG(end>=buf&&end<=buf+cap&&(!Eof()||end==buf),Panic(EStreamReadInBreach));
+	const TUint8* from=buf;
+	TInt len=iFltr->FilterL(iPtr,iLeft,from,end);
+	__ASSERT_DEBUG(len>=0&&len<=iLeft,Panic(EStreamFilterInBreach));
+	__ASSERT_DEBUG(from==end,Panic(EStreamFilterInBreach));
+	if (end==buf && len==0)	// no input && no output, => end of stream
+		iPtr=NULL;
+	else
+		iPtr+=len;
+	iLeft-=len;
+	return aTransfer-(from-buf);
+	}
+
+TInt TFilterOutput::PullL(TAny* aPtr,TInt aMaxLength)
+//
+// Pull up to aMaxLength bytes of data through the filter.
+//
+	{
+	__ASSERT_DEBUG(aMaxLength>=0,Panic(EStreamPullLengthNegative));
+	__ASSERT_DEBUG(aMaxLength>0,Panic(EStreamPullNoTransfer));
+	__ASSERT_DEBUG(iFltr!=NULL&&iFrom!=NULL&&iFrom<=iEnd,User::Invariant());
+	if (Done())
+		return 0;
+//
+	__DEBUG(const TUint8* from=iFrom);
+	TInt len=iFltr->FilterL(aPtr,aMaxLength,iFrom,iEnd);
+	__ASSERT_DEBUG(len>=0&&len<=aMaxLength,Panic(EStreamFilterInBreach));
+	__ASSERT_DEBUG(iFrom>=from&&iFrom<=iEnd,Panic(EStreamFilterInBreach));
+	__ASSERT_DEBUG(len==aMaxLength||iFrom==iEnd,Panic(EStreamFilterInBreach));
+	return len;
+	}
+
+TStreamTransfer TFilterOutput::WriteToL(MStreamBuf& aSink,TStreamTransfer aTransfer)
+//
+// Write data put through the filter to aSink using a temporary buffer.
+//
+	{
+	__ASSERT_DEBUG(aTransfer>0,Panic(EStreamWriteNoTransfer));
+	__ASSERT_DEBUG(iFltr!=NULL&&iFrom!=NULL&&iFrom<=iEnd,User::Invariant());
+	if (Done())
+		return aTransfer;
+//
+	TUint8 buf[KFilterIoBufSize];
+	__DEBUG(const TUint8* from=iFrom);
+	TInt len=iFltr->FilterL(buf,aTransfer[sizeof(buf)],iFrom,iEnd);
+	__ASSERT_DEBUG(len>=0&&len<=aTransfer[sizeof(buf)],Panic(EStreamFilterInBreach));
+	__ASSERT_DEBUG(iFrom>=from&&iFrom<=iEnd,Panic(EStreamFilterInBreach));
+	__ASSERT_DEBUG(len==aTransfer[sizeof(buf)]||iFrom==iEnd,Panic(EStreamFilterInBreach));
+	if (len>0)
+		aSink.WriteL(buf,len);
+	return aTransfer-len;
+	}
+
+TDelimitedInput8::TDelimitedInput8(TUint8* aPtr,TInt aLength,TChar aDelim)
+	: iPtr(aPtr),iLeft(aLength),iDelim(aDelim)
+	{}
+
+TInt TDelimitedInput8::PushL(const TAny* aPtr,TInt aMaxLength)
+//
+// Push 8-bit text into this input buffer up to the first occurrence of the delimiter.
+//
+	{
+	TInt len=Min(aMaxLength,iLeft);
+	TInt d=TPtrC8((TUint8*)aPtr,len).Locate(iDelim)+1;
+	if (d<=0)
+		{
+		d=len;
+		iLeft-=len;
+		}
+	else
+		iLeft=0;
+	iPtr=(TUint8*)Mem::Copy(iPtr,aPtr,d);
+	return d;
+	}
+
+TStreamTransfer TDelimitedInput8::ReadFromL(MStreamBuf& aSource,TStreamTransfer aTransfer)
+//
+// Read a single 8-bit text character from aSource, testing it against the delimiter.
+//
+	{
+	if (Done())
+		return aTransfer;
+//
+	RReadStream stream(&aSource);
+	TUint8 c=stream.ReadUint8L();
+	*iPtr++=c;
+	if (c==(TUint8)iDelim)
+		iLeft=0;
+	else
+		--iLeft;
+	return aTransfer-sizeof(c);
+	}
+
+TDelimitedInput16::TDelimitedInput16(TUint16* aPtr,TInt aLength,TChar aDelim)
+	: iPtr(aPtr),iLeft(aLength),iDelim(aDelim)
+	{}
+
+TInt TDelimitedInput16::PushL(const TAny* aPtr,TInt aMaxLength)
+//
+// Push 16-bit text into this input buffer up to the first occurrence of the delimiter.
+// We cannot use TPtrC16 here as the data may not be half-word aligned
+//
+	{
+	TInt len=Min(aMaxLength>>1,iLeft);
+	iLeft-=len;
+	TInt lbyte=iDelim&0xffu;
+	TInt hbyte=iDelim>>8;
+	const TUint8* p=static_cast<const TUint8*>(aPtr);
+	TInt d=0;
+	while (d<len)
+		{
+		if (p[d<<1]==lbyte && p[(d<<1)+1]==hbyte) // platform dependency
+			{
+			++d;		// include the delimiter
+			iLeft=0;	// found a match
+			break;
+			}
+		++d;
+		}
+
+	iPtr=(TUint16*)Mem::Copy(iPtr,aPtr,d<<1); // platform dependency
+	return d<<1;
+	}
+
+TStreamTransfer TDelimitedInput16::ReadFromL(MStreamBuf& aSource,TStreamTransfer aTransfer)
+//
+// Read a single 16-bit text character from aSource, testing it against the delimiter.
+//
+	{
+	if (Done())
+		return aTransfer;
+//
+	RReadStream stream(&aSource);
+	TUint16 c=stream.ReadUint16L();
+//
+	*iPtr++=c;
+	if (c==(TUint16)iDelim)
+		iLeft=0;
+	else
+		--iLeft;
+	return aTransfer-sizeof(c);
+	}
+