/*

* 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: 

*

*/

template <class T>

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

{

	const std::string &name = anObject.Name();

	if(!aStream.Quiet())

		{

		// Generate human readable progress

		REncodeWriteStream tmp(prog);

		tmp << anObject;

		}

	if(aStream.HumanReadable())

		{

		if(anObject.CommentOnlyInHumanMode() && !aStream.Verbose())

			{

			return aStream;

			}

		aStream.WriteIndent();

		if(anObject.CommentOnlyInHumanMode())

			{

			aStream.WriteByte('#');

			}

		aStream.WriteBin(name.data(), name.size());

		aStream.WriteSpace();

		EncodeHuman(aStream, anObject.Value());

		aStream.WriteLineEnd();

		}

	else

		{

		// Just write as binary "store" format

		aStream.StoreWriteStream() << anObject.Value();

		}

	return aStream;

}

template <typename T>

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

{

	const std::string &name = aEncDecEnum.Name();

	if(!aStream.Quiet())

		{

		// Generate human readable progress

		REncodeWriteStream tmp(prog);

		tmp << aEncDecEnum;

		}

	if(aStream.HumanReadable())

		{

		if(aEncDecEnum.CommentOnlyInHumanMode() && !aStream.Verbose())

			{

			return aStream;

			}

		aStream.WriteIndent();

		if(aEncDecEnum.CommentOnlyInHumanMode())

			{

			aStream.WriteByte('#');

			}

		aStream.WriteBin(name.data(), name.size());

		aStream.WriteSpace();

		const char *enumName = aEncDecEnum.ValueName();

		if(enumName)

			{

			aStream.WriteByte('"');

			aStream.WriteBin(enumName, strlen(enumName));

			aStream.WriteByte('"');

			if(aStream.Verbose())

				{

				// In verbose mode so include numeric value as a comment

				aStream.WriteCStr(" # ");

				EncodeHuman(aStream, TUint32(aEncDecEnum.Value()));		

				}

			}

		else

			{

			// Symbolic value not available, so write as numeric

			EncodeHuman(aStream, TUint32(aEncDecEnum.Value()));		

			}

		aStream.WriteLineEnd();

		}

	else

		{

		// Just write as binary "store" format

		aStream.StoreWriteStream() << aEncDecEnum.Value();

		}

	return aStream;

}

template <class T>

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

{

	const std::string &name = anObject.Name();

	if(aStream.HumanReadable())

		{

		if(anObject.CommentOnlyInHumanMode())

			{

			return aStream; // Not accepted in human mode, so just return...

			}

		// Need to convert to ascii

		aStream.CheckName(name);

		DecodeHuman(aStream, anObject.Value());

		}

	else

		{

		// Just read binary

		aStream.iReadStream >> anObject.Value();

		}

	// Generate human readable progress

	//	prog.WriteIndent();

	REncodeWriteStream tmp(prog);

	tmp << anObject;

	return aStream;

}

template <typename T>

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

{

	const std::string &name = aEncDecEnum.Name();

	if(aStream.HumanReadable())

		{

		if(aEncDecEnum.CommentOnlyInHumanMode())

			{

			return aStream; // Not accepted in human mode, so just return...

			}

		// Need to convert to ascii

		aStream.CheckName(name);

		aStream.ReadNextToken();

		aEncDecEnum.SetValue(aStream.Token().c_str());

		}

	else

		{

		// Just read binary

		aStream.iReadStream >> aEncDecEnum.Value();

		}

	// Generate human readable progress

	//	prog.WriteIndent();

	REncodeWriteStream tmp(prog);

	tmp << aEncDecEnum;

	return aStream;

}

template<typename T>

EncDecEnum<T>::EncDecEnum(const char *aName, const EnumEntry *aEnumEntries, bool aCommentOnlyInHumanMode)

	: iName(aName), iEnumEntries(aEnumEntries), iCommentOnlyInHumanMode(aCommentOnlyInHumanMode), iValue(0)

{

	if(iEnumEntries == 0)

		{

		FatalError(); // programing error

		}

}

template<typename T>

void EncDecEnum<T>::SetValue(const T &aValue)

{

	// Search enum entires which one which matches

	if(ValueToName(aValue) == 0)

		{

		dbg << Log::Endl();

		dbg << Log::Indent() << "Unknown value for enum " << iName << " value " << TUint32(aValue) << Log::Endl();

		//		FatalError();

		}

	iValue = aValue;

	return;

}

template<typename T>

void EncDecEnum<T>::SetValue(const char *aName)

{

	// Search enum entires which one which matches

	const EnumEntry *p = iEnumEntries;

	while(p && p->iName)

		{

		// We ignore case when matching enums

		if(strcasecmp(aName, p->iName) == 0)

			{

			// Found it

			iValue = p->iValue;

			return;

			}

		++p;

		}

	dbg << Log::Endl();

	dbg << Log::Indent() << "Unknown value for enum " << iName << " value '" << aName << "'" << Log::Endl();

	std::string str(aName);

	iValue = ReadUnsignedNumber(str,sizeof(T));

}

template<typename T>

const char *EncDecEnum<T>::ValueToName(const T &aValue) const

{

	if(iEnumEntries == 0) FatalError();

	const EnumEntry *p = iEnumEntries;

	while(p && p->iName)

		{

		if(p->iValue == aValue)

			{

			return p->iName;

			}

		++p;

		}

	return 0;

}

// end of file