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