diff -r 666f914201fb -r 2fe1408b6811 epoc32/include/s32buf.inl
--- a/epoc32/include/s32buf.inl	Tue Nov 24 13:55:44 2009 +0000
+++ b/epoc32/include/s32buf.inl	Tue Mar 16 16:12:26 2010 +0000
@@ -1,1 +1,600 @@
-s32buf.inl
+// 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 the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+// Class TStreamPos
+inline TStreamPos::TStreamPos(TInt anOffset)
+	: iOff(anOffset)
+/** Constructs the stream position object from the specified value.
+
+@param anOffset The position value. */
+	{}
+inline TBool TStreamPos::operator==(TStreamPos aPos) const
+/** Tests whether the stream position is equal to the specified stream position.
+
+@param aPos The stream position to be compared.
+@return True, if this object's stream position value is equal to the specified 
+stream position's value; false, otherwise. */
+	{return iOff==aPos.iOff;}
+inline TBool TStreamPos::operator!=(TStreamPos aPos) const
+/** Tests whether the stream position is not equal to the specified stream position.
+
+@param aPos The stream position to be compared.
+@return True, if this object's stream position value is not equal to the specified 
+stream position's value; false, otherwise. */
+	{return iOff!=aPos.iOff;}
+inline TBool TStreamPos::operator<(TStreamPos aPos) const
+/** Tests whether the stream position is less than the specified stream position.
+
+@param aPos The stream position to be compared.
+@return True, if this object's stream position value is less than the specified 
+stream position's value; false, otherwise. */
+	{return iOff<aPos.iOff;}
+inline TBool TStreamPos::operator<=(TStreamPos aPos) const
+/** Tests whether the stream position is less than or equal to the specified stream 
+position.
+
+@param aPos The stream position to be compared.
+@return True, if this object's stream position value is less than or equal 
+to the specified stream position's value; false, otherwise. */
+	{return iOff<=aPos.iOff;}
+inline TBool TStreamPos::operator>(TStreamPos aPos) const
+/** Tests whether the stream position is greater than the specified stream position.
+
+@param aPos The stream position to be compared.
+@return True, if this object's stream position value is greater than the specified 
+stream position's value; false, otherwise. */
+	{return iOff>aPos.iOff;}
+inline TBool TStreamPos::operator>=(TStreamPos aPos) const
+/** Tests whether the stream position is greater than or equal to the specified 
+stream position.
+
+@param aPos The stream position to be compared.
+@return True, if this object's stream position value is greater than or equal 
+to the specified stream position's value; false, otherwise. */
+	{return iOff>=aPos.iOff;}
+inline TInt TStreamPos::operator-(TStreamPos aPos) const
+/** Gets the result of subtracting the specified stream position value from this 
+object's stream position value.
+
+@param aPos The stream position whose value is to be subtracted.
+@return The result of the calculation. */
+	{return iOff-aPos.iOff;}
+inline TStreamPos TStreamPos::operator+(TInt anOffset) const
+/** Gets a stream position object that holds the result of adding the specified 
+value to this object's stream position value.
+
+@param anOffset The value to be added.
+@return The stream position object holding the result of the calculation. */
+	{return TStreamPos(iOff+anOffset);}
+inline TStreamPos TStreamPos::operator-(TInt anOffset) const
+/** Gets a stream position object that holds the result of subtracting the specified 
+value from this object's stream position value.
+
+@param anOffset The value to be subtracted.
+@return The stream position object holding the result of the calculation. */
+	{return TStreamPos(iOff-anOffset);}
+inline TStreamPos& TStreamPos::operator+=(TInt anOffset)
+/** Adds the specified value to this stream position object.
+
+@param anOffset The value to be added.
+@return A reference to this stream position object. */
+	{iOff+=anOffset;return *this;}
+inline TStreamPos& TStreamPos::operator-=(TInt anOffset)
+/** Subtracts the specified value from this stream position object.
+
+@param anOffset The value to be subtracted.
+@return A reference to this stream position object. */
+	{iOff-=anOffset;return *this;}
+inline TInt TStreamPos::Offset() const
+/** Gets the stream position value.
+
+@return The stream position value. */
+	{return iOff;}
+inline TStreamPos operator+(TInt anOffset,TStreamPos aPos)
+	{return aPos+anOffset;}
+
+// Class TStreamTransfer
+inline TStreamTransfer::TStreamTransfer(TInt aMaxLength)
+	: iVal(aMaxLength)
+/** Constructs a stream transfer object specifying a length value.
+
+This value represents the maximum amount of data that can be transferred between 
+streams.
+
+@param aMaxLength The maximum length of data that can be transferred. In debug 
+mode, the function raises a STORE-Stream 13 panic, if this value is negative. */
+	{
+#if defined (_DEBUG)
+	__DbgChkNonNegative(aMaxLength);
+#endif
+	}
+inline TStreamTransfer::TStreamTransfer(TUnlimited)
+	: iVal(-1)
+/** Constructs a stream transfer object specifying that there is no explicit limit 
+to the amount of data that can be transferred between streams.
+
+The amount of data to be transferred is only limited by the streams themselves.
+
+The arithmetical operators do not change the state of an unlimited stream 
+transfer object.
+
+@param (The enumerator value is not used). */
+	{}
+inline TBool TStreamTransfer::operator==(TInt aLength) const
+/** Tests whether the stream transfer value is equal to the specified value.
+
+@param aLength The length to compared. In debug mode, the function raises 
+a STORE-Stream 13 panic, if this value is negative.
+@return True, if the stream transfer value is equal to the specified value; 
+false, otherwise. */
+	{
+#if defined (_DEBUG)
+	__DbgChkNonNegative(aLength);
+#endif
+	return iVal==aLength;
+	}
+inline TBool TStreamTransfer::operator>(TInt aLength) const
+/** Tests whether the stream transfer value is greater than the specified value.
+
+@param aLength The length to compared. In debug mode, the function raises 
+a STORE-Stream 13 panic, if this value is negative.
+@return True, if the stream transfer value is greater than the specified value; 
+false, otherwise. */
+	{
+#if defined (_DEBUG)
+	__DbgChkNonNegative(aLength);
+#endif
+	return TUint(iVal)>TUint(aLength);
+	}
+inline TStreamTransfer TStreamTransfer::operator-(TInt aLength) const
+/** Subtracts the specified value from the stream transfer value.
+
+If this stream transfer object was originally constructed as an unlimited 
+type, i.e. using the TStreamTransfer(TUnlimited) constructor, then this operator 
+does not change the state of the object, and it remains an unlimited type.
+
+@param aLength The length to be subtracted. In debug mode, the function raises 
+a STORE-Stream 13 panic, if this value is negative.
+@return A stream transfer object containing the result of the subtraction. */
+	{
+#if defined (_DEBUG)
+	__DbgChkNonNegative(aLength);
+#endif
+	return iVal<0?*this:TStreamTransfer(iVal-aLength);
+	}
+inline TInt TStreamTransfer::operator[](TInt aMaxLength) const
+	{return *this>aMaxLength?aMaxLength:iVal;}
+inline TStreamTransfer& TStreamTransfer::operator-=(TInt aLength)
+/** Subtracts the specified value from the stream transfer value, updating this 
+stream transfer object.
+
+If this stream transfer object was originally constructed as an unlimited 
+type, i.e. using the TStreamTransfer(TUnlimited) constructor, then this operator 
+does not change the state of the object, and it remains an unlimited type.
+
+If this stream transfer object was not an unlimited type, then, in debug mode, 
+the function raises a STORE-Stream 13 panic, if the result of the calculation 
+is negative.
+
+@param aLength The length to be subtracted. In debug mode, the function raises 
+a STORE-Stream 13 panic, if this value is negative.
+@return A reference to this stream transfer object. */
+	{
+#if defined (_DEBUG)
+	__DbgChkNonNegative(aLength);
+#endif
+	if (iVal>=0)
+		{
+		iVal-=aLength;
+#if defined (_DEBUG)
+		__DbgChkNonNegative(iVal);
+#endif
+		}
+	return *this;
+	}
+inline TInt TStreamTransfer::Left() const
+/** Gets the stream transfer value.
+
+@return The current stream transfer value. */
+	{
+#if defined (_DEBUG)
+	__DbgChkNonNegative(iVal);
+#endif
+	return iVal;
+	}
+inline TBool operator==(TInt aLength,TStreamTransfer aTransfer)
+	{return aTransfer==aLength;}
+inline TBool operator<(TInt aLength,TStreamTransfer aTransfer)
+	{return aTransfer>aLength;}
+
+// Class MStreamBuf
+inline void MStreamBuf::Release()
+/** Frees resources before abandoning the stream buffer.
+
+The function calls the virtual function DoRelease() to implement this behaviour.
+
+Release() is called by both RReadStream::Release() and RWriteStream::Release().
+
+@see MStreamBuf::DoRelease()
+@see RReadStream::Release()
+@see RWriteStream::Release() */
+	{DoRelease();}
+inline void MStreamBuf::SynchL()
+/** Synchronises the stream buffer with the stream, leaving if any error occurs.
+
+In effect, this ensures that buffered data is delivered to the stream.
+
+The function calls the virtual function DoSynchL() to implement this behaviour.
+
+@see MStreamBuf::DoSynchL() */
+	{DoSynchL();}
+inline TInt MStreamBuf::ReadL(TAny* aPtr,TInt aMaxLength)
+/** Reads data from the stream buffer into the specified memory location.
+
+The function calls the virtual function DoReadL(TAny*,TInt) to implement this 
+behaviour.
+
+@param aPtr A pointer to the target memory location for the data read from 
+the stream buffer.
+@param aMaxLength The maximum number of bytes to be read.
+@return The number of bytes read.
+@see MStreamBuf::DoReadL() */
+	{return DoReadL(aPtr,aMaxLength);}
+inline TInt MStreamBuf::ReadL(TDes8& aDes,TInt aMaxLength,TRequestStatus& aStatus)
+/** Reads data, asynchronously, from the stream buffer into the specified descriptor.
+
+The function calls the virtual function DoReadL(TDes8&,TInt,TRequestStatus&) 
+to implement this behaviour.
+
+If the function leaves, then no read request will have been initiated.
+
+@param aDes The target descriptor for the data read from the stream buffer.
+@param aMaxLength The maximum number of bytes to be read.
+@param aStatus The request status that indicates the completion status of this 
+asynchronous request.
+@return The maximum number of bytes to be read, as used in this request. This 
+can be different to the value supplied in aMaxLength; this is dependent on 
+the implementation.
+@see MStreamBuf::DoReadL() */
+	{return DoReadL(aDes,aMaxLength,aStatus);}
+inline TStreamTransfer MStreamBuf::ReadL(MStreamInput& anInput,TStreamTransfer aTransfer)
+/** Reads data from the stream buffer into the specified data sink.
+
+The function calls the virtual function DoReadL(MStreamInput&,TStreamTransfer) 
+to implement this behaviour.
+
+@param anInput The data sink that is the target for the read operation.
+@param aTransfer Defines the amount of data available to be read.
+@return The amount of data that was not consumed. */
+	{return DoReadL(anInput,aTransfer);}
+inline void MStreamBuf::ReadL(MStreamInput& anInput)
+/** Reads data from the stream buffer into the specified data sink.
+
+The function uses the virtual function DoReadL(MStreamInput&,TStreamTransfer) 
+to implement this behaviour.
+
+No explicit limit is placed on the amount of data that can be read.
+
+@param anInput The data sink that is the target for the read operation. */
+	{DoReadL(anInput,KStreamUnlimited);}
+inline void MStreamBuf::WriteL(const TAny* aPtr,TInt aLength)
+/** Writes data from the specified memory location into the stream buffer.
+
+The function calls the virtual function DoWriteL(TAny*,TInt) to implement 
+this behaviour.
+
+@param aPtr A pointer to the memory location from which data is to be written 
+to the stream buffer.
+@param aLength The number of bytes to be written.
+@see MStreamBuf::DoWriteL() */
+	{DoWriteL(aPtr,aLength);}
+inline TInt MStreamBuf::WriteL(const TDesC8& aDes,TInt aMaxLength,TRequestStatus& aStatus)
+/** Writes data, asynchronously, from the specified descriptor into the stream buffer.
+
+The function calls the virtual function DoWriteL(const TDesC8&,TInt,TRequestStatus&) 
+to implement this behaviour.
+
+If the function leaves, then no write request will have been initiated.
+
+@param aDes The source descriptor for the data to be written into the stream 
+buffer.
+@param aMaxLength The maximum number of bytes to be written.
+@param aStatus The request status that indicates the completion status of this 
+asynchronous request.
+@return The maximum number of bytes to be written, as used in this request. 
+This can be different to the value supplied in aMaxLength; this is dependent 
+on the implementation.
+@see MStreamBuf::DoWriteL() */
+	{return DoWriteL(aDes,aMaxLength,aStatus);}
+inline TStreamTransfer MStreamBuf::WriteL(MStreamOutput& anOutput,TStreamTransfer aTransfer)
+/** Writes data into the stream buffer from the specified data source.
+
+The function calls the virtual function DoWriteL(MStreamOutput&,TStreamTransfer) 
+to implement this behaviour.
+
+@param anOutput The data source for the write operation.
+@param aTransfer Defines the amount of data to be pulled from the output stream 
+object.
+@return A stream transfer object defining the amount of data that was not consumed. */
+	{return DoWriteL(anOutput,aTransfer);}
+inline void MStreamBuf::WriteL(MStreamOutput& anOutput)
+/**Writes data into the stream buffer from the specified data source.
+
+The function calls the virtual function DoWriteL(MStreamOutput&,TStreamTransfer) to implement this behaviour.
+
+No explicit limit is placed on the amount of data that can be written.
+
+@param anOutput The data source for the write operation.
+@param aMaxLength The maximum amount of data available to be written.
+*/
+	{DoWriteL(anOutput,KStreamUnlimited);}
+inline void MStreamBuf::SeekL(TMark aMark,TStreamPos aPos)
+/**Moves the position of the read or write mark in the stream.
+
+The new position is calculated by adding the specified value to the position of the beginning of the stream.
+
+The function calls virtual function DoSeekL(TMark,TStreamLocation,TInt) to implement this behaviour.
+Notes:
+As there are two current positions, one for the read mark and one for the write mark, it is not valid, in general, to use a single call to SeekL() to move both the read and write marks. 
+Not all streams are seekable. 
+
+@param aMark The type of mark, i.e. read or write.
+@param aLocation A stream position value on which the calculation of the new position is based.
+*/
+	{DoSeekL(aMark,EStreamBeginning,aPos.Offset());}
+inline TStreamPos MStreamBuf::SeekL(TMark aMark,TStreamLocation aLocation,TInt anOffset)
+/** Moves the position of the read mark or the write mark in the stream.
+
+The new position is calculated by adding the specified offset to one of:
+
+the position of the beginning of the stream
+
+the position of the end of the stream
+
+the position of the current read mark or write mark.
+
+The function calls the virtual function DoSeekL(TMark,TStreamLocation,TInt) 
+to implement this behaviour.
+
+As there are two current positions, one for the read mark and one for the 
+write mark, it is not valid, in general, to use a single call to SeekL() to 
+move both the read and write marks.
+
+Not all streams are seekable.
+
+@param aMark The type of mark, i.e read or write.
+@param aLocation The location in the stream on which the calculation of the 
+new position is based.
+@param anOffset The offset value.
+@return The new stream position of the read or write mark. */
+	{return DoSeekL(aMark,aLocation,anOffset);}
+inline TStreamPos MStreamBuf::SeekL(TRead,TStreamLocation aLocation,TInt anOffset)
+/** Moves the position of the read mark in the stream.
+
+The new position is calculated by adding the specified offset to one of:
+
+the position of the beginning of the stream
+
+the position of the end of the stream
+
+the position of the current read mark.
+
+The function calls the virtual function DoSeekL(TMark,TStreamLocation,TInt) 
+to implement this behaviour.
+
+Not all streams are seekable.
+
+@param (The enumerator value is not used)
+@param aLocation The location in the stream on which the calculation of the 
+new position is based.
+@param anOffset The offset value.
+@return The new stream position of the read mark. */
+	{return DoSeekL(ERead,aLocation,anOffset);}
+inline TStreamPos MStreamBuf::SeekL(TWrite,TStreamLocation aLocation,TInt anOffset)
+/** Moves the position of the write mark in the stream.
+
+The new position is calculated by adding the specified offset to one of:
+
+the position of the beginning of the stream
+
+the position of the end of the stream
+
+the position of the current write mark.
+
+The function calls the virtual function DoSeekL(TMark,TStreamLocation,TInt) 
+to implement this behaviour.
+
+Not all streams are seekable.
+
+@param (The enumerator value is not used)
+@param aLocation The location in the stream on which the calculation of the 
+new position is based.
+@param anOffset The offset value.
+@return The new stream position of the write mark. */
+	{return DoSeekL(EWrite,aLocation,anOffset);}
+inline TStreamPos MStreamBuf::SeekL(TRead,TInt anOffset)
+/** Moves the position of the read mark in the stream by the specified offset.
+
+The function calls the virtual function DoSeekL(TMark,TStreamLocation,TInt) 
+to implement this behaviour.
+
+Not all streams are seekable.
+
+@param (The enumerator value is not used)
+@param anOffset The amount by which the position of the read mark is to be 
+moved relative to the existing position of the read mark.
+@return The new stream position of the read mark. */
+	{return DoSeekL(ERead,EStreamMark,anOffset);}
+inline TStreamPos MStreamBuf::SeekL(TWrite,TInt anOffset)
+/** Moves the position of the write mark in the stream by the specified offset.
+
+The function calls the virtual function DoSeekL(TMark,TStreamLocation,TInt) 
+to implement this behaviour.
+
+Not all streams are seekable.
+
+@param (The enumerator value is not used)
+@param anOffset The amount by which the position of the write mark is to be 
+moved relative to the existing position of the write mark.
+@return The new stream position of the write mark. */
+	{return DoSeekL(EWrite,EStreamMark,anOffset);}
+inline TStreamPos MStreamBuf::TellL(TRead) const
+/** Gets the position of the read mark within the stream.
+
+The function calls the virtual function DoSeekL(TMark,TStreamLocation,TInt) 
+to implement this behaviour.
+
+@param (The enumerator value is not used).
+@return The stream position. */
+	{return CONST_CAST(MStreamBuf*,this)->DoSeekL(ERead,EStreamMark,0);}
+inline TStreamPos MStreamBuf::TellL(TWrite) const
+/** Gets the position of the write mark within the stream.
+
+The function calls the virtual function DoSeekL(TMark,TStreamLocation,TInt) 
+to implement this behaviour.
+
+@param (The enumerator value is not used).
+@return The stream position. */
+	{return CONST_CAST(MStreamBuf*,this)->DoSeekL(EWrite,EStreamMark,0);}
+inline TInt MStreamBuf::SizeL() const
+/** Gets the size of the stream.
+
+@return The size of the stream, in bytes. */
+	{return CONST_CAST(MStreamBuf*,this)->DoSeekL(0,EStreamEnd,0).Offset();}
+
+// Class TStreamBuf
+inline void TStreamBuf::SetBuf(TRead,TUint8* aPtr,TUint8* anEnd)
+/** Sets the start and end points of the read area within the intermediate buffer.
+
+A start point is always within an area; an end point is always the first byte 
+beyond the end of an area.
+
+@param (The enumerator is not used).
+@param aPtr The start point.
+@param anEnd The end point.
+@see MStreamBuf::TRead */
+	{iRPtr=aPtr;iREnd=anEnd;}
+inline void TStreamBuf::SetBuf(TWrite,TUint8* aPtr,TUint8* anEnd)
+/** Sets the start and end points of the write area within the intermediate buffer.
+
+A start point is always within an area; an end point is always the first byte 
+beyond the end of an area.
+
+@param (The enumerator is not used).
+@param aPtr The start point.
+@param anEnd The end point.
+@see MStreamBuf::TWrite */
+	{iWPtr=aPtr;iWEnd=anEnd;}
+inline void TStreamBuf::SetPtr(TRead,TUint8* aPtr)
+/** Sets the start point of the write area within the intermediate buffer.
+
+A start point is always within an area.
+
+@param (The enumerator is not used).
+@param aPtr The start point.
+@see MStreamBuf::TWrite */
+	{iRPtr=aPtr;}
+inline void TStreamBuf::SetPtr(TWrite,TUint8* aPtr)
+/** Sets the start point of the write area within the intermediate buffer.
+
+A start point is always within an area.
+
+@param (The enumerator is not used).
+@param aPtr The start point.
+@see MStreamBuf::TWrite */
+	{iWPtr=aPtr;}
+inline void TStreamBuf::SetEnd(TRead,TUint8* anEnd)
+	{iREnd=anEnd;}
+inline void TStreamBuf::SetEnd(TWrite,TUint8* anEnd)
+	{iWEnd=anEnd;}
+inline TUint8* TStreamBuf::Ptr(TRead) const
+/** Gets the current start point of the read area within the intermediate buffer.
+
+@param (The enumerator is not used).
+@return The start point.
+@see MStreamBuf::TRead */
+	{return iRPtr;}
+inline TUint8* TStreamBuf::Ptr(TWrite) const
+/** Gets the current start point of the write area within the intermediate buffer.
+
+@param (The enumerator is not used).
+@return The start point.
+@see MStreamBuf::TWrite */
+	{return iWPtr;}
+inline TUint8* TStreamBuf::End(TRead) const
+/** Gets the current end point of the read area within the intermediate buffer.
+
+An end point is always the first byte beyond the end of an area.
+
+@param (The enumerator is not used).
+@return The end point.
+@see MStreamBuf::TRead */
+	{return iREnd;}
+inline TUint8* TStreamBuf::End(TWrite) const
+/** Gets the current end point of the write area within the intermediate buffer.
+
+An end point is always the first byte beyond the end of an area.
+
+@param (The enumerator is not used).
+@return The end point.
+@see MStreamBuf::TWrite */
+	{return iWEnd;}
+inline TInt TStreamBuf::Avail(TRead) const
+/** Gets the number of bytes available in the read area within the intermediate 
+buffer.
+
+@param (The enumerator is not used).
+@return The number of bytes available.
+@see MStreamBuf::TRead */
+	{return iREnd-iRPtr;}
+inline TInt TStreamBuf::Avail(TWrite) const
+/** Gets the number of bytes available in the write area within the intermediate 
+buffer.
+
+@param (The enumerator is not used).
+@return The number of bytes available.
+@see MStreamBuf::TWrite */
+	{return iWEnd-iWPtr;}
+
+// Class TStreamFilter
+inline void TStreamFilter::Set(MStreamBuf* aHost,TInt aMode)
+/** Sets up the filter to use the specified host for streamed data.
+
+Taking ownership of the host stream buffer means that calls to SynchL() propagate 
+to the host buffer after the filter has flushed its data, and that when the 
+filter is released it also releases the host buffer. 
+
+@param aHost The host for the streamed data - a stream buffer.
+@param aMode The mode in which the stream buffer is to be used. It can be used 
+in either read or write modes, represented by ERead and EWrite, but not both 
+at the same time. In debug mode, setting both raises a STORE-Stream 18 panic. 
+In addition, specify EAttached to indicate that the filter should take ownership 
+of the host stream buffer.
+@see MStreamBuf::TRead
+@see MStreamBuf::TWrite */
+	{
+#if defined (_DEBUG)
+	__DbgChkMode(aMode);
+#endif
+	iHost=aHost;iMode=aMode;
+	}
+inline void TStreamFilter::Committed()
+/** Flags the streamed data as committed. */
+	{iMode&=~EWrite;}
+inline TBool TStreamFilter::IsCommitted() const
+/** Tests whether the streamed data is committed.
+
+@return True, if streamed data is committed; false, otherwise. */
+	{return iHost==NULL||!(iMode&EWrite);}