// 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(__S32STRM_H__)

 #define __S32STRM_H__

 #if !defined(__E32BASE_H__)

 #include <e32base.h>

 #endif

 /** The largest integer value which can be stored as a TCardinality type. */

 const TInt KMaxCardinality=0x1fffffff;

 //

 class MStreamBuf;

 class RWriteStream;

 /**

  * @publishedAll 

  * @released

  * The read stream interface. The process of internalising from a stream is 

 achieved through a reference to an object of this type.

 A store aware class defines an implements an InternalizeL() member function 

 which is used to internalise that object and takes a reference to an 

 RReadStream as the interface to the read stream. 

 */

 class RReadStream

 	{

 public:

 	inline RReadStream();

 	inline RReadStream(MStreamBuf* aSource);

 	inline MStreamBuf* Source();

 	inline void Close();

 	IMPORT_C void Release();

 //

 	IMPORT_C void PushL();

 	inline void Pop();

 //

 	IMPORT_C void ReadL(TDes8& aDes);

 	IMPORT_C void ReadL(TDes8& aDes,TInt aLength);

 	IMPORT_C void ReadL(TDes8& aDes,TChar aDelim);

 	IMPORT_C void ReadL(TUint8* aPtr,TInt aLength);

 	IMPORT_C void ReadL(TInt aLength);

 	inline void ReadL(RWriteStream& aStream);

 	inline void ReadL(RWriteStream& aStream,TInt aLength);

 //

 	IMPORT_C void ReadL(TDes16& aDes);

 	IMPORT_C void ReadL(TDes16& aDes,TInt aLength);

 	IMPORT_C void ReadL(TDes16& aDes,TChar aDelim);

 	IMPORT_C void ReadL(TUint16* aPtr,TInt aLength);

 //

 	IMPORT_C TInt8 ReadInt8L();

 	IMPORT_C TInt16 ReadInt16L();

 	IMPORT_C TInt32 ReadInt32L();

 	IMPORT_C TUint8 ReadUint8L();

 	IMPORT_C TUint16 ReadUint16L();

 	IMPORT_C TUint32 ReadUint32L();

 	IMPORT_C TReal32 ReadReal32L() __SOFTFP;

 	IMPORT_C TReal64 ReadReal64L() __SOFTFP;

 protected:

 	inline void Attach(MStreamBuf* aSource);

 	inline void Detach();

 private:

 	MStreamBuf* iSrc;

 private:

 	friend class RWriteStream;

 	};

 template <class T>

 class MExternalizer;

 class TStreamRef;

 /**

  * @publishedAll 

  * @released

  * The write stream interface. The process of externalising to a stream is 

 achieved through a reference to an object of this type.

 A store aware class defines and implements an ExternalizeL() member function 

 which is used to externalise that object and takes a reference to an 

 RWriteStream as the interface to the write stream. 

 */

 class RWriteStream

 	{

 public:

 	inline RWriteStream();

 	inline RWriteStream(const MExternalizer<TStreamRef>& anExter);

 	inline RWriteStream(MStreamBuf* aSink);

 	inline MStreamBuf* Sink();

 	IMPORT_C void Close();

 	IMPORT_C void Release();

 	IMPORT_C void CommitL();

 //

 	IMPORT_C void PushL();

 	inline void Pop();

 //

 	IMPORT_C void WriteL(const TDesC8& aDes);

 	IMPORT_C void WriteL(const TDesC8& aDes,TInt aLength);

 	IMPORT_C void WriteL(const TUint8* aPtr,TInt aLength);

 	IMPORT_C void WriteL(RReadStream& aStream);

 	IMPORT_C void WriteL(RReadStream& aStream,TInt aLength);

 //

 	IMPORT_C void WriteL(const TDesC16& aDes);

 	IMPORT_C void WriteL(const TDesC16& aDes,TInt aLength);

 	IMPORT_C void WriteL(const TUint16* aPtr,TInt aLength);

 //

 	IMPORT_C void WriteInt8L(TInt aValue);

 	IMPORT_C void WriteInt16L(TInt aValue);

 	IMPORT_C void WriteInt32L(TInt32 aValue);

 	IMPORT_C void WriteUint8L(TUint aValue);

 	IMPORT_C void WriteUint16L(TUint aValue);

 	IMPORT_C void WriteUint32L(TUint32 aValue);

 	IMPORT_C void WriteReal32L(TReal aValue) __SOFTFP;

 	IMPORT_C void WriteReal64L(TReal64 aValue) __SOFTFP;

 protected:

 	inline void Attach(MStreamBuf* aSink);

 	inline void Detach();

 private:

 	IMPORT_C void WriteRefL(TStreamRef aRef);

 private:

 	MStreamBuf* iSnk;

 	const MExternalizer<TStreamRef>* iExterL;

 private:

 	friend class TStreamRef;

 	};

 //

 template <class T>

 inline RWriteStream& operator<<(RWriteStream& aStream,const T& anObject);

 template <class T>

 inline RReadStream& operator>>(RReadStream& aStream,T& anObject);

 /**

  * @publishedAll 

  * @released

  * Compact stream format for positive integer values in the range 0 to 

 536,870,911 ((2^29)-1). Values in the range 0-127 are stored in a single byte, 

 128-16383 in two bytes and other values in 4 bytes.

 The class provides conversion to and from TInt, and both externalization and 

 internalization functions. It is used to significant effect within Symbian 

 code. 

 */

 class TCardinality

 	{

 public:

 	TCardinality() {}

 	inline TCardinality(TInt aCount);

 	inline operator TInt() const;

 //

 	IMPORT_C void ExternalizeL(RWriteStream& aStream) const;

 	IMPORT_C void InternalizeL(RReadStream& aStream);

 private:

 	TInt iCount;

 private:

 	IMPORT_C static void __DbgChkRange(TInt aCount);

 	};

 //

 /** Defines a function type for a function returned by TExternalizer::Function() 

 and TStreamRef. */

 typedef void (*TExternalizeFunction)(const TAny* aPtr,RWriteStream& aStream);

 /** Defines a function type for a function returned by TInternalizer::Function(). */

 typedef void (*TInternalizeFunction)(TAny* aPtr,RReadStream& aStream);

 /**

  * @publishedAll 

  * @released

  * A family of classes whose instances can be used to perform externalisation 

 on behalf of other objects.

 @see TStreamRef  

 */

 template <class T>

 class TExternalizer

 	{

 public:

 	inline void operator()(const T& anObject,RWriteStream& aStream) const;

 	inline static TExternalizeFunction Function();

 private:

 	static void ExternalizeAsL(const TAny* aPtr,RWriteStream& aStream);

 	};

 /**

  * @publishedAll 

  * @released

  * A specific instantiation of the family of TExternalizer<class T> classes whose 

 instances can be used to perform externalisation on behalf of other untyped 

 objects. 

 */

 TEMPLATE_SPECIALIZATION class TExternalizer<TAny>

 	{

 public:

 	/** Default constructor. */

 	TExternalizer() {}

 	/** Constructs the externaliser with the specified externalisation function.

 	@param aFunction The externalisation function. */

 	inline TExternalizer(TExternalizeFunction aFunction);

 	inline void operator()(const TAny* aPtr,RWriteStream& aStream) const;

 	/** Gets a pointer to the function to be used to perform externalisation.

 	@return The externalisation function. */

 	inline TExternalizeFunction Function() const;

 private:

 	TExternalizeFunction iFunc;

 	};

 /**

  * @publishedAll 

  * @released

  * A family of classes whose instances can be used to perform internalisation 

 on behalf of other objects. 

 */

 template <class T>

 class TInternalizer

 	{

 public:

 	inline void operator()(T& anObject,RReadStream& aStream) const;

 	inline static TInternalizeFunction Function();

 private:

 	static void InternalizeAsL(TAny* aPtr,RReadStream& aStream);

 	};

 /**

  * @publishedAll 

  * @released

  * A specific instantiation of the family of TInternalizer<class T> classes whose 

 instances can be used to perform internalisation on behalf of other objects. 

 */

 TEMPLATE_SPECIALIZATION class TInternalizer<TAny>

 	{

 public:

 	/** Default constructor. */

 	TInternalizer() {}

 	/** Constructs the internaliser with the specified internalisation function.

 	@param aFunction The internalisation function. */

 	inline TInternalizer(TInternalizeFunction aFunction);

 	inline void operator()(TAny* aPtr,RReadStream& aStream) const;

 	/** Gets a pointer to the function to be used to perform internalisation.

 	@return The internalisation function. */

 	inline TInternalizeFunction Function() const;

 private:

 	TInternalizeFunction iFunc;

 	};

 /**

  * @publishedAll 

  * @released

  * A family of classes defining an interface that can be implemented by classes 

 that need to perform externalisation on behalf of others.

 @see CStoreMap 

 */

 template <class T>

 class MExternalizer

 	{

 public:

 	inline void operator()(const T& anObject,RWriteStream& aStream) const;

 private:

 	/** Performs externalisation.

 	The function is called by operator().

 	@param anObject The object to be externalised.

 	@param aStream The write stream. */

 	virtual void ExternalizeL(const T& anObject,RWriteStream& aStream) const=0;

 	};

 /**

  * @publishedAll 

  * @released

  * A family of classes defining an interface that can be implemented by classes 

 that need to perform internalisation on behalf of others.

 @see CStoreMap 

 */

 template <class T>

 class MInternalizer

 	{

 public:

 	inline void operator()(T& anObject,RReadStream& aStream) const;

 private:

 	/** Performs internalisation.

 	The function is called by operator().

 	@param anObject The object to be the target of the internalisation process.

 	@param aStream The read stream. */

 	virtual void InternalizeL(T& anObject,RReadStream& aStream) const=0;

 	};

 /**

  * @publishedAll 

  * @released

  * A proxy for perfoming externalisation for classes that do not have an 

 externalisation member. 

 */

 class TStreamRef

 	{

 public:

 	inline TStreamRef(const TAny* aPtr,TExternalizeFunction aFunction);

 	inline const TAny* Ptr() const;

 	inline TExternalizeFunction Function() const;

 //

 	inline void ExternalizeL(RWriteStream& aStream) const;

 private:

 	const TAny* iPtr;

 	TExternalizeFunction iFunc;

 	};

 /**

  * @publishedAll 

  * @released

  * A class whose members are used to distinguish between the two variants of 

 the Symbian OS internal function DoExternalizeL(). 

 */

 class Externalize

 	{

 public:

 	/** Indicates that an object will be externalized by calling its 

 	ExternalizeL() member. */

 	class Member {};

 	/** Indicates that an object will be externalized by calling a global 

 	ExternalizeL() function. */

 	class Function {};

 	};

 /**

  * @publishedAll 

  * @released

  * A class whose members are used to distinguish between the two variants of 

 the Symbian OS internal function DoInternalizeL(). 

 */

 class Internalize

 	{

 public:

 	/** Indicates that an object will be internalized by calling its 

 	InternalizeL() member. */

 	class Member {};

 	/** Indicates that an object will be internalized by calling a global 

 	InternalizeL() function. */

 	class Function {};

 	};

 #include <s32strm.inl>

 #endif