diff -r 666f914201fb -r 2fe1408b6811 epoc32/include/s32strm.h --- a/epoc32/include/s32strm.h Tue Nov 24 13:55:44 2009 +0000 +++ b/epoc32/include/s32strm.h Tue Mar 16 16:12:26 2010 +0000 @@ -1,1 +1,363 @@ -s32strm.h +// 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: +// + +#if !defined(__S32STRM_H__) +#define __S32STRM_H__ +#if !defined(__E32BASE_H__) +#include +#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 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& 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* iExterL; +private: + friend class TStreamRef; + }; +// +template +inline RWriteStream& operator<<(RWriteStream& aStream,const T& anObject); +template +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 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 classes whose +instances can be used to perform externalisation on behalf of other untyped +objects. +*/ +TEMPLATE_SPECIALIZATION class TExternalizer + { +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 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 classes whose +instances can be used to perform internalisation on behalf of other objects. +*/ +TEMPLATE_SPECIALIZATION class TInternalizer + { +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 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 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 +#endif