1 // Copyright (c) 2001-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 //

    15 

    16 #include <delimitedparser8.h>

    17 #include <delimitedparser16.h>

    18 #include "DelimitedParserInternal.h"

    19 #include <uriutilscommon.h>

    20 

    21 // Panic category

    22 //

    23 _LIT(KDelimitedParserPanicCategory,"DELIM-PARSER"); 

    24 

    25 //

    26 //

    27 // Implementation of TDelimitedParserBase8

    28 //

    29 //

    30 

    31 /**

    32 	Constructor.

    33 	

    34 	@since			6.0

    35 */

    36 EXPORT_C TDelimitedParserBase8::TDelimitedParserBase8()

    37 : iDataDes(0,0), iCurrentSegment(0,0), iNextSegmentPos(-1), iMode(EDelimitedDataNotParsed), iDelimiter(0)

    38 	{

    39 	}

    40 

    41 /**

    42 	Resets the internal pointer position to the start or end or the descriptor

    43 	depending on whether the decriptor is parsing mode.

    44 	

    45 	@warning		There will be a KUriUtilsErrBadDelimitedParserMode panic if the data mode has 

    46 	not been correctly set.

    47  */

    48 EXPORT_C void TDelimitedParserBase8::Reset() const

    49 	{

    50 	iNextSegmentPos = InitialDelimiterPosition(iDataDes, iMode);

    51 	}

    52 

    53 /**

    54 	Retrieves the current segment and then parses the data to the next one.

    55 	

    56 	@warning		There will be a KDelimitedParserErrNotParsed panic if the data has 

    57 	not been parsed, and a KDelimitedParserErrNoDelimiter panic if the delimiter has not 

    58 	been set.

    59 	@since			6.0

    60 	@param			aSegment	This is an output argument that is set to the current segment.

    61 	@return			A error value of KErrNotFound if there is no current segment. The 

    62 	value KErrNone if there is a current segment.

    63 	@pre 			The string must have been initially parsed by Parse() or ParseReverse(). 

    64 	@post			The current segment is updated to the next one.

    65 */

    66 EXPORT_C TInt TDelimitedParserBase8::GetNext(TPtrC8& aSegment) const

    67 	{

    68 	__ASSERT_ALWAYS(iMode != EDelimitedDataNotParsed, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNotParsed));

    69 	__ASSERT_ALWAYS(iDelimiter != 0, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNoDelimiter));

    70 

    71 	// Check that there is a segment

    72 	if( iNextSegmentPos == KErrNotFound )

    73 		{

    74 		// There is no segment

    75 		return KErrNotFound;

    76 		}

    77 	// There is one - set aSegment

    78 	aSegment.Set(iCurrentSegment);

    79 	// Parse the next segment

    80 	iNextSegmentPos = FindNextSegment(iNextSegmentPos);

    81 	return KErrNone;

    82 	}

    83 

    84 /**

    85 	Parses to the next segment.

    86 	

    87 	@warning		There will be a KDelimitedParserErrNotParsed panic if the data has 

    88 	not been parsed, and a KDelimitedParserErrNoDelimiter panic if the delimiter has not 

    89 	been set.

    90 	@since			6.0

    91 	@return			A error value of KErrNotFound if there is no current segment. The 

    92 	value KErrNone if there is a current segment.

    93 	@pre 			The string must have been initially parsed by Parse() or ParseReverse(). 

    94 	@post			The current segment is updated to the next one.

    95  */	

    96 EXPORT_C TInt TDelimitedParserBase8::Inc() const

    97 	{

    98 	__ASSERT_ALWAYS(iMode != EDelimitedDataNotParsed, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNotParsed));

    99 	__ASSERT_ALWAYS(iDelimiter != 0, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNoDelimiter));

   100 

   101 	// Check that there is a segment

   102 	if( iNextSegmentPos == KErrNotFound )

   103 		{

   104 		// There is no segment

   105 		return KErrNotFound;

   106 		}

   107 	// Parse the next segment

   108 	iNextSegmentPos = FindNextSegment(iNextSegmentPos);

   109 	return KErrNone;

   110 	}

   111 

   112 /**

   113 	Parses back to the previous segment.

   114 	

   115 	@warning		There will be a KDelimitedParserErrNotParsed panic if the data has 

   116 	not been parsed, and a KDelimitedParserErrNoDelimiter panic if the delimiter has not 

   117 	been set.

   118 	@since			6.0

   119 	@return			A error value of KErrNotFound if the current segment is the initial 

   120 	segment. The value KErrNone if the data has been parsed to the previous segment.

   121 	@pre 			The string must have been initially parsed by Parse() or ParseReverse(). 

   122 	@post			If the parse was successful then the  current segment is updated 

   123 	to the previous one. Otherwise there is no change.

   124 */

   125 EXPORT_C TInt TDelimitedParserBase8::Dec() const

   126 	{

   127 	__ASSERT_ALWAYS(iMode != EDelimitedDataNotParsed, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNotParsed));

   128 	__ASSERT_ALWAYS(iDelimiter != 0, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNoDelimiter));

   129 

   130 	// Find position of previous delimiter 

   131 	TInt prev = PrevDelimiterPosition(iDataDes, iNextSegmentPos, iDelimiter, iMode);

   132 

   133 	// Get the previous segment

   134 	if( FindPrevSegment(prev) == KErrNotFound )

   135 		{

   136 		// There is no previous segment - set to start of data

   137 		return KErrNotFound;

   138 		}

   139 	// Update next segment position

   140 	iNextSegmentPos = prev;

   141 	return KErrNone;

   142 	}

   143 

   144 /**

   145 	Retrieves the current segment.

   146 	

   147 	@warning		There will be a KDelimitedParserErrNotParsed panic if the data has 

   148 	not been parsed, and a KDelimitedParserErrNoDelimiter panic if the delimiter has not 

   149 	been set.

   150 	@since			6.0

   151 	@param			aSegment	This is an output argument that is set to the current segment.

   152 	@return			A error value of KErrNotFound if there is no current segment. The 

   153 	value KErrNone if there is a current segment.

   154 	@pre 			The string must have been initially parsed by Parse() or ParseReverse(). 

   155 */

   156 EXPORT_C TInt TDelimitedParserBase8::Peek(TPtrC8& aSegment) const

   157 	{

   158 	__ASSERT_ALWAYS(iMode != EDelimitedDataNotParsed, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNotParsed));

   159 	__ASSERT_ALWAYS(iDelimiter != 0, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNoDelimiter));

   160 

   161 	// Check that there is a segment

   162 	if( iNextSegmentPos == KErrNotFound )

   163 		{

   164 		// There is no segment

   165 		return KErrNotFound;

   166 		}

   167 	// There is one - set aSegment

   168 	aSegment.Set(iCurrentSegment);

   169 	return KErrNone;

   170 	}

   171 

   172 /**

   173 	Indicates whether the end of the data has been reached and there are no more segments 

   174 	to parse.

   175 	

   176 	@warning		There will be a KDelimitedParserErrNotParsed panic if the data has 

   177 	not been parsed, and a KDelimitedParserErrNoDelimiter panic if the delimiter has not 

   178 	been set.

   179 	@since			6.0

   180 	@return			A boolean value of ETrue if the end of the data has been reached,

   181 	or EFalse if there are more segements to parse.

   182 	@pre 			The string must have been initially parsed by Parse() or ParseReverse(). 

   183 */

   184 EXPORT_C TBool TDelimitedParserBase8::Eos() const

   185 	{

   186 	__ASSERT_ALWAYS(iMode != EDelimitedDataNotParsed, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNotParsed));

   187 

   188 	TBool eos = iNextSegmentPos == KErrNotFound ? ETrue : EFalse;

   189 	return eos;

   190 	}

   191 

   192 /**

   193 	Checks for a delimiter at the front (left) of the data.

   194 	

   195 	@warning		There will be a KDelimitedParserErrNotParsed panic if the data has 

   196 	not been parsed, and a KDelimitedParserErrNoDelimiter panic if the delimiter has not been set.

   197 	@since			6.0

   198 	@return			A boolean of value ETrue if there is a front delimiter, or EFalse 

   199 	if there is no front delimiter.

   200 	@pre 			The string must have been initially parsed by Parse() or ParseReverse(). 

   201 */

   202 EXPORT_C TBool TDelimitedParserBase8::FrontDelimiter() const

   203 	{

   204 	__ASSERT_ALWAYS(iDelimiter != 0, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNoDelimiter));

   205 

   206 	return (iDataDes.Locate(iDelimiter) == 0);

   207 	}

   208 

   209 /**

   210 	Checks for a delimiter at the back (right) of the data.

   211 	

   212 	@warning		There will be a KDelimitedParserErrNotParsed panic if the data has 

   213 	not been parsed, and a KDelimitedParserErrNoDelimiter panic if the delimiter has not 

   214 	been set.

   215 	@since			6.0

   216 	@return			A boolean of value ETrue if there is a back delimiter, or EFalse 

   217 	if there is no back delimiter.

   218 	@pre 			The string must have been initially parsed by Parse() or ParseReverse(). 

   219 */

   220 EXPORT_C TBool TDelimitedParserBase8::BackDelimiter() const

   221 	{

   222 	__ASSERT_ALWAYS(iDelimiter != 0, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNoDelimiter));

   223 

   224 	TInt delimiterPos = iDataDes.LocateReverse(iDelimiter);

   225 	if( delimiterPos == KErrNotFound )

   226 		return EFalse;

   227 	return (delimiterPos == iDataDes.Length() - 1);

   228 	}

   229 

   230 /**

   231 	Retrieves the descriptor reference with the data

   232 	

   233 	@since			6.0

   234 	@return			A const descriptor reference with the data.

   235 */

   236 EXPORT_C const TDesC8& TDelimitedParserBase8::Des() const

   237 	{

   238 	return iDataDes;

   239 	}

   240 

   241 /**

   242 	Gives the remainder of the data from (and including) the current segment. Any other segments 

   243 	that have parsed through are not included.

   244 	

   245 	@warning		There will be a KDelimitedParserErrNotParsed panic if the data has 

   246 	not been parsed, and a KDelimitedParserErrNoDelimiter panic if the delimiter has not 

   247 	been set.

   248 	@since			6.0

   249 	@param			aRemainder	This is an output argument that is set to the remaining data.

   250 	@return			An error value of KErrNotFound if there is no remaining data, or 

   251 	value of KErrNone if there is remaining data.

   252 	@pre 			The data must have been initially parsed by Parse() or ParseReverse().

   253  */

   254 EXPORT_C TInt TDelimitedParserBase8::Remainder(TPtrC8& aRemainder) const

   255 	{

   256 	__ASSERT_ALWAYS(iMode != EDelimitedDataNotParsed, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNotParsed));

   257 	__ASSERT_ALWAYS(iDelimiter != 0, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNoDelimiter));

   258 

   259 	// Check to see if there is a segment left

   260 	if( iNextSegmentPos == KErrNotFound )

   261 		{

   262 		// There is no segment

   263 		return KErrNotFound;

   264 		}

   265 	// Find the previous delimiter -> the start of the current segment

   266 	TInt prev = PrevDelimiterPosition(iDataDes, iNextSegmentPos, iDelimiter, iMode);

   267 

   268 	// Need to see which direction the parsing is going to set the remainder

   269 	switch(iMode)

   270 		{

   271 	case EDelimitedDataForward:

   272 		{

   273 		aRemainder.Set(iDataDes.Right(iDataDes.Length() - prev));

   274 		} break;

   275 	case EDelimitedDataReverse:

   276 		{

   277 		aRemainder.Set(iDataDes.Left(prev));

   278 		} break;

   279 	default:

   280 		// Bad mode!

   281 		User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrBadDelimitedParserMode);

   282 		break;

   283 		}

   284 	return KErrNone;

   285 	}

   286 

   287 /**

   288 	This parses the data into segments from left to right.

   289 

   290 	@warning		There will be a KDelimitedParserErrNoDelimiter panic if the delimiter

   291 	has not been set.

   292 	@since			6.0

   293 	@param			aData	A descriptor containing the data.

   294 	@pre 			The delimiter must have been set.

   295 	@post			The current segment is the leftmost segment and the direction of 

   296 	parsing is set from left to right (EDelimitedDataFroward).

   297  */

   298 EXPORT_C void TDelimitedParserBase8::Parse(const TDesC8& aData)

   299 	{

   300 	__ASSERT_ALWAYS(iDelimiter != 0, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNoDelimiter));

   301 

   302 	// Initialise data for EForward direction

   303 	iMode = EDelimitedDataForward;

   304 	DoParse(aData);

   305 	}

   306 

   307 /**

   308 	This parses the data into segments from lright to left.

   309 

   310 	@warning		There will be a KDelimitedParserErrNoDelimiter panic if the delimiter

   311 	has not been set.

   312 	@since			6.0

   313 	@param			aData	A descriptor containing the data.

   314 	@pre 			The delimiter must have been set.

   315 	@post			The current segment is the leftmost segment and the direction of 

   316 	parsing is set from right to left (EDelimitedDataReverse).

   317  */

   318 EXPORT_C void TDelimitedParserBase8::ParseReverse(const TDesC8& aData)

   319 	{

   320 	__ASSERT_ALWAYS(iDelimiter != 0, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNoDelimiter));

   321 

   322 	// Initialise data for EReverse direction

   323 	iMode = EDelimitedDataReverse;

   324 	DoParse(aData);

   325 	}

   326 

   327 /**

   328 	Sets the delimiting character.

   329 	

   330 	@since			6.0

   331 	@param			aDelimiter	The delimiting character.

   332 	@post			The delimiting character is set.

   333 */

   334 EXPORT_C void TDelimitedParserBase8::SetDelimiter(TChar aDelimiter)

   335 	{

   336 	iDelimiter = aDelimiter;

   337 	}

   338 

   339 /**

   340 	Initialises the parsing of the data.

   341 	

   342 	@since			6.0

   343 	@param			aData	A descriptor reference with the data.

   344 	@pre 			The delimiting character has been set.

   345 	@post			The data descriptor is set to the input argument. The current 

   346 	segment refers to the initial segment of the data.

   347 */

   348 void TDelimitedParserBase8::DoParse(const TDesC8& aData)

   349 	{

   350 	// Reset the segment information, then set the new Data - set pointer to NULL and length to zero

   351 	iCurrentSegment.Set(NULL,0);

   352 	iDataDes.Set(aData);

   353 

   354 	// Check that there is a string!

   355 	if( iDataDes.Length() == 0 )

   356 		{

   357 		// No string - ensure functionality blocked for this descriptor

   358 		iNextSegmentPos = KErrNotFound;

   359 		return;

   360 		}

   361 	// Find the segment - search from initial start position

   362 	iNextSegmentPos = FindNextSegment(InitialDelimiterPosition(iDataDes, iMode));

   363 	}

   364 

   365 /**

   366 	Finds the next segment from the given start position.

   367 	

   368 	@since			6.0

   369 	@param			aStartPos	The position from where to start the search for the

   370 	next segment.

   371 	@return			The position of delimiter after the specified start position, or 

   372 	an error value of KErrNotFound if no more delimiters are found.

   373 */

   374 TInt TDelimitedParserBase8::FindNextSegment(TInt aStartPos) const

   375 	{

   376 	// Find position of next delimiter

   377 	TInt next = NextDelimiterPosition(iDataDes, aStartPos, iDelimiter, iMode);

   378 

   379 	if( next != KErrNotFound )

   380 		{

   381 		TInt startPos = next < aStartPos ? next : aStartPos;

   382 		TInt endPos = next < aStartPos ? aStartPos : next;

   383 		if( iDataDes[startPos] == iDelimiter )

   384 			{

   385 			// Move past delimiter

   386 			++startPos;

   387 			}

   388 		TInt length = endPos - startPos;

   389 		iCurrentSegment.Set(iDataDes.Mid(startPos, length));

   390 		}

   391 	return next;

   392 	}

   393 

   394 /**

   395 	Finds the previous segment from the given start position.

   396 	

   397 	@since			6.0

   398 	@param			aStartPos	The position from where to start the search for the

   399 					previous segment.

   400 	@return			The position of delimiter before the specified start position, or 

   401 	an error value of KErrNotFound if no more delimiters are found.

   402 */

   403 TInt TDelimitedParserBase8::FindPrevSegment(TInt aStartPos) const

   404 	{

   405 	// Find position of previous delimiter 

   406 	TInt prev = PrevDelimiterPosition(iDataDes, aStartPos, iDelimiter, iMode);

   407 	

   408 	if( prev != KErrNotFound )

   409 		{

   410 		TInt startPos = prev < aStartPos ? prev : aStartPos;

   411 		TInt endPos = prev < aStartPos ? aStartPos : prev;

   412 		if( iDataDes[startPos] == iDelimiter )

   413 			{

   414 			// Move past delimiter

   415 			++startPos;

   416 			}

   417 		TInt length = endPos - startPos;

   418 		iCurrentSegment.Set(iDataDes.Mid(startPos, length));

   419 		}

   420 	return prev;

   421 	}

   422 

   423 //

   424 //

   425 // Implementation of CDelimitedDataBase8

   426 //

   427 //

   428 

   429 /**

   430 	Destructor.

   431 	

   432 	@since			6.0

   433 */

   434 EXPORT_C CDelimitedDataBase8::~CDelimitedDataBase8()

   435 	{

   436 	delete iDataBuf;

   437 	}

   438 

   439 /**

   440 	Inserts the new segment in a position before the current parsed	segment. The new 

   441 	segment can be made up of several segments and have delimiters at either extreme. 

   442 	The insert functionality will ensure that there is always a delimiter at the front 

   443 	of the new segment. The parser is left in a state where its current segment is the 

   444 	same one as before the insertion.

   445 	

   446 	@warning		There will be a KDelimitedParserErrNotParsed panic if the data has not been 

   447 	parsed, and a KDelimitedParserErrNoDelimiter panic if the delimiter has not been set.

   448 	@since			6.0

   449 	@param			aSegment	A descriptor with the new segment to be inserted.

   450 	@pre 			The data must have been initially parsed by Parse() or ParseReverse().

   451 	@post			The data will have been extended to include the new segment. The 

   452 	current segment will remain as the one before the insertion.

   453 */

   454 EXPORT_C void CDelimitedDataBase8::InsertCurrentL(const TDesC8& aSegment)

   455 	{

   456 	__ASSERT_ALWAYS(iParser.iMode != EDelimitedDataNotParsed, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNotParsed));

   457 	__ASSERT_ALWAYS(iParser.iDelimiter != 0, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNoDelimiter));

   458 

   459 	DoInsertL(aSegment);

   460 	}

   461 

   462 /**

   463 	Removes the current segment. After removing the segment, the parser's new current segment 

   464 	will be the next segment. If the last segment is the one that is removed then the parser 

   465 	will be set to the end of the data.

   466 	

   467 	@warning		There will be a KDelimitedParserErrNotParsed panic if the data has 

   468 	not been parsed, and a KDelimitedParserErrNoDelimiter panic if the delimiter has not 

   469 	been set.

   470 	@since			6.0

   471 	@pre 			The data must have been initially parsed by Parse() or ParseReverse().

   472 	@post			The data will have been reduced to exclude the removed segment.

   473 	The current segment will be set to what was the next segment. If the removed segment was 

   474 	the last segment, the parser is at the end of the data.

   475 */

   476 EXPORT_C void CDelimitedDataBase8::RemoveCurrentL()

   477 	{

   478 	__ASSERT_ALWAYS(iParser.iMode != EDelimitedDataNotParsed, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNotParsed));

   479 	__ASSERT_ALWAYS(iParser.iDelimiter != 0, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNoDelimiter));

   480 

   481 	DoRemoveL();

   482 	}

   483 

   484 /**

   485 	Adds a new segment to the end of the data. The new segment can be made up of several segments 

   486 	and have  delimiters at either extreme. The insert functionality will ensure that there is 

   487 	always a delimiter at the front of the new segment. The data must re-parsed to ensure that the 

   488 	parser is valid.

   489 						

   490 	@warning		There will be a KDelimitedParserErrNotParsed panic if the data has 

   491 	not been parsed, and a KDelimitedParserErrNoDelimiter panic if the delimiter has not 

   492 	been set. A re-parse is required to ensure that the parser is valid.

   493 	@since			6.0

   494 	@param			aSegment	A descriptor with the new segment to be inserted.

   495 	@pre 			The delimiter must have been set. 

   496 	@post			The data will have been extended to include the new segment.

   497 */

   498 EXPORT_C void CDelimitedDataBase8::PushBackL(const TDesC8& aSegment)

   499 	{

   500 	__ASSERT_ALWAYS(iParser.iDelimiter != 0, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNoDelimiter));

   501 

   502 	// Parse the string in reverse direction - sets last segment as current

   503 	iParser.ParseReverse(*iDataBuf);

   504 

   505 	// Insert the segment

   506 	DoInsertL(aSegment);

   507 

   508 	// Make sure that a re-parse is required

   509 	iParser.iMode = EDelimitedDataNotParsed;

   510 	}

   511 

   512 /**

   513 	Removes the last segment from the data. The data must be re-parsed to ensure that the parser is valid.

   514 						

   515 	@warning		There will be a KDelimitedParserErrNotParsed panic if the data has 

   516 	not been parsed, and a KDelimitedParserErrNoDelimiter panic if the delimiter has not 

   517 	been set. A re-parse is required to ensure that the parser is valid.

   518 	@since			6.0

   519 	@pre 			The delimiter must have been set.

   520 	@post			The data will have been reduced to exclude the last segment. 

   521 */

   522 EXPORT_C void CDelimitedDataBase8::PopBackL()

   523 	{

   524 	__ASSERT_ALWAYS(iParser.iDelimiter != 0, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNoDelimiter));

   525 

   526 	// Parse the string in reverse direction - sets last segment as current

   527 	iParser.ParseReverse(*iDataBuf);

   528 

   529 	// Remove the current segment

   530 	DoRemoveL();

   531 

   532 	// Make sure that a re-parse is required

   533 	iParser.iMode = EDelimitedDataNotParsed;

   534 	}

   535 

   536 /**

   537 	Adds a new segment to the front of the data. The new segment can be made up of several segments 

   538 	and have delimiters at either extreme. The insert functionality will ensure that there is always 

   539 	a delimiter at the front of the new segment. The data must re-parsed to ensure that the parser 

   540 	is valid.

   541 						

   542 	@warning		There will be a KDelimitedParserErrNotParsed panic if the data has 

   543 	not been parsed, and a KDelimitedParserErrNoDelimiter panic if the delimiter has not 

   544 	been set. A re-parse is required to ensure that the parser is valid.					

   545 	@since			6.0

   546 	@param			aSegment	A descriptor with the new segment to be inserted.

   547 	@pre 			The delimiter must have been set. 

   548 	@post			The data will have been extended to include the new segment.

   549 */

   550 EXPORT_C void CDelimitedDataBase8::PushFrontL(const TDesC8& aSegment)

   551 	{

   552 	__ASSERT_ALWAYS(iParser.iDelimiter != 0, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNoDelimiter));

   553 

   554 	// Parse the string in forward direction - sets first segment as current

   555 	iParser.Parse(*iDataBuf);

   556 

   557 	// Insert the segment

   558 	DoInsertL(aSegment);

   559 

   560 	// Make sure that a re-parse is required

   561 	iParser.iMode = EDelimitedDataNotParsed;

   562 	}

   563 

   564 /**

   565 	Removes the first segment from the data. The data must be re-parsed to ensure that the parser is valid.

   566 	

   567 	@warning		There will be a KDelimitedParserErrNotParsed panic if the data has 

   568 	not been parsed, and a KDelimitedParserErrNoDelimiter panic if the delimiter has not 

   569 	been set. A re-parse is required to ensure that the parser is valid.

   570 	@since			6.0

   571 	@pre 			The delimiter must have been set.

   572 	@post			The data will have been reduced to exclude the last segment. 

   573 */

   574 EXPORT_C void CDelimitedDataBase8::PopFrontL()

   575 	{

   576 	__ASSERT_ALWAYS(iParser.iDelimiter != 0, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNoDelimiter));

   577 

   578 	// Parse the string in forward direction - sets first segment as current

   579 	iParser.Parse(*iDataBuf);

   580 

   581 	// Remove the current segment

   582 	DoRemoveL();

   583 

   584 	// Make sure that a re-parse is required

   585 	iParser.iMode = EDelimitedDataNotParsed;

   586 	}

   587 

   588 /**

   589 	Removes the front delimiter (if exists) from the data.

   590 	

   591 	@warning		There will be a KDelimitedParserErrNotParsed panic if the data has 

   592 	not been parsed, and a KDelimitedParserErrNoDelimiter panic if the delimiter has not 

   593 	been set. A re-parse is required to ensure that the parser is valid.

   594 	@since			6.0

   595 	@pre 			The delimiter must have been set.

   596 	@post			The data might have been reduced to exclude the front delimiter. 

   597 */

   598 EXPORT_C void CDelimitedDataBase8::TrimFrontDelimiterL()

   599 	{

   600 	__ASSERT_ALWAYS(iParser.iDelimiter != 0, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNoDelimiter));

   601 

   602 	// Search for delimiter

   603 	if( iParser.FrontDelimiter() )

   604 		{

   605 		// Remove front delimiter and update member data

   606 		SetDataL(iParser.iDataDes.Right(iParser.iDataDes.Length() - 1));

   607 		}

   608 	// Make sure that a re-parse is required

   609 	iParser.iMode = EDelimitedDataNotParsed;

   610 	}

   611 

   612 /**

   613 	Adds a delimiter to the front of the data (if it doesn't exist).

   614 	

   615 	@warning		There will be a KDelimitedParserErrNotParsed panic if the data has 

   616 	not been parsed, and a KDelimitedParserErrNoDelimiter panic if the delimiter has not 

   617 	been set. A re-parse is required to ensure that the parser is valid.

   618 	@since			6.0

   619 	@pre 			The delimiter must have been set.

   620 	@post			The data might have been extended to include a front delimiter. 

   621 */

   622 EXPORT_C void CDelimitedDataBase8::AddFrontDelimiterL()

   623 	{

   624 	__ASSERT_ALWAYS(iParser.iDelimiter != 0, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNoDelimiter));

   625 

   626 	if( !iParser.FrontDelimiter() )

   627 		{

   628 		// Create a new buffer of correct size

   629 		HBufC8* buf = HBufC8::NewL(iParser.iDataDes.Length() + 1);

   630 		TPtr8 str = buf->Des();

   631 

   632 		// Append a delimiter, then append the current string

   633 		str.Append(iParser.iDelimiter);

   634 		str.Append(iParser.iDataDes);

   635 

   636 		// Set buffer to this new string

   637 		SetData(buf);

   638 		}

   639 	// Make sure that a re-parse is required

   640 	iParser.iMode = EDelimitedDataNotParsed;

   641 	}

   642 

   643 /**

   644 	Removes the back delimiter (if exists) from the data.

   645 	

   646 	@warning		There will be a KDelimitedParserErrNotParsed panic if the data has 

   647 	not been parsed, and a KDelimitedParserErrNoDelimiter panic if the delimiter has not 

   648 	been set. A re-parse is required to ensure that the parser is valid.

   649 	@since			6.0

   650 	@pre 			The delimiter must have been set.

   651 	@post			The data might have been reduced to exclude the front delimiter. 

   652 */

   653 EXPORT_C void CDelimitedDataBase8::TrimBackDelimiterL()

   654 	{

   655 	__ASSERT_ALWAYS(iParser.iDelimiter != 0, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNoDelimiter));

   656 

   657 	// Search for delimiter

   658 	if( iParser.BackDelimiter() )

   659 		{

   660 		// Remove back delimiter and update member data

   661 		SetDataL(iParser.iDataDes.Left(iParser.iDataDes.Length() - 1));

   662 		}

   663 	// Make sure that a re-parse is required

   664 	iParser.iMode = EDelimitedDataNotParsed;

   665 	}

   666 

   667 /**

   668 	Adds a delimiter to the back of the data (if it doesn't exist).

   669 	

   670 	@warning		There will be a KDelimitedParserErrNotParsed panic if the data has 

   671 	not been parsed, and a KDelimitedParserErrNoDelimiter panic if the delimiter has not 

   672 	been set. A re-parse is required to ensure that the parser is valid.

   673 	@since			6.0

   674 	@pre 			The delimiter must have been set.

   675 	@post			The data might have been extended to include a front delimiter. 

   676 */

   677 EXPORT_C void CDelimitedDataBase8::AddBackDelimiterL()

   678 	{

   679 	__ASSERT_ALWAYS(iParser.iDelimiter != 0, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNoDelimiter));

   680 

   681 	if( !iParser.BackDelimiter() )

   682 		{

   683 		// Create a new buffer of correct size

   684 		HBufC8* buf = HBufC8::NewL(iParser.iDataDes.Length() + 1);

   685 		TPtr8 str = buf->Des();

   686 

   687 		// Append the current string, then append a delimiter

   688 		str.Append(iParser.iDataDes);

   689 		str.Append(iParser.iDelimiter);

   690 

   691 		// Set buffer to this new string

   692 		SetData(buf);

   693 		}

   694 	// Make sure that a re-parse is required

   695 	iParser.iMode = EDelimitedDataNotParsed;

   696 	}

   697 

   698 /**

   699 	This parses the data into segments from left to right.

   700 	

   701 	@warning		There will be a KDelimitedParserErrNoDelimiter panic if the delimiter

   702 	has not been set.

   703 	@since			6.0

   704 	@pre 			The delimiter must have been set.

   705 	@post			The current segment is the leftmost segment and the direction of 

   706 	parsing is set from left to right (EDelimitedDataFroward).

   707 */

   708 EXPORT_C void CDelimitedDataBase8::Parse()

   709 	{

   710 	// This call will panic with KUriUtilsErrNoDelimiter if the delimiter is not set

   711 	iParser.Parse(*iDataBuf);

   712 	}

   713 

   714 /**

   715 	This parses the string into segments from right to left.

   716 	

   717 	@since			6.0

   718 	@pre 			The delimiter must have been set. Will get a KDelimitedParserErrNoDelimiter panic if 

   719 	the delimiter has not been initialized.

   720 	@post			The current segment is the leftmost segment and the direction of parsing is right to left.

   721 */

   722 EXPORT_C void CDelimitedDataBase8::ParseReverse()

   723 	{

   724 	// This call will panic with KUriUtilsErrNoDelimiter if the delimiter is not set

   725 	iParser.ParseReverse(*iDataBuf);

   726 	}

   727 

   728 /**

   729 	Retrieves a const reference to the delimited data parser. 

   730 	

   731 	@since			6.0

   732 	@return			A const reference to the delimited data parser. 

   733 */

   734 EXPORT_C const TDelimitedParserBase8& CDelimitedDataBase8::Parser() const

   735 	{

   736 	return iParser;

   737 	}

   738 

   739 /**

   740 	Sets the delimiting character.

   741 	

   742 	@since			6.0

   743 	@param			aDelimiter	The delimiting character.

   744 	@post			The delimiting character is updated.

   745 */

   746 EXPORT_C void CDelimitedDataBase8::SetDelimiter(TChar aDelimiter)

   747 	{

   748 	iParser.SetDelimiter(aDelimiter);

   749 	}

   750 

   751 /**

   752 	Constructor. First phase of two-phase construction method. Does non-allocating construction.

   753 						

   754 	@since			6.0

   755 */

   756 EXPORT_C CDelimitedDataBase8::CDelimitedDataBase8()

   757 	{

   758 	}

   759 

   760 /**

   761 	Second phase of two-phase construction method. Does any allocations required to fully construct 

   762 	the object.

   763 						

   764 	@since			6.0

   765 	@param			aData	A descriptor with the initial string.

   766 	@pre 			First phase of construction is complete.

   767 	@post			The object is fully constructed.

   768 */

   769 EXPORT_C void CDelimitedDataBase8::ConstructL(const TDesC8& aData)

   770 	{

   771 	// Create copy of string and set descriptor in the parser

   772 	SetDataL(aData);

   773 	}

   774 

   775 /**

   776 	Inserts the new segment in a position before the current segment. The new segment can be made up 

   777 	of several segments and have delimiters at either extreme. The insert functionality will ensure 

   778 	that there is always a delimiter at the front of the new segment. The parser will be left in a 

   779 	state where its current segment is the same one as before the insertion.

   780 						

   781 	@since			6.0

   782 	@param			aSegment	The descriptor with the segment to be inserted.

   783 	@pre 			The string must have been parsed.

   784 	@post			The string will have been extended to include the new segment. The current segment will

   785 	remain as the one before the insertion.

   786 */

   787 void CDelimitedDataBase8::DoInsertL(const TDesC8& aSegment)

   788 	{

   789 	// Get previous delimiter to split the current string into prefix and suffix to the new segment

   790 	TInt prevPos = PrevDelimiterPosition(iParser.iDataDes, iParser.iNextSegmentPos, iParser.iDelimiter, iParser.iMode);

   791 	TPtrC8 prefix = iParser.iDataDes.Left(prevPos);

   792 

   793 	TInt suffixLength = iParser.iDataDes.Length() - prevPos;

   794 	TPtrC8 suffix = iParser.iDataDes.Right(suffixLength);

   795 	if( suffixLength && suffix[0] == iParser.iDelimiter )

   796 		{

   797 		// Remove front delimiter on suffix

   798 		suffix.Set(suffix.Right(--suffixLength));

   799 		}	

   800 

   801 	// Check for delimiters

   802 	TPtrC8 segment = aSegment;

   803 	TInt segmentLength = segment.Length();

   804 	TBool segmentBackDelimiter = (segmentLength && segment[segmentLength - 1] == iParser.iDelimiter);

   805 	if( segmentBackDelimiter )

   806 		{

   807 		// Remove back delimiter from the segment

   808 		segment.Set(segment.Left(--segmentLength));

   809 		}

   810 	if( segmentLength && segment[0] == iParser.iDelimiter )

   811 		{

   812 		// Remove front delimiter from the segment

   813 		segment.Set(segment.Right(--segmentLength));

   814 		}

   815 

   816 	// Check if a back delimiter is needed - NOTE always add a front delimiter

   817 	TInt extra = 1;

   818 	TBool needBackDelimiter = EFalse;

   819 	if( suffix.Length() || segmentBackDelimiter )

   820 		{

   821 		++extra;

   822 		needBackDelimiter = ETrue;

   823 		}

   824 	// Create space for new string

   825 	HBufC8* buf = HBufC8::NewL(prevPos + segmentLength + suffixLength + extra);

   826 	TPtr8 str = buf->Des();

   827 

   828 	// Form the new string

   829 	str.Append(prefix);

   830 	str.Append(iParser.iDelimiter);

   831 	str.Append(segment);

   832 	if( needBackDelimiter )

   833 		str.Append(iParser.iDelimiter);

   834 	str.Append(suffix);

   835 

   836 	// Update string data

   837 	SetData(buf);

   838 

   839 	// Check to see if the internal parser object (iParser) has been parsed

   840 	// (can tell if it has if the data pointer in iCurrentSegment is not NULL)

   841 	// If so update iCurrentSegment to ensure that iParser remains valid

   842 	if( iParser.iCurrentSegment.Ptr() )

   843 		{

   844 		// Ensure parser is in correct position and current segment is correct

   845 		iParser.iNextSegmentPos = prevPos;

   846 		if( iParser.iMode == EDelimitedDataForward )

   847 			{

   848 			// Move iterator to delimiter before iCurrentSegment - length of segment + a delimiter

   849 			iParser.iNextSegmentPos += segmentLength + 1;

   850 			}

   851 		// Get the next segment

   852 		iParser.iNextSegmentPos = iParser.FindNextSegment(iParser.iNextSegmentPos);

   853 		}

   854 	}

   855 

   856 /**

   857 	Removes the current segment. After removing the segment, the parser's new current segment will be 

   858 	the next segment. If the last segment is the one that is removed then the parser will be set to the 

   859 	end of the data.

   860 						

   861 	@since			6.0

   862 	@pre 			The data must have been parsed.

   863 	@post			The data will have been reduced to exclude the removed data. The 

   864 	current segment is set to what was the next segment. If the removed segment was 

   865 	the last segment, the parser is at the end of the data.

   866 */

   867 void CDelimitedDataBase8::DoRemoveL()

   868 	{

   869 	// Check if there is anything to remove

   870 	if( iParser.iDataDes.Length() == 0 )

   871 		{

   872 		return;

   873 		}

   874 	// Find the previous delimiter

   875 	TInt prev = PrevDelimiterPosition(iParser.iDataDes, iParser.iNextSegmentPos, iParser.iDelimiter, iParser.iMode);

   876 

   877 	// Set up the start and end position of current segment

   878 	TInt endPos = iParser.iNextSegmentPos;

   879 	TInt startPos = iParser.iNextSegmentPos;

   880 	if( prev < iParser.iNextSegmentPos )

   881 		startPos = prev;

   882 	else

   883 		endPos = prev;

   884 

   885 	// Ok, get the prefix and suffix parts

   886 	TPtrC8 prefix = iParser.iDataDes.Left(startPos);

   887 	TInt suffixLength = iParser.iDataDes.Length() - endPos;

   888 	TPtrC8 suffix = iParser.iDataDes.Right(suffixLength);

   889 

   890 	// Create the space

   891 	HBufC8* buf = HBufC8::NewL(startPos + suffixLength);

   892 	TPtr8 str = buf->Des();

   893 

   894 	// Form the new string

   895 	str.Append(prefix);

   896 	str.Append(suffix);

   897 

   898 	// Update string data

   899 	SetData(buf);

   900 

   901 	// Ensure parser is in correct position

   902 	iParser.iNextSegmentPos = iParser.FindNextSegment(startPos);

   903 	}

   904 

   905 /**

   906 	Updates internal data buffer with the new data. Creates a copy of the new data.

   907 						

   908 	@since			6.0

   909 	@param			aData	A descriptor with the new string.

   910 	@post			The internal data buffer now contains a copy of the new data and the 

   911 	parser is set to the new data.

   912 */

   913 void CDelimitedDataBase8::SetDataL(const TDesC8& aData)

   914     {

   915 	// Cleanup old data and set new

   916 	HBufC8* buf =  aData.AllocL();

   917 	SetData(buf);

   918 	}

   919 

   920 /**

   921 	Sets internal data buffer and parser. Cleans up the old data and uses the data buffer. 

   922 	The parser is set to the new data.						

   923 	

   924 	@since			6.0

   925 	@param			aDataBuf	A pointer to a decriptor buffer with the new data.

   926 	@post			The internal data buffer now points to the new buffer and the parser 

   927 	is set to the data in the new buffer..

   928 */

   929 void CDelimitedDataBase8::SetData(HBufC8* aDataBuf)

   930 	{

   931 	delete iDataBuf;

   932 	iDataBuf = aDataBuf;

   933 	iParser.iDataDes.Set(*iDataBuf);

   934 	}

   935 

   936 //

   937 //

   938 // Implementation of TDelimitedParserBase16

   939 //

   940 //

   941 /**

   942 	Constructor.

   943 	

   944 	@since			6.0

   945  */

   946 EXPORT_C TDelimitedParserBase16::TDelimitedParserBase16()

   947 : iDataDes(0,0), iCurrentSegment(0,0), iNextSegmentPos(-1), iMode(EDelimitedDataNotParsed), iDelimiter(0)

   948 	{

   949 	}

   950 

   951 /**

   952 	Resets the internal pointer position to the start or end or the descriptor depending 

   953 	on whether the decriptor is parsing mode.

   954 	

   955 	@warning		There will be a KUriUtilsErrBadDelimitedParserMode panic if the data mode has 

   956 	not been correctly set.

   957  */

   958 EXPORT_C void TDelimitedParserBase16::Reset() const

   959 	{

   960 	__ASSERT_ALWAYS(iMode != EDelimitedDataNotParsed, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNotParsed));

   961 	__ASSERT_ALWAYS(iDelimiter != 0, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNoDelimiter));

   962 

   963 	iNextSegmentPos = InitialDelimiterPosition(iDataDes, iMode);

   964 	}

   965 /**

   966 	Retrieves the current segment and then parses the data to the next one.

   967 						

   968 	@warning		There will be a KDelimitedParserErrNotParsed panic if the data has not 

   969 	been parsed, and a KDelimitedParserErrNoDelimiter panic if the delimiter has not been set.

   970 	@since			6.0

   971 	@param			aSegment	This is an output argument that is set to the current segment.

   972 	@return			A error value of KErrNotFound if there is no current segment. The

   973 	value KErrNone if there is a current segment.

   974 	@pre 			The string must have been initially parsed by Parse() or ParseReverse().

   975 	@post			The current segment is updated to the next one.

   976  */

   977 EXPORT_C TInt TDelimitedParserBase16::GetNext(TPtrC16& aSegment) const

   978 	{

   979 	__ASSERT_ALWAYS(iMode != EDelimitedDataNotParsed, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNotParsed));

   980 	__ASSERT_ALWAYS(iDelimiter != 0, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNoDelimiter));

   981 

   982 	// Check that there is a segment

   983 	if( iNextSegmentPos == KErrNotFound )

   984 		{

   985 		// There is no segment

   986 		return KErrNotFound;

   987 		}

   988 	// There is one - set aSegment

   989 	aSegment.Set(iCurrentSegment);

   990 	// Parse the next segment

   991 	iNextSegmentPos = FindNextSegment(iNextSegmentPos);

   992 	return KErrNone;

   993 	}

   994 	

   995 /**

   996 	Parses to the next segment.

   997 	

   998 	@warning		There will be a KDelimitedParserErrNotParsed panic if the data has not 

   999 	been parsed, and a KDelimitedParserErrNoDelimiter panic if the delimiter has not been set.

  1000 	@since			6.0

  1001 	@return			A error value of KErrNotFound if there is no current segment. The

  1002 	value KErrNone if there is a current segment.

  1003 	@pre 			The string must have been initially parsed by Parse() or ParseReverse().

  1004 	@post			The current segment is updated to the next one.

  1005  */

  1006 EXPORT_C TInt TDelimitedParserBase16::Inc() const

  1007 	{

  1008 	__ASSERT_ALWAYS(iMode != EDelimitedDataNotParsed, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNotParsed));

  1009 	__ASSERT_ALWAYS(iDelimiter != 0, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNoDelimiter));

  1010 

  1011 	// Check that there is a segment

  1012 	if( iNextSegmentPos == KErrNotFound )

  1013 		{

  1014 		// There is no segment

  1015 		return KErrNotFound;

  1016 		}

  1017 	// Parse the next segment

  1018 	iNextSegmentPos = FindNextSegment(iNextSegmentPos);

  1019 	return KErrNone;

  1020 	}

  1021 	

  1022 /**

  1023 	Parses back to the previous segment.

  1024 	

  1025 	@warning		There will be a KDelimitedParserErrNotParsed panic if the data has not 

  1026 	been parsed, and a KDelimitedParserErrNoDelimiter panic if the delimiter has not been set.

  1027 	@since			6.0

  1028 	@return			A error value of KErrNotFound if the current segment is the initial

  1029 	segment. The value KErrNone if the data has been parsed to the previous segment.

  1030 	@pre 			The string must have been initially parsed by Parse() or ParseReverse().

  1031 	@post			If the parse was successful then the  current segment is updated

  1032 	to the previous one. Otherwise there is no change.

  1033  */

  1034 EXPORT_C TInt TDelimitedParserBase16::Dec() const

  1035 	{

  1036 	__ASSERT_ALWAYS(iMode != EDelimitedDataNotParsed, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNotParsed));

  1037 	__ASSERT_ALWAYS(iDelimiter != 0, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNoDelimiter));

  1038 

  1039 	// Find position of previous delimiter 

  1040 	TInt prev = PrevDelimiterPosition(iDataDes, iNextSegmentPos, iDelimiter, iMode);

  1041 

  1042 	// Get the previous segment

  1043 	if( FindPrevSegment(prev) == KErrNotFound )

  1044 		{

  1045 		// There is no previous segment - set to start of data

  1046 		return KErrNotFound;

  1047 		}

  1048 	// Update next segment position

  1049 	iNextSegmentPos = prev;

  1050 	return KErrNone;

  1051 	}

  1052 

  1053 /**

  1054 	Retrieves the current segment.

  1055 	

  1056 	@warning		There will be a KDelimitedParserErrNotParsed panic if the data has not 

  1057 	been parsed, and a KDelimitedParserErrNoDelimiter panic if the delimiter has not been set.

  1058 	@since			6.0

  1059 	@param			aSegment	This is an output argument that is set to the current segment.

  1060 	@return			A error value of KErrNotFound if there is no current segment. The

  1061 					value KErrNone if there is a current segment.

  1062 	@pre 			The string must have been initially parsed by Parse() or ParseReverse().

  1063  */

  1064 EXPORT_C TInt TDelimitedParserBase16::Peek(TPtrC16& aSegment) const

  1065 	{

  1066 	__ASSERT_ALWAYS(iMode != EDelimitedDataNotParsed, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNotParsed));

  1067 	__ASSERT_ALWAYS(iDelimiter != 0, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNoDelimiter));

  1068 

  1069 	// Check that there is a segment

  1070 	if( iNextSegmentPos == KErrNotFound )

  1071 		{

  1072 		// There is no segment

  1073 		return KErrNotFound;

  1074 		}

  1075 	// There is one - set aSegment

  1076 	aSegment.Set(iCurrentSegment);

  1077 	return KErrNone;

  1078 	}

  1079 	

  1080 /**

  1081 	Indicates whether the end of the data has been reached and there are no more segments to parse.

  1082 						

  1083 	@warning		There will be a KDelimitedParserErrNotParsed panic if the data has not 

  1084 	been parsed, and a KDelimitedParserErrNoDelimiter panic if the delimiter has not been set.

  1085 	@since			6.0

  1086 	@return			A boolean value of ETrue if the end of the data has been reached,

  1087 	or EFalse if there are more segements to parse.

  1088 	@pre 			The string must have been initially parsed by Parse() or ParseReverse().

  1089  */

  1090 EXPORT_C TBool TDelimitedParserBase16::Eos() const

  1091 	{

  1092 	__ASSERT_ALWAYS(iMode != EDelimitedDataNotParsed, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNotParsed));

  1093 

  1094 	TBool eos = iNextSegmentPos == KErrNotFound ? ETrue : EFalse;

  1095 	return eos;

  1096 	}

  1097 	

  1098 /**

  1099 	Checks for a delimiter at the front (left) of the data.

  1100 	

  1101 	@warning		There will be a KDelimitedParserErrNotParsed panic if the data has not 

  1102 	been parsed, and a KDelimitedParserErrNoDelimiter panic if the delimiter has not been set.

  1103 	@since			6.0

  1104 	@return			A boolean of value ETrue if there is a front delimiter, or EFalse

  1105 	if there is no front delimiter.

  1106 	@pre 			The string must have been initially parsed by Parse() or ParseReverse().

  1107  */

  1108 EXPORT_C TBool TDelimitedParserBase16::FrontDelimiter() const

  1109 	{

  1110 	__ASSERT_ALWAYS(iDelimiter != 0, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNoDelimiter));

  1111 

  1112 	return (iDataDes.Locate(iDelimiter) == 0);

  1113 	}

  1114 

  1115 /**

  1116 	Checks for a delimiter at the back (right) of the data.

  1117 	

  1118 	@warning		There will be a KDelimitedParserErrNotParsed panic if the data has not 

  1119 	been parsed, and a KDelimitedParserErrNoDelimiter panic if the delimiter has not been set.

  1120 	@since			6.0

  1121 	@return			A boolean of value ETrue if there is a back delimiter, or EFalse

  1122 	if there is no back delimiter.

  1123 	@pre 			The string must have been initially parsed by Parse() or ParseReverse().

  1124  */

  1125 EXPORT_C TBool TDelimitedParserBase16::BackDelimiter() const

  1126 	{

  1127 	__ASSERT_ALWAYS(iDelimiter != 0, User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrNoDelimiter));

  1128 

  1129 	TInt delimiterPos = iDataDes.LocateReverse(iDelimiter);

  1130 	if( delimiterPos == KErrNotFound )

  1131 		return EFalse;

  1132 	return (delimiterPos == iDataDes.Length() - 1);

  1133 	}

  1134 	

  1135 /**