#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