// 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:

//

#if !defined(__S32MEM_H__)

#define __S32MEM_H__

#if !defined(__S32BUF_H__)

#include <s32buf.h>

#endif

#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();

	IMPORT_C void Set(TUint8* aPtr,TUint8* anEnd,TInt aMode=ERead|EWrite);

protected:

	IMPORT_C TInt UnderflowL(TInt aMaxLength);

	IMPORT_C void OverflowL();

	IMPORT_C TStreamPos DoSeekL(TMark aMark,TStreamLocation aLocation,TInt anOffset);

private:

	inline TUint8* Base() const;

	inline TUint8* End() const;

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();

	IMPORT_C void Set(TDes8& aDes,TInt aMode=ERead|EWrite);

protected:

	IMPORT_C TInt UnderflowL(TInt aMaxLength);

	IMPORT_C void OverflowL();

	IMPORT_C void DoSynchL();

	IMPORT_C TStreamPos DoSeekL(TMark aMark,TStreamLocation aLocation,TInt anOffset);

private:

	inline TDes8& Des() const;

	inline TUint8* Base() const;

 	void Consolidate();

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};

public:

	IMPORT_C TBufBuf();

	IMPORT_C void Set(CBufBase& aBuf,TInt aPos,TInt aMode=ERead|EWrite);

protected:

	IMPORT_C TInt UnderflowL(TInt aMaxLength);

	IMPORT_C void OverflowL();

	IMPORT_C void DoSynchL();

	IMPORT_C void DoWriteL(const TAny* aPtr,TInt aLength);

	IMPORT_C TStreamPos DoSeekL(TMark aMark,TStreamLocation aLocation,TInt anOffset);

private:

	inline CBufBase& Buf() const;

 	void Consolidate();

//

	void SetPos(TMark aMark,TInt aPos);

	inline void SetPos(TRead,TInt aPos);

	inline void SetPos(TWrite,TInt aPos);

	TInt Pos(TMark aMark) const;

	inline TInt Pos(TRead) const;

	inline TInt Pos(TWrite) const;

	inline TInt MovePos(TRead,TInt anOffset);

	inline TInt MovePos(TWrite,TInt anOffset);

	inline TInt Mark(TRead) const;

	inline TInt Mark(TWrite) const;

private:

	CBufBase* iBuf;

	TInt iRPos;

	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 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 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.  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);

	inline void Append(CBufBase& aBuf);

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);

	IMPORT_C static CBufStore* NewLC(TInt anExpandSize);

	IMPORT_C CBufStore(TInt anExpandSize);

	IMPORT_C ~CBufStore();

protected:

	IMPORT_C TStreamId DoExtendL();

	IMPORT_C void DoDeleteL(TStreamId anId);

	IMPORT_C MStreamBuf* DoReadL(TStreamId anId) const;

	IMPORT_C MStreamBuf* DoCreateL(TStreamId& anId);

	IMPORT_C MStreamBuf* DoWriteL(TStreamId anId);

	IMPORT_C MStreamBuf* DoReplaceL(TStreamId anId);

private:

	CBufSeg& BufL(TStreamId anId) const;

private:

	CArrayFixFlat<CBufSeg*> iBufArray;

	TInt iExpandSize;

	};

#include <s32mem.inl>

#endif