// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

// @internalComponent

// 

//

#ifndef __INITEMPLATE_H__

#define __INITEMPLATE_H__

#include <e32base.h>

#include <e32std.h>

#include <f32file.h>

#include <s32file.h>

#include <e32des16.h>

namespace BSUL

{

//Line Type enumeration //

enum TLineType

	{	

	EComment, 

	ESection, 

	EKeyValue

	};

//utils template class//

static void GetBufferL(RFs& aFs,const TDesC& aFileName,HBufC8*& aBufferPtr)

	{

	//open the file for reading

	RFile file;

	User::LeaveIfError(file.Open(aFs,aFileName,EFileShareReadersOnly));

	//only process the file if it exists		

	TInt filesize;

	CleanupClosePushL(file);

	User::LeaveIfError(file.Size(filesize)); 

	aBufferPtr=HBufC8::NewLC(filesize + 2); //In case '\r\n' needs to be appended

	TPtr8 asWritableBuffer(aBufferPtr->Des());

	User::LeaveIfError(file.Read(0,asWritableBuffer,filesize));

	//check if '\n' is present

	if( filesize > 0 && asWritableBuffer[filesize - 1] != '\n' )

		{

		asWritableBuffer.Append(_L8("\r\n"));

		}

	//pop the buffer

	CleanupStack::Pop();

	//close the file

	CleanupStack::PopAndDestroy();	

	}

template <class TLexX>

TBool IsEosAfterSpace(TLexX& aLex)

	{

	aLex.SkipSpace();

	return (aLex.Eos());

	}

template<class TPtrCX>

void RemoveComment(TPtrCX& aLine)

	{

	//Trim anything on the rhs of any inline comment ';' or '#'

	//in this case we need to locate which is the first occuring from left

	TInt semiColon=aLine.Locate(';');

	TInt hash=aLine.Locate('#');

	if (semiColon!=KErrNotFound || hash!=KErrNotFound)

		{

		if (semiColon!=KErrNotFound && hash!=KErrNotFound)

			{

			aLine.Set(aLine.Left(semiColon<hash?semiColon:hash));				

			}

		else

			{

			aLine.Set(aLine.Left(semiColon!=KErrNotFound?semiColon:hash));

			}	

		}	

	}

template <class TPtrCX,class TLexX>

void RemoveWSBeforeAndAfter(const TPtrCX& aString,TPtrCX& aOutput)

	{

	TLexX parser(aString);

	parser.SkipSpaceAndMark();

	TInt offset=parser.Offset();

	while(!parser.Eos())

		{

		//now skip for whitespace and check end of string					

		//if this is eos we are done unget to mark and break

		parser.SkipCharacters();

		parser.Mark();

		if (IsEosAfterSpace(parser))

			{

			parser.UnGetToMark();

			break;			

			}		

		}

	TInt endOffset=parser.MarkedOffset();

	aOutput.Set(aString.Mid(offset,endOffset-offset));		

	}

template<class TPtrCX,class TLexX>

TInt CountTokens(TPtrCX aLine)

	{

	TLexX myLexer(aLine);

	TInt tokenCount=0;

	while (!myLexer.Eos())

		{

		TPtrCX next = myLexer.NextToken();

		if (next.Size())

			{

			tokenCount++;

			}

		}

	return tokenCount;

	}

static void CorruptIfL(TBool aIsCorrupt)

	{

	if (aIsCorrupt)

		{

		User::Leave(KErrCorrupt);

		}

	}

template<class HBufCX, class TPtrCX>

TPtrCX ExtractLineFromBuffer(const TPtrCX& aFileBuffer, TInt aStartOffset)

	{

	TChar delim('\n');

	TPtrCX partialLine = aFileBuffer.Mid(aStartOffset, aFileBuffer.Length()- aStartOffset);

	TInt delimOffset= partialLine.Locate(delim);

	if (delimOffset==KErrNotFound)

		{

		return partialLine;

		}

	return partialLine.Left(delimOffset+1);

	}

//ini line template class //

template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>

NONSHARABLE_CLASS(CIniLine) : public CBase 

{

public:

	static CIniLine* NewL(const TDesCX& aLine);

	static CIniLine* NewLC(const TDesCX& aLine);

	static CIniLine* NewLC(HBufCX* aLine, TLineType aTypeOfLine);

	static CIniLine* NewFromSectionNameLC(const TDesCX& aSectionName);

	static CIniLine* NewFromKeyValueLineLC(const TDesCX& aKeyName, const TDesCX& aKeyValue);

	~CIniLine();		

	TLineType LineType() const;

	void InsertBefore(CIniLine* aLine);

	const HBufCX& LineBuffer() const;

	TBool operator==(const CIniLine&) const;

public:

	TDblQueLink iLink;

private:

	TLineType DetermineTypeOfLine(const TDesCX& aLine);

	void ConstructL(const TDesCX& aLine);

	CIniLine(HBufCX* aLine, TLineType aLineType);

	CIniLine();

private:

	HBufCX*     iLine;

	TLineType   iLineType; 

};

template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>

CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>* CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>::NewL(const TDesCX& aLine)

	{

	CIniLine* self=CIniLine::NewLC(aLine);

	CleanupStack::Pop(self);

	return self;	

	}

template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>

CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>* CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>::NewLC(const TDesCX& aLine)

	{

	CIniLine* self=new (ELeave) CIniLine();

	CleanupStack::PushL(self);

	self->ConstructL(aLine);

	return self;	

	}

template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>

CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>* CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>::NewLC(HBufCX* aLine, TLineType aTypeOfLine)

	{

	CIniLine* self=new (ELeave) CIniLine(aLine, aTypeOfLine);

	CleanupStack::PushL(self);

	return self;	

	}

template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>	

CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>::CIniLine(HBufCX* aLine, TLineType aTypeOfLine):iLine(aLine), iLineType(aTypeOfLine)

	{}

template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>	

CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>::CIniLine()

	{}

template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>	

CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>::~CIniLine()

	{

	iLink.Deque();

	delete iLine;

	}

template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>

void CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>::ConstructL(const TDesCX& aLine)

	{

	HBufCX* myHBuf = aLine.AllocL();

	this->iLine = myHBuf;

	this->iLineType = this->DetermineTypeOfLine(aLine);

	}

template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>

TLineType CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>::DetermineTypeOfLine(const TDesCX& aLine)

	{

	// First recognized character wins. Otherwise return a comment.

	for (TInt i=0; i< aLine.Length();i++)

		{

		TText myChar = aLine[i];

		switch (myChar)

			{

			case TText('#'):

			case ';':

				return EComment;

			case TText('['):

				return ESection;

			case TText('='):

				return EKeyValue;

			default:

				break;

			}

		}

	return EComment;

	}

template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>

CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>* CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>::NewFromSectionNameLC(const TDesCX& aSectionName)

	{

	//Fabricate a section name.

	HBufCX* myBuffer=HBufCX::NewLC(aSectionName.Size()+ 6);	//6= "2 cr's and \r" + "[]".

	TPtrX myBuf (myBuffer->Des());

	myBuf.Append(_L("\r\n["));

	myBuf.Append(aSectionName);

	myBuf.Append(_L("]\r\n"));

	CIniLine* myLine = CIniLine::NewLC(myBuffer, ESection);

	CleanupStack::Pop(2);

	CleanupStack::PushL(myLine);

	return myLine;

	}

template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>

CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>* CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>::NewFromKeyValueLineLC(const TDesCX& aKeyName, const TDesCX& aKeyValue)

	{

	//Fabricate a key = value line.

	HBufCX* myBuffer=HBufCX::NewLC(aKeyName.Size()+ aKeyValue.Size() + 3);	//3= "1 cr + \r" + "=".

	TPtrX myBuf (myBuffer->Des());

	myBuf.Set(myBuffer->Des());

	myBuf.Append(aKeyName);

	myBuf.Append('=');

	myBuf.Append(aKeyValue);

	myBuf.Append(_L("\r\n"));

	CIniLine* myLine = CIniLine::NewLC(myBuffer, EKeyValue);

	CleanupStack::Pop(2);

	CleanupStack::PushL(myLine);

	return myLine;

	}

template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>

TLineType CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>::LineType() const

	{

	return iLineType;

	}

template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>	

void CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>::InsertBefore(CIniLine* aLine)

	{

	aLine->iLink.AddBefore(&(this->iLink));

	}

template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>	

const HBufCX& CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>::LineBuffer() const

	{

	return *iLine;

	}

template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>	

TBool CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>::operator==(const CIniLine& aLine)const

	{

	if (LineType() != aLine.LineType())

		return EFalse;

	if ((LineBuffer()).Compare(aLine.LineBuffer()) != 0)

		return EFalse;

	return ETrue;

	}

//ini key template class//

template<class TDesCX,class HBufCX,class TPtrCX, class CIniLineX, class TPtrX,class TLexX>

NONSHARABLE_CLASS(CIniKey): public CBase

{

public:

	static CIniKey* NewL(const TDesCX& aKeyName,const TDesCX& aKeyValue);

	static CIniKey* NewLC(const TDesCX& aKeyName,const TDesCX& aKeyValue);

	static CIniKey* NewLC(CIniLineX* aLine);

	static TInt CompareKey(const CIniKey& aFirstKey,const CIniKey& aSecondKey);

	void SetKeyValue(const TDesCX& aKeyValue);	

	TPtrCX KeyName() const;

	TPtrCX KeyValue() const;

	CIniLineX* LineSrc() const;

	~CIniKey();

private:

	CIniKey(const TDesCX& aKeyName, const TDesCX& aKeyValue, CIniLineX* aLine);

	CIniKey(const TDesCX& aKeyName, const TDesCX& aKeyValue);

	static CIniKey* ParseKeyLineL(CIniLineX* aLine);

private:

	TPtrCX iKeyName;

	TPtrCX iKeyValue;

	CIniLineX* iLineSrc;

};

template<class TDesCX,class HBufCX,class TPtrCX, class CIniLineX,class TPtrX,class TLexX>

CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>* CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>::NewL(const TDesCX& aKeyName,const TDesCX& aKeyValue)

	{

	CIniKey* self=new (ELeave) CIniKey(aKeyName, aKeyValue);

	return self;		

	}

template<class TDesCX,class HBufCX,class TPtrCX, class CIniLineX,class TPtrX,class TLexX>

CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>* CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>::NewLC(const TDesCX& aKeyName,const TDesCX& aKeyValue)

	{

	CIniKey* self=CIniKey::NewL(aKeyName,aKeyValue);

	CleanupStack::PushL(self);

	return self;

	}

template<class TDesCX,class HBufCX,class TPtrCX, class CIniLineX,class TPtrX,class TLexX>

CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>* CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>::NewLC(CIniLineX* aLine)

	{

	CIniKey* self=ParseKeyLineL(aLine);

	CleanupStack::PushL(self);

	self->iLineSrc=aLine;

	return self;

	}

template<class TDesCX,class HBufCX,class TPtrCX, class CIniLineX,class TPtrX,class TLexX>	

CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>::CIniKey(const TDesCX& aKeyName, const TDesCX& aKeyValue, CIniLineX* aLine):iKeyName(aKeyName),iKeyValue(aKeyValue),iLineSrc(aLine)

	{	}

template<class TDesCX,class HBufCX,class TPtrCX, class CIniLineX,class TPtrX,class TLexX>	

CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>::CIniKey(const TDesCX& aKeyName, const TDesCX& aKeyValue):iKeyName(aKeyName),iKeyValue(aKeyValue),iLineSrc(NULL)

	{	}

template<class TDesCX,class HBufCX,class TPtrCX, class CIniLineX,class TPtrX,class TLexX>

CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>::~CIniKey()

	{}

template<class TDesCX,class HBufCX,class TPtrCX, class CIniLineX,class TPtrX,class TLexX>

TPtrCX CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>::KeyName() const

	{ 	

	return iKeyName;

	}

template<class TDesCX,class HBufCX,class TPtrCX, class CIniLineX,class TPtrX,class TLexX>

TPtrCX CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>::KeyValue() const

	{ 	

	return iKeyValue;

	}

template<class TDesCX,class HBufCX,class TPtrCX, class CIniLineX,class TPtrX,class TLexX>

CIniLineX* CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>::LineSrc() const

	{ 	

	return iLineSrc;

	}

template<class TDesCX,class HBufCX,class TPtrCX, class CIniLineX,class TPtrX,class TLexX>	

void CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>::SetKeyValue(const TDesCX& aKeyValue)

	{	

	iKeyValue.Set(aKeyValue);

	}

template<class TDesCX,class HBufCX,class TPtrCX, class CIniLineX,class TPtrX,class TLexX>	

TInt CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>::CompareKey(const CIniKey& aFirstKey,const CIniKey& aSecondKey)

	{ 	

	return (aFirstKey.KeyName()).Compare(aSecondKey.KeyName());	

	}

template<class TDesCX,class HBufCX,class TPtrCX, class CIniLineX,class TPtrX,class TLexX>	

CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>* CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>::ParseKeyLineL(CIniLineX* aIniLine)

	{

	const HBufCX& myLine = aIniLine->LineBuffer();

	//Get the first occurence of '=' sign

	TInt equalOffset=myLine.Locate('=');

	CorruptIfL(equalOffset==KErrNotFound);

	TInt tokenCount = CountTokens<TPtrCX, TLexX>(myLine.Left(equalOffset));

	CorruptIfL(tokenCount != 1);

	//construct a TLex for checking the lhs of equal sign

	TLexX parser;

	parser.Assign(myLine.Left(equalOffset));

	parser.SkipSpaceAndMark();

	parser.SkipCharacters();

	TPtrCX keyname=parser.MarkedToken();

	TBool check = (keyname.Length()==0);

	CorruptIfL(check);	

	//strip off any white space before and after the value

	TInt edgeOfValue=equalOffset;

	while(++edgeOfValue < myLine.Length())

		{

		TChar t = (myLine)[edgeOfValue];

		if (!t.IsSpace())

			{

			break;

			}

		}

	TPtrCX keyvalue;

	if (edgeOfValue < myLine.Length())

		{

		keyvalue.Set(myLine.Mid(edgeOfValue, (myLine.Length()-edgeOfValue-1)));

		}

	TInt hashOffset=keyvalue.Locate('#');

	if (hashOffset>0)

		{

		keyvalue.Set(keyvalue.Left(hashOffset));

		}

	TInt commentOffset=keyvalue.Locate(';');

	if (commentOffset > 0)

		{

		keyvalue.Set(keyvalue.Left(commentOffset));

		}

	TInt index = keyvalue.Length()-1;

	if (index > 0)

		{

		while (index > 0)

			{

			TChar t = keyvalue[index];

			if (t.IsSpace())

				{

				index--;

				}

			else

				{

				break;

				}

			}

		if (index < (keyvalue.Length()-1))

			{

			keyvalue.Set(keyvalue.Left(index+1));

			}

		}

	CIniKey* myKey = new (ELeave) CIniKey(keyname,keyvalue, aIniLine);

	return myKey;

	}

//section template class//

template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX,class CIniLineX,class TPtrX, class TLexX>

NONSHARABLE_CLASS(CIniSection): public CBase 

{

public:

	static CIniSection* NewL(const TDesCX& aSectionName);

	static CIniSection* NewLC(const TDesCX& aSectionName);

	static CIniSection* NewL(const TDesCX& aSectionName, CIniLineX* aLineSrc);

	static CIniSection* NewLC(CIniLineX* aLineSrc);

	static TInt CompareSection(const CIniSection& aFirstSection,const CIniSection& aSecondSection);

	~CIniSection();

	void InsertKeyL(const TDesCX& aKeyName,const TDesCX& aKeyValue);

	void InsertKeyL(const CIniKeyX* aKey);

	void RemoveKeyL(const TDesCX& aKeyName);

	TPtrCX KeyValueL(const TDesCX& aKeyName) const;	

	TInt KeyCount() const;

	CIniKeyX* FindKeyL(const TDesCX& aKeyName) const;	

	TPtrCX SectionName() const;

	CIniLineX* SrcLine();

	void SetSrcLine(CIniLineX* aLineSrc);

	//to be used to access individual item

	const CIniKeyX* Key(TInt aIndex) const {return iKeyArray[aIndex];}

	void ReserveSpaceInKeyArrayL(){iKeyArray.ReserveL(1);}

private:

	CIniSection(TPtrCX aSectionName);

	CIniSection(TPtrCX aSectionName, CIniLineX* aLine);

	static TPtrCX ParseSectionLineL(const HBufCX& aLine);

private:

	TPtrCX iSectionName;

	RPointerArray<CIniKeyX> iKeyArray;

	CIniLineX* iLineSrc;		//If no document object exists, then this object is not used.

};

template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX,class TLexX>

CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>* CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::NewL(const TDesCX& aSectionName)

	{

	CIniSection* self=new (ELeave) CIniSection(aSectionName);

	return self;

	}

template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX,class TLexX>

CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>* CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::NewL(const TDesCX& aSectionName,CIniLineX* aLineSrc)

	{

	CIniSection* self=new (ELeave) CIniSection(aSectionName, aLineSrc);

	return self;

	}

template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX,class TLexX>

CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>* CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::NewLC(const TDesCX& aSectionName)