diff -r 000000000000 -r bde4ae8d615e os/ossrv/lowlevellibsandfws/apputils/bsul/src/IniTemplate.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/ossrv/lowlevellibsandfws/apputils/bsul/src/IniTemplate.h	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,1253 @@
+// 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)
+	{
+	CIniSection* self=new (ELeave) CIniSection(aSectionName);
+	CleanupStack::PushL(self);
+	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(CIniLineX* aLineSrc)
+	{
+	const HBufCX& buffer = aLineSrc->LineBuffer();
+	TPtrCX sectionName = ParseSectionLineL(buffer);
+	CIniSection* self=new (ELeave) CIniSection(sectionName, aLineSrc);
+	CleanupStack::PushL(self);
+	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(TPtrCX aSectionName, CIniLineX* aLine):iSectionName(aSectionName), iLineSrc(aLine)
+	{ 
+	iKeyArray.Reset();
+	}
+
+template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX,class TLexX>
+CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::CIniSection(TPtrCX aSectionName):iSectionName(aSectionName)
+	{ 
+	iKeyArray.Reset();
+	}
+
+template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX,class TLexX>
+CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::~CIniSection()
+	{ 
+	iKeyArray.ResetAndDestroy();
+	}
+
+template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX, class TLexX>	
+void CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::SetSrcLine(CIniLineX* aLineSrc)
+	{ 	
+	if (iLineSrc)
+		{
+		delete iLineSrc;
+		}
+	iLineSrc = aLineSrc;
+	}
+
+template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX,class TLexX>
+TInt CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::KeyCount() const
+	{ 	
+	return iKeyArray.Count(); 	
+	}
+
+template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX,class TLexX>	
+TPtrCX CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::SectionName() const
+	{ 	
+	return iSectionName;	
+	}
+
+template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX,class TLexX>	
+CIniLineX* CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::SrcLine()
+	{ 	
+	return iLineSrc; 	
+	}
+
+template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX,class TLexX>	
+TInt CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::CompareSection(const CIniSection& aFirstSection,const CIniSection& aSecondSection)
+	{ 	
+	return aFirstSection.SectionName().Compare(aSecondSection.SectionName());	 	
+	}
+
+template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX, class TLexX>	
+void CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::InsertKeyL(const TDesCX& aKeyName,const TDesCX& aKeyValue)
+	{
+	CIniKeyX* newKey=CIniKeyX::NewLC(aKeyName,aKeyValue);
+	InsertKeyL(newKey);
+	CleanupStack::Pop(newKey);
+	}	
+
+template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX, class TLexX>	
+void CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::InsertKeyL(const CIniKeyX* aKey)
+	{
+	iKeyArray.InsertInOrderL(aKey,TLinearOrder<CIniKeyX>(CIniKeyX::CompareKey));
+	}	
+
+template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX,class TLexX>
+void CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::RemoveKeyL(const TDesCX& aKeyName)
+	{
+	CIniKeyX* key=FindKeyL(aKeyName);
+	CIniLineX* myLine = key->LineSrc();
+	TInt index=iKeyArray.FindInOrderL(key,TLinearOrder<CIniKeyX>(CIniKeyX::CompareKey));
+	iKeyArray.Remove(index);
+	delete key;
+	delete myLine;
+	}	
+
+template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX, class TLexX>
+CIniKeyX* CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::FindKeyL(const TDesCX& aKeyName) const
+	{
+	CIniKeyX* key=CIniKeyX::NewLC(aKeyName, aKeyName);
+	TInt index=iKeyArray.FindInOrderL(key,TLinearOrder<CIniKeyX>(CIniKeyX::CompareKey));
+	CleanupStack::PopAndDestroy(key);
+	return iKeyArray[index];
+	}
+
+template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX,class TLexX>
+TPtrCX CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::KeyValueL(const TDesCX& aKeyName) const
+	{
+	CIniKeyX* key=FindKeyL(aKeyName);
+	return key->KeyValue();
+	}
+
+template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX,class TLexX>
+TPtrCX CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::ParseSectionLineL(const HBufCX& aLine)	
+	{
+	//find the last terminating bracket ']'
+	//anything in between is considered the section name
+	TInt endBracket=aLine.Locate(']');
+	//Check if the terminating bracket exits. Leave with an error code if not found.
+	CorruptIfL(endBracket == KErrNotFound);
+	
+	TInt startBracket=aLine.Locate('[');
+	CorruptIfL(startBracket == KErrNotFound);
+	
+	TPtrCX sectionName=aLine.Mid(startBracket+1, (endBracket-startBracket)-1);
+	
+	//corrupt if empty section e.g []
+	TBool check = (sectionName.Length()==0);
+	CorruptIfL(check);
+	
+	TLexX lex(sectionName);
+	
+	//Check for any white space within section name	
+	//check any white spaces directly after the '['
+	lex.SkipSpace();
+	check = (lex.Offset()>lex.MarkedOffset());
+	CorruptIfL(check);			
+	lex.SkipCharacters();
+	
+	//At this stage we can extract the section name
+	sectionName.Set(lex.MarkedToken());
+	return (sectionName);
+	}
+
+//iterator template class//
+template<class TDesCX,class TPtrCX,class CIniSectionX,class CIniDocumentX,class CIniKeyX>
+NONSHARABLE_CLASS(CIniSecIterImplX): public CBase
+{
+public:
+	CIniSecIterImplX():iCurrentIndex(0),iSection(NULL){}
+	TBool Next(TPtrCX& aKeyName,TPtrCX& aKeyValue);
+	void Reset(){iCurrentIndex=0;}
+	TBool End(){return iCurrentIndex>=iSection->KeyCount();}
+public:	
+	TInt iCurrentIndex;
+	CIniSectionX* iSection;	
+};
+
+template<class TDesCX,class TPtrCX,class CIniSectionX,class CIniDocumentX,class CIniKeyX>
+TBool CIniSecIterImplX<TDesCX,TPtrCX,CIniSectionX,CIniDocumentX,CIniKeyX>::Next(TPtrCX& aKeyName,TPtrCX& aKeyValue)
+	{
+	if (iSection)
+		{
+		if (iCurrentIndex<iSection->KeyCount())
+			{
+			const CIniKeyX* key=iSection->Key(iCurrentIndex);
+			aKeyName.Set(key->KeyName());
+			aKeyValue.Set(key->KeyValue());
+			iCurrentIndex++;
+			return ETrue;
+			}
+		}
+	return EFalse;
+	}
+
+
+//inidocument template class//
+template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX,class CIniLineX,class CIniKeyX>
+NONSHARABLE_CLASS(CIniDocumentTmplX) : public CBase 
+{
+public:
+	CIniDocumentTmplX(RFs& aFs,TBool aNarrow);
+	~CIniDocumentTmplX();
+	void FlushL(const TDesC& aFileName);
+	
+	TInt GetSectionList(RArray<TPtrCX>& aSectionList) const;
+	void GetKeyValueL(const TDesCX& aSectionName,const TDesCX& aKeyName,TPtrCX& aKeyValue) const;
+	CIniSectionX* SectionL(const TDesCX& aSectionName) const;
+	
+	CIniSectionX* AddSectionL(const TDesCX& aSectionName, CIniLineX* aLine);
+	CIniSectionX* AddSectionL(const TDesCX& aSectionName);
+	void AddSectionL(const CIniSectionX* aSection);
+	
+	void RemoveSectionL(const TDesCX& aSectionName);
+	void SetKeyL(const TDesCX& aSectionName,const TDesCX& aKeyName,const TDesCX& aKeyValue);
+	void RemoveKeyL(const TDesCX& aSectionName,const TDesCX& aKeyName);	
+	void RemoveLineL(CIniLineX* aLine);
+	void InsertKeyValueIntoQueueL(CIniLineX* aKeyValue, CIniSectionX& aSection);
+	void AppendIntoQueue(CIniLineX* aSection);
+	TBool CompareDocs(CIniDocumentTmplX& aDoc);
+	
+private:
+	CIniSectionX* FindSectionL(const TDesCX& aSectionName) const;
+	void ConstructL(const TDesC& aFileName);
+	
+private:
+	TBool iNarrow;		
+	RFs& iFs;
+	TDblQue<CIniLineX> iDocument;
+	RPointerArray<CIniSectionX> iSectionArray;	
+};
+
+template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX, class CIniLineX,class CIniKeyX>
+CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::CIniDocumentTmplX(RFs& aFs,TBool aNarrow):iNarrow(aNarrow),iFs(aFs)
+	{
+	iSectionArray.Reset();
+	iDocument.SetOffset(_FOFF(CIniLineX, iLink));
+	iDocument.Reset();
+	}
+
+template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX,class CIniLineX,class CIniKeyX>
+TBool CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::CompareDocs(CIniDocumentTmplX& aDoc)
+	{
+	CIniLineX* lineFromA; // This object is a. The passed in one is b.
+	CIniLineX* lineFromB;
+	TDblQueIter<CIniLineX> itera(this->iDocument);
+	TDblQueIter<CIniLineX> iterb(aDoc.iDocument);
+	
+	TBool NotDoneYet= ETrue;
+	while (NotDoneYet)
+		{
+		lineFromA = itera++;
+		lineFromB = iterb++;
+		if ((lineFromA == NULL) || (lineFromB == NULL))
+			break;
+		
+		if (!(*lineFromA == *lineFromB))
+			{
+			return EFalse;
+			}
+		}
+	
+	if ( (lineFromA) || (lineFromB))
+		return EFalse;
+	
+	if ((this->iSectionArray.Count()) != (aDoc.iSectionArray.Count()))
+		{
+		return EFalse;
+		}
+	
+	for (TInt i=0; i<this->iSectionArray.Count(); i++)
+		{
+		TPtrCX secNameA = this->iSectionArray[i]->SectionName();
+		TPtrCX secNameB = aDoc.iSectionArray[i]->SectionName();		
+		if ((secNameA.Compare(secNameB))!= 0)
+			return EFalse;
+		
+		if ((this->iSectionArray[i]->KeyCount()) != (aDoc.iSectionArray[i]->KeyCount()))
+			return EFalse;
+		
+		lineFromA = this->iSectionArray[i]->SrcLine();
+		lineFromB = aDoc.iSectionArray[i]->SrcLine();
+		
+		if (!(*lineFromA == *lineFromB))
+			{
+			return EFalse;
+			}
+		
+		for (TInt k=0; k<this->iSectionArray[i]->KeyCount(); k++)
+			{
+			const CIniKeyX* keyA = this->iSectionArray[i]->Key(k);
+			const CIniKeyX* keyB = aDoc.iSectionArray[i]->Key(k);
+			if (keyA->KeyName().Compare(keyB->KeyName()) != 0)
+					return EFalse;
+			if (keyA->KeyValue().Compare(keyB->KeyValue()) != 0)
+				return EFalse;
+			
+			lineFromA = keyA->LineSrc();
+			lineFromB = keyB->LineSrc();
+			
+			if (!(*lineFromA == *lineFromB))
+				{
+				return EFalse;
+				}
+			}
+		}
+
+	return ETrue;
+	}
+
+template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX, class CIniLineX,class CIniKeyX>
+void CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::AppendIntoQueue(CIniLineX* aLine)
+	{
+	if (iDocument.IsEmpty())
+		{
+		iDocument.AddFirst(*aLine);
+		}
+	else
+		{
+		iDocument.AddLast(*aLine);	//always at the end of the list.
+		}
+	}
+
+template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX, class CIniLineX,class CIniKeyX>
+void CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::InsertKeyValueIntoQueueL(CIniLineX* aKeyValue,CIniSectionX& aSection)
+	{
+	// Find the end of the section (if exists).
+	CIniLineX* lastEntry;
+	CIniLineX* line;
+	TDblQueIter<CIniLineX> iter(iDocument);
+	
+	lastEntry = aSection.SrcLine();	//by default insert into queue after this line entry.
+	iter.Set(*lastEntry);	// search after this point for a keyvalue line.
+	iter++;	//point to next line
+	while ((line = iter++) != NULL)
+		{
+		lastEntry=line;
+		TLineType typeOfLine = line->LineType();
+		if (typeOfLine == ESection)
+			{
+			break;
+			}
+		}
+	
+	if ( line == NULL )
+		{
+		AppendIntoQueue(aKeyValue);
+		}
+	else
+		{
+		if (iDocument.IsLast(lastEntry))
+			{
+			AppendIntoQueue(aKeyValue);
+			}
+		else
+			{
+			lastEntry->InsertBefore(aKeyValue);
+			}
+		}
+	}
+
+template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX, class CIniLineX,class CIniKeyX>
+void CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::FlushL(const TDesC& aFileName)
+	{
+	//we need to get the path for the target file
+	TParse originFile;
+	User::LeaveIfError(originFile.Set(aFileName,NULL,NULL));
+
+	//Need to ensure path exists
+	TInt error=iFs.MkDirAll(originFile.DriveAndPath());
+	if (error!=KErrAlreadyExists)
+		{
+		User::LeaveIfError(error);
+		}
+	
+	//Constructing the temp file name with the same directory and path
+	TFileName tempFile;
+	RFile file;
+	User::LeaveIfError(file.Temp(iFs,originFile.DriveAndPath(),tempFile,EFileWrite));
+	CleanupClosePushL(file);
+		
+	TPtrC8 bufPtr; 	
+	if (!iNarrow)
+		{
+		TChar myChar(0xFEFF);
+		const unsigned char* myChar8=reinterpret_cast<const unsigned char*>(&myChar);
+		bufPtr.Set(myChar8, 2);
+		User::LeaveIfError(file.Write(bufPtr));
+		}
+	
+	TDblQueIter<CIniLineX> iter(iDocument);
+	CIniLineX* line;
+	while ((line = iter++) != NULL)
+		{
+		const HBufCX& tempBuffer=line->LineBuffer();
+		const TUint8* rawptr8=reinterpret_cast<const TUint8*>(tempBuffer.Ptr());	
+		if (iNarrow)
+			{
+			bufPtr.Set(rawptr8,tempBuffer.Length());
+			}
+		else
+			{
+			bufPtr.Set(rawptr8,tempBuffer.Length()*2);
+			}
+		User::LeaveIfError(file.Write(bufPtr));
+		}
+	User::LeaveIfError(file.Flush());
+	CleanupStack::PopAndDestroy();
+	
+	//Finally try replacing or creating a new file
+	//depending on whether file exist or not
+	TEntry entry;
+	if (iFs.Entry(aFileName,entry)==KErrNone)
+		{
+		User::LeaveIfError(iFs.Replace(tempFile,aFileName));
+		}
+	else
+		{
+		User::LeaveIfError(iFs.Rename(tempFile,aFileName));		
+		}
+	}
+	
+template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX, class CIniLineX,class CIniKeyX>	
+TInt CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::GetSectionList(RArray<TPtrCX>& aSectionList) const
+	{
+	//Reset the list first
+	aSectionList.Reset();
+	for (TInt i=0;i<iSectionArray.Count();i++)
+		{
+		TPtrCX nameptr=iSectionArray[i]->SectionName();
+		TInt ret=aSectionList.Append(nameptr);
+		//If error half way fo the copying, reset the list first
+		if (ret!=KErrNone)
+			{
+			aSectionList.Reset();
+			return ret;
+			}
+		}
+	return KErrNone;	
+	}
+	
+template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX, class CIniLineX,class CIniKeyX>
+void CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::GetKeyValueL(const TDesCX& aSectionName,const TDesCX& aKeyName,TPtrCX& aKeyValue) const
+	{
+	//Find if section exists
+	CIniSectionX* section = SectionL(aSectionName);
+	aKeyValue.Set(section->KeyValueL(aKeyName));
+	}
+	 
+template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX,class CIniLineX,class CIniKeyX>
+CIniSectionX* CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::SectionL(const TDesCX& aSectionName) const
+	{
+	CIniSectionX* section = FindSectionL(aSectionName);
+	return section;	
+	}
+
+template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX,class CIniLineX,class CIniKeyX>
+CIniSectionX* CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::AddSectionL(const TDesCX& aSectionName)
+	{
+	//Find if section exists
+	CIniSectionX* section = NULL;
+	TRAPD(ret, section = FindSectionL(aSectionName));
+	if ((ret == KErrNone) && (section != NULL))
+		User::Leave(KErrAlreadyExists);
+	
+	//Fabricate objects upfront and on the cleanup stack to ensure their deletion if OOM conditions occur.
+	CIniLineX* myLine = CIniLineX::NewFromSectionNameLC(aSectionName);
+	AppendIntoQueue(myLine);
+	
+	// reserve 1 slot for the new section name to provoke the out of memory condition 
+	// before actually inserting the object to avoid having to go back and remove it if it fails.
+	this->iSectionArray.ReserveL(1);	
+	
+	// If we have not left, we are sure adding a section should not leave due to OOM.
+	CIniSectionX* newSection=AddSectionL(aSectionName, myLine);
+	CleanupStack::Pop(myLine);
+	return newSection;
+	}
+
+template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX,class CIniLineX,class CIniKeyX>
+CIniSectionX* CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::AddSectionL(const TDesCX& aSectionName, CIniLineX* aLine)
+	{
+	CIniSectionX* newSection=CIniSectionX::NewLC(aSectionName);
+	AddSectionL(newSection);
+	newSection->SetSrcLine(aLine);
+	CleanupStack::Pop(newSection);
+	return newSection;
+	}
+
+template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX,class CIniLineX,class CIniKeyX>
+void CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::AddSectionL(const CIniSectionX* aSection)
+	{
+	iSectionArray.InsertInOrderL(aSection,TLinearOrder<CIniSectionX>(CIniSectionX::CompareSection));
+	}
+
+template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX,class CIniLineX,class CIniKeyX>
+void CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::RemoveSectionL(const TDesCX& aSectionName)
+	{
+	CIniSectionX* section = FindSectionL(aSectionName);
+	CIniLineX* line = section->SrcLine();
+	ASSERT(line);	//This should never happen ie. the Key object must have a line associated with it.
+	
+	// remove the lines after to the start of the next section
+	TDblQueIter<CIniLineX> iter(iDocument);
+	iter.Set(*line);	// search after this point for a keyvalue line.
+	TBool atStartofSection = ETrue;
+	while ((line = iter++) != NULL)
+		{
+		TLineType typeOfLine = line->LineType();
+		if ((typeOfLine == ESection))
+			{
+			if (!atStartofSection)
+				{
+				break;
+				}
+			else
+				{
+				delete line;
+				atStartofSection = EFalse;
+				}
+			}
+		else
+			{
+			delete line;		//includes comment lines which are only in the document object. Otherwise you could just ~section.
+			}
+		}
+	
+	TInt index=this->iSectionArray.FindInOrderL(section,TLinearOrder<CIniSectionX>(CIniSectionX::CompareSection));
+	iSectionArray.Remove(index);		
+	delete section;
+	}
+
+template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX,class CIniLineX,class CIniKeyX>
+void CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::SetKeyL(const TDesCX& aSectionName,const TDesCX& aKeyName,const TDesCX& aKeyValue)	
+	{
+	//Find if section exists
+	CIniSectionX* section = NULL;
+	TRAPD(ret, section = FindSectionL(aSectionName));
+	if (ret == KErrNone)
+		{
+		TRAPD(ret2, RemoveKeyL(aSectionName, aKeyName));
+		if ((ret2 != KErrNone) && (ret2 != KErrNotFound))
+			{
+			User::Leave(ret2);
+			}
+		
+		CIniLineX* myLine2 = CIniLineX::NewFromKeyValueLineLC(aKeyName, aKeyValue);
+		CIniKeyX* myKey = CIniKeyX::NewLC(myLine2);
+		InsertKeyValueIntoQueueL(myLine2, *section);
+		
+		// reserve 1 slot in the key array to provoke the out of memory condition
+		// before inserting the key to avoid having to go back and remove the key if OOM occurs.
+		section->ReserveSpaceInKeyArrayL();
+		section->InsertKeyL(myKey);
+		
+		CleanupStack::Pop(2);
+		return;
+		}
+	if (ret!=KErrNotFound)
+		{
+		User::Leave(ret);
+		}
+	
+	//Fabricate objects upfront and on the cleanup stack to ensure their deletion if OOM conditions occur.
+	CIniLineX* myLine = CIniLineX::NewFromSectionNameLC(aSectionName);
+	AppendIntoQueue(myLine);
+	CIniLineX* myLine3 = CIniLineX::NewFromKeyValueLineLC(aKeyName, aKeyValue);
+	AppendIntoQueue(myLine3);
+	CIniKeyX* myKey = CIniKeyX::NewLC(myLine3);
+	
+	// reserve 1 slot for the new section name to provoke the out of memory condition 
+	// before actually inserting the object to avoid having to go back and remove it if it fails.
+	this->iSectionArray.ReserveL(1);	
+	
+	// If we have not left, we are sure adding a section should not leave due to OOM.
+	CIniSectionX* newSection=AddSectionL(aSectionName, myLine);
+	
+	// reserve 1 slot in the key array of the newly created empty section to provoke the out of memory condition
+	// before inserting the key to avoid having to go back and remove the key if OOM occurs.
+	TRAPD(err, newSection->ReserveSpaceInKeyArrayL());
+	if (err == KErrNoMemory)
+		{
+		// In this case, we have an empty newSection object to be removed.
+		TInt index=this->iSectionArray.FindInOrder(newSection,TLinearOrder<CIniSectionX>(CIniSectionX::CompareSection));
+		iSectionArray.Remove(index);
+		delete newSection;
+		CleanupStack::PopAndDestroy(3);
+		User::Leave(KErrNoMemory);
+		}
+	else
+		{
+		if (err!= KErrNone)
+			User::Leave(err);
+		}
+	
+	// we are now sure the next inserts will not fail due to OOM.
+	newSection->InsertKeyL(myKey);
+	CleanupStack::Pop(3);
+	}
+	
+template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX,class CIniLineX,class CIniKeyX>
+void CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::RemoveKeyL(const TDesCX& aSectionName,const TDesCX& aKeyName)
+	{
+	//Find if section exists
+	CIniSectionX* section = FindSectionL(aSectionName);
+	section->RemoveKeyL(aKeyName);
+	}
+
+template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX,class CIniLineX,class CIniKeyX>
+CIniSectionX* CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::FindSectionL(const TDesCX& aSectionName) const
+	{
+	CIniSectionX* newSection=CIniSectionX::NewLC(aSectionName);
+	TInt index=iSectionArray.FindInOrderL(newSection,TLinearOrder<CIniSectionX>(CIniSectionX::CompareSection));
+	CleanupStack::PopAndDestroy(newSection);
+	return iSectionArray[index];
+	}
+
+template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX,class CIniLineX,class CIniKeyX>
+CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::~CIniDocumentTmplX()
+	{
+	CIniLineX* line;
+	TDblQueIter<CIniLineX> iter(iDocument);
+	
+	while ((line = iter++) != NULL)
+		{
+		delete line;
+		}
+	iSectionArray.ResetAndDestroy();
+	}
+
+//light weight template class//
+template<class TDesCX,class TPtrCX,class HBufCX,class TLexX,class TPtrX,class TBufX,class CIniLineX>
+NONSHARABLE_CLASS(CIniFileImplX): public CBase	
+{
+public:
+	CIniFileImplX():iBuffer(NULL) {}
+	TInt FindVar(const TDesCX& aSection,const TDesCX& aKey,TPtrCX& aValue);
+	void ProcessBufferL(const TDesCX& aPtr);
+	~CIniFileImplX()
+		{ 
+		delete iBuffer;
+		}
+private:	
+	HBufCX* iBuffer;
+};
+
+template<class TDesCX,class TPtrCX,class HBufCX,class TLexX,class TPtrX,class TBufX,class CIniLineX>
+void CIniFileImplX<TDesCX,TPtrCX,HBufCX,TLexX,TPtrX,TBufX,CIniLineX>::ProcessBufferL(const TDesCX& aPtr)
+	{
+	iBuffer = HBufCX::NewL(aPtr.Length() + sizeof('\n'));	//1 for cr.
+	TPtrX bufferPtr(iBuffer->Des());
+	TLexX lineParser(aPtr);
+	while (!lineParser.Eos())
+		{
+		//Get line by line which is terminated by \n
+		lineParser.SkipSpaceAndMark();
+		while (!lineParser.Eos() && lineParser.Peek()!='\n')
+			{
+			lineParser.Inc();
+			}
+		TPtrCX line=lineParser.MarkedToken();
+		//Now append the LHS of the comment to the buffer		
+		RemoveComment(line);
+
+		//trim any white space before section,key- value and comments
+		TLexX removeWs(line);
+		removeWs.SkipSpace();
+		if (!removeWs.Eos())
+			{
+			bufferPtr.Append(line);
+			//this added own delimiter is useful for syntax checking
+			bufferPtr.Append('\n');	
+			}
+		}
+	}
+
+template<class TDesCX,class TPtrCX,class HBufCX,class TLexX,class TPtrX,class TBufX,class CIniLineX>
+TInt CIniFileImplX<TDesCX,TPtrCX,HBufCX,TLexX,TPtrX,TBufX,CIniLineX>::FindVar(const TDesCX& aSection,const TDesCX& aKey,TPtrCX& aValue)
+	{
+	//first find the start of the section [aSectionName]
+	//5 here is []\n and the wildcard *\n[sectionname]*
+	HBufCX* section=HBufCX::New(aSection.Length()+5);
+	if (!section)
+		return KErrNoMemory;
+	TPtrX sectionPtr(section->Des());
+	sectionPtr.Append(_L("*\n["));
+	sectionPtr.Append(aSection);
+	sectionPtr.Append(_L("]*"));
+
+	// Find a match purely on the section and not on the value, i.e. checking for a match on
+	// [SECTION] does not find a match on key=[SECTION].
+
+	TBool firstSection=ETrue;
+	// Matching on first section is different as it should be the first
+	// entry, i.e. no *\n before [aSection]* .
+	TInt sectionStart=iBuffer->Match(sectionPtr.Mid(2));
+	if (sectionStart==KErrNotFound)
+		{
+		firstSection=EFalse;
+		// Then try to match on any section after the first, i.e. *\n[aSection]* .
+		sectionStart=iBuffer->Match(sectionPtr);	
+		}
+	delete section;
+	if (sectionStart!=KErrNotFound)
+		{
+		// There will be always \n added after section, key or value.
+		TPtrCX searchBoundary(iBuffer->Mid(sectionStart+aSection.Length()+(firstSection?2:3)));
+		searchBoundary.Set(searchBoundary.Mid(searchBoundary.Locate('\n')));
+		//now need to locate the start of next section or end of file
+		TBufX matchPattern;
+		matchPattern.Append(_L("*\n[*]*"));
+		TInt endSearchPos=searchBoundary.Match(matchPattern);
+		if (endSearchPos!=KErrNotFound)	
+			{
+			//if can find next section block reduce the search boundary
+			searchBoundary.Set(searchBoundary.Left(++endSearchPos));
+			}
+		//now time to find the first exact match key i.e "key" does not match "subkey"
+		TInt equalOffset;
+		//search through the boundary for matching key
+		while ((equalOffset=searchBoundary.Locate('='))!=KErrNotFound)
+			{
+			//skip over the \n char
+			searchBoundary.Set(searchBoundary.Mid(1));
+			TLexX keyCheck(searchBoundary.Left(--equalOffset));
+			keyCheck.SkipSpaceAndMark();
+			keyCheck.SkipCharacters();
+			TPtrCX key(keyCheck.MarkedToken());		
+			keyCheck.SkipSpace();
+			if (keyCheck.Eos() && key.Compare(aKey)==0)
+				{
+				TInt location = searchBoundary.Locate('\n');
+				__ASSERT_DEBUG(location >= 0, User::Invariant());
+				//trim any white space before and after the value
+				TPtrCX rhs(searchBoundary.Mid(equalOffset+1,location-equalOffset-1));
+				RemoveWSBeforeAndAfter<TPtrCX,TLexX>(rhs,aValue);					
+				return KErrNone;
+				}
+			//update the next search boundary
+			searchBoundary.Set(searchBoundary.Mid(searchBoundary.Locate('\n')));
+			}
+		}
+	//cannot find here
+	return KErrNotFound;	
+	}
+
+}//namespace BSUL
+#endif//__BAINIPARSERIMPL_H__