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