#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