#ifndef __ENCDEC_H__

#define __ENCDEC_H__

/*

* Copyright (c) 2008-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 "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: 

*

*/

#include <s32strm.h>

#include "filestream.h"

#include "logger.h"

/**

 * @file

 * @internalComponent

 */

typedef uint64_t TUint64;

typedef int64_t TInt64;

typedef	int	TInt32;

typedef	unsigned int TUint32;

typedef	short TInt16;

typedef	unsigned short TUint16;

typedef	signed char	TInt8;

typedef	unsigned char TUint8;

typedef	TUint32 TChar;

typedef	int TBool;

typedef void TAny;

TUint8 fromHex(TUint8 ch);

TUint32 ReadUnsignedNumber(std::string &aStr, size_t aSize);

class RDecodeReadStream

	{

public:

	// Create store based stream in binary mode

	RDecodeReadStream(CFileStore *aStore, RReadStream &aReadStream);

	// Create a file based stream  in human mode

	RDecodeReadStream(const std::string &aCertBaseName, RReadStream &aReadStream);

	void RawRead(void *aPtr, TUint32 aLength);

	void CheckName(const std::string &aExpected);

	TUint32 ReadUnsignedNumber(size_t aSize);

	// Return current token

	const std::string &Token() const;

	// Discard current token and read the next

	void ReadNextToken();

	// Return the token after the current token.

	// The current token is not updated.

	// This will only look ahead a single token.

	const std::string &PeakToken();

	bool HumanReadable() const;

	void Close();

	CFileStore *iStore;  // Only used for STORE based streams ie. not human readable

	std::string iCertBaseName; // Only used for file based streams ie. human readable

	RReadStream &iReadStream;

private:

	bool iHumanReadable; 

	std::string iToken;

	bool iPrefetchedTokenIsValid;

	std::string iPrefetchedToken;

	void GetToken(std::string &aToken);

	};

class REncodeWriteStream

	{

public:

	// Construct stream based on a store in binary mode

	REncodeWriteStream(CFileStore *aStore, RWriteStream &aWriteStream); // store stream

	// Construct stream based on a file in human mode

	REncodeWriteStream(const std::string &aCertBaseName, RWriteStream &aWriteStream); // file stream

	// Create a human readable log

	REncodeWriteStream(Log &aLog);

	/**

	   Write binary data to the output stream without escaping

	   it. This data is allowed to contain the NUL (0) character and

	   may be binary data for the store file or UTF-8 text for the

	   human readable config file output.

	*/

	void WriteBin(const void *aPtr, TUint32 aLength);

	/**

	   Write a C style string to the output stream without escaping

	   it. It is NOT safe to write a generic UTF-8 string via this

	   this function, because such a string may contain embedded 0

	   characters. A 7-bit ASCII string will work reliably.  This

	   function is intended for writing 7-but ASCII strings to the

	   human readable config file, and should not be used for writing

	   data to a store file.

	 */

	void WriteQuotedUtf8(const void *aStr, TUint32 aLength);

	/**

	   Write a single byte.

	 */

	void WriteByte(TUint8 aByte);

	/**

	   Write a UTF-8 string quoting backslash and double quote characters.

	   A backslash will be written as \\

	   A quote character will be written as \"

	   Note that all bytes in UTF-8 escape sequences have the top bit

	   set therefore the quoting technique used by this function will

	   not effect them.

	 */

	void WriteCStr(const void *aCstr);

	void WriteHexNumber(TUint32 aNumber);

	void WriteSpace();

	void WriteLineEnd();

	void WriteIndent();

	void IncIndent();

	void DecIndent();

	bool HumanReadable() const;

	bool &PemOut();

	bool &Verbose();

	void Close();

	bool Quiet() const;

	CFileStore *StoreObject();

	RWriteStream &StoreWriteStream();

	std::string CertFileName(TUint32 aFormat, TUint32 aCertNumber);

private:

	CFileStore *iStore; // Only used for STORE based streams ie. not human readable

	std::string iCertBaseName; // Only used for file based streams ie. human readable

	RWriteStream *iWriteStream; // STORE or file based stream, valid if iLogStream==0

	std::ostream *iLogStream;

private:

	bool iHumanReadable; 

	bool iPemOut; 

	bool iVerbose; 

	int iIndentLevel;

	};

/**

  A template which generates a class which can be

  internalised/externalised via the REncodeWriteStream and

  RDecodeReadStream templates.

  The constructor takes a C string constant which specifies the field

  name.

  The optional aCommentOnlyInHumanMode parameter changes operation in human

  mode only - The field will be written as a comment, and will not be

  accepted whilst reading.

  Typical use is something like this:-

  EncDecObject<TUint32> fieldCost("cost");

  Typically this template will not require specialisations to handle

  additional types.

*/

template <class T> class EncDecObject

	{

public:

	EncDecObject(const char *aName, bool aCommentOnlyInHumanMode = false)

		: iName(aName), iCommentOnlyInHumanMode(aCommentOnlyInHumanMode), iValue()

		{

		}

	const std::string &Name() const { return iName; }

	const T &Value() const { return iValue; }

	T &Value() { return iValue; }

	bool CommentOnlyInHumanMode() const { return iCommentOnlyInHumanMode; }

private:

	std::string iName;

	bool iCommentOnlyInHumanMode;

	T iValue;

	};

/**

   Class for handling Enum values

 */

struct EnumEntry

	{

	const char *iName;

	TUint32 iValue;

	};

// This class should be template by a type which standard store can

// internalise/externalise ie TUint8/TUin16/TUint32 (probably not an enum)

template<typename T>class EncDecEnum

	{

public:

	/**

	   Construct an object for handling an enum type.

	   aEnumEntries must be a pointer to a static array of EnumEntry

	   structs terminated by one with iName==0.

	 */

	EncDecEnum(const char *aName, const EnumEntry *aEnumEntries, bool aCommentOnlyInHumanMode = false);

	const std::string &Name() const { return iName; }

	const T &Value() const { return iValue; }

	T &Value() { return iValue; }

	const char *ValueName() const { return ValueToName(iValue); }

	bool CommentOnlyInHumanMode() const { return iCommentOnlyInHumanMode; }

	void SetValue(const T &aValue);

	void SetValue(const char *aName);

private:

	const char *ValueToName(const T &aValue) const;

	std::string iName;

	TUint8 iWidth;

	const EnumEntry *iEnumEntries; // Array terminated by entry with iName==0

	bool iCommentOnlyInHumanMode;

	T iValue;

	};

/*

  The EncDecContainer class manages a set of objects which inherit

  from the EncDecContainerItem base class. It can be

  internalised/externalised via the REncodeWriteStream and

  RDecodeReadStream templates.

  The constructor takes a C string constant which specifies the

  container name.

  The binary form is a 32 bit count followed by a sequence of

  EncDecContainerItem objects.

  In human readable form is a sequence of zero or more human readable

  representations of T bracketed by StartX and EndX. Where X is the

  container name.

*/

class EncDecContainerItem

	{

public:

	virtual ~EncDecContainerItem();

	// Get the type name for the container. If 0 then do not bracket item with StartType/EndType

	virtual const char *ItemType() const = 0;

	// If ItemType()!=0 then ItemName will be included after StartType

	virtual std::string ItemName() const;

	virtual void SetItemName(const std::string &aName);

	virtual void Encode(REncodeWriteStream &aWriteStream) = 0;

	virtual void Decode(RDecodeReadStream &aReadStream) = 0;

	};

typedef EncDecContainerItem *EncDecContainerItemFactoryFunc();

class EncDecContainer

	{

public:

	EncDecContainer(const char *aContainerName, EncDecContainerItemFactoryFunc *aFactory);

	~EncDecContainer();

	void push_back(EncDecContainerItem *aItem);

	const EncDecContainerItem &operator[](TUint32 aIndex) const;

	EncDecContainerItem &operator[](TUint32 aIndex);

	TUint32 size() const;

	void reset();

	void Encode(REncodeWriteStream &aWriteStream) const;

	void Decode(RDecodeReadStream &aReadStream);

private:

	std::string iName;

	EncDecContainerItemFactoryFunc *iFactory;

	std::vector<EncDecContainerItem *> iArray;

	};

void readContainer(const std::string &aFileName, bool aHuman, EncDecContainer &container);

void writeContainer(const char *aFileName, bool aHuman, bool aPemOut, bool aVerbose, const EncDecContainer &container);

/*

  The EncodeHuman template functions are used to convert a type to

  human readable form.

  Do NOT try and write specialisations of these templates, it probably

  will not work, instead just write a conventional function which is

  selected via the norml overloading rules. See GOTW articles on the

  web.

 */

// The basic EncodeHuman template assumes that T is an unsigned

// integer and encodes it in hex.

template <class T> void EncodeHuman(REncodeWriteStream& aStream,const T &aUnsignedIntType)

{

	aStream.WriteHexNumber(aUnsignedIntType);

}

void EncodeHuman(REncodeWriteStream& aStream,const TUid &aUid);

void EncodeHuman(REncodeWriteStream& aStream,const TName &aName);

/*

  The DecodeHuman template functions are used to read in the human

  readable form.

  Do NOT try and write specialisations of these templates, it probably

  will not work, instead just write a conventional function which is

  selected via the norml overloading rules. See GOTW articles on the

  web.

 */

// The basic DecodeHuman template assumes that T is an unsigned integer

// and decodes it from either decimal or hex (starting with 0x).  The

// code calls RDecodeReadStream::ReadUnsignedNumber which will decode

// the number (max 32bits) and check it fits into specified type.

template <class T> void DecodeHuman(RDecodeReadStream& aStream,T &aUnsignedIntType)

{

	aUnsignedIntType = (T) aStream.ReadUnsignedNumber(sizeof(aUnsignedIntType));

}

void DecodeHuman(RDecodeReadStream& aStream,TUid &aUid);

void DecodeHuman(RDecodeReadStream& aStream,TName &aName);

/*

  The following two template operators require the object which is

  being internalised or externalised to provide a const Name function

  (which returns the field name) and two Value functions (one const

  and one not) which return a reference to an instance of the type

  being handled. A function called CommentOnlyInHumanMode should

  return true if the human output should be prefixed with # and should

  be reject when reading.

  Typicaly types will be wrapped by the EncDecObject template to

  provide the Name() and Value() functions required by these

  templates.

  Do NOT try and write specialisations of these templates, it probably

  will not work, instead just write a conventional function which is

  selected via the norml overloading rules. See GOTW articles on the

  web.

  Note: You probably only need to enhance the EncodeHuman/DecodeHuman

  functions unless you are adding a new variable length container type.

 */

/*

  The externalise operator << first checks if the destination stream

  is HumanReadable. If it is, it writes the Name(), followed by a

  space, calls EncodeHuman, then WriteLineEnd. If the stream is not

  HumanReadable it simply applies the << operator to the Value().

*/

template <class T>

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

REncodeWriteStream& operator<<(REncodeWriteStream& aStream, const EncDecContainer &aContainer);

template <typename T>

REncodeWriteStream& operator<<(REncodeWriteStream& aStream, const EncDecEnum<T> &aEncDecEnum);

/*

  The internalise operator >> first checks if the source stream is

  HumanReadable. If it is, it reads/checks the field name then calls

  DecodeHuman. If the stream is not HumanReadable

  it simply applies the >> operator to the Value().

*/

template <class T>

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

RDecodeReadStream& operator>>(RDecodeReadStream& aStream,EncDecContainer &aContainer);

template <typename T>

RDecodeReadStream& operator>>(RDecodeReadStream& aStream, EncDecEnum<T> &aEncDecEnum);

#include "encdec.inl"

#endif