API_REF/Public_API: comparison epoc32/include/s32mem.h

equal deleted inserted replaced

-:e1b950c65cb4
+:837f303aceeb
 // 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
+// under the terms of "Eclipse Public License v1.0"
 // which accompanies this distribution, and is available
-// at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
 //
 // Initial Contributors:
 // Nokia Corporation - initial contribution.
 //
 // Contributors:
 #if !defined(__S32STOR_H__)
 #include <s32stor.h>
 #endif
 /**
 * @publishedAll
 * @released
 * A stream buffer that uses plain memory for its implementation.
 A stream of this type is used by RMemWriteStream and RMemReadStream objects.
 It also has intermediate buffering capabilities.
 This is a seekable stream buffer.
 @see RMemWriteStream
 @see RMemReadStream
 */
 class TMemBuf : public TStreamBuf
 	{
 public:
 	IMPORT_C TMemBuf();
 private:
 	TUint8* iBase;
 	};
 /**
 * @publishedAll
 * @released
 * A stream buffer that uses a descriptor for its implementation.
 A stream of this type is used by RDesWriteStream and RDesReadStream objects.
 It also has intermediate buffering capabilities.
 This is a seekable stream buffer.
 When used in write mode, the length of the descriptor is only updated when
 the stream buffer's SynchL() function is called, i.e. as a result of a call
 to RWriteStream::CommitL().
 @see RDesWriteStream
 @see RDesReadStream
 @see RWriteStream::CommitL()
 @see MStreamBuf::SynchL()
 */
 class TDesBuf : public TStreamBuf
 	{
 public:
 	IMPORT_C TDesBuf();
 private:
 	TDes8* iDes;
 	};
 /**
 * @publishedAll
 * @released
 * A stream buffer that uses a dynamic buffer for its implementation.
 A stream of this type is used by RBufWriteStream and RBufReadStream objects.
 It also has intermediate buffering capabilities.
 This is a seekable stream buffer.
 There are three write modes:
 insert mode - inserts new data into the buffer at the offset passed to Set()
 overwrite mode - replaces the data in the buffer starting at the offset passed
 to Set(). Once the end of the buffer is reached, it is automatically extended
 as more data is written. This is the default mode.
 truncate mode - truncates the buffer to the offset passed to Set() before
 data is written, extending the buffer. When writing, the buffer size as reported
 by CBufBase::Size() may be larger than the data written to the stream. To
 synchronise the buffer's reported size with the stream, call the MStreamBuf::SynchL()
 function.
 Note that this object never takes ownership of the dynamic buffer, the CBufBase
 type object.
 @see RBufWriteStream
 @see RBufReadStream
 @see CBufBase::Size()
 @see MStreamBuf::SynchL()
 */
 class TBufBuf : public TStreamBuf
 	{
 public:
 	enum {ETruncate=0x10,EInsert=0x20};
 	TInt iWPos;
 	TInt iMode;
 	};
 /**
 @publishedAll
 @released
 Supports the reading of a stream from a pointer of any type.
 @see TMemBuf
 @see RReadStream
 */
 class RMemReadStream : public RReadStream
 	{
 public:
+/**
+Constructs an empty object.
+Call Open() to prepare the stream for reading.
+*/
 	RMemReadStream() {}
 	IMPORT_C RMemReadStream(const TAny* aPtr,TInt aLength);
 	IMPORT_C void Open(const TAny* aPtr,TInt aLength);
 private:
 	TMemBuf iSource;
 	};
 /**
 @publishedAll
 @released
 Supports the writing of a stream to a pointer of any type.
 @see TMemBuf
 @see RWriteStream
 */
 class RMemWriteStream : public RWriteStream
 	{
 public:
+/**
+Constructs an empty write stream object.
+Call Open() to prepare a stream for writing.
+*/
 	RMemWriteStream() {}
 	inline RMemWriteStream(const MExternalizer<TStreamRef>& anExter);
 	IMPORT_C RMemWriteStream(TAny* aPtr,TInt aMaxLength);
 	IMPORT_C void Open(TAny* aPtr,TInt aMaxLength);
 private:
 	TMemBuf iSink;
 	};
 /**
 @publishedAll
 @released
 Supports the reading of a stream from an 8-bit descriptor.
 @see TMemBuf
 @see RReadStream
 */
 class RDesReadStream : public RReadStream
 	{
 public:
+/**
+Constructs an empty read stream object.
+Call Open() to prepare the stream for reading.
+*/
 	RDesReadStream() {}
 	IMPORT_C RDesReadStream(const TDesC8& aDes);
 	IMPORT_C void Open(const TDesC8& aDes);
 private:
 	TMemBuf iSource;
 	};
 /**
 @publishedAll
 @released
-Supports the writing of a stream to an 8-bit descriptor.
+Supports the writing of a stream to a stream buffer hosted by an 8-bit descriptor.
 @see TDesBuf
 @see RWriteStream
 */
 class RDesWriteStream : public RWriteStream
 	{
 public:
+/**
+Constructs an empty write stream object.
+Call Open() to prepare a stream for writing.
+*/
 	RDesWriteStream() {}
 	inline RDesWriteStream(const MExternalizer<TStreamRef>& anExter);
 	IMPORT_C RDesWriteStream(TDes8& aDes);
 	IMPORT_C void Open(TDes8& aDes);
 private:
 	TDesBuf iSink;
 	};
 /**
 @publishedAll
 @released
-Supports the reading of a stream from a dynamic buffer.
+Supports the opening of an existing stream hosted by a dynamic buffer.
+The stream does not take ownership of the dynamic buffer, which means
+that the creator is responsible for deleting the buffer when it is no
+longer needed.
 @see TBufBuf
 @see RReadStream
 */
 class RBufReadStream : public RReadStream
 	{
 public:
+/**
+Constructs an empty read stream object.
+Call Open() to prepare the stream for reading.
+*/
 	RBufReadStream() {}
 	IMPORT_C RBufReadStream(const CBufBase& aBuf,TInt aPos=0);
 	IMPORT_C void Open(const CBufBase& aBuf,TInt aPos=0);
 private:
 	TBufBuf iSource;
 	};
 /**
 @publishedAll
 @released
-Supports the writing of a stream to a dynamic buffer.
+Supports the writing of a stream to a dynamic buffer.  The stream does
+not take ownership of the dynamic buffer, which means that the creator
+is responsible for deleting the buffer when it is no longer needed.
 @see TBufBuf
 @see RWriteStream
 */
 class RBufWriteStream : public RWriteStream
 	{
 public:
+/**
+Default constructor.  Constructs an empty write stream object.
+Call Open(), Truncate() or Insert() to prepare a stream for writing.
+*/
 	RBufWriteStream() {}
 	inline RBufWriteStream(const MExternalizer<TStreamRef>& anExter);
 	IMPORT_C RBufWriteStream(CBufBase& aBuf,TInt aPos=0);
 	IMPORT_C void Open(CBufBase& aBuf,TInt aPos=0);
 	IMPORT_C void Truncate(CBufBase& aBuf,TInt aPos=0);
 	IMPORT_C void Insert(CBufBase& aBuf,TInt aPos);
 private:
 	TBufBuf iSink;
 	};
 /**
 * @publishedAll
 * @released
 * In-memory non-persistent store. The buffer store does not have a root stream
 and cannot be closed without losing all the data.
 It implements many of the operations defined by the store abstract framework.
 Specifically, streams in this store can be: overwritten, replaced, appended,
 deleted, and created in advance of being written to. However the class does
 not support commit and revert operations.
 Overwriting an existing stream can result in a shorter stream; however, a
 stream cannot be extended beyond its original length. Replacing a stream can
 result in a stream which is longer or shorter than the original. The order
 in which streams are written to a memory store is not important as streams
 can be changed and rewritten.
 */
 class CBufStore : public CStreamStore
 	{
 public:
 	IMPORT_C static CBufStore* NewL(TInt anExpandSize);
 private:
 	CBufSeg& BufL(TStreamId anId) const;
 private:
 	CArrayFixFlat<CBufSeg*> iBufArray;
 	TInt iExpandSize;
 	};
 #include <s32mem.inl>
 #endif

branch	Symbian3
changeset 4	837f303aceeb
parent 2	2fe1408b6811