Symaptic: os/ossrv/lowlevellibsandfws/apputils/bsul/src/IniTemplate.h@260cb5ec6c19

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

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // @internalComponent

    15 //

    16 //

    18 #ifndef __INITEMPLATE_H__

    19 #define __INITEMPLATE_H__

    21 #include <e32base.h>

    22 #include <e32std.h>

    23 #include <f32file.h>

    24 #include <s32file.h>

    25 #include <e32des16.h>

    27 namespace BSUL

    28 {

    29 //Line Type enumeration //

    30 enum TLineType

    31 	{

    32 	EComment,

    33 	ESection,

    34 	EKeyValue

    35 	};

    37 //utils template class//

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

    39 	{

    40 	//open the file for reading

    41 	RFile file;

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

    44 	//only process the file if it exists

    45 	TInt filesize;

    46 	CleanupClosePushL(file);

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

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

    49 	TPtr8 asWritableBuffer(aBufferPtr->Des());

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

    52 	//check if '\n' is present

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

    54 		{

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

    56 		}

    57 	//pop the buffer

    58 	CleanupStack::Pop();

    59 	//close the file

    60 	CleanupStack::PopAndDestroy();

    61 	}

    63 template <class TLexX>

    64 TBool IsEosAfterSpace(TLexX& aLex)

    65 	{

    66 	aLex.SkipSpace();

    67 	return (aLex.Eos());

    68 	}

    70 template<class TPtrCX>

    71 void RemoveComment(TPtrCX& aLine)

    72 	{

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

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

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

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

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

    78 		{

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

    80 			{

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

    82 			}

    83 		else

    84 			{

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

    86 			}

    87 		}

    88 	}

    90 template <class TPtrCX,class TLexX>

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

    92 	{

    93 	TLexX parser(aString);

    94 	parser.SkipSpaceAndMark();

    95 	TInt offset=parser.Offset();

    96 	while(!parser.Eos())

    97 		{

    98 		//now skip for whitespace and check end of string

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

   100 		parser.SkipCharacters();

   101 		parser.Mark();

   102 		if (IsEosAfterSpace(parser))

   103 			{

   104 			parser.UnGetToMark();

   105 			break;

   106 			}

   107 		}

   108 	TInt endOffset=parser.MarkedOffset();

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

   110 	}

   112 template<class TPtrCX,class TLexX>

   113 TInt CountTokens(TPtrCX aLine)

   114 	{

   115 	TLexX myLexer(aLine);

   116 	TInt tokenCount=0;

   117 	while (!myLexer.Eos())

   118 		{

   119 		TPtrCX next = myLexer.NextToken();

   120 		if (next.Size())

   121 			{

   122 			tokenCount++;

   123 			}

   124 		}

   125 	return tokenCount;

   126 	}

   128 static void CorruptIfL(TBool aIsCorrupt)

   129 	{

   130 	if (aIsCorrupt)

   131 		{

   132 		User::Leave(KErrCorrupt);

   133 		}

   134 	}

   136 template<class HBufCX, class TPtrCX>

   137 TPtrCX ExtractLineFromBuffer(const TPtrCX& aFileBuffer, TInt aStartOffset)

   138 	{

   139 	TChar delim('\n');

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

   141 	TInt delimOffset= partialLine.Locate(delim);

   142 	if (delimOffset==KErrNotFound)

   143 		{

   144 		return partialLine;

   145 		}

   146 	return partialLine.Left(delimOffset+1);

   147 	}

   149 //ini line template class //

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

   151 NONSHARABLE_CLASS(CIniLine) : public CBase

   152 {

   153 public:

   154 	static CIniLine* NewL(const TDesCX& aLine);

   155 	static CIniLine* NewLC(const TDesCX& aLine);

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

   157 	static CIniLine* NewFromSectionNameLC(const TDesCX& aSectionName);

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

   160 	~CIniLine();

   161 	TLineType LineType() const;

   162 	void InsertBefore(CIniLine* aLine);

   163 	const HBufCX& LineBuffer() const;

   164 	TBool operator==(const CIniLine&) const;

   165 public:

   166 	TDblQueLink iLink;

   167 private:

   168 	TLineType DetermineTypeOfLine(const TDesCX& aLine);

   169 	void ConstructL(const TDesCX& aLine);

   170 	CIniLine(HBufCX* aLine, TLineType aLineType);

   171 	CIniLine();

   172 private:

   173 	HBufCX*     iLine;

   174 	TLineType   iLineType;

   175 };

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

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

   179 	{

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

   181 	CleanupStack::Pop(self);

   182 	return self;

   183 	}

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

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

   187 	{

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

   189 	CleanupStack::PushL(self);

   190 	self->ConstructL(aLine);

   191 	return self;

   192 	}

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

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

   196 	{

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

   198 	CleanupStack::PushL(self);

   199 	return self;

   200 	}

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

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

   204 	{}

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

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

   208 	{}

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

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

   212 	{

   213 	iLink.Deque();

   214 	delete iLine;

   215 	}

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

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

   219 	{

   220 	HBufCX* myHBuf = aLine.AllocL();

   221 	this->iLine = myHBuf;

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

   223 	}

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

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

   227 	{

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

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

   230 		{

   231 		TText myChar = aLine[i];

   232 		switch (myChar)

   233 			{

   234 			case TText('#'):

   235 			case ';':

   236 				return EComment;

   238 			case TText('['):

   239 				return ESection;

   241 			case TText('='):

   242 				return EKeyValue;

   244 			default:

   245 				break;

   246 			}

   247 		}

   248 	return EComment;

   249 	}

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

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

   253 	{

   254 	//Fabricate a section name.

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

   256 	TPtrX myBuf (myBuffer->Des());

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

   258 	myBuf.Append(aSectionName);

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

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

   261 	CleanupStack::Pop(2);

   262 	CleanupStack::PushL(myLine);

   263 	return myLine;

   264 	}

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

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

   268 	{

   269 	//Fabricate a key = value line.

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

   271 	TPtrX myBuf (myBuffer->Des());

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

   273 	myBuf.Append(aKeyName);

   274 	myBuf.Append('=');

   275 	myBuf.Append(aKeyValue);

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

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

   278 	CleanupStack::Pop(2);

   279 	CleanupStack::PushL(myLine);

   280 	return myLine;

   281 	}

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

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

   285 	{

   286 	return iLineType;

   287 	}

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

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

   291 	{

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

   293 	}

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

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

   297 	{

   298 	return *iLine;

   299 	}

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

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

   303 	{

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

   305 		return EFalse;

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

   308 		return EFalse;

   309 	return ETrue;

   310 	}

   312 //ini key template class//

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

   314 NONSHARABLE_CLASS(CIniKey): public CBase

   315 {

   316 public:

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

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

   319 	static CIniKey* NewLC(CIniLineX* aLine);

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

   322 	void SetKeyValue(const TDesCX& aKeyValue);

   323 	TPtrCX KeyName() const;

   324 	TPtrCX KeyValue() const;

   325 	CIniLineX* LineSrc() const;

   326 	~CIniKey();

   327 private:

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

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

   330 	static CIniKey* ParseKeyLineL(CIniLineX* aLine);

   331 private:

   332 	TPtrCX iKeyName;

   333 	TPtrCX iKeyValue;

   334 	CIniLineX* iLineSrc;

   335 };

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

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

   339 	{

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

   341 	return self;

   342 	}

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

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

   346 	{

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

   348 	CleanupStack::PushL(self);

   349 	return self;

   350 	}

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

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

   354 	{

   355 	CIniKey* self=ParseKeyLineL(aLine);

   356 	CleanupStack::PushL(self);

   357 	self->iLineSrc=aLine;

   358 	return self;

   359 	}

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

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

   363 	{	}

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

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

   367 	{	}

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

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

   371 	{}

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

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

   375 	{

   376 	return iKeyName;

   377 	}

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

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

   381 	{

   382 	return iKeyValue;

   383 	}

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

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

   387 	{

   388 	return iLineSrc;

   389 	}

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

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

   393 	{

   394 	iKeyValue.Set(aKeyValue);

   395 	}

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

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

   399 	{

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

   401 	}

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

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

   405 	{

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

   407 	//Get the first occurence of '=' sign

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

   409 	CorruptIfL(equalOffset==KErrNotFound);

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

   412 	CorruptIfL(tokenCount != 1);

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

   415 	TLexX parser;

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

   417 	parser.SkipSpaceAndMark();

   418 	parser.SkipCharacters();

   419 	TPtrCX keyname=parser.MarkedToken();

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

   421 	CorruptIfL(check);

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

   424 	TInt edgeOfValue=equalOffset;

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

   426 		{

   427 		TChar t = (myLine)[edgeOfValue];

   428 		if (!t.IsSpace())

   429 			{

   430 			break;

   431 			}

   432 		}

   433 	TPtrCX keyvalue;

   434 	if (edgeOfValue < myLine.Length())

   435 		{

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

   437 		}

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

   440 	if (hashOffset>0)

   441 		{

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

   443 		}

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

   445 	if (commentOffset > 0)

   446 		{

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

   448 		}

   450 	TInt index = keyvalue.Length()-1;

   451 	if (index > 0)

   452 		{

   453 		while (index > 0)

   454 			{

   455 			TChar t = keyvalue[index];

   456 			if (t.IsSpace())

   457 				{

   458 				index--;

   459 				}

   460 			else

   461 				{

   462 				break;

   463 				}

   464 			}

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

   466 			{

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

   468 			}

   469 		}

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

   472 	return myKey;

   473 	}

   475 //section template class//

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

   477 NONSHARABLE_CLASS(CIniSection): public CBase

   478 {

   479 public:

   480 	static CIniSection* NewL(const TDesCX& aSectionName);

   481 	static CIniSection* NewLC(const TDesCX& aSectionName);

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

   483 	static CIniSection* NewLC(CIniLineX* aLineSrc);

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

   485 	~CIniSection();

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

   488 	void InsertKeyL(const CIniKeyX* aKey);

   489 	void RemoveKeyL(const TDesCX& aKeyName);

   491 	TPtrCX KeyValueL(const TDesCX& aKeyName) const;

   492 	TInt KeyCount() const;

   493 	CIniKeyX* FindKeyL(const TDesCX& aKeyName) const;

   494 	TPtrCX SectionName() const;

   496 	CIniLineX* SrcLine();

   497 	void SetSrcLine(CIniLineX* aLineSrc);

   499 	//to be used to access individual item

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

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

   502 private:

   503 	CIniSection(TPtrCX aSectionName);

   504 	CIniSection(TPtrCX aSectionName, CIniLineX* aLine);

   505 	static TPtrCX ParseSectionLineL(const HBufCX& aLine);

   507 private:

   508 	TPtrCX iSectionName;

   509 	RPointerArray<CIniKeyX> iKeyArray;

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

   511 };

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

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

   515 	{

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

   517 	return self;

   518 	}

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

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

   522 	{

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

   524 	return self;

   525 	}

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

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

   529 	{

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

   531 	CleanupStack::PushL(self);

   532 	return self;

   533 	}

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

   536 CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>* CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::NewLC(CIniLineX* aLineSrc)

   537 	{

   538 	const HBufCX& buffer = aLineSrc->LineBuffer();

   539 	TPtrCX sectionName = ParseSectionLineL(buffer);

   540 	CIniSection* self=new (ELeave) CIniSection(sectionName, aLineSrc);

   541 	CleanupStack::PushL(self);

   542 	return self;

   543 	}

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

   546 CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::CIniSection(TPtrCX aSectionName, CIniLineX* aLine):iSectionName(aSectionName), iLineSrc(aLine)

   547 	{

   548 	iKeyArray.Reset();

   549 	}

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

   552 CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::CIniSection(TPtrCX aSectionName):iSectionName(aSectionName)

   553 	{

   554 	iKeyArray.Reset();

   555 	}

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

   558 CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::~CIniSection()

   559 	{

   560 	iKeyArray.ResetAndDestroy();

   561 	}

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

   564 void CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::SetSrcLine(CIniLineX* aLineSrc)

   565 	{

   566 	if (iLineSrc)

   567 		{

   568 		delete iLineSrc;

   569 		}

   570 	iLineSrc = aLineSrc;

   571 	}

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

   574 TInt CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::KeyCount() const

   575 	{

   576 	return iKeyArray.Count();

   577 	}

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

   580 TPtrCX CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::SectionName() const

   581 	{

   582 	return iSectionName;

   583 	}

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

   586 CIniLineX* CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::SrcLine()

   587 	{

   588 	return iLineSrc;

   589 	}

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

   592 TInt CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::CompareSection(const CIniSection& aFirstSection,const CIniSection& aSecondSection)

   593 	{

   594 	return aFirstSection.SectionName().Compare(aSecondSection.SectionName());

   595 	}

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

   598 void CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::InsertKeyL(const TDesCX& aKeyName,const TDesCX& aKeyValue)

   599 	{

   600 	CIniKeyX* newKey=CIniKeyX::NewLC(aKeyName,aKeyValue);

   601 	InsertKeyL(newKey);

   602 	CleanupStack::Pop(newKey);

   603 	}

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

   606 void CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::InsertKeyL(const CIniKeyX* aKey)

   607 	{

   608 	iKeyArray.InsertInOrderL(aKey,TLinearOrder<CIniKeyX>(CIniKeyX::CompareKey));

   609 	}

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

   612 void CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::RemoveKeyL(const TDesCX& aKeyName)

   613 	{

   614 	CIniKeyX* key=FindKeyL(aKeyName);

   615 	CIniLineX* myLine = key->LineSrc();

   616 	TInt index=iKeyArray.FindInOrderL(key,TLinearOrder<CIniKeyX>(CIniKeyX::CompareKey));

   617 	iKeyArray.Remove(index);

   618 	delete key;

   619 	delete myLine;

   620 	}

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

   623 CIniKeyX* CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::FindKeyL(const TDesCX& aKeyName) const

   624 	{

   625 	CIniKeyX* key=CIniKeyX::NewLC(aKeyName, aKeyName);

   626 	TInt index=iKeyArray.FindInOrderL(key,TLinearOrder<CIniKeyX>(CIniKeyX::CompareKey));

   627 	CleanupStack::PopAndDestroy(key);

   628 	return iKeyArray[index];

   629 	}

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

   632 TPtrCX CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::KeyValueL(const TDesCX& aKeyName) const

   633 	{

   634 	CIniKeyX* key=FindKeyL(aKeyName);

   635 	return key->KeyValue();

   636 	}

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

   639 TPtrCX CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::ParseSectionLineL(const HBufCX& aLine)

   640 	{

   641 	//find the last terminating bracket ']'

   642 	//anything in between is considered the section name

   643 	TInt endBracket=aLine.Locate(']');

   644 	//Check if the terminating bracket exits. Leave with an error code if not found.

   645 	CorruptIfL(endBracket == KErrNotFound);

   647 	TInt startBracket=aLine.Locate('[');

   648 	CorruptIfL(startBracket == KErrNotFound);

   650 	TPtrCX sectionName=aLine.Mid(startBracket+1, (endBracket-startBracket)-1);

   652 	//corrupt if empty section e.g []

   653 	TBool check = (sectionName.Length()==0);

   654 	CorruptIfL(check);

   656 	TLexX lex(sectionName);

   658 	//Check for any white space within section name

   659 	//check any white spaces directly after the '['

   660 	lex.SkipSpace();

   661 	check = (lex.Offset()>lex.MarkedOffset());

   662 	CorruptIfL(check);

   663 	lex.SkipCharacters();

   665 	//At this stage we can extract the section name

   666 	sectionName.Set(lex.MarkedToken());

   667 	return (sectionName);

   668 	}

   670 //iterator template class//

   671 template<class TDesCX,class TPtrCX,class CIniSectionX,class CIniDocumentX,class CIniKeyX>

   672 NONSHARABLE_CLASS(CIniSecIterImplX): public CBase

   673 {

   674 public:

   675 	CIniSecIterImplX():iCurrentIndex(0),iSection(NULL){}

   676 	TBool Next(TPtrCX& aKeyName,TPtrCX& aKeyValue);

   677 	void Reset(){iCurrentIndex=0;}

   678 	TBool End(){return iCurrentIndex>=iSection->KeyCount();}

   679 public:

   680 	TInt iCurrentIndex;

   681 	CIniSectionX* iSection;

   682 };

   684 template<class TDesCX,class TPtrCX,class CIniSectionX,class CIniDocumentX,class CIniKeyX>

   685 TBool CIniSecIterImplX<TDesCX,TPtrCX,CIniSectionX,CIniDocumentX,CIniKeyX>::Next(TPtrCX& aKeyName,TPtrCX& aKeyValue)

   686 	{

   687 	if (iSection)

   688 		{

   689 		if (iCurrentIndex<iSection->KeyCount())

   690 			{

   691 			const CIniKeyX* key=iSection->Key(iCurrentIndex);

   692 			aKeyName.Set(key->KeyName());

   693 			aKeyValue.Set(key->KeyValue());

   694 			iCurrentIndex++;

   695 			return ETrue;

   696 			}

   697 		}

   698 	return EFalse;

   699 	}

   702 //inidocument template class//

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

   704 NONSHARABLE_CLASS(CIniDocumentTmplX) : public CBase

   705 {

   706 public:

   707 	CIniDocumentTmplX(RFs& aFs,TBool aNarrow);

   708 	~CIniDocumentTmplX();

   709 	void FlushL(const TDesC& aFileName);

   711 	TInt GetSectionList(RArray<TPtrCX>& aSectionList) const;

   712 	void GetKeyValueL(const TDesCX& aSectionName,const TDesCX& aKeyName,TPtrCX& aKeyValue) const;

   713 	CIniSectionX* SectionL(const TDesCX& aSectionName) const;

   715 	CIniSectionX* AddSectionL(const TDesCX& aSectionName, CIniLineX* aLine);

   716 	CIniSectionX* AddSectionL(const TDesCX& aSectionName);

   717 	void AddSectionL(const CIniSectionX* aSection);

   719 	void RemoveSectionL(const TDesCX& aSectionName);

   720 	void SetKeyL(const TDesCX& aSectionName,const TDesCX& aKeyName,const TDesCX& aKeyValue);

   721 	void RemoveKeyL(const TDesCX& aSectionName,const TDesCX& aKeyName);

   722 	void RemoveLineL(CIniLineX* aLine);

   723 	void InsertKeyValueIntoQueueL(CIniLineX* aKeyValue, CIniSectionX& aSection);

   724 	void AppendIntoQueue(CIniLineX* aSection);

   725 	TBool CompareDocs(CIniDocumentTmplX& aDoc);

   727 private:

   728 	CIniSectionX* FindSectionL(const TDesCX& aSectionName) const;

   729 	void ConstructL(const TDesC& aFileName);

   731 private:

   732 	TBool iNarrow;

   733 	RFs& iFs;

   734 	TDblQue<CIniLineX> iDocument;

   735 	RPointerArray<CIniSectionX> iSectionArray;

   736 };

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

   739 CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::CIniDocumentTmplX(RFs& aFs,TBool aNarrow):iNarrow(aNarrow),iFs(aFs)

   740 	{

   741 	iSectionArray.Reset();

   742 	iDocument.SetOffset(_FOFF(CIniLineX, iLink));

   743 	iDocument.Reset();

   744 	}

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

   747 TBool CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::CompareDocs(CIniDocumentTmplX& aDoc)

   748 	{

   749 	CIniLineX* lineFromA; // This object is a. The passed in one is b.

   750 	CIniLineX* lineFromB;

   751 	TDblQueIter<CIniLineX> itera(this->iDocument);

   752 	TDblQueIter<CIniLineX> iterb(aDoc.iDocument);

   754 	TBool NotDoneYet= ETrue;

   755 	while (NotDoneYet)

   756 		{

   757 		lineFromA = itera++;

   758 		lineFromB = iterb++;

   759 		if ((lineFromA == NULL) || (lineFromB == NULL))

   760 			break;

   762 		if (!(*lineFromA == *lineFromB))

   763 			{

   764 			return EFalse;

   765 			}

   766 		}

   768 	if ( (lineFromA) || (lineFromB))

   769 		return EFalse;

   771 	if ((this->iSectionArray.Count()) != (aDoc.iSectionArray.Count()))

   772 		{

   773 		return EFalse;

   774 		}

   776 	for (TInt i=0; i<this->iSectionArray.Count(); i++)

   777 		{

   778 		TPtrCX secNameA = this->iSectionArray[i]->SectionName();

   779 		TPtrCX secNameB = aDoc.iSectionArray[i]->SectionName();

   780 		if ((secNameA.Compare(secNameB))!= 0)

   781 			return EFalse;

   783 		if ((this->iSectionArray[i]->KeyCount()) != (aDoc.iSectionArray[i]->KeyCount()))

   784 			return EFalse;

   786 		lineFromA = this->iSectionArray[i]->SrcLine();

   787 		lineFromB = aDoc.iSectionArray[i]->SrcLine();

   789 		if (!(*lineFromA == *lineFromB))

   790 			{

   791 			return EFalse;

   792 			}

   794 		for (TInt k=0; k<this->iSectionArray[i]->KeyCount(); k++)

   795 			{

   796 			const CIniKeyX* keyA = this->iSectionArray[i]->Key(k);

   797 			const CIniKeyX* keyB = aDoc.iSectionArray[i]->Key(k);

   798 			if (keyA->KeyName().Compare(keyB->KeyName()) != 0)

   799 					return EFalse;

   800 			if (keyA->KeyValue().Compare(keyB->KeyValue()) != 0)

   801 				return EFalse;

   803 			lineFromA = keyA->LineSrc();

   804 			lineFromB = keyB->LineSrc();

   806 			if (!(*lineFromA == *lineFromB))

   807 				{

   808 				return EFalse;

   809 				}

   810 			}

   811 		}

   813 	return ETrue;

   814 	}

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

   817 void CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::AppendIntoQueue(CIniLineX* aLine)

   818 	{

   819 	if (iDocument.IsEmpty())

   820 		{

   821 		iDocument.AddFirst(*aLine);

   822 		}

   823 	else

   824 		{

   825 		iDocument.AddLast(*aLine);	//always at the end of the list.

   826 		}

   827 	}

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

   830 void CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::InsertKeyValueIntoQueueL(CIniLineX* aKeyValue,CIniSectionX& aSection)

   831 	{

   832 	// Find the end of the section (if exists).

   833 	CIniLineX* lastEntry;

   834 	CIniLineX* line;

   835 	TDblQueIter<CIniLineX> iter(iDocument);

   837 	lastEntry = aSection.SrcLine();	//by default insert into queue after this line entry.

   838 	iter.Set(*lastEntry);	// search after this point for a keyvalue line.

   839 	iter++;	//point to next line

   840 	while ((line = iter++) != NULL)

   841 		{

   842 		lastEntry=line;

   843 		TLineType typeOfLine = line->LineType();

   844 		if (typeOfLine == ESection)

   845 			{

   846 			break;

   847 			}

   848 		}

   850 	if ( line == NULL )

   851 		{

   852 		AppendIntoQueue(aKeyValue);

   853 		}

   854 	else

   855 		{

   856 		if (iDocument.IsLast(lastEntry))

   857 			{

   858 			AppendIntoQueue(aKeyValue);

   859 			}

   860 		else

   861 			{

   862 			lastEntry->InsertBefore(aKeyValue);

   863 			}

   864 		}

   865 	}

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

   868 void CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::FlushL(const TDesC& aFileName)

   869 	{

   870 	//we need to get the path for the target file

   871 	TParse originFile;

   872 	User::LeaveIfError(originFile.Set(aFileName,NULL,NULL));

   874 	//Need to ensure path exists

   875 	TInt error=iFs.MkDirAll(originFile.DriveAndPath());

   876 	if (error!=KErrAlreadyExists)

   877 		{

   878 		User::LeaveIfError(error);

   879 		}

   881 	//Constructing the temp file name with the same directory and path

   882 	TFileName tempFile;

   883 	RFile file;

   884 	User::LeaveIfError(file.Temp(iFs,originFile.DriveAndPath(),tempFile,EFileWrite));

   885 	CleanupClosePushL(file);

   887 	TPtrC8 bufPtr;

   888 	if (!iNarrow)

   889 		{

   890 		TChar myChar(0xFEFF);

   891 		const unsigned char* myChar8=reinterpret_cast<const unsigned char*>(&myChar);

   892 		bufPtr.Set(myChar8, 2);

   893 		User::LeaveIfError(file.Write(bufPtr));

   894 		}

   896 	TDblQueIter<CIniLineX> iter(iDocument);

   897 	CIniLineX* line;

   898 	while ((line = iter++) != NULL)

   899 		{

   900 		const HBufCX& tempBuffer=line->LineBuffer();

   901 		const TUint8* rawptr8=reinterpret_cast<const TUint8*>(tempBuffer.Ptr());

   902 		if (iNarrow)

   903 			{

   904 			bufPtr.Set(rawptr8,tempBuffer.Length());

   905 			}

   906 		else

   907 			{

   908 			bufPtr.Set(rawptr8,tempBuffer.Length()*2);

   909 			}

   910 		User::LeaveIfError(file.Write(bufPtr));

   911 		}

   912 	User::LeaveIfError(file.Flush());

   913 	CleanupStack::PopAndDestroy();

   915 	//Finally try replacing or creating a new file

   916 	//depending on whether file exist or not

   917 	TEntry entry;

   918 	if (iFs.Entry(aFileName,entry)==KErrNone)

   919 		{

   920 		User::LeaveIfError(iFs.Replace(tempFile,aFileName));

   921 		}

   922 	else

   923 		{

   924 		User::LeaveIfError(iFs.Rename(tempFile,aFileName));

   925 		}

   926 	}

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

   929 TInt CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::GetSectionList(RArray<TPtrCX>& aSectionList) const

   930 	{

   931 	//Reset the list first

   932 	aSectionList.Reset();

   933 	for (TInt i=0;i<iSectionArray.Count();i++)

   934 		{

   935 		TPtrCX nameptr=iSectionArray[i]->SectionName();

   936 		TInt ret=aSectionList.Append(nameptr);

   937 		//If error half way fo the copying, reset the list first

   938 		if (ret!=KErrNone)

   939 			{

   940 			aSectionList.Reset();

   941 			return ret;

   942 			}

   943 		}

   944 	return KErrNone;

   945 	}

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

   948 void CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::GetKeyValueL(const TDesCX& aSectionName,const TDesCX& aKeyName,TPtrCX& aKeyValue) const

   949 	{

   950 	//Find if section exists

   951 	CIniSectionX* section = SectionL(aSectionName);

   952 	aKeyValue.Set(section->KeyValueL(aKeyName));

   953 	}

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

   956 CIniSectionX* CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::SectionL(const TDesCX& aSectionName) const

   957 	{

   958 	CIniSectionX* section = FindSectionL(aSectionName);

   959 	return section;

   960 	}

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

   963 CIniSectionX* CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::AddSectionL(const TDesCX& aSectionName)

   964 	{

   965 	//Find if section exists

   966 	CIniSectionX* section = NULL;

   967 	TRAPD(ret, section = FindSectionL(aSectionName));

   968 	if ((ret == KErrNone) && (section != NULL))

   969 		User::Leave(KErrAlreadyExists);

   971 	//Fabricate objects upfront and on the cleanup stack to ensure their deletion if OOM conditions occur.

   972 	CIniLineX* myLine = CIniLineX::NewFromSectionNameLC(aSectionName);

   973 	AppendIntoQueue(myLine);

   975 	// reserve 1 slot for the new section name to provoke the out of memory condition

   976 	// before actually inserting the object to avoid having to go back and remove it if it fails.

   977 	this->iSectionArray.ReserveL(1);

   979 	// If we have not left, we are sure adding a section should not leave due to OOM.

   980 	CIniSectionX* newSection=AddSectionL(aSectionName, myLine);

   981 	CleanupStack::Pop(myLine);

   982 	return newSection;

   983 	}

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

   986 CIniSectionX* CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::AddSectionL(const TDesCX& aSectionName, CIniLineX* aLine)

   987 	{

   988 	CIniSectionX* newSection=CIniSectionX::NewLC(aSectionName);

   989 	AddSectionL(newSection);

   990 	newSection->SetSrcLine(aLine);

   991 	CleanupStack::Pop(newSection);

   992 	return newSection;

   993 	}

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

   996 void CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::AddSectionL(const CIniSectionX* aSection)

   997 	{

   998 	iSectionArray.InsertInOrderL(aSection,TLinearOrder<CIniSectionX>(CIniSectionX::CompareSection));

   999 	}

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

  1002 void CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::RemoveSectionL(const TDesCX& aSectionName)

  1003 	{

  1004 	CIniSectionX* section = FindSectionL(aSectionName);

  1005 	CIniLineX* line = section->SrcLine();

  1006 	ASSERT(line);	//This should never happen ie. the Key object must have a line associated with it.

  1008 	// remove the lines after to the start of the next section

  1009 	TDblQueIter<CIniLineX> iter(iDocument);

  1010 	iter.Set(*line);	// search after this point for a keyvalue line.

  1011 	TBool atStartofSection = ETrue;

  1012 	while ((line = iter++) != NULL)

  1013 		{

  1014 		TLineType typeOfLine = line->LineType();

  1015 		if ((typeOfLine == ESection))

  1016 			{

  1017 			if (!atStartofSection)

  1018 				{

  1019 				break;

  1020 				}

  1021 			else

  1022 				{

  1023 				delete line;

  1024 				atStartofSection = EFalse;

  1025 				}

  1026 			}

  1027 		else

  1028 			{

  1029 			delete line;		//includes comment lines which are only in the document object. Otherwise you could just ~section.

  1030 			}

  1031 		}

  1033 	TInt index=this->iSectionArray.FindInOrderL(section,TLinearOrder<CIniSectionX>(CIniSectionX::CompareSection));

  1034 	iSectionArray.Remove(index);

  1035 	delete section;

  1036 	}

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

  1039 void CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::SetKeyL(const TDesCX& aSectionName,const TDesCX& aKeyName,const TDesCX& aKeyValue)

  1040 	{

  1041 	//Find if section exists

  1042 	CIniSectionX* section = NULL;

  1043 	TRAPD(ret, section = FindSectionL(aSectionName));

  1044 	if (ret == KErrNone)

  1045 		{

  1046 		TRAPD(ret2, RemoveKeyL(aSectionName, aKeyName));

  1047 		if ((ret2 != KErrNone) && (ret2 != KErrNotFound))

  1048 			{

  1049 			User::Leave(ret2);

  1050 			}

  1052 		CIniLineX* myLine2 = CIniLineX::NewFromKeyValueLineLC(aKeyName, aKeyValue);

  1053 		CIniKeyX* myKey = CIniKeyX::NewLC(myLine2);

  1054 		InsertKeyValueIntoQueueL(myLine2, *section);

  1056 		// reserve 1 slot in the key array to provoke the out of memory condition

  1057 		// before inserting the key to avoid having to go back and remove the key if OOM occurs.

  1058 		section->ReserveSpaceInKeyArrayL();

  1059 		section->InsertKeyL(myKey);

  1061 		CleanupStack::Pop(2);

  1062 		return;

  1063 		}

  1064 	if (ret!=KErrNotFound)

  1065 		{

  1066 		User::Leave(ret);

  1067 		}

  1069 	//Fabricate objects upfront and on the cleanup stack to ensure their deletion if OOM conditions occur.

  1070 	CIniLineX* myLine = CIniLineX::NewFromSectionNameLC(aSectionName);

  1071 	AppendIntoQueue(myLine);

  1072 	CIniLineX* myLine3 = CIniLineX::NewFromKeyValueLineLC(aKeyName, aKeyValue);

  1073 	AppendIntoQueue(myLine3);

  1074 	CIniKeyX* myKey = CIniKeyX::NewLC(myLine3);

  1076 	// reserve 1 slot for the new section name to provoke the out of memory condition

  1077 	// before actually inserting the object to avoid having to go back and remove it if it fails.

  1078 	this->iSectionArray.ReserveL(1);

  1080 	// If we have not left, we are sure adding a section should not leave due to OOM.

  1081 	CIniSectionX* newSection=AddSectionL(aSectionName, myLine);

  1083 	// reserve 1 slot in the key array of the newly created empty section to provoke the out of memory condition

  1084 	// before inserting the key to avoid having to go back and remove the key if OOM occurs.

  1085 	TRAPD(err, newSection->ReserveSpaceInKeyArrayL());

  1086 	if (err == KErrNoMemory)

  1087 		{

  1088 		// In this case, we have an empty newSection object to be removed.

  1089 		TInt index=this->iSectionArray.FindInOrder(newSection,TLinearOrder<CIniSectionX>(CIniSectionX::CompareSection));

  1090 		iSectionArray.Remove(index);

  1091 		delete newSection;

  1092 		CleanupStack::PopAndDestroy(3);

  1093 		User::Leave(KErrNoMemory);

  1094 		}

  1095 	else

  1096 		{

  1097 		if (err!= KErrNone)

  1098 			User::Leave(err);

  1099 		}

  1101 	// we are now sure the next inserts will not fail due to OOM.

  1102 	newSection->InsertKeyL(myKey);

  1103 	CleanupStack::Pop(3);

  1104 	}

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

  1107 void CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::RemoveKeyL(const TDesCX& aSectionName,const TDesCX& aKeyName)

  1108 	{

  1109 	//Find if section exists

  1110 	CIniSectionX* section = FindSectionL(aSectionName);

  1111 	section->RemoveKeyL(aKeyName);

  1112 	}

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

  1115 CIniSectionX* CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::FindSectionL(const TDesCX& aSectionName) const

  1116 	{

  1117 	CIniSectionX* newSection=CIniSectionX::NewLC(aSectionName);

  1118 	TInt index=iSectionArray.FindInOrderL(newSection,TLinearOrder<CIniSectionX>(CIniSectionX::CompareSection));

  1119 	CleanupStack::PopAndDestroy(newSection);

  1120 	return iSectionArray[index];

  1121 	}

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

  1124 CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::~CIniDocumentTmplX()

  1125 	{

  1126 	CIniLineX* line;

  1127 	TDblQueIter<CIniLineX> iter(iDocument);

  1129 	while ((line = iter++) != NULL)

  1130 		{

  1131 		delete line;

  1132 		}

  1133 	iSectionArray.ResetAndDestroy();

  1134 	}

  1136 //light weight template class//

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

  1138 NONSHARABLE_CLASS(CIniFileImplX): public CBase

  1139 {

  1140 public:

  1141 	CIniFileImplX():iBuffer(NULL) {}

  1142 	TInt FindVar(const TDesCX& aSection,const TDesCX& aKey,TPtrCX& aValue);

  1143 	void ProcessBufferL(const TDesCX& aPtr);

  1144 	~CIniFileImplX()

  1145 		{

  1146 		delete iBuffer;

  1147 		}

  1148 private:

  1149 	HBufCX* iBuffer;

  1150 };

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

  1153 void CIniFileImplX<TDesCX,TPtrCX,HBufCX,TLexX,TPtrX,TBufX,CIniLineX>::ProcessBufferL(const TDesCX& aPtr)

  1154 	{

  1155 	iBuffer = HBufCX::NewL(aPtr.Length() + sizeof('\n'));	//1 for cr.

  1156 	TPtrX bufferPtr(iBuffer->Des());

  1157 	TLexX lineParser(aPtr);

  1158 	while (!lineParser.Eos())

  1159 		{

  1160 		//Get line by line which is terminated by \n

  1161 		lineParser.SkipSpaceAndMark();

  1162 		while (!lineParser.Eos() && lineParser.Peek()!='\n')

  1163 			{

  1164 			lineParser.Inc();

  1165 			}

  1166 		TPtrCX line=lineParser.MarkedToken();

  1167 		//Now append the LHS of the comment to the buffer

  1168 		RemoveComment(line);

  1170 		//trim any white space before section,key- value and comments

  1171 		TLexX removeWs(line);

  1172 		removeWs.SkipSpace();

  1173 		if (!removeWs.Eos())

  1174 			{

  1175 			bufferPtr.Append(line);

  1176 			//this added own delimiter is useful for syntax checking

  1177 			bufferPtr.Append('\n');

  1178 			}

  1179 		}

  1180 	}

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

  1183 TInt CIniFileImplX<TDesCX,TPtrCX,HBufCX,TLexX,TPtrX,TBufX,CIniLineX>::FindVar(const TDesCX& aSection,const TDesCX& aKey,TPtrCX& aValue)

  1184 	{

  1185 	//first find the start of the section [aSectionName]

  1186 	//5 here is []\n and the wildcard *\n[sectionname]*

  1187 	HBufCX* section=HBufCX::New(aSection.Length()+5);

  1188 	if (!section)

  1189 		return KErrNoMemory;

  1190 	TPtrX sectionPtr(section->Des());

  1191 	sectionPtr.Append(_L("*\n["));

  1192 	sectionPtr.Append(aSection);

  1193 	sectionPtr.Append(_L("]*"));

  1195 	// Find a match purely on the section and not on the value, i.e. checking for a match on

  1196 	// [SECTION] does not find a match on key=[SECTION].

  1198 	TBool firstSection=ETrue;

  1199 	// Matching on first section is different as it should be the first

  1200 	// entry, i.e. no *\n before [aSection]* .

  1201 	TInt sectionStart=iBuffer->Match(sectionPtr.Mid(2));

  1202 	if (sectionStart==KErrNotFound)

  1203 		{

  1204 		firstSection=EFalse;

  1205 		// Then try to match on any section after the first, i.e. *\n[aSection]* .

  1206 		sectionStart=iBuffer->Match(sectionPtr);

  1207 		}

  1208 	delete section;

  1209 	if (sectionStart!=KErrNotFound)

  1210 		{

  1211 		// There will be always \n added after section, key or value.

  1212 		TPtrCX searchBoundary(iBuffer->Mid(sectionStart+aSection.Length()+(firstSection?2:3)));

  1213 		searchBoundary.Set(searchBoundary.Mid(searchBoundary.Locate('\n')));

  1214 		//now need to locate the start of next section or end of file

  1215 		TBufX matchPattern;

  1216 		matchPattern.Append(_L("*\n[*]*"));

  1217 		TInt endSearchPos=searchBoundary.Match(matchPattern);

  1218 		if (endSearchPos!=KErrNotFound)

  1219 			{

  1220 			//if can find next section block reduce the search boundary

  1221 			searchBoundary.Set(searchBoundary.Left(++endSearchPos));

  1222 			}

  1223 		//now time to find the first exact match key i.e "key" does not match "subkey"

  1224 		TInt equalOffset;

  1225 		//search through the boundary for matching key

  1226 		while ((equalOffset=searchBoundary.Locate('='))!=KErrNotFound)

  1227 			{

  1228 			//skip over the \n char

  1229 			searchBoundary.Set(searchBoundary.Mid(1));

  1230 			TLexX keyCheck(searchBoundary.Left(--equalOffset));

  1231 			keyCheck.SkipSpaceAndMark();

  1232 			keyCheck.SkipCharacters();

  1233 			TPtrCX key(keyCheck.MarkedToken());

  1234 			keyCheck.SkipSpace();

  1235 			if (keyCheck.Eos() && key.Compare(aKey)==0)

  1236 				{

  1237 				TInt location = searchBoundary.Locate('\n');

  1238 				__ASSERT_DEBUG(location >= 0, User::Invariant());

  1239 				//trim any white space before and after the value

  1240 				TPtrCX rhs(searchBoundary.Mid(equalOffset+1,location-equalOffset-1));

  1241 				RemoveWSBeforeAndAfter<TPtrCX,TLexX>(rhs,aValue);

  1242 				return KErrNone;

  1243 				}

  1244 			//update the next search boundary

  1245 			searchBoundary.Set(searchBoundary.Mid(searchBoundary.Locate('\n')));

  1246 			}

  1247 		}

  1248 	//cannot find here

  1249 	return KErrNotFound;

  1250 	}

  1252 }//namespace BSUL

  1253 #endif//__BAINIPARSERIMPL_H__

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--