|
sl@0
|
1 |
// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
|
|
sl@0
|
2 |
// All rights reserved.
|
|
sl@0
|
3 |
// This component and the accompanying materials are made available
|
|
sl@0
|
4 |
// under the terms of "Eclipse Public License v1.0"
|
|
sl@0
|
5 |
// which accompanies this distribution, and is available
|
|
sl@0
|
6 |
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
|
|
sl@0
|
7 |
//
|
|
sl@0
|
8 |
// Initial Contributors:
|
|
sl@0
|
9 |
// Nokia Corporation - initial contribution.
|
|
sl@0
|
10 |
//
|
|
sl@0
|
11 |
// Contributors:
|
|
sl@0
|
12 |
//
|
|
sl@0
|
13 |
// Description:
|
|
sl@0
|
14 |
// @internalComponent
|
|
sl@0
|
15 |
//
|
|
sl@0
|
16 |
//
|
|
sl@0
|
17 |
|
|
sl@0
|
18 |
#ifndef __INITEMPLATE_H__
|
|
sl@0
|
19 |
#define __INITEMPLATE_H__
|
|
sl@0
|
20 |
|
|
sl@0
|
21 |
#include <e32base.h>
|
|
sl@0
|
22 |
#include <e32std.h>
|
|
sl@0
|
23 |
#include <f32file.h>
|
|
sl@0
|
24 |
#include <s32file.h>
|
|
sl@0
|
25 |
#include <e32des16.h>
|
|
sl@0
|
26 |
|
|
sl@0
|
27 |
namespace BSUL
|
|
sl@0
|
28 |
{
|
|
sl@0
|
29 |
//Line Type enumeration //
|
|
sl@0
|
30 |
enum TLineType
|
|
sl@0
|
31 |
{
|
|
sl@0
|
32 |
EComment,
|
|
sl@0
|
33 |
ESection,
|
|
sl@0
|
34 |
EKeyValue
|
|
sl@0
|
35 |
};
|
|
sl@0
|
36 |
|
|
sl@0
|
37 |
//utils template class//
|
|
sl@0
|
38 |
static void GetBufferL(RFs& aFs,const TDesC& aFileName,HBufC8*& aBufferPtr)
|
|
sl@0
|
39 |
{
|
|
sl@0
|
40 |
//open the file for reading
|
|
sl@0
|
41 |
RFile file;
|
|
sl@0
|
42 |
User::LeaveIfError(file.Open(aFs,aFileName,EFileShareReadersOnly));
|
|
sl@0
|
43 |
|
|
sl@0
|
44 |
//only process the file if it exists
|
|
sl@0
|
45 |
TInt filesize;
|
|
sl@0
|
46 |
CleanupClosePushL(file);
|
|
sl@0
|
47 |
User::LeaveIfError(file.Size(filesize));
|
|
sl@0
|
48 |
aBufferPtr=HBufC8::NewLC(filesize + 2); //In case '\r\n' needs to be appended
|
|
sl@0
|
49 |
TPtr8 asWritableBuffer(aBufferPtr->Des());
|
|
sl@0
|
50 |
User::LeaveIfError(file.Read(0,asWritableBuffer,filesize));
|
|
sl@0
|
51 |
|
|
sl@0
|
52 |
//check if '\n' is present
|
|
sl@0
|
53 |
if( filesize > 0 && asWritableBuffer[filesize - 1] != '\n' )
|
|
sl@0
|
54 |
{
|
|
sl@0
|
55 |
asWritableBuffer.Append(_L8("\r\n"));
|
|
sl@0
|
56 |
}
|
|
sl@0
|
57 |
//pop the buffer
|
|
sl@0
|
58 |
CleanupStack::Pop();
|
|
sl@0
|
59 |
//close the file
|
|
sl@0
|
60 |
CleanupStack::PopAndDestroy();
|
|
sl@0
|
61 |
}
|
|
sl@0
|
62 |
|
|
sl@0
|
63 |
template <class TLexX>
|
|
sl@0
|
64 |
TBool IsEosAfterSpace(TLexX& aLex)
|
|
sl@0
|
65 |
{
|
|
sl@0
|
66 |
aLex.SkipSpace();
|
|
sl@0
|
67 |
return (aLex.Eos());
|
|
sl@0
|
68 |
}
|
|
sl@0
|
69 |
|
|
sl@0
|
70 |
template<class TPtrCX>
|
|
sl@0
|
71 |
void RemoveComment(TPtrCX& aLine)
|
|
sl@0
|
72 |
{
|
|
sl@0
|
73 |
//Trim anything on the rhs of any inline comment ';' or '#'
|
|
sl@0
|
74 |
//in this case we need to locate which is the first occuring from left
|
|
sl@0
|
75 |
TInt semiColon=aLine.Locate(';');
|
|
sl@0
|
76 |
TInt hash=aLine.Locate('#');
|
|
sl@0
|
77 |
if (semiColon!=KErrNotFound || hash!=KErrNotFound)
|
|
sl@0
|
78 |
{
|
|
sl@0
|
79 |
if (semiColon!=KErrNotFound && hash!=KErrNotFound)
|
|
sl@0
|
80 |
{
|
|
sl@0
|
81 |
aLine.Set(aLine.Left(semiColon<hash?semiColon:hash));
|
|
sl@0
|
82 |
}
|
|
sl@0
|
83 |
else
|
|
sl@0
|
84 |
{
|
|
sl@0
|
85 |
aLine.Set(aLine.Left(semiColon!=KErrNotFound?semiColon:hash));
|
|
sl@0
|
86 |
}
|
|
sl@0
|
87 |
}
|
|
sl@0
|
88 |
}
|
|
sl@0
|
89 |
|
|
sl@0
|
90 |
template <class TPtrCX,class TLexX>
|
|
sl@0
|
91 |
void RemoveWSBeforeAndAfter(const TPtrCX& aString,TPtrCX& aOutput)
|
|
sl@0
|
92 |
{
|
|
sl@0
|
93 |
TLexX parser(aString);
|
|
sl@0
|
94 |
parser.SkipSpaceAndMark();
|
|
sl@0
|
95 |
TInt offset=parser.Offset();
|
|
sl@0
|
96 |
while(!parser.Eos())
|
|
sl@0
|
97 |
{
|
|
sl@0
|
98 |
//now skip for whitespace and check end of string
|
|
sl@0
|
99 |
//if this is eos we are done unget to mark and break
|
|
sl@0
|
100 |
parser.SkipCharacters();
|
|
sl@0
|
101 |
parser.Mark();
|
|
sl@0
|
102 |
if (IsEosAfterSpace(parser))
|
|
sl@0
|
103 |
{
|
|
sl@0
|
104 |
parser.UnGetToMark();
|
|
sl@0
|
105 |
break;
|
|
sl@0
|
106 |
}
|
|
sl@0
|
107 |
}
|
|
sl@0
|
108 |
TInt endOffset=parser.MarkedOffset();
|
|
sl@0
|
109 |
aOutput.Set(aString.Mid(offset,endOffset-offset));
|
|
sl@0
|
110 |
}
|
|
sl@0
|
111 |
|
|
sl@0
|
112 |
template<class TPtrCX,class TLexX>
|
|
sl@0
|
113 |
TInt CountTokens(TPtrCX aLine)
|
|
sl@0
|
114 |
{
|
|
sl@0
|
115 |
TLexX myLexer(aLine);
|
|
sl@0
|
116 |
TInt tokenCount=0;
|
|
sl@0
|
117 |
while (!myLexer.Eos())
|
|
sl@0
|
118 |
{
|
|
sl@0
|
119 |
TPtrCX next = myLexer.NextToken();
|
|
sl@0
|
120 |
if (next.Size())
|
|
sl@0
|
121 |
{
|
|
sl@0
|
122 |
tokenCount++;
|
|
sl@0
|
123 |
}
|
|
sl@0
|
124 |
}
|
|
sl@0
|
125 |
return tokenCount;
|
|
sl@0
|
126 |
}
|
|
sl@0
|
127 |
|
|
sl@0
|
128 |
static void CorruptIfL(TBool aIsCorrupt)
|
|
sl@0
|
129 |
{
|
|
sl@0
|
130 |
if (aIsCorrupt)
|
|
sl@0
|
131 |
{
|
|
sl@0
|
132 |
User::Leave(KErrCorrupt);
|
|
sl@0
|
133 |
}
|
|
sl@0
|
134 |
}
|
|
sl@0
|
135 |
|
|
sl@0
|
136 |
template<class HBufCX, class TPtrCX>
|
|
sl@0
|
137 |
TPtrCX ExtractLineFromBuffer(const TPtrCX& aFileBuffer, TInt aStartOffset)
|
|
sl@0
|
138 |
{
|
|
sl@0
|
139 |
TChar delim('\n');
|
|
sl@0
|
140 |
TPtrCX partialLine = aFileBuffer.Mid(aStartOffset, aFileBuffer.Length()- aStartOffset);
|
|
sl@0
|
141 |
TInt delimOffset= partialLine.Locate(delim);
|
|
sl@0
|
142 |
if (delimOffset==KErrNotFound)
|
|
sl@0
|
143 |
{
|
|
sl@0
|
144 |
return partialLine;
|
|
sl@0
|
145 |
}
|
|
sl@0
|
146 |
return partialLine.Left(delimOffset+1);
|
|
sl@0
|
147 |
}
|
|
sl@0
|
148 |
|
|
sl@0
|
149 |
//ini line template class //
|
|
sl@0
|
150 |
template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>
|
|
sl@0
|
151 |
NONSHARABLE_CLASS(CIniLine) : public CBase
|
|
sl@0
|
152 |
{
|
|
sl@0
|
153 |
public:
|
|
sl@0
|
154 |
static CIniLine* NewL(const TDesCX& aLine);
|
|
sl@0
|
155 |
static CIniLine* NewLC(const TDesCX& aLine);
|
|
sl@0
|
156 |
static CIniLine* NewLC(HBufCX* aLine, TLineType aTypeOfLine);
|
|
sl@0
|
157 |
static CIniLine* NewFromSectionNameLC(const TDesCX& aSectionName);
|
|
sl@0
|
158 |
static CIniLine* NewFromKeyValueLineLC(const TDesCX& aKeyName, const TDesCX& aKeyValue);
|
|
sl@0
|
159 |
|
|
sl@0
|
160 |
~CIniLine();
|
|
sl@0
|
161 |
TLineType LineType() const;
|
|
sl@0
|
162 |
void InsertBefore(CIniLine* aLine);
|
|
sl@0
|
163 |
const HBufCX& LineBuffer() const;
|
|
sl@0
|
164 |
TBool operator==(const CIniLine&) const;
|
|
sl@0
|
165 |
public:
|
|
sl@0
|
166 |
TDblQueLink iLink;
|
|
sl@0
|
167 |
private:
|
|
sl@0
|
168 |
TLineType DetermineTypeOfLine(const TDesCX& aLine);
|
|
sl@0
|
169 |
void ConstructL(const TDesCX& aLine);
|
|
sl@0
|
170 |
CIniLine(HBufCX* aLine, TLineType aLineType);
|
|
sl@0
|
171 |
CIniLine();
|
|
sl@0
|
172 |
private:
|
|
sl@0
|
173 |
HBufCX* iLine;
|
|
sl@0
|
174 |
TLineType iLineType;
|
|
sl@0
|
175 |
};
|
|
sl@0
|
176 |
|
|
sl@0
|
177 |
template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>
|
|
sl@0
|
178 |
CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>* CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>::NewL(const TDesCX& aLine)
|
|
sl@0
|
179 |
{
|
|
sl@0
|
180 |
CIniLine* self=CIniLine::NewLC(aLine);
|
|
sl@0
|
181 |
CleanupStack::Pop(self);
|
|
sl@0
|
182 |
return self;
|
|
sl@0
|
183 |
}
|
|
sl@0
|
184 |
|
|
sl@0
|
185 |
template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>
|
|
sl@0
|
186 |
CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>* CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>::NewLC(const TDesCX& aLine)
|
|
sl@0
|
187 |
{
|
|
sl@0
|
188 |
CIniLine* self=new (ELeave) CIniLine();
|
|
sl@0
|
189 |
CleanupStack::PushL(self);
|
|
sl@0
|
190 |
self->ConstructL(aLine);
|
|
sl@0
|
191 |
return self;
|
|
sl@0
|
192 |
}
|
|
sl@0
|
193 |
|
|
sl@0
|
194 |
template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>
|
|
sl@0
|
195 |
CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>* CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>::NewLC(HBufCX* aLine, TLineType aTypeOfLine)
|
|
sl@0
|
196 |
{
|
|
sl@0
|
197 |
CIniLine* self=new (ELeave) CIniLine(aLine, aTypeOfLine);
|
|
sl@0
|
198 |
CleanupStack::PushL(self);
|
|
sl@0
|
199 |
return self;
|
|
sl@0
|
200 |
}
|
|
sl@0
|
201 |
|
|
sl@0
|
202 |
template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>
|
|
sl@0
|
203 |
CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>::CIniLine(HBufCX* aLine, TLineType aTypeOfLine):iLine(aLine), iLineType(aTypeOfLine)
|
|
sl@0
|
204 |
{}
|
|
sl@0
|
205 |
|
|
sl@0
|
206 |
template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>
|
|
sl@0
|
207 |
CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>::CIniLine()
|
|
sl@0
|
208 |
{}
|
|
sl@0
|
209 |
|
|
sl@0
|
210 |
template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>
|
|
sl@0
|
211 |
CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>::~CIniLine()
|
|
sl@0
|
212 |
{
|
|
sl@0
|
213 |
iLink.Deque();
|
|
sl@0
|
214 |
delete iLine;
|
|
sl@0
|
215 |
}
|
|
sl@0
|
216 |
|
|
sl@0
|
217 |
template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>
|
|
sl@0
|
218 |
void CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>::ConstructL(const TDesCX& aLine)
|
|
sl@0
|
219 |
{
|
|
sl@0
|
220 |
HBufCX* myHBuf = aLine.AllocL();
|
|
sl@0
|
221 |
this->iLine = myHBuf;
|
|
sl@0
|
222 |
this->iLineType = this->DetermineTypeOfLine(aLine);
|
|
sl@0
|
223 |
}
|
|
sl@0
|
224 |
|
|
sl@0
|
225 |
template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>
|
|
sl@0
|
226 |
TLineType CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>::DetermineTypeOfLine(const TDesCX& aLine)
|
|
sl@0
|
227 |
{
|
|
sl@0
|
228 |
// First recognized character wins. Otherwise return a comment.
|
|
sl@0
|
229 |
for (TInt i=0; i< aLine.Length();i++)
|
|
sl@0
|
230 |
{
|
|
sl@0
|
231 |
TText myChar = aLine[i];
|
|
sl@0
|
232 |
switch (myChar)
|
|
sl@0
|
233 |
{
|
|
sl@0
|
234 |
case TText('#'):
|
|
sl@0
|
235 |
case ';':
|
|
sl@0
|
236 |
return EComment;
|
|
sl@0
|
237 |
|
|
sl@0
|
238 |
case TText('['):
|
|
sl@0
|
239 |
return ESection;
|
|
sl@0
|
240 |
|
|
sl@0
|
241 |
case TText('='):
|
|
sl@0
|
242 |
return EKeyValue;
|
|
sl@0
|
243 |
|
|
sl@0
|
244 |
default:
|
|
sl@0
|
245 |
break;
|
|
sl@0
|
246 |
}
|
|
sl@0
|
247 |
}
|
|
sl@0
|
248 |
return EComment;
|
|
sl@0
|
249 |
}
|
|
sl@0
|
250 |
|
|
sl@0
|
251 |
template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>
|
|
sl@0
|
252 |
CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>* CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>::NewFromSectionNameLC(const TDesCX& aSectionName)
|
|
sl@0
|
253 |
{
|
|
sl@0
|
254 |
//Fabricate a section name.
|
|
sl@0
|
255 |
HBufCX* myBuffer=HBufCX::NewLC(aSectionName.Size()+ 6); //6= "2 cr's and \r" + "[]".
|
|
sl@0
|
256 |
TPtrX myBuf (myBuffer->Des());
|
|
sl@0
|
257 |
myBuf.Append(_L("\r\n["));
|
|
sl@0
|
258 |
myBuf.Append(aSectionName);
|
|
sl@0
|
259 |
myBuf.Append(_L("]\r\n"));
|
|
sl@0
|
260 |
CIniLine* myLine = CIniLine::NewLC(myBuffer, ESection);
|
|
sl@0
|
261 |
CleanupStack::Pop(2);
|
|
sl@0
|
262 |
CleanupStack::PushL(myLine);
|
|
sl@0
|
263 |
return myLine;
|
|
sl@0
|
264 |
}
|
|
sl@0
|
265 |
|
|
sl@0
|
266 |
template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>
|
|
sl@0
|
267 |
CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>* CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>::NewFromKeyValueLineLC(const TDesCX& aKeyName, const TDesCX& aKeyValue)
|
|
sl@0
|
268 |
{
|
|
sl@0
|
269 |
//Fabricate a key = value line.
|
|
sl@0
|
270 |
HBufCX* myBuffer=HBufCX::NewLC(aKeyName.Size()+ aKeyValue.Size() + 3); //3= "1 cr + \r" + "=".
|
|
sl@0
|
271 |
TPtrX myBuf (myBuffer->Des());
|
|
sl@0
|
272 |
myBuf.Set(myBuffer->Des());
|
|
sl@0
|
273 |
myBuf.Append(aKeyName);
|
|
sl@0
|
274 |
myBuf.Append('=');
|
|
sl@0
|
275 |
myBuf.Append(aKeyValue);
|
|
sl@0
|
276 |
myBuf.Append(_L("\r\n"));
|
|
sl@0
|
277 |
CIniLine* myLine = CIniLine::NewLC(myBuffer, EKeyValue);
|
|
sl@0
|
278 |
CleanupStack::Pop(2);
|
|
sl@0
|
279 |
CleanupStack::PushL(myLine);
|
|
sl@0
|
280 |
return myLine;
|
|
sl@0
|
281 |
}
|
|
sl@0
|
282 |
|
|
sl@0
|
283 |
template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>
|
|
sl@0
|
284 |
TLineType CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>::LineType() const
|
|
sl@0
|
285 |
{
|
|
sl@0
|
286 |
return iLineType;
|
|
sl@0
|
287 |
}
|
|
sl@0
|
288 |
|
|
sl@0
|
289 |
template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>
|
|
sl@0
|
290 |
void CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>::InsertBefore(CIniLine* aLine)
|
|
sl@0
|
291 |
{
|
|
sl@0
|
292 |
aLine->iLink.AddBefore(&(this->iLink));
|
|
sl@0
|
293 |
}
|
|
sl@0
|
294 |
|
|
sl@0
|
295 |
template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>
|
|
sl@0
|
296 |
const HBufCX& CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>::LineBuffer() const
|
|
sl@0
|
297 |
{
|
|
sl@0
|
298 |
return *iLine;
|
|
sl@0
|
299 |
}
|
|
sl@0
|
300 |
|
|
sl@0
|
301 |
template<class TDesCX,class HBufCX,class TPtrCX, class TPtrX>
|
|
sl@0
|
302 |
TBool CIniLine<TDesCX,HBufCX,TPtrCX,TPtrX>::operator==(const CIniLine& aLine)const
|
|
sl@0
|
303 |
{
|
|
sl@0
|
304 |
if (LineType() != aLine.LineType())
|
|
sl@0
|
305 |
return EFalse;
|
|
sl@0
|
306 |
|
|
sl@0
|
307 |
if ((LineBuffer()).Compare(aLine.LineBuffer()) != 0)
|
|
sl@0
|
308 |
return EFalse;
|
|
sl@0
|
309 |
return ETrue;
|
|
sl@0
|
310 |
}
|
|
sl@0
|
311 |
|
|
sl@0
|
312 |
//ini key template class//
|
|
sl@0
|
313 |
template<class TDesCX,class HBufCX,class TPtrCX, class CIniLineX, class TPtrX,class TLexX>
|
|
sl@0
|
314 |
NONSHARABLE_CLASS(CIniKey): public CBase
|
|
sl@0
|
315 |
{
|
|
sl@0
|
316 |
public:
|
|
sl@0
|
317 |
static CIniKey* NewL(const TDesCX& aKeyName,const TDesCX& aKeyValue);
|
|
sl@0
|
318 |
static CIniKey* NewLC(const TDesCX& aKeyName,const TDesCX& aKeyValue);
|
|
sl@0
|
319 |
static CIniKey* NewLC(CIniLineX* aLine);
|
|
sl@0
|
320 |
static TInt CompareKey(const CIniKey& aFirstKey,const CIniKey& aSecondKey);
|
|
sl@0
|
321 |
|
|
sl@0
|
322 |
void SetKeyValue(const TDesCX& aKeyValue);
|
|
sl@0
|
323 |
TPtrCX KeyName() const;
|
|
sl@0
|
324 |
TPtrCX KeyValue() const;
|
|
sl@0
|
325 |
CIniLineX* LineSrc() const;
|
|
sl@0
|
326 |
~CIniKey();
|
|
sl@0
|
327 |
private:
|
|
sl@0
|
328 |
CIniKey(const TDesCX& aKeyName, const TDesCX& aKeyValue, CIniLineX* aLine);
|
|
sl@0
|
329 |
CIniKey(const TDesCX& aKeyName, const TDesCX& aKeyValue);
|
|
sl@0
|
330 |
static CIniKey* ParseKeyLineL(CIniLineX* aLine);
|
|
sl@0
|
331 |
private:
|
|
sl@0
|
332 |
TPtrCX iKeyName;
|
|
sl@0
|
333 |
TPtrCX iKeyValue;
|
|
sl@0
|
334 |
CIniLineX* iLineSrc;
|
|
sl@0
|
335 |
};
|
|
sl@0
|
336 |
|
|
sl@0
|
337 |
template<class TDesCX,class HBufCX,class TPtrCX, class CIniLineX,class TPtrX,class TLexX>
|
|
sl@0
|
338 |
CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>* CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>::NewL(const TDesCX& aKeyName,const TDesCX& aKeyValue)
|
|
sl@0
|
339 |
{
|
|
sl@0
|
340 |
CIniKey* self=new (ELeave) CIniKey(aKeyName, aKeyValue);
|
|
sl@0
|
341 |
return self;
|
|
sl@0
|
342 |
}
|
|
sl@0
|
343 |
|
|
sl@0
|
344 |
template<class TDesCX,class HBufCX,class TPtrCX, class CIniLineX,class TPtrX,class TLexX>
|
|
sl@0
|
345 |
CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>* CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>::NewLC(const TDesCX& aKeyName,const TDesCX& aKeyValue)
|
|
sl@0
|
346 |
{
|
|
sl@0
|
347 |
CIniKey* self=CIniKey::NewL(aKeyName,aKeyValue);
|
|
sl@0
|
348 |
CleanupStack::PushL(self);
|
|
sl@0
|
349 |
return self;
|
|
sl@0
|
350 |
}
|
|
sl@0
|
351 |
|
|
sl@0
|
352 |
template<class TDesCX,class HBufCX,class TPtrCX, class CIniLineX,class TPtrX,class TLexX>
|
|
sl@0
|
353 |
CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>* CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>::NewLC(CIniLineX* aLine)
|
|
sl@0
|
354 |
{
|
|
sl@0
|
355 |
CIniKey* self=ParseKeyLineL(aLine);
|
|
sl@0
|
356 |
CleanupStack::PushL(self);
|
|
sl@0
|
357 |
self->iLineSrc=aLine;
|
|
sl@0
|
358 |
return self;
|
|
sl@0
|
359 |
}
|
|
sl@0
|
360 |
|
|
sl@0
|
361 |
template<class TDesCX,class HBufCX,class TPtrCX, class CIniLineX,class TPtrX,class TLexX>
|
|
sl@0
|
362 |
CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>::CIniKey(const TDesCX& aKeyName, const TDesCX& aKeyValue, CIniLineX* aLine):iKeyName(aKeyName),iKeyValue(aKeyValue),iLineSrc(aLine)
|
|
sl@0
|
363 |
{ }
|
|
sl@0
|
364 |
|
|
sl@0
|
365 |
template<class TDesCX,class HBufCX,class TPtrCX, class CIniLineX,class TPtrX,class TLexX>
|
|
sl@0
|
366 |
CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>::CIniKey(const TDesCX& aKeyName, const TDesCX& aKeyValue):iKeyName(aKeyName),iKeyValue(aKeyValue),iLineSrc(NULL)
|
|
sl@0
|
367 |
{ }
|
|
sl@0
|
368 |
|
|
sl@0
|
369 |
template<class TDesCX,class HBufCX,class TPtrCX, class CIniLineX,class TPtrX,class TLexX>
|
|
sl@0
|
370 |
CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>::~CIniKey()
|
|
sl@0
|
371 |
{}
|
|
sl@0
|
372 |
|
|
sl@0
|
373 |
template<class TDesCX,class HBufCX,class TPtrCX, class CIniLineX,class TPtrX,class TLexX>
|
|
sl@0
|
374 |
TPtrCX CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>::KeyName() const
|
|
sl@0
|
375 |
{
|
|
sl@0
|
376 |
return iKeyName;
|
|
sl@0
|
377 |
}
|
|
sl@0
|
378 |
|
|
sl@0
|
379 |
template<class TDesCX,class HBufCX,class TPtrCX, class CIniLineX,class TPtrX,class TLexX>
|
|
sl@0
|
380 |
TPtrCX CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>::KeyValue() const
|
|
sl@0
|
381 |
{
|
|
sl@0
|
382 |
return iKeyValue;
|
|
sl@0
|
383 |
}
|
|
sl@0
|
384 |
|
|
sl@0
|
385 |
template<class TDesCX,class HBufCX,class TPtrCX, class CIniLineX,class TPtrX,class TLexX>
|
|
sl@0
|
386 |
CIniLineX* CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>::LineSrc() const
|
|
sl@0
|
387 |
{
|
|
sl@0
|
388 |
return iLineSrc;
|
|
sl@0
|
389 |
}
|
|
sl@0
|
390 |
|
|
sl@0
|
391 |
template<class TDesCX,class HBufCX,class TPtrCX, class CIniLineX,class TPtrX,class TLexX>
|
|
sl@0
|
392 |
void CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>::SetKeyValue(const TDesCX& aKeyValue)
|
|
sl@0
|
393 |
{
|
|
sl@0
|
394 |
iKeyValue.Set(aKeyValue);
|
|
sl@0
|
395 |
}
|
|
sl@0
|
396 |
|
|
sl@0
|
397 |
template<class TDesCX,class HBufCX,class TPtrCX, class CIniLineX,class TPtrX,class TLexX>
|
|
sl@0
|
398 |
TInt CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>::CompareKey(const CIniKey& aFirstKey,const CIniKey& aSecondKey)
|
|
sl@0
|
399 |
{
|
|
sl@0
|
400 |
return (aFirstKey.KeyName()).Compare(aSecondKey.KeyName());
|
|
sl@0
|
401 |
}
|
|
sl@0
|
402 |
|
|
sl@0
|
403 |
template<class TDesCX,class HBufCX,class TPtrCX, class CIniLineX,class TPtrX,class TLexX>
|
|
sl@0
|
404 |
CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>* CIniKey<TDesCX,HBufCX,TPtrCX,CIniLineX,TPtrX,TLexX>::ParseKeyLineL(CIniLineX* aIniLine)
|
|
sl@0
|
405 |
{
|
|
sl@0
|
406 |
const HBufCX& myLine = aIniLine->LineBuffer();
|
|
sl@0
|
407 |
//Get the first occurence of '=' sign
|
|
sl@0
|
408 |
TInt equalOffset=myLine.Locate('=');
|
|
sl@0
|
409 |
CorruptIfL(equalOffset==KErrNotFound);
|
|
sl@0
|
410 |
|
|
sl@0
|
411 |
TInt tokenCount = CountTokens<TPtrCX, TLexX>(myLine.Left(equalOffset));
|
|
sl@0
|
412 |
CorruptIfL(tokenCount != 1);
|
|
sl@0
|
413 |
|
|
sl@0
|
414 |
//construct a TLex for checking the lhs of equal sign
|
|
sl@0
|
415 |
TLexX parser;
|
|
sl@0
|
416 |
parser.Assign(myLine.Left(equalOffset));
|
|
sl@0
|
417 |
parser.SkipSpaceAndMark();
|
|
sl@0
|
418 |
parser.SkipCharacters();
|
|
sl@0
|
419 |
TPtrCX keyname=parser.MarkedToken();
|
|
sl@0
|
420 |
TBool check = (keyname.Length()==0);
|
|
sl@0
|
421 |
CorruptIfL(check);
|
|
sl@0
|
422 |
|
|
sl@0
|
423 |
//strip off any white space before and after the value
|
|
sl@0
|
424 |
TInt edgeOfValue=equalOffset;
|
|
sl@0
|
425 |
while(++edgeOfValue < myLine.Length())
|
|
sl@0
|
426 |
{
|
|
sl@0
|
427 |
TChar t = (myLine)[edgeOfValue];
|
|
sl@0
|
428 |
if (!t.IsSpace())
|
|
sl@0
|
429 |
{
|
|
sl@0
|
430 |
break;
|
|
sl@0
|
431 |
}
|
|
sl@0
|
432 |
}
|
|
sl@0
|
433 |
TPtrCX keyvalue;
|
|
sl@0
|
434 |
if (edgeOfValue < myLine.Length())
|
|
sl@0
|
435 |
{
|
|
sl@0
|
436 |
keyvalue.Set(myLine.Mid(edgeOfValue, (myLine.Length()-edgeOfValue-1)));
|
|
sl@0
|
437 |
}
|
|
sl@0
|
438 |
|
|
sl@0
|
439 |
TInt hashOffset=keyvalue.Locate('#');
|
|
sl@0
|
440 |
if (hashOffset>0)
|
|
sl@0
|
441 |
{
|
|
sl@0
|
442 |
keyvalue.Set(keyvalue.Left(hashOffset));
|
|
sl@0
|
443 |
}
|
|
sl@0
|
444 |
TInt commentOffset=keyvalue.Locate(';');
|
|
sl@0
|
445 |
if (commentOffset > 0)
|
|
sl@0
|
446 |
{
|
|
sl@0
|
447 |
keyvalue.Set(keyvalue.Left(commentOffset));
|
|
sl@0
|
448 |
}
|
|
sl@0
|
449 |
|
|
sl@0
|
450 |
TInt index = keyvalue.Length()-1;
|
|
sl@0
|
451 |
if (index > 0)
|
|
sl@0
|
452 |
{
|
|
sl@0
|
453 |
while (index > 0)
|
|
sl@0
|
454 |
{
|
|
sl@0
|
455 |
TChar t = keyvalue[index];
|
|
sl@0
|
456 |
if (t.IsSpace())
|
|
sl@0
|
457 |
{
|
|
sl@0
|
458 |
index--;
|
|
sl@0
|
459 |
}
|
|
sl@0
|
460 |
else
|
|
sl@0
|
461 |
{
|
|
sl@0
|
462 |
break;
|
|
sl@0
|
463 |
}
|
|
sl@0
|
464 |
}
|
|
sl@0
|
465 |
if (index < (keyvalue.Length()-1))
|
|
sl@0
|
466 |
{
|
|
sl@0
|
467 |
keyvalue.Set(keyvalue.Left(index+1));
|
|
sl@0
|
468 |
}
|
|
sl@0
|
469 |
}
|
|
sl@0
|
470 |
|
|
sl@0
|
471 |
CIniKey* myKey = new (ELeave) CIniKey(keyname,keyvalue, aIniLine);
|
|
sl@0
|
472 |
return myKey;
|
|
sl@0
|
473 |
}
|
|
sl@0
|
474 |
|
|
sl@0
|
475 |
//section template class//
|
|
sl@0
|
476 |
template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX,class CIniLineX,class TPtrX, class TLexX>
|
|
sl@0
|
477 |
NONSHARABLE_CLASS(CIniSection): public CBase
|
|
sl@0
|
478 |
{
|
|
sl@0
|
479 |
public:
|
|
sl@0
|
480 |
static CIniSection* NewL(const TDesCX& aSectionName);
|
|
sl@0
|
481 |
static CIniSection* NewLC(const TDesCX& aSectionName);
|
|
sl@0
|
482 |
static CIniSection* NewL(const TDesCX& aSectionName, CIniLineX* aLineSrc);
|
|
sl@0
|
483 |
static CIniSection* NewLC(CIniLineX* aLineSrc);
|
|
sl@0
|
484 |
static TInt CompareSection(const CIniSection& aFirstSection,const CIniSection& aSecondSection);
|
|
sl@0
|
485 |
~CIniSection();
|
|
sl@0
|
486 |
|
|
sl@0
|
487 |
void InsertKeyL(const TDesCX& aKeyName,const TDesCX& aKeyValue);
|
|
sl@0
|
488 |
void InsertKeyL(const CIniKeyX* aKey);
|
|
sl@0
|
489 |
void RemoveKeyL(const TDesCX& aKeyName);
|
|
sl@0
|
490 |
|
|
sl@0
|
491 |
TPtrCX KeyValueL(const TDesCX& aKeyName) const;
|
|
sl@0
|
492 |
TInt KeyCount() const;
|
|
sl@0
|
493 |
CIniKeyX* FindKeyL(const TDesCX& aKeyName) const;
|
|
sl@0
|
494 |
TPtrCX SectionName() const;
|
|
sl@0
|
495 |
|
|
sl@0
|
496 |
CIniLineX* SrcLine();
|
|
sl@0
|
497 |
void SetSrcLine(CIniLineX* aLineSrc);
|
|
sl@0
|
498 |
|
|
sl@0
|
499 |
//to be used to access individual item
|
|
sl@0
|
500 |
const CIniKeyX* Key(TInt aIndex) const {return iKeyArray[aIndex];}
|
|
sl@0
|
501 |
void ReserveSpaceInKeyArrayL(){iKeyArray.ReserveL(1);}
|
|
sl@0
|
502 |
private:
|
|
sl@0
|
503 |
CIniSection(TPtrCX aSectionName);
|
|
sl@0
|
504 |
CIniSection(TPtrCX aSectionName, CIniLineX* aLine);
|
|
sl@0
|
505 |
static TPtrCX ParseSectionLineL(const HBufCX& aLine);
|
|
sl@0
|
506 |
|
|
sl@0
|
507 |
private:
|
|
sl@0
|
508 |
TPtrCX iSectionName;
|
|
sl@0
|
509 |
RPointerArray<CIniKeyX> iKeyArray;
|
|
sl@0
|
510 |
CIniLineX* iLineSrc; //If no document object exists, then this object is not used.
|
|
sl@0
|
511 |
};
|
|
sl@0
|
512 |
|
|
sl@0
|
513 |
template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX,class TLexX>
|
|
sl@0
|
514 |
CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>* CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::NewL(const TDesCX& aSectionName)
|
|
sl@0
|
515 |
{
|
|
sl@0
|
516 |
CIniSection* self=new (ELeave) CIniSection(aSectionName);
|
|
sl@0
|
517 |
return self;
|
|
sl@0
|
518 |
}
|
|
sl@0
|
519 |
|
|
sl@0
|
520 |
template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX,class TLexX>
|
|
sl@0
|
521 |
CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>* CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::NewL(const TDesCX& aSectionName,CIniLineX* aLineSrc)
|
|
sl@0
|
522 |
{
|
|
sl@0
|
523 |
CIniSection* self=new (ELeave) CIniSection(aSectionName, aLineSrc);
|
|
sl@0
|
524 |
return self;
|
|
sl@0
|
525 |
}
|
|
sl@0
|
526 |
|
|
sl@0
|
527 |
template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX,class TLexX>
|
|
sl@0
|
528 |
CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>* CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::NewLC(const TDesCX& aSectionName)
|
|
sl@0
|
529 |
{
|
|
sl@0
|
530 |
CIniSection* self=new (ELeave) CIniSection(aSectionName);
|
|
sl@0
|
531 |
CleanupStack::PushL(self);
|
|
sl@0
|
532 |
return self;
|
|
sl@0
|
533 |
}
|
|
sl@0
|
534 |
|
|
sl@0
|
535 |
template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX,class TLexX>
|
|
sl@0
|
536 |
CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>* CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::NewLC(CIniLineX* aLineSrc)
|
|
sl@0
|
537 |
{
|
|
sl@0
|
538 |
const HBufCX& buffer = aLineSrc->LineBuffer();
|
|
sl@0
|
539 |
TPtrCX sectionName = ParseSectionLineL(buffer);
|
|
sl@0
|
540 |
CIniSection* self=new (ELeave) CIniSection(sectionName, aLineSrc);
|
|
sl@0
|
541 |
CleanupStack::PushL(self);
|
|
sl@0
|
542 |
return self;
|
|
sl@0
|
543 |
}
|
|
sl@0
|
544 |
|
|
sl@0
|
545 |
template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX,class TLexX>
|
|
sl@0
|
546 |
CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::CIniSection(TPtrCX aSectionName, CIniLineX* aLine):iSectionName(aSectionName), iLineSrc(aLine)
|
|
sl@0
|
547 |
{
|
|
sl@0
|
548 |
iKeyArray.Reset();
|
|
sl@0
|
549 |
}
|
|
sl@0
|
550 |
|
|
sl@0
|
551 |
template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX,class TLexX>
|
|
sl@0
|
552 |
CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::CIniSection(TPtrCX aSectionName):iSectionName(aSectionName)
|
|
sl@0
|
553 |
{
|
|
sl@0
|
554 |
iKeyArray.Reset();
|
|
sl@0
|
555 |
}
|
|
sl@0
|
556 |
|
|
sl@0
|
557 |
template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX,class TLexX>
|
|
sl@0
|
558 |
CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::~CIniSection()
|
|
sl@0
|
559 |
{
|
|
sl@0
|
560 |
iKeyArray.ResetAndDestroy();
|
|
sl@0
|
561 |
}
|
|
sl@0
|
562 |
|
|
sl@0
|
563 |
template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX, class TLexX>
|
|
sl@0
|
564 |
void CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::SetSrcLine(CIniLineX* aLineSrc)
|
|
sl@0
|
565 |
{
|
|
sl@0
|
566 |
if (iLineSrc)
|
|
sl@0
|
567 |
{
|
|
sl@0
|
568 |
delete iLineSrc;
|
|
sl@0
|
569 |
}
|
|
sl@0
|
570 |
iLineSrc = aLineSrc;
|
|
sl@0
|
571 |
}
|
|
sl@0
|
572 |
|
|
sl@0
|
573 |
template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX,class TLexX>
|
|
sl@0
|
574 |
TInt CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::KeyCount() const
|
|
sl@0
|
575 |
{
|
|
sl@0
|
576 |
return iKeyArray.Count();
|
|
sl@0
|
577 |
}
|
|
sl@0
|
578 |
|
|
sl@0
|
579 |
template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX,class TLexX>
|
|
sl@0
|
580 |
TPtrCX CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::SectionName() const
|
|
sl@0
|
581 |
{
|
|
sl@0
|
582 |
return iSectionName;
|
|
sl@0
|
583 |
}
|
|
sl@0
|
584 |
|
|
sl@0
|
585 |
template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX,class TLexX>
|
|
sl@0
|
586 |
CIniLineX* CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::SrcLine()
|
|
sl@0
|
587 |
{
|
|
sl@0
|
588 |
return iLineSrc;
|
|
sl@0
|
589 |
}
|
|
sl@0
|
590 |
|
|
sl@0
|
591 |
template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX,class TLexX>
|
|
sl@0
|
592 |
TInt CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::CompareSection(const CIniSection& aFirstSection,const CIniSection& aSecondSection)
|
|
sl@0
|
593 |
{
|
|
sl@0
|
594 |
return aFirstSection.SectionName().Compare(aSecondSection.SectionName());
|
|
sl@0
|
595 |
}
|
|
sl@0
|
596 |
|
|
sl@0
|
597 |
template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX, class TLexX>
|
|
sl@0
|
598 |
void CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::InsertKeyL(const TDesCX& aKeyName,const TDesCX& aKeyValue)
|
|
sl@0
|
599 |
{
|
|
sl@0
|
600 |
CIniKeyX* newKey=CIniKeyX::NewLC(aKeyName,aKeyValue);
|
|
sl@0
|
601 |
InsertKeyL(newKey);
|
|
sl@0
|
602 |
CleanupStack::Pop(newKey);
|
|
sl@0
|
603 |
}
|
|
sl@0
|
604 |
|
|
sl@0
|
605 |
template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX, class TLexX>
|
|
sl@0
|
606 |
void CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::InsertKeyL(const CIniKeyX* aKey)
|
|
sl@0
|
607 |
{
|
|
sl@0
|
608 |
iKeyArray.InsertInOrderL(aKey,TLinearOrder<CIniKeyX>(CIniKeyX::CompareKey));
|
|
sl@0
|
609 |
}
|
|
sl@0
|
610 |
|
|
sl@0
|
611 |
template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX,class TLexX>
|
|
sl@0
|
612 |
void CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::RemoveKeyL(const TDesCX& aKeyName)
|
|
sl@0
|
613 |
{
|
|
sl@0
|
614 |
CIniKeyX* key=FindKeyL(aKeyName);
|
|
sl@0
|
615 |
CIniLineX* myLine = key->LineSrc();
|
|
sl@0
|
616 |
TInt index=iKeyArray.FindInOrderL(key,TLinearOrder<CIniKeyX>(CIniKeyX::CompareKey));
|
|
sl@0
|
617 |
iKeyArray.Remove(index);
|
|
sl@0
|
618 |
delete key;
|
|
sl@0
|
619 |
delete myLine;
|
|
sl@0
|
620 |
}
|
|
sl@0
|
621 |
|
|
sl@0
|
622 |
template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX, class TLexX>
|
|
sl@0
|
623 |
CIniKeyX* CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::FindKeyL(const TDesCX& aKeyName) const
|
|
sl@0
|
624 |
{
|
|
sl@0
|
625 |
CIniKeyX* key=CIniKeyX::NewLC(aKeyName, aKeyName);
|
|
sl@0
|
626 |
TInt index=iKeyArray.FindInOrderL(key,TLinearOrder<CIniKeyX>(CIniKeyX::CompareKey));
|
|
sl@0
|
627 |
CleanupStack::PopAndDestroy(key);
|
|
sl@0
|
628 |
return iKeyArray[index];
|
|
sl@0
|
629 |
}
|
|
sl@0
|
630 |
|
|
sl@0
|
631 |
template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX,class TLexX>
|
|
sl@0
|
632 |
TPtrCX CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::KeyValueL(const TDesCX& aKeyName) const
|
|
sl@0
|
633 |
{
|
|
sl@0
|
634 |
CIniKeyX* key=FindKeyL(aKeyName);
|
|
sl@0
|
635 |
return key->KeyValue();
|
|
sl@0
|
636 |
}
|
|
sl@0
|
637 |
|
|
sl@0
|
638 |
template<class TDesCX,class HBufCX,class TPtrCX,class CIniKeyX, class CIniLineX, class TPtrX,class TLexX>
|
|
sl@0
|
639 |
TPtrCX CIniSection<TDesCX,HBufCX,TPtrCX,CIniKeyX,CIniLineX,TPtrX,TLexX>::ParseSectionLineL(const HBufCX& aLine)
|
|
sl@0
|
640 |
{
|
|
sl@0
|
641 |
//find the last terminating bracket ']'
|
|
sl@0
|
642 |
//anything in between is considered the section name
|
|
sl@0
|
643 |
TInt endBracket=aLine.Locate(']');
|
|
sl@0
|
644 |
//Check if the terminating bracket exits. Leave with an error code if not found.
|
|
sl@0
|
645 |
CorruptIfL(endBracket == KErrNotFound);
|
|
sl@0
|
646 |
|
|
sl@0
|
647 |
TInt startBracket=aLine.Locate('[');
|
|
sl@0
|
648 |
CorruptIfL(startBracket == KErrNotFound);
|
|
sl@0
|
649 |
|
|
sl@0
|
650 |
TPtrCX sectionName=aLine.Mid(startBracket+1, (endBracket-startBracket)-1);
|
|
sl@0
|
651 |
|
|
sl@0
|
652 |
//corrupt if empty section e.g []
|
|
sl@0
|
653 |
TBool check = (sectionName.Length()==0);
|
|
sl@0
|
654 |
CorruptIfL(check);
|
|
sl@0
|
655 |
|
|
sl@0
|
656 |
TLexX lex(sectionName);
|
|
sl@0
|
657 |
|
|
sl@0
|
658 |
//Check for any white space within section name
|
|
sl@0
|
659 |
//check any white spaces directly after the '['
|
|
sl@0
|
660 |
lex.SkipSpace();
|
|
sl@0
|
661 |
check = (lex.Offset()>lex.MarkedOffset());
|
|
sl@0
|
662 |
CorruptIfL(check);
|
|
sl@0
|
663 |
lex.SkipCharacters();
|
|
sl@0
|
664 |
|
|
sl@0
|
665 |
//At this stage we can extract the section name
|
|
sl@0
|
666 |
sectionName.Set(lex.MarkedToken());
|
|
sl@0
|
667 |
return (sectionName);
|
|
sl@0
|
668 |
}
|
|
sl@0
|
669 |
|
|
sl@0
|
670 |
//iterator template class//
|
|
sl@0
|
671 |
template<class TDesCX,class TPtrCX,class CIniSectionX,class CIniDocumentX,class CIniKeyX>
|
|
sl@0
|
672 |
NONSHARABLE_CLASS(CIniSecIterImplX): public CBase
|
|
sl@0
|
673 |
{
|
|
sl@0
|
674 |
public:
|
|
sl@0
|
675 |
CIniSecIterImplX():iCurrentIndex(0),iSection(NULL){}
|
|
sl@0
|
676 |
TBool Next(TPtrCX& aKeyName,TPtrCX& aKeyValue);
|
|
sl@0
|
677 |
void Reset(){iCurrentIndex=0;}
|
|
sl@0
|
678 |
TBool End(){return iCurrentIndex>=iSection->KeyCount();}
|
|
sl@0
|
679 |
public:
|
|
sl@0
|
680 |
TInt iCurrentIndex;
|
|
sl@0
|
681 |
CIniSectionX* iSection;
|
|
sl@0
|
682 |
};
|
|
sl@0
|
683 |
|
|
sl@0
|
684 |
template<class TDesCX,class TPtrCX,class CIniSectionX,class CIniDocumentX,class CIniKeyX>
|
|
sl@0
|
685 |
TBool CIniSecIterImplX<TDesCX,TPtrCX,CIniSectionX,CIniDocumentX,CIniKeyX>::Next(TPtrCX& aKeyName,TPtrCX& aKeyValue)
|
|
sl@0
|
686 |
{
|
|
sl@0
|
687 |
if (iSection)
|
|
sl@0
|
688 |
{
|
|
sl@0
|
689 |
if (iCurrentIndex<iSection->KeyCount())
|
|
sl@0
|
690 |
{
|
|
sl@0
|
691 |
const CIniKeyX* key=iSection->Key(iCurrentIndex);
|
|
sl@0
|
692 |
aKeyName.Set(key->KeyName());
|
|
sl@0
|
693 |
aKeyValue.Set(key->KeyValue());
|
|
sl@0
|
694 |
iCurrentIndex++;
|
|
sl@0
|
695 |
return ETrue;
|
|
sl@0
|
696 |
}
|
|
sl@0
|
697 |
}
|
|
sl@0
|
698 |
return EFalse;
|
|
sl@0
|
699 |
}
|
|
sl@0
|
700 |
|
|
sl@0
|
701 |
|
|
sl@0
|
702 |
//inidocument template class//
|
|
sl@0
|
703 |
template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX,class CIniLineX,class CIniKeyX>
|
|
sl@0
|
704 |
NONSHARABLE_CLASS(CIniDocumentTmplX) : public CBase
|
|
sl@0
|
705 |
{
|
|
sl@0
|
706 |
public:
|
|
sl@0
|
707 |
CIniDocumentTmplX(RFs& aFs,TBool aNarrow);
|
|
sl@0
|
708 |
~CIniDocumentTmplX();
|
|
sl@0
|
709 |
void FlushL(const TDesC& aFileName);
|
|
sl@0
|
710 |
|
|
sl@0
|
711 |
TInt GetSectionList(RArray<TPtrCX>& aSectionList) const;
|
|
sl@0
|
712 |
void GetKeyValueL(const TDesCX& aSectionName,const TDesCX& aKeyName,TPtrCX& aKeyValue) const;
|
|
sl@0
|
713 |
CIniSectionX* SectionL(const TDesCX& aSectionName) const;
|
|
sl@0
|
714 |
|
|
sl@0
|
715 |
CIniSectionX* AddSectionL(const TDesCX& aSectionName, CIniLineX* aLine);
|
|
sl@0
|
716 |
CIniSectionX* AddSectionL(const TDesCX& aSectionName);
|
|
sl@0
|
717 |
void AddSectionL(const CIniSectionX* aSection);
|
|
sl@0
|
718 |
|
|
sl@0
|
719 |
void RemoveSectionL(const TDesCX& aSectionName);
|
|
sl@0
|
720 |
void SetKeyL(const TDesCX& aSectionName,const TDesCX& aKeyName,const TDesCX& aKeyValue);
|
|
sl@0
|
721 |
void RemoveKeyL(const TDesCX& aSectionName,const TDesCX& aKeyName);
|
|
sl@0
|
722 |
void RemoveLineL(CIniLineX* aLine);
|
|
sl@0
|
723 |
void InsertKeyValueIntoQueueL(CIniLineX* aKeyValue, CIniSectionX& aSection);
|
|
sl@0
|
724 |
void AppendIntoQueue(CIniLineX* aSection);
|
|
sl@0
|
725 |
TBool CompareDocs(CIniDocumentTmplX& aDoc);
|
|
sl@0
|
726 |
|
|
sl@0
|
727 |
private:
|
|
sl@0
|
728 |
CIniSectionX* FindSectionL(const TDesCX& aSectionName) const;
|
|
sl@0
|
729 |
void ConstructL(const TDesC& aFileName);
|
|
sl@0
|
730 |
|
|
sl@0
|
731 |
private:
|
|
sl@0
|
732 |
TBool iNarrow;
|
|
sl@0
|
733 |
RFs& iFs;
|
|
sl@0
|
734 |
TDblQue<CIniLineX> iDocument;
|
|
sl@0
|
735 |
RPointerArray<CIniSectionX> iSectionArray;
|
|
sl@0
|
736 |
};
|
|
sl@0
|
737 |
|
|
sl@0
|
738 |
template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX, class CIniLineX,class CIniKeyX>
|
|
sl@0
|
739 |
CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::CIniDocumentTmplX(RFs& aFs,TBool aNarrow):iNarrow(aNarrow),iFs(aFs)
|
|
sl@0
|
740 |
{
|
|
sl@0
|
741 |
iSectionArray.Reset();
|
|
sl@0
|
742 |
iDocument.SetOffset(_FOFF(CIniLineX, iLink));
|
|
sl@0
|
743 |
iDocument.Reset();
|
|
sl@0
|
744 |
}
|
|
sl@0
|
745 |
|
|
sl@0
|
746 |
template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX,class CIniLineX,class CIniKeyX>
|
|
sl@0
|
747 |
TBool CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::CompareDocs(CIniDocumentTmplX& aDoc)
|
|
sl@0
|
748 |
{
|
|
sl@0
|
749 |
CIniLineX* lineFromA; // This object is a. The passed in one is b.
|
|
sl@0
|
750 |
CIniLineX* lineFromB;
|
|
sl@0
|
751 |
TDblQueIter<CIniLineX> itera(this->iDocument);
|
|
sl@0
|
752 |
TDblQueIter<CIniLineX> iterb(aDoc.iDocument);
|
|
sl@0
|
753 |
|
|
sl@0
|
754 |
TBool NotDoneYet= ETrue;
|
|
sl@0
|
755 |
while (NotDoneYet)
|
|
sl@0
|
756 |
{
|
|
sl@0
|
757 |
lineFromA = itera++;
|
|
sl@0
|
758 |
lineFromB = iterb++;
|
|
sl@0
|
759 |
if ((lineFromA == NULL) || (lineFromB == NULL))
|
|
sl@0
|
760 |
break;
|
|
sl@0
|
761 |
|
|
sl@0
|
762 |
if (!(*lineFromA == *lineFromB))
|
|
sl@0
|
763 |
{
|
|
sl@0
|
764 |
return EFalse;
|
|
sl@0
|
765 |
}
|
|
sl@0
|
766 |
}
|
|
sl@0
|
767 |
|
|
sl@0
|
768 |
if ( (lineFromA) || (lineFromB))
|
|
sl@0
|
769 |
return EFalse;
|
|
sl@0
|
770 |
|
|
sl@0
|
771 |
if ((this->iSectionArray.Count()) != (aDoc.iSectionArray.Count()))
|
|
sl@0
|
772 |
{
|
|
sl@0
|
773 |
return EFalse;
|
|
sl@0
|
774 |
}
|
|
sl@0
|
775 |
|
|
sl@0
|
776 |
for (TInt i=0; i<this->iSectionArray.Count(); i++)
|
|
sl@0
|
777 |
{
|
|
sl@0
|
778 |
TPtrCX secNameA = this->iSectionArray[i]->SectionName();
|
|
sl@0
|
779 |
TPtrCX secNameB = aDoc.iSectionArray[i]->SectionName();
|
|
sl@0
|
780 |
if ((secNameA.Compare(secNameB))!= 0)
|
|
sl@0
|
781 |
return EFalse;
|
|
sl@0
|
782 |
|
|
sl@0
|
783 |
if ((this->iSectionArray[i]->KeyCount()) != (aDoc.iSectionArray[i]->KeyCount()))
|
|
sl@0
|
784 |
return EFalse;
|
|
sl@0
|
785 |
|
|
sl@0
|
786 |
lineFromA = this->iSectionArray[i]->SrcLine();
|
|
sl@0
|
787 |
lineFromB = aDoc.iSectionArray[i]->SrcLine();
|
|
sl@0
|
788 |
|
|
sl@0
|
789 |
if (!(*lineFromA == *lineFromB))
|
|
sl@0
|
790 |
{
|
|
sl@0
|
791 |
return EFalse;
|
|
sl@0
|
792 |
}
|
|
sl@0
|
793 |
|
|
sl@0
|
794 |
for (TInt k=0; k<this->iSectionArray[i]->KeyCount(); k++)
|
|
sl@0
|
795 |
{
|
|
sl@0
|
796 |
const CIniKeyX* keyA = this->iSectionArray[i]->Key(k);
|
|
sl@0
|
797 |
const CIniKeyX* keyB = aDoc.iSectionArray[i]->Key(k);
|
|
sl@0
|
798 |
if (keyA->KeyName().Compare(keyB->KeyName()) != 0)
|
|
sl@0
|
799 |
return EFalse;
|
|
sl@0
|
800 |
if (keyA->KeyValue().Compare(keyB->KeyValue()) != 0)
|
|
sl@0
|
801 |
return EFalse;
|
|
sl@0
|
802 |
|
|
sl@0
|
803 |
lineFromA = keyA->LineSrc();
|
|
sl@0
|
804 |
lineFromB = keyB->LineSrc();
|
|
sl@0
|
805 |
|
|
sl@0
|
806 |
if (!(*lineFromA == *lineFromB))
|
|
sl@0
|
807 |
{
|
|
sl@0
|
808 |
return EFalse;
|
|
sl@0
|
809 |
}
|
|
sl@0
|
810 |
}
|
|
sl@0
|
811 |
}
|
|
sl@0
|
812 |
|
|
sl@0
|
813 |
return ETrue;
|
|
sl@0
|
814 |
}
|
|
sl@0
|
815 |
|
|
sl@0
|
816 |
template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX, class CIniLineX,class CIniKeyX>
|
|
sl@0
|
817 |
void CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::AppendIntoQueue(CIniLineX* aLine)
|
|
sl@0
|
818 |
{
|
|
sl@0
|
819 |
if (iDocument.IsEmpty())
|
|
sl@0
|
820 |
{
|
|
sl@0
|
821 |
iDocument.AddFirst(*aLine);
|
|
sl@0
|
822 |
}
|
|
sl@0
|
823 |
else
|
|
sl@0
|
824 |
{
|
|
sl@0
|
825 |
iDocument.AddLast(*aLine); //always at the end of the list.
|
|
sl@0
|
826 |
}
|
|
sl@0
|
827 |
}
|
|
sl@0
|
828 |
|
|
sl@0
|
829 |
template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX, class CIniLineX,class CIniKeyX>
|
|
sl@0
|
830 |
void CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::InsertKeyValueIntoQueueL(CIniLineX* aKeyValue,CIniSectionX& aSection)
|
|
sl@0
|
831 |
{
|
|
sl@0
|
832 |
// Find the end of the section (if exists).
|
|
sl@0
|
833 |
CIniLineX* lastEntry;
|
|
sl@0
|
834 |
CIniLineX* line;
|
|
sl@0
|
835 |
TDblQueIter<CIniLineX> iter(iDocument);
|
|
sl@0
|
836 |
|
|
sl@0
|
837 |
lastEntry = aSection.SrcLine(); //by default insert into queue after this line entry.
|
|
sl@0
|
838 |
iter.Set(*lastEntry); // search after this point for a keyvalue line.
|
|
sl@0
|
839 |
iter++; //point to next line
|
|
sl@0
|
840 |
while ((line = iter++) != NULL)
|
|
sl@0
|
841 |
{
|
|
sl@0
|
842 |
lastEntry=line;
|
|
sl@0
|
843 |
TLineType typeOfLine = line->LineType();
|
|
sl@0
|
844 |
if (typeOfLine == ESection)
|
|
sl@0
|
845 |
{
|
|
sl@0
|
846 |
break;
|
|
sl@0
|
847 |
}
|
|
sl@0
|
848 |
}
|
|
sl@0
|
849 |
|
|
sl@0
|
850 |
if ( line == NULL )
|
|
sl@0
|
851 |
{
|
|
sl@0
|
852 |
AppendIntoQueue(aKeyValue);
|
|
sl@0
|
853 |
}
|
|
sl@0
|
854 |
else
|
|
sl@0
|
855 |
{
|
|
sl@0
|
856 |
if (iDocument.IsLast(lastEntry))
|
|
sl@0
|
857 |
{
|
|
sl@0
|
858 |
AppendIntoQueue(aKeyValue);
|
|
sl@0
|
859 |
}
|
|
sl@0
|
860 |
else
|
|
sl@0
|
861 |
{
|
|
sl@0
|
862 |
lastEntry->InsertBefore(aKeyValue);
|
|
sl@0
|
863 |
}
|
|
sl@0
|
864 |
}
|
|
sl@0
|
865 |
}
|
|
sl@0
|
866 |
|
|
sl@0
|
867 |
template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX, class CIniLineX,class CIniKeyX>
|
|
sl@0
|
868 |
void CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::FlushL(const TDesC& aFileName)
|
|
sl@0
|
869 |
{
|
|
sl@0
|
870 |
//we need to get the path for the target file
|
|
sl@0
|
871 |
TParse originFile;
|
|
sl@0
|
872 |
User::LeaveIfError(originFile.Set(aFileName,NULL,NULL));
|
|
sl@0
|
873 |
|
|
sl@0
|
874 |
//Need to ensure path exists
|
|
sl@0
|
875 |
TInt error=iFs.MkDirAll(originFile.DriveAndPath());
|
|
sl@0
|
876 |
if (error!=KErrAlreadyExists)
|
|
sl@0
|
877 |
{
|
|
sl@0
|
878 |
User::LeaveIfError(error);
|
|
sl@0
|
879 |
}
|
|
sl@0
|
880 |
|
|
sl@0
|
881 |
//Constructing the temp file name with the same directory and path
|
|
sl@0
|
882 |
TFileName tempFile;
|
|
sl@0
|
883 |
RFile file;
|
|
sl@0
|
884 |
User::LeaveIfError(file.Temp(iFs,originFile.DriveAndPath(),tempFile,EFileWrite));
|
|
sl@0
|
885 |
CleanupClosePushL(file);
|
|
sl@0
|
886 |
|
|
sl@0
|
887 |
TPtrC8 bufPtr;
|
|
sl@0
|
888 |
if (!iNarrow)
|
|
sl@0
|
889 |
{
|
|
sl@0
|
890 |
TChar myChar(0xFEFF);
|
|
sl@0
|
891 |
const unsigned char* myChar8=reinterpret_cast<const unsigned char*>(&myChar);
|
|
sl@0
|
892 |
bufPtr.Set(myChar8, 2);
|
|
sl@0
|
893 |
User::LeaveIfError(file.Write(bufPtr));
|
|
sl@0
|
894 |
}
|
|
sl@0
|
895 |
|
|
sl@0
|
896 |
TDblQueIter<CIniLineX> iter(iDocument);
|
|
sl@0
|
897 |
CIniLineX* line;
|
|
sl@0
|
898 |
while ((line = iter++) != NULL)
|
|
sl@0
|
899 |
{
|
|
sl@0
|
900 |
const HBufCX& tempBuffer=line->LineBuffer();
|
|
sl@0
|
901 |
const TUint8* rawptr8=reinterpret_cast<const TUint8*>(tempBuffer.Ptr());
|
|
sl@0
|
902 |
if (iNarrow)
|
|
sl@0
|
903 |
{
|
|
sl@0
|
904 |
bufPtr.Set(rawptr8,tempBuffer.Length());
|
|
sl@0
|
905 |
}
|
|
sl@0
|
906 |
else
|
|
sl@0
|
907 |
{
|
|
sl@0
|
908 |
bufPtr.Set(rawptr8,tempBuffer.Length()*2);
|
|
sl@0
|
909 |
}
|
|
sl@0
|
910 |
User::LeaveIfError(file.Write(bufPtr));
|
|
sl@0
|
911 |
}
|
|
sl@0
|
912 |
User::LeaveIfError(file.Flush());
|
|
sl@0
|
913 |
CleanupStack::PopAndDestroy();
|
|
sl@0
|
914 |
|
|
sl@0
|
915 |
//Finally try replacing or creating a new file
|
|
sl@0
|
916 |
//depending on whether file exist or not
|
|
sl@0
|
917 |
TEntry entry;
|
|
sl@0
|
918 |
if (iFs.Entry(aFileName,entry)==KErrNone)
|
|
sl@0
|
919 |
{
|
|
sl@0
|
920 |
User::LeaveIfError(iFs.Replace(tempFile,aFileName));
|
|
sl@0
|
921 |
}
|
|
sl@0
|
922 |
else
|
|
sl@0
|
923 |
{
|
|
sl@0
|
924 |
User::LeaveIfError(iFs.Rename(tempFile,aFileName));
|
|
sl@0
|
925 |
}
|
|
sl@0
|
926 |
}
|
|
sl@0
|
927 |
|
|
sl@0
|
928 |
template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX, class CIniLineX,class CIniKeyX>
|
|
sl@0
|
929 |
TInt CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::GetSectionList(RArray<TPtrCX>& aSectionList) const
|
|
sl@0
|
930 |
{
|
|
sl@0
|
931 |
//Reset the list first
|
|
sl@0
|
932 |
aSectionList.Reset();
|
|
sl@0
|
933 |
for (TInt i=0;i<iSectionArray.Count();i++)
|
|
sl@0
|
934 |
{
|
|
sl@0
|
935 |
TPtrCX nameptr=iSectionArray[i]->SectionName();
|
|
sl@0
|
936 |
TInt ret=aSectionList.Append(nameptr);
|
|
sl@0
|
937 |
//If error half way fo the copying, reset the list first
|
|
sl@0
|
938 |
if (ret!=KErrNone)
|
|
sl@0
|
939 |
{
|
|
sl@0
|
940 |
aSectionList.Reset();
|
|
sl@0
|
941 |
return ret;
|
|
sl@0
|
942 |
}
|
|
sl@0
|
943 |
}
|
|
sl@0
|
944 |
return KErrNone;
|
|
sl@0
|
945 |
}
|
|
sl@0
|
946 |
|
|
sl@0
|
947 |
template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX, class CIniLineX,class CIniKeyX>
|
|
sl@0
|
948 |
void CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::GetKeyValueL(const TDesCX& aSectionName,const TDesCX& aKeyName,TPtrCX& aKeyValue) const
|
|
sl@0
|
949 |
{
|
|
sl@0
|
950 |
//Find if section exists
|
|
sl@0
|
951 |
CIniSectionX* section = SectionL(aSectionName);
|
|
sl@0
|
952 |
aKeyValue.Set(section->KeyValueL(aKeyName));
|
|
sl@0
|
953 |
}
|
|
sl@0
|
954 |
|
|
sl@0
|
955 |
template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX,class CIniLineX,class CIniKeyX>
|
|
sl@0
|
956 |
CIniSectionX* CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::SectionL(const TDesCX& aSectionName) const
|
|
sl@0
|
957 |
{
|
|
sl@0
|
958 |
CIniSectionX* section = FindSectionL(aSectionName);
|
|
sl@0
|
959 |
return section;
|
|
sl@0
|
960 |
}
|
|
sl@0
|
961 |
|
|
sl@0
|
962 |
template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX,class CIniLineX,class CIniKeyX>
|
|
sl@0
|
963 |
CIniSectionX* CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::AddSectionL(const TDesCX& aSectionName)
|
|
sl@0
|
964 |
{
|
|
sl@0
|
965 |
//Find if section exists
|
|
sl@0
|
966 |
CIniSectionX* section = NULL;
|
|
sl@0
|
967 |
TRAPD(ret, section = FindSectionL(aSectionName));
|
|
sl@0
|
968 |
if ((ret == KErrNone) && (section != NULL))
|
|
sl@0
|
969 |
User::Leave(KErrAlreadyExists);
|
|
sl@0
|
970 |
|
|
sl@0
|
971 |
//Fabricate objects upfront and on the cleanup stack to ensure their deletion if OOM conditions occur.
|
|
sl@0
|
972 |
CIniLineX* myLine = CIniLineX::NewFromSectionNameLC(aSectionName);
|
|
sl@0
|
973 |
AppendIntoQueue(myLine);
|
|
sl@0
|
974 |
|
|
sl@0
|
975 |
// reserve 1 slot for the new section name to provoke the out of memory condition
|
|
sl@0
|
976 |
// before actually inserting the object to avoid having to go back and remove it if it fails.
|
|
sl@0
|
977 |
this->iSectionArray.ReserveL(1);
|
|
sl@0
|
978 |
|
|
sl@0
|
979 |
// If we have not left, we are sure adding a section should not leave due to OOM.
|
|
sl@0
|
980 |
CIniSectionX* newSection=AddSectionL(aSectionName, myLine);
|
|
sl@0
|
981 |
CleanupStack::Pop(myLine);
|
|
sl@0
|
982 |
return newSection;
|
|
sl@0
|
983 |
}
|
|
sl@0
|
984 |
|
|
sl@0
|
985 |
template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX,class CIniLineX,class CIniKeyX>
|
|
sl@0
|
986 |
CIniSectionX* CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::AddSectionL(const TDesCX& aSectionName, CIniLineX* aLine)
|
|
sl@0
|
987 |
{
|
|
sl@0
|
988 |
CIniSectionX* newSection=CIniSectionX::NewLC(aSectionName);
|
|
sl@0
|
989 |
AddSectionL(newSection);
|
|
sl@0
|
990 |
newSection->SetSrcLine(aLine);
|
|
sl@0
|
991 |
CleanupStack::Pop(newSection);
|
|
sl@0
|
992 |
return newSection;
|
|
sl@0
|
993 |
}
|
|
sl@0
|
994 |
|
|
sl@0
|
995 |
template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX,class CIniLineX,class CIniKeyX>
|
|
sl@0
|
996 |
void CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::AddSectionL(const CIniSectionX* aSection)
|
|
sl@0
|
997 |
{
|
|
sl@0
|
998 |
iSectionArray.InsertInOrderL(aSection,TLinearOrder<CIniSectionX>(CIniSectionX::CompareSection));
|
|
sl@0
|
999 |
}
|
|
sl@0
|
1000 |
|
|
sl@0
|
1001 |
template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX,class CIniLineX,class CIniKeyX>
|
|
sl@0
|
1002 |
void CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::RemoveSectionL(const TDesCX& aSectionName)
|
|
sl@0
|
1003 |
{
|
|
sl@0
|
1004 |
CIniSectionX* section = FindSectionL(aSectionName);
|
|
sl@0
|
1005 |
CIniLineX* line = section->SrcLine();
|
|
sl@0
|
1006 |
ASSERT(line); //This should never happen ie. the Key object must have a line associated with it.
|
|
sl@0
|
1007 |
|
|
sl@0
|
1008 |
// remove the lines after to the start of the next section
|
|
sl@0
|
1009 |
TDblQueIter<CIniLineX> iter(iDocument);
|
|
sl@0
|
1010 |
iter.Set(*line); // search after this point for a keyvalue line.
|
|
sl@0
|
1011 |
TBool atStartofSection = ETrue;
|
|
sl@0
|
1012 |
while ((line = iter++) != NULL)
|
|
sl@0
|
1013 |
{
|
|
sl@0
|
1014 |
TLineType typeOfLine = line->LineType();
|
|
sl@0
|
1015 |
if ((typeOfLine == ESection))
|
|
sl@0
|
1016 |
{
|
|
sl@0
|
1017 |
if (!atStartofSection)
|
|
sl@0
|
1018 |
{
|
|
sl@0
|
1019 |
break;
|
|
sl@0
|
1020 |
}
|
|
sl@0
|
1021 |
else
|
|
sl@0
|
1022 |
{
|
|
sl@0
|
1023 |
delete line;
|
|
sl@0
|
1024 |
atStartofSection = EFalse;
|
|
sl@0
|
1025 |
}
|
|
sl@0
|
1026 |
}
|
|
sl@0
|
1027 |
else
|
|
sl@0
|
1028 |
{
|
|
sl@0
|
1029 |
delete line; //includes comment lines which are only in the document object. Otherwise you could just ~section.
|
|
sl@0
|
1030 |
}
|
|
sl@0
|
1031 |
}
|
|
sl@0
|
1032 |
|
|
sl@0
|
1033 |
TInt index=this->iSectionArray.FindInOrderL(section,TLinearOrder<CIniSectionX>(CIniSectionX::CompareSection));
|
|
sl@0
|
1034 |
iSectionArray.Remove(index);
|
|
sl@0
|
1035 |
delete section;
|
|
sl@0
|
1036 |
}
|
|
sl@0
|
1037 |
|
|
sl@0
|
1038 |
template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX,class CIniLineX,class CIniKeyX>
|
|
sl@0
|
1039 |
void CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::SetKeyL(const TDesCX& aSectionName,const TDesCX& aKeyName,const TDesCX& aKeyValue)
|
|
sl@0
|
1040 |
{
|
|
sl@0
|
1041 |
//Find if section exists
|
|
sl@0
|
1042 |
CIniSectionX* section = NULL;
|
|
sl@0
|
1043 |
TRAPD(ret, section = FindSectionL(aSectionName));
|
|
sl@0
|
1044 |
if (ret == KErrNone)
|
|
sl@0
|
1045 |
{
|
|
sl@0
|
1046 |
TRAPD(ret2, RemoveKeyL(aSectionName, aKeyName));
|
|
sl@0
|
1047 |
if ((ret2 != KErrNone) && (ret2 != KErrNotFound))
|
|
sl@0
|
1048 |
{
|
|
sl@0
|
1049 |
User::Leave(ret2);
|
|
sl@0
|
1050 |
}
|
|
sl@0
|
1051 |
|
|
sl@0
|
1052 |
CIniLineX* myLine2 = CIniLineX::NewFromKeyValueLineLC(aKeyName, aKeyValue);
|
|
sl@0
|
1053 |
CIniKeyX* myKey = CIniKeyX::NewLC(myLine2);
|
|
sl@0
|
1054 |
InsertKeyValueIntoQueueL(myLine2, *section);
|
|
sl@0
|
1055 |
|
|
sl@0
|
1056 |
// reserve 1 slot in the key array to provoke the out of memory condition
|
|
sl@0
|
1057 |
// before inserting the key to avoid having to go back and remove the key if OOM occurs.
|
|
sl@0
|
1058 |
section->ReserveSpaceInKeyArrayL();
|
|
sl@0
|
1059 |
section->InsertKeyL(myKey);
|
|
sl@0
|
1060 |
|
|
sl@0
|
1061 |
CleanupStack::Pop(2);
|
|
sl@0
|
1062 |
return;
|
|
sl@0
|
1063 |
}
|
|
sl@0
|
1064 |
if (ret!=KErrNotFound)
|
|
sl@0
|
1065 |
{
|
|
sl@0
|
1066 |
User::Leave(ret);
|
|
sl@0
|
1067 |
}
|
|
sl@0
|
1068 |
|
|
sl@0
|
1069 |
//Fabricate objects upfront and on the cleanup stack to ensure their deletion if OOM conditions occur.
|
|
sl@0
|
1070 |
CIniLineX* myLine = CIniLineX::NewFromSectionNameLC(aSectionName);
|
|
sl@0
|
1071 |
AppendIntoQueue(myLine);
|
|
sl@0
|
1072 |
CIniLineX* myLine3 = CIniLineX::NewFromKeyValueLineLC(aKeyName, aKeyValue);
|
|
sl@0
|
1073 |
AppendIntoQueue(myLine3);
|
|
sl@0
|
1074 |
CIniKeyX* myKey = CIniKeyX::NewLC(myLine3);
|
|
sl@0
|
1075 |
|
|
sl@0
|
1076 |
// reserve 1 slot for the new section name to provoke the out of memory condition
|
|
sl@0
|
1077 |
// before actually inserting the object to avoid having to go back and remove it if it fails.
|
|
sl@0
|
1078 |
this->iSectionArray.ReserveL(1);
|
|
sl@0
|
1079 |
|
|
sl@0
|
1080 |
// If we have not left, we are sure adding a section should not leave due to OOM.
|
|
sl@0
|
1081 |
CIniSectionX* newSection=AddSectionL(aSectionName, myLine);
|
|
sl@0
|
1082 |
|
|
sl@0
|
1083 |
// reserve 1 slot in the key array of the newly created empty section to provoke the out of memory condition
|
|
sl@0
|
1084 |
// before inserting the key to avoid having to go back and remove the key if OOM occurs.
|
|
sl@0
|
1085 |
TRAPD(err, newSection->ReserveSpaceInKeyArrayL());
|
|
sl@0
|
1086 |
if (err == KErrNoMemory)
|
|
sl@0
|
1087 |
{
|
|
sl@0
|
1088 |
// In this case, we have an empty newSection object to be removed.
|
|
sl@0
|
1089 |
TInt index=this->iSectionArray.FindInOrder(newSection,TLinearOrder<CIniSectionX>(CIniSectionX::CompareSection));
|
|
sl@0
|
1090 |
iSectionArray.Remove(index);
|
|
sl@0
|
1091 |
delete newSection;
|
|
sl@0
|
1092 |
CleanupStack::PopAndDestroy(3);
|
|
sl@0
|
1093 |
User::Leave(KErrNoMemory);
|
|
sl@0
|
1094 |
}
|
|
sl@0
|
1095 |
else
|
|
sl@0
|
1096 |
{
|
|
sl@0
|
1097 |
if (err!= KErrNone)
|
|
sl@0
|
1098 |
User::Leave(err);
|
|
sl@0
|
1099 |
}
|
|
sl@0
|
1100 |
|
|
sl@0
|
1101 |
// we are now sure the next inserts will not fail due to OOM.
|
|
sl@0
|
1102 |
newSection->InsertKeyL(myKey);
|
|
sl@0
|
1103 |
CleanupStack::Pop(3);
|
|
sl@0
|
1104 |
}
|
|
sl@0
|
1105 |
|
|
sl@0
|
1106 |
template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX,class CIniLineX,class CIniKeyX>
|
|
sl@0
|
1107 |
void CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::RemoveKeyL(const TDesCX& aSectionName,const TDesCX& aKeyName)
|
|
sl@0
|
1108 |
{
|
|
sl@0
|
1109 |
//Find if section exists
|
|
sl@0
|
1110 |
CIniSectionX* section = FindSectionL(aSectionName);
|
|
sl@0
|
1111 |
section->RemoveKeyL(aKeyName);
|
|
sl@0
|
1112 |
}
|
|
sl@0
|
1113 |
|
|
sl@0
|
1114 |
template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX,class CIniLineX,class CIniKeyX>
|
|
sl@0
|
1115 |
CIniSectionX* CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::FindSectionL(const TDesCX& aSectionName) const
|
|
sl@0
|
1116 |
{
|
|
sl@0
|
1117 |
CIniSectionX* newSection=CIniSectionX::NewLC(aSectionName);
|
|
sl@0
|
1118 |
TInt index=iSectionArray.FindInOrderL(newSection,TLinearOrder<CIniSectionX>(CIniSectionX::CompareSection));
|
|
sl@0
|
1119 |
CleanupStack::PopAndDestroy(newSection);
|
|
sl@0
|
1120 |
return iSectionArray[index];
|
|
sl@0
|
1121 |
}
|
|
sl@0
|
1122 |
|
|
sl@0
|
1123 |
template<class TDesCX,class TPtrCX,class CIniSectionX,class TLexX,class TPtrX,class HBufCX,class CIniLineX,class CIniKeyX>
|
|
sl@0
|
1124 |
CIniDocumentTmplX<TDesCX,TPtrCX,CIniSectionX,TLexX,TPtrX,HBufCX,CIniLineX,CIniKeyX>::~CIniDocumentTmplX()
|
|
sl@0
|
1125 |
{
|
|
sl@0
|
1126 |
CIniLineX* line;
|
|
sl@0
|
1127 |
TDblQueIter<CIniLineX> iter(iDocument);
|
|
sl@0
|
1128 |
|
|
sl@0
|
1129 |
while ((line = iter++) != NULL)
|
|
sl@0
|
1130 |
{
|
|
sl@0
|
1131 |
delete line;
|
|
sl@0
|
1132 |
}
|
|
sl@0
|
1133 |
iSectionArray.ResetAndDestroy();
|
|
sl@0
|
1134 |
}
|
|
sl@0
|
1135 |
|
|
sl@0
|
1136 |
//light weight template class//
|
|
sl@0
|
1137 |
template<class TDesCX,class TPtrCX,class HBufCX,class TLexX,class TPtrX,class TBufX,class CIniLineX>
|
|
sl@0
|
1138 |
NONSHARABLE_CLASS(CIniFileImplX): public CBase
|
|
sl@0
|
1139 |
{
|
|
sl@0
|
1140 |
public:
|
|
sl@0
|
1141 |
CIniFileImplX():iBuffer(NULL) {}
|
|
sl@0
|
1142 |
TInt FindVar(const TDesCX& aSection,const TDesCX& aKey,TPtrCX& aValue);
|
|
sl@0
|
1143 |
void ProcessBufferL(const TDesCX& aPtr);
|
|
sl@0
|
1144 |
~CIniFileImplX()
|
|
sl@0
|
1145 |
{
|
|
sl@0
|
1146 |
delete iBuffer;
|
|
sl@0
|
1147 |
}
|
|
sl@0
|
1148 |
private:
|
|
sl@0
|
1149 |
HBufCX* iBuffer;
|
|
sl@0
|
1150 |
};
|
|
sl@0
|
1151 |
|
|
sl@0
|
1152 |
template<class TDesCX,class TPtrCX,class HBufCX,class TLexX,class TPtrX,class TBufX,class CIniLineX>
|
|
sl@0
|
1153 |
void CIniFileImplX<TDesCX,TPtrCX,HBufCX,TLexX,TPtrX,TBufX,CIniLineX>::ProcessBufferL(const TDesCX& aPtr)
|
|
sl@0
|
1154 |
{
|
|
sl@0
|
1155 |
iBuffer = HBufCX::NewL(aPtr.Length() + sizeof('\n')); //1 for cr.
|
|
sl@0
|
1156 |
TPtrX bufferPtr(iBuffer->Des());
|
|
sl@0
|
1157 |
TLexX lineParser(aPtr);
|
|
sl@0
|
1158 |
while (!lineParser.Eos())
|
|
sl@0
|
1159 |
{
|
|
sl@0
|
1160 |
//Get line by line which is terminated by \n
|
|
sl@0
|
1161 |
lineParser.SkipSpaceAndMark();
|
|
sl@0
|
1162 |
while (!lineParser.Eos() && lineParser.Peek()!='\n')
|
|
sl@0
|
1163 |
{
|
|
sl@0
|
1164 |
lineParser.Inc();
|
|
sl@0
|
1165 |
}
|
|
sl@0
|
1166 |
TPtrCX line=lineParser.MarkedToken();
|
|
sl@0
|
1167 |
//Now append the LHS of the comment to the buffer
|
|
sl@0
|
1168 |
RemoveComment(line);
|
|
sl@0
|
1169 |
|
|
sl@0
|
1170 |
//trim any white space before section,key- value and comments
|
|
sl@0
|
1171 |
TLexX removeWs(line);
|
|
sl@0
|
1172 |
removeWs.SkipSpace();
|
|
sl@0
|
1173 |
if (!removeWs.Eos())
|
|
sl@0
|
1174 |
{
|
|
sl@0
|
1175 |
bufferPtr.Append(line);
|
|
sl@0
|
1176 |
//this added own delimiter is useful for syntax checking
|
|
sl@0
|
1177 |
bufferPtr.Append('\n');
|
|
sl@0
|
1178 |
}
|
|
sl@0
|
1179 |
}
|
|
sl@0
|
1180 |
}
|
|
sl@0
|
1181 |
|
|
sl@0
|
1182 |
template<class TDesCX,class TPtrCX,class HBufCX,class TLexX,class TPtrX,class TBufX,class CIniLineX>
|
|
sl@0
|
1183 |
TInt CIniFileImplX<TDesCX,TPtrCX,HBufCX,TLexX,TPtrX,TBufX,CIniLineX>::FindVar(const TDesCX& aSection,const TDesCX& aKey,TPtrCX& aValue)
|
|
sl@0
|
1184 |
{
|
|
sl@0
|
1185 |
//first find the start of the section [aSectionName]
|
|
sl@0
|
1186 |
//5 here is []\n and the wildcard *\n[sectionname]*
|
|
sl@0
|
1187 |
HBufCX* section=HBufCX::New(aSection.Length()+5);
|
|
sl@0
|
1188 |
if (!section)
|
|
sl@0
|
1189 |
return KErrNoMemory;
|
|
sl@0
|
1190 |
TPtrX sectionPtr(section->Des());
|
|
sl@0
|
1191 |
sectionPtr.Append(_L("*\n["));
|
|
sl@0
|
1192 |
sectionPtr.Append(aSection);
|
|
sl@0
|
1193 |
sectionPtr.Append(_L("]*"));
|
|
sl@0
|
1194 |
|
|
sl@0
|
1195 |
// Find a match purely on the section and not on the value, i.e. checking for a match on
|
|
sl@0
|
1196 |
// [SECTION] does not find a match on key=[SECTION].
|
|
sl@0
|
1197 |
|
|
sl@0
|
1198 |
TBool firstSection=ETrue;
|
|
sl@0
|
1199 |
// Matching on first section is different as it should be the first
|
|
sl@0
|
1200 |
// entry, i.e. no *\n before [aSection]* .
|
|
sl@0
|
1201 |
TInt sectionStart=iBuffer->Match(sectionPtr.Mid(2));
|
|
sl@0
|
1202 |
if (sectionStart==KErrNotFound)
|
|
sl@0
|
1203 |
{
|
|
sl@0
|
1204 |
firstSection=EFalse;
|
|
sl@0
|
1205 |
// Then try to match on any section after the first, i.e. *\n[aSection]* .
|
|
sl@0
|
1206 |
sectionStart=iBuffer->Match(sectionPtr);
|
|
sl@0
|
1207 |
}
|
|
sl@0
|
1208 |
delete section;
|
|
sl@0
|
1209 |
if (sectionStart!=KErrNotFound)
|
|
sl@0
|
1210 |
{
|
|
sl@0
|
1211 |
// There will be always \n added after section, key or value.
|
|
sl@0
|
1212 |
TPtrCX searchBoundary(iBuffer->Mid(sectionStart+aSection.Length()+(firstSection?2:3)));
|
|
sl@0
|
1213 |
searchBoundary.Set(searchBoundary.Mid(searchBoundary.Locate('\n')));
|
|
sl@0
|
1214 |
//now need to locate the start of next section or end of file
|
|
sl@0
|
1215 |
TBufX matchPattern;
|
|
sl@0
|
1216 |
matchPattern.Append(_L("*\n[*]*"));
|
|
sl@0
|
1217 |
TInt endSearchPos=searchBoundary.Match(matchPattern);
|
|
sl@0
|
1218 |
if (endSearchPos!=KErrNotFound)
|
|
sl@0
|
1219 |
{
|
|
sl@0
|
1220 |
//if can find next section block reduce the search boundary
|
|
sl@0
|
1221 |
searchBoundary.Set(searchBoundary.Left(++endSearchPos));
|
|
sl@0
|
1222 |
}
|
|
sl@0
|
1223 |
//now time to find the first exact match key i.e "key" does not match "subkey"
|
|
sl@0
|
1224 |
TInt equalOffset;
|
|
sl@0
|
1225 |
//search through the boundary for matching key
|
|
sl@0
|
1226 |
while ((equalOffset=searchBoundary.Locate('='))!=KErrNotFound)
|
|
sl@0
|
1227 |
{
|
|
sl@0
|
1228 |
//skip over the \n char
|
|
sl@0
|
1229 |
searchBoundary.Set(searchBoundary.Mid(1));
|
|
sl@0
|
1230 |
TLexX keyCheck(searchBoundary.Left(--equalOffset));
|
|
sl@0
|
1231 |
keyCheck.SkipSpaceAndMark();
|
|
sl@0
|
1232 |
keyCheck.SkipCharacters();
|
|
sl@0
|
1233 |
TPtrCX key(keyCheck.MarkedToken());
|
|
sl@0
|
1234 |
keyCheck.SkipSpace();
|
|
sl@0
|
1235 |
if (keyCheck.Eos() && key.Compare(aKey)==0)
|
|
sl@0
|
1236 |
{
|
|
sl@0
|
1237 |
TInt location = searchBoundary.Locate('\n');
|
|
sl@0
|
1238 |
__ASSERT_DEBUG(location >= 0, User::Invariant());
|
|
sl@0
|
1239 |
//trim any white space before and after the value
|
|
sl@0
|
1240 |
TPtrCX rhs(searchBoundary.Mid(equalOffset+1,location-equalOffset-1));
|
|
sl@0
|
1241 |
RemoveWSBeforeAndAfter<TPtrCX,TLexX>(rhs,aValue);
|
|
sl@0
|
1242 |
return KErrNone;
|
|
sl@0
|
1243 |
}
|
|
sl@0
|
1244 |
//update the next search boundary
|
|
sl@0
|
1245 |
searchBoundary.Set(searchBoundary.Mid(searchBoundary.Locate('\n')));
|
|
sl@0
|
1246 |
}
|
|
sl@0
|
1247 |
}
|
|
sl@0
|
1248 |
//cannot find here
|
|
sl@0
|
1249 |
return KErrNotFound;
|
|
sl@0
|
1250 |
}
|
|
sl@0
|
1251 |
|
|
sl@0
|
1252 |
}//namespace BSUL
|
|
sl@0
|
1253 |
#endif//__BAINIPARSERIMPL_H__
|