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

 // All rights reserved.

 // This component and the accompanying materials are made available

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

 // which accompanies this distribution, and is available

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

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 //

 #include <delimitedparser8.h>

 #include <delimitedparser16.h>

 #include "DelimitedParserInternal.h"

 #include <uriutilscommon.h>

 // Panic category

 //

 _LIT(KDelimitedParserPanicCategory,"DELIM-PARSER"); 

 //

 //

 // Implementation of TDelimitedParserBase8

 //

 //

 /**

 	Constructor.

 	@since			6.0

 */

 EXPORT_C TDelimitedParserBase8::TDelimitedParserBase8()

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

 	{

 	}

 /**

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

 	depending on whether the decriptor is parsing mode.

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

 	not been correctly set.

  */

 EXPORT_C void TDelimitedParserBase8::Reset() const

 	{

 	iNextSegmentPos = InitialDelimiterPosition(iDataDes, iMode);

 	}

 /**

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

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

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

 	been set.

 	@since			6.0

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

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

 	value KErrNone if there is a current segment.

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

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

 */

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

 	{

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

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

 	// Check that there is a segment

 	if( iNextSegmentPos == KErrNotFound )

 		{

 		// There is no segment

 		return KErrNotFound;

 		}

 	// There is one - set aSegment

 	aSegment.Set(iCurrentSegment);

 	// Parse the next segment

 	iNextSegmentPos = FindNextSegment(iNextSegmentPos);

 	return KErrNone;

 	}

 /**

 	Parses to the next segment.

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

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

 	been set.

 	@since			6.0

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

 	value KErrNone if there is a current segment.

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

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

  */	

 EXPORT_C TInt TDelimitedParserBase8::Inc() const

 	{

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

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

 	// Check that there is a segment

 	if( iNextSegmentPos == KErrNotFound )

 		{

 		// There is no segment

 		return KErrNotFound;

 		}

 	// Parse the next segment

 	iNextSegmentPos = FindNextSegment(iNextSegmentPos);

 	return KErrNone;

 	}

 /**

 	Parses back to the previous segment.

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

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

 	been set.

 	@since			6.0

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

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

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

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

 	to the previous one. Otherwise there is no change.

 */

 EXPORT_C TInt TDelimitedParserBase8::Dec() const

 	{

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

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

 	// Find position of previous delimiter 

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

 	// Get the previous segment

 	if( FindPrevSegment(prev) == KErrNotFound )

 		{

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

 		return KErrNotFound;

 		}

 	// Update next segment position

 	iNextSegmentPos = prev;

 	return KErrNone;

 	}

 /**

 	Retrieves the current segment.

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

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

 	been set.

 	@since			6.0

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

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

 	value KErrNone if there is a current segment.

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

 */

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

 	{

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

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

 	// Check that there is a segment

 	if( iNextSegmentPos == KErrNotFound )

 		{

 		// There is no segment

 		return KErrNotFound;

 		}

 	// There is one - set aSegment

 	aSegment.Set(iCurrentSegment);

 	return KErrNone;

 	}

 /**

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

 	to parse.

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

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

 	been set.

 	@since			6.0

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

 	or EFalse if there are more segements to parse.

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

 */

 EXPORT_C TBool TDelimitedParserBase8::Eos() const

 	{

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

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

 	return eos;

 	}

 /**

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

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

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

 	@since			6.0

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

 	if there is no front delimiter.

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

 */

 EXPORT_C TBool TDelimitedParserBase8::FrontDelimiter() const

 	{

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

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

 	}

 /**

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

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

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

 	been set.

 	@since			6.0

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

 	if there is no back delimiter.

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

 */

 EXPORT_C TBool TDelimitedParserBase8::BackDelimiter() const

 	{

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

 	TInt delimiterPos = iDataDes.LocateReverse(iDelimiter);

 	if( delimiterPos == KErrNotFound )

 		return EFalse;

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

 	}

 /**

 	Retrieves the descriptor reference with the data

 	@since			6.0

 	@return			A const descriptor reference with the data.

 */

 EXPORT_C const TDesC8& TDelimitedParserBase8::Des() const

 	{

 	return iDataDes;

 	}

 /**

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

 	that have parsed through are not included.

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

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

 	been set.

 	@since			6.0

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

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

 	value of KErrNone if there is remaining data.

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

  */

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

 	{

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

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

 	// Check to see if there is a segment left

 	if( iNextSegmentPos == KErrNotFound )

 		{

 		// There is no segment

 		return KErrNotFound;

 		}

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

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

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

 	switch(iMode)

 		{

 	case EDelimitedDataForward:

 		{

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

 		} break;

 	case EDelimitedDataReverse:

 		{

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

 		} break;

 	default:

 		// Bad mode!

 		User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrBadDelimitedParserMode);

 		break;

 		}

 	return KErrNone;

 	}

 /**

 	This parses the data into segments from left to right.

 	@warning		There will be a KDelimitedParserErrNoDelimiter panic if the delimiter

 	has not been set.

 	@since			6.0

 	@param			aData	A descriptor containing the data.

 	@pre 			The delimiter must have been set.

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

 	parsing is set from left to right (EDelimitedDataFroward).

  */

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

 	{

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

 	// Initialise data for EForward direction

 	iMode = EDelimitedDataForward;

 	DoParse(aData);

 	}

 /**

 	This parses the data into segments from lright to left.

 	@warning		There will be a KDelimitedParserErrNoDelimiter panic if the delimiter

 	has not been set.

 	@since			6.0

 	@param			aData	A descriptor containing the data.

 	@pre 			The delimiter must have been set.

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

 	parsing is set from right to left (EDelimitedDataReverse).

  */

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

 	{

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

 	// Initialise data for EReverse direction

 	iMode = EDelimitedDataReverse;

 	DoParse(aData);

 	}

 /**

 	Sets the delimiting character.

 	@since			6.0

 	@param			aDelimiter	The delimiting character.

 	@post			The delimiting character is set.

 */

 EXPORT_C void TDelimitedParserBase8::SetDelimiter(TChar aDelimiter)

 	{

 	iDelimiter = aDelimiter;

 	}

 /**

 	Initialises the parsing of the data.

 	@since			6.0

 	@param			aData	A descriptor reference with the data.

 	@pre 			The delimiting character has been set.

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

 	segment refers to the initial segment of the data.

 */

 void TDelimitedParserBase8::DoParse(const TDesC8& aData)

 	{

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

 	iCurrentSegment.Set(NULL,0);

 	iDataDes.Set(aData);

 	// Check that there is a string!

 	if( iDataDes.Length() == 0 )

 		{

 		// No string - ensure functionality blocked for this descriptor

 		iNextSegmentPos = KErrNotFound;

 		return;

 		}

 	// Find the segment - search from initial start position

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

 	}

 /**

 	Finds the next segment from the given start position.

 	@since			6.0

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

 	next segment.

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

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

 */

 TInt TDelimitedParserBase8::FindNextSegment(TInt aStartPos) const

 	{

 	// Find position of next delimiter

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

 	if( next != KErrNotFound )

 		{

 		TInt startPos = next < aStartPos ? next : aStartPos;

 		TInt endPos = next < aStartPos ? aStartPos : next;

 		if( iDataDes[startPos] == iDelimiter )

 			{

 			// Move past delimiter

 			++startPos;

 			}

 		TInt length = endPos - startPos;

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

 		}

 	return next;

 	}

 /**

 	Finds the previous segment from the given start position.

 	@since			6.0

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

 					previous segment.

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

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

 */

 TInt TDelimitedParserBase8::FindPrevSegment(TInt aStartPos) const

 	{

 	// Find position of previous delimiter 

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

 	if( prev != KErrNotFound )

 		{

 		TInt startPos = prev < aStartPos ? prev : aStartPos;

 		TInt endPos = prev < aStartPos ? aStartPos : prev;

 		if( iDataDes[startPos] == iDelimiter )

 			{

 			// Move past delimiter

 			++startPos;

 			}

 		TInt length = endPos - startPos;

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

 		}

 	return prev;

 	}

 //

 //

 // Implementation of CDelimitedDataBase8

 //

 //

 /**

 	Destructor.

 	@since			6.0

 */

 EXPORT_C CDelimitedDataBase8::~CDelimitedDataBase8()

 	{

 	delete iDataBuf;

 	}

 /**

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

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

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

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

 	same one as before the insertion.

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

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

 	@since			6.0

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

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

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

 	current segment will remain as the one before the insertion.

 */

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

 	{

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

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

 	DoInsertL(aSegment);

 	}

 /**

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

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

 	will be set to the end of the data.

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

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

 	been set.

 	@since			6.0

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

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

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

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

 */

 EXPORT_C void CDelimitedDataBase8::RemoveCurrentL()

 	{

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

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

 	DoRemoveL();

 	}

 /**

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

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

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

 	parser is valid.

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

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

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

 	@since			6.0

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

 	@pre 			The delimiter must have been set. 

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

 */

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

 	{

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

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

 	iParser.ParseReverse(*iDataBuf);

 	// Insert the segment

 	DoInsertL(aSegment);

 	// Make sure that a re-parse is required

 	iParser.iMode = EDelimitedDataNotParsed;

 	}

 /**

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

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

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

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

 	@since			6.0

 	@pre 			The delimiter must have been set.

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

 */

 EXPORT_C void CDelimitedDataBase8::PopBackL()

 	{

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

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

 	iParser.ParseReverse(*iDataBuf);

 	// Remove the current segment

 	DoRemoveL();

 	// Make sure that a re-parse is required

 	iParser.iMode = EDelimitedDataNotParsed;

 	}

 /**

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

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

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

 	is valid.

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

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

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

 	@since			6.0

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

 	@pre 			The delimiter must have been set. 

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

 */

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

 	{

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

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

 	iParser.Parse(*iDataBuf);

 	// Insert the segment

 	DoInsertL(aSegment);

 	// Make sure that a re-parse is required

 	iParser.iMode = EDelimitedDataNotParsed;

 	}

 /**

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

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

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

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

 	@since			6.0

 	@pre 			The delimiter must have been set.

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

 */

 EXPORT_C void CDelimitedDataBase8::PopFrontL()

 	{

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

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

 	iParser.Parse(*iDataBuf);

 	// Remove the current segment

 	DoRemoveL();

 	// Make sure that a re-parse is required

 	iParser.iMode = EDelimitedDataNotParsed;

 	}

 /**

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

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

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

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

 	@since			6.0

 	@pre 			The delimiter must have been set.

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

 */

 EXPORT_C void CDelimitedDataBase8::TrimFrontDelimiterL()

 	{

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

 	// Search for delimiter

 	if( iParser.FrontDelimiter() )

 		{

 		// Remove front delimiter and update member data

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

 		}

 	// Make sure that a re-parse is required

 	iParser.iMode = EDelimitedDataNotParsed;

 	}

 /**

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

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

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

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

 	@since			6.0

 	@pre 			The delimiter must have been set.

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

 */

 EXPORT_C void CDelimitedDataBase8::AddFrontDelimiterL()

 	{

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

 	if( !iParser.FrontDelimiter() )

 		{

 		// Create a new buffer of correct size

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

 		TPtr8 str = buf->Des();

 		// Append a delimiter, then append the current string

 		str.Append(iParser.iDelimiter);

 		str.Append(iParser.iDataDes);

 		// Set buffer to this new string

 		SetData(buf);

 		}

 	// Make sure that a re-parse is required

 	iParser.iMode = EDelimitedDataNotParsed;

 	}

 /**

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

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

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

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

 	@since			6.0

 	@pre 			The delimiter must have been set.

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

 */

 EXPORT_C void CDelimitedDataBase8::TrimBackDelimiterL()

 	{

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

 	// Search for delimiter

 	if( iParser.BackDelimiter() )

 		{

 		// Remove back delimiter and update member data

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

 		}

 	// Make sure that a re-parse is required

 	iParser.iMode = EDelimitedDataNotParsed;

 	}

 /**

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

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

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

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

 	@since			6.0

 	@pre 			The delimiter must have been set.

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

 */

 EXPORT_C void CDelimitedDataBase8::AddBackDelimiterL()

 	{

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

 	if( !iParser.BackDelimiter() )

 		{

 		// Create a new buffer of correct size

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

 		TPtr8 str = buf->Des();

 		// Append the current string, then append a delimiter

 		str.Append(iParser.iDataDes);

 		str.Append(iParser.iDelimiter);

 		// Set buffer to this new string

 		SetData(buf);

 		}

 	// Make sure that a re-parse is required

 	iParser.iMode = EDelimitedDataNotParsed;

 	}

 /**

 	This parses the data into segments from left to right.

 	@warning		There will be a KDelimitedParserErrNoDelimiter panic if the delimiter

 	has not been set.

 	@since			6.0

 	@pre 			The delimiter must have been set.

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

 	parsing is set from left to right (EDelimitedDataFroward).

 */

 EXPORT_C void CDelimitedDataBase8::Parse()

 	{

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

 	iParser.Parse(*iDataBuf);

 	}

 /**

 	This parses the string into segments from right to left.

 	@since			6.0

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

 	the delimiter has not been initialized.

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

 */

 EXPORT_C void CDelimitedDataBase8::ParseReverse()

 	{

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

 	iParser.ParseReverse(*iDataBuf);

 	}

 /**

 	Retrieves a const reference to the delimited data parser. 

 	@since			6.0

 	@return			A const reference to the delimited data parser. 

 */

 EXPORT_C const TDelimitedParserBase8& CDelimitedDataBase8::Parser() const

 	{

 	return iParser;

 	}

 /**

 	Sets the delimiting character.

 	@since			6.0

 	@param			aDelimiter	The delimiting character.

 	@post			The delimiting character is updated.

 */

 EXPORT_C void CDelimitedDataBase8::SetDelimiter(TChar aDelimiter)

 	{

 	iParser.SetDelimiter(aDelimiter);

 	}

 /**

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

 	@since			6.0

 */

 EXPORT_C CDelimitedDataBase8::CDelimitedDataBase8()

 	{

 	}

 /**

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

 	the object.

 	@since			6.0

 	@param			aData	A descriptor with the initial string.

 	@pre 			First phase of construction is complete.

 	@post			The object is fully constructed.

 */

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

 	{

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

 	SetDataL(aData);

 	}

 /**

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

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

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

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

 	@since			6.0

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

 	@pre 			The string must have been parsed.

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

 	remain as the one before the insertion.

 */

 void CDelimitedDataBase8::DoInsertL(const TDesC8& aSegment)

 	{

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

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

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

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

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

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

 		{

 		// Remove front delimiter on suffix

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

 		}	

 	// Check for delimiters

 	TPtrC8 segment = aSegment;

 	TInt segmentLength = segment.Length();

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

 	if( segmentBackDelimiter )

 		{

 		// Remove back delimiter from the segment

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

 		}

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

 		{

 		// Remove front delimiter from the segment

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

 		}

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

 	TInt extra = 1;

 	TBool needBackDelimiter = EFalse;

 	if( suffix.Length() || segmentBackDelimiter )

 		{

 		++extra;

 		needBackDelimiter = ETrue;

 		}

 	// Create space for new string

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

 	TPtr8 str = buf->Des();

 	// Form the new string

 	str.Append(prefix);

 	str.Append(iParser.iDelimiter);

 	str.Append(segment);

 	if( needBackDelimiter )

 		str.Append(iParser.iDelimiter);

 	str.Append(suffix);

 	// Update string data

 	SetData(buf);

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

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

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

 	if( iParser.iCurrentSegment.Ptr() )

 		{

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

 		iParser.iNextSegmentPos = prevPos;

 		if( iParser.iMode == EDelimitedDataForward )

 			{

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

 			iParser.iNextSegmentPos += segmentLength + 1;

 			}

 		// Get the next segment

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

 		}

 	}

 /**

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

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

 	end of the data.

 	@since			6.0

 	@pre 			The data must have been parsed.

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

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

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

 */

 void CDelimitedDataBase8::DoRemoveL()

 	{

 	// Check if there is anything to remove

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

 		{

 		return;

 		}

 	// Find the previous delimiter

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

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

 	TInt endPos = iParser.iNextSegmentPos;

 	TInt startPos = iParser.iNextSegmentPos;

 	if( prev < iParser.iNextSegmentPos )

 		startPos = prev;

 	else

 		endPos = prev;

 	// Ok, get the prefix and suffix parts

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

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

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

 	// Create the space

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

 	TPtr8 str = buf->Des();

 	// Form the new string

 	str.Append(prefix);

 	str.Append(suffix);

 	// Update string data

 	SetData(buf);

 	// Ensure parser is in correct position

 	iParser.iNextSegmentPos = iParser.FindNextSegment(startPos);

 	}

 /**

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

 	@since			6.0

 	@param			aData	A descriptor with the new string.

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

 	parser is set to the new data.

 */

 void CDelimitedDataBase8::SetDataL(const TDesC8& aData)

     {

 	// Cleanup old data and set new

 	HBufC8* buf =  aData.AllocL();

 	SetData(buf);

 	}

 /**

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

 	The parser is set to the new data.						

 	@since			6.0

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

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

 	is set to the data in the new buffer..

 */

 void CDelimitedDataBase8::SetData(HBufC8* aDataBuf)

 	{

 	delete iDataBuf;

 	iDataBuf = aDataBuf;

 	iParser.iDataDes.Set(*iDataBuf);

 	}

 //

 //

 // Implementation of TDelimitedParserBase16

 //

 //

 /**

 	Constructor.

 	@since			6.0

  */

 EXPORT_C TDelimitedParserBase16::TDelimitedParserBase16()

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

 	{

 	}

 /**

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

 	on whether the decriptor is parsing mode.

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

 	not been correctly set.

  */

 EXPORT_C void TDelimitedParserBase16::Reset() const

 	{

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

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

 	iNextSegmentPos = InitialDelimiterPosition(iDataDes, iMode);

 	}

 /**

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

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

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

 	@since			6.0

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

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

 	value KErrNone if there is a current segment.

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

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

  */

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

 	{

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

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

 	// Check that there is a segment

 	if( iNextSegmentPos == KErrNotFound )

 		{

 		// There is no segment

 		return KErrNotFound;

 		}

 	// There is one - set aSegment

 	aSegment.Set(iCurrentSegment);

 	// Parse the next segment

 	iNextSegmentPos = FindNextSegment(iNextSegmentPos);

 	return KErrNone;

 	}

 /**

 	Parses to the next segment.

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

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

 	@since			6.0

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

 	value KErrNone if there is a current segment.

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

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

  */

 EXPORT_C TInt TDelimitedParserBase16::Inc() const

 	{

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

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

 	// Check that there is a segment

 	if( iNextSegmentPos == KErrNotFound )

 		{

 		// There is no segment

 		return KErrNotFound;

 		}

 	// Parse the next segment

 	iNextSegmentPos = FindNextSegment(iNextSegmentPos);

 	return KErrNone;

 	}

 /**

 	Parses back to the previous segment.

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

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

 	@since			6.0

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

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

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

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

 	to the previous one. Otherwise there is no change.

  */

 EXPORT_C TInt TDelimitedParserBase16::Dec() const

 	{

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

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

 	// Find position of previous delimiter 

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

 	// Get the previous segment

 	if( FindPrevSegment(prev) == KErrNotFound )

 		{

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

 		return KErrNotFound;

 		}

 	// Update next segment position

 	iNextSegmentPos = prev;

 	return KErrNone;

 	}

 /**

 	Retrieves the current segment.

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

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

 	@since			6.0

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

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

 					value KErrNone if there is a current segment.

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

  */

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

 	{

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

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

 	// Check that there is a segment

 	if( iNextSegmentPos == KErrNotFound )

 		{

 		// There is no segment

 		return KErrNotFound;

 		}

 	// There is one - set aSegment

 	aSegment.Set(iCurrentSegment);

 	return KErrNone;

 	}

 /**

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

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

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

 	@since			6.0

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

 	or EFalse if there are more segements to parse.

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

  */

 EXPORT_C TBool TDelimitedParserBase16::Eos() const

 	{

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

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

 	return eos;

 	}

 /**

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

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

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

 	@since			6.0

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

 	if there is no front delimiter.

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

  */

 EXPORT_C TBool TDelimitedParserBase16::FrontDelimiter() const

 	{

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

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

 	}

 /**

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

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

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

 	@since			6.0

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

 	if there is no back delimiter.

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

  */

 EXPORT_C TBool TDelimitedParserBase16::BackDelimiter() const

 	{

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

 	TInt delimiterPos = iDataDes.LocateReverse(iDelimiter);

 	if( delimiterPos == KErrNotFound )

 		return EFalse;

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

 	}

 /**

 	Retrieves the descriptor reference with the data

 	@since			6.0

 	@return			A const descriptor reference with the data.

  */

 EXPORT_C const TDesC16& TDelimitedParserBase16::Des() const

 	{

 	return iDataDes;

 	}

 /**

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

 	have parsed through are not included.

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

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

 	@since			6.0

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

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

 	if there is remaining data.

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

  */

 EXPORT_C TInt TDelimitedParserBase16::Remainder(TPtrC16& aRemainder) const

 	{

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

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

 	// Check to see if there is a segment left

 	if( iNextSegmentPos == KErrNotFound )

 		{

 		// There is no segment

 		return KErrNotFound;

 		}

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

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

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

 	switch(iMode)

 		{

 	case EDelimitedDataForward:

 		{

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

 		} break;

 	case EDelimitedDataReverse:

 		{

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

 		} break;

 	default:

 		// Bad mode!

 		User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrBadDelimitedParserMode);

 		break;

 		}

 	return KErrNone;

 	}

 /**

 	This parses the data into segments from left to right.

 	@warning		There will be a KDelimitedParserErrNoDelimiter panic if the delimiter

 	has not been set.

 	@since			6.0

 	@param			aData	A descriptor containing the data.

 	@pre 			The delimiter must have been set.

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

 	parsing is set from left to right (EDelimitedDataFroward).

  */

 EXPORT_C void TDelimitedParserBase16::Parse(const TDesC16& aData)

 	{

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

 	// Initialise data for EForward direction

 	iMode = EDelimitedDataForward;

 	DoParse(aData);

 	}

 /**

 	This parses the data into segments from lright to left.

 	@warning		There will be a KDelimitedParserErrNoDelimiter panic if the delimiter

 	has not been set.

 	@since			6.0

 	@param			aData	A descriptor containing the data.

 	@pre 			The delimiter must have been set.

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

 	parsing is set from right to left (EDelimitedDataReverse).

  */

 EXPORT_C void TDelimitedParserBase16::ParseReverse(const TDesC16& aData)

 	{

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

 	// Initialise data for EReverse direction

 	iMode = EDelimitedDataReverse;

 	DoParse(aData);

 	}

 /**

 	Sets the delimiting character.

 	@since			6.0

 	@param			aDelimiter	The delimiting character.

 	@post			The delimiting character is set.

 */

 EXPORT_C void TDelimitedParserBase16::SetDelimiter(TChar aDelimiter)

 	{

 	iDelimiter = aDelimiter;

 	}

 /**

 	Initialises the parsing of the data.

 	@since			6.0

 	@param			aData	A descriptor reference with the data.

 	@pre 			The delimiting character has been set.

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

 	refers to the initial segment of the data.

  */

 void TDelimitedParserBase16::DoParse(const TDesC16& aData)

 	{

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

 	iCurrentSegment.Set(NULL,0);

 	iDataDes.Set(aData);

 	// Check that there is a string!

 	if( iDataDes.Length() == 0 )

 		{

 		// No string - ensure functionality blocked for this descriptor

 		iNextSegmentPos = KErrNotFound;

 		return;

 		}

 	// Find the segment - search from initial start position

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

 	}

 /**

 	Finds the next segment from the given start position.

 	@since			6.0

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

 	next segment.

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

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

  */

 TInt TDelimitedParserBase16::FindNextSegment(TInt aStartPos) const

 	{

 	// Find position of next delimiter

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

 	if( next != KErrNotFound )

 		{

 		TInt startPos = next < aStartPos ? next : aStartPos;

 		TInt endPos = next < aStartPos ? aStartPos : next;

 		if( iDataDes[startPos] == iDelimiter )

 			{

 			// Move past delimiter

 			++startPos;

 			}

 		TInt length = endPos - startPos;

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

 		}

 	return next;

 	}

 /**

 	Finds the previous segment from the given start position.

 	@since			6.0

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

 	previous segment.

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

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

 */

 TInt TDelimitedParserBase16::FindPrevSegment(TInt aStartPos) const

 	{

 	// Find position of previous delimiter 

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

 	if( prev != KErrNotFound )

 		{

 		TInt startPos = prev < aStartPos ? prev : aStartPos;

 		TInt endPos = prev < aStartPos ? aStartPos : prev;

 		if( iDataDes[startPos] == iDelimiter )

 			{

 			// Move past delimiter

 			++startPos;

 			}

 		TInt length = endPos - startPos;

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

 		}

 	return prev;

 	}

 //

 //

 // Implementation of CDelimitedDataBase16

 //

 //

 /**

 	Destructor.

 	@since			6.0

  */

 EXPORT_C CDelimitedDataBase16::~CDelimitedDataBase16()

 	{

 	delete iDataBuf;

 	}

 /**

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

 	made up of several segments and have delimiters at either extreme. The insert functionality will 

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

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

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

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

 	@since			6.0

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

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

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

 	will remain as the one before the insertion.

  */

 EXPORT_C void CDelimitedDataBase16::InsertCurrentL(const TDesC16& aSegment)

 	{

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

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

 	DoInsertL(aSegment);

 	}

 /**

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

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

 	the data.

 	@warning		There will be a KDelimitedParserErrNotParsed panic if the data has not been parsed, and 

 	a KDelimitedParserErrNoDelimiter panic if the delimiter has not been set.

 	@since			6.0

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

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

 	be set to what was the next segment. If the removed segment was the last segment, the parser is at the end 

 	of the data.

  */

 EXPORT_C void CDelimitedDataBase16::RemoveCurrentL()

 	{

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

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

 	DoRemoveL();

 	}

 /**

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

 	delimiters at either extreme. The insert functionality will ensure that there is always a delimiter at 

 	the front of the new segment. The data must re-parsed to ensure that the parser is valid.

 	@warning		There will be a KDelimitedParserErrNotParsed panic if the data has not been parsed, and a 

 	KDelimitedParserErrNoDelimiter panic if the delimiter has not been set. A re-parse is required to ensure 

 	that the parser is valid.

 	@since			6.0

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

 	@pre 			The delimiter must have been set.

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

  */

 EXPORT_C void CDelimitedDataBase16::PushBackL(const TDesC16& aSegment)

 	{

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

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

 	iParser.ParseReverse(*iDataBuf);

 	// Insert the segment

 	DoInsertL(aSegment);

 	// Make sure that a re-parse is required

 	iParser.iMode = EDelimitedDataNotParsed;

 	}

 /**

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

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

 	and a KDelimitedParserErrNoDelimiter panic if the delimiter has not been set. A re-parse is required 

 	to ensure that the parser is valid.

 	@since			6.0

 	@pre 			The delimiter must have been set.

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

  */

 EXPORT_C void CDelimitedDataBase16::PopBackL()

 	{

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

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

 	iParser.ParseReverse(*iDataBuf);

 	// Remove the current segment

 	DoRemoveL();

 	// Make sure that a re-parse is required

 	iParser.iMode = EDelimitedDataNotParsed;

 	}

 /**

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

 	delimiters at either extreme. The insert functionality will ensure that there is always a delimiter at 

 	the front of the new segment. The data must re-parsed to ensure that the parser is valid.

 	@warning		There will be a KDelimitedParserErrNotParsed panic if the data has not been parsed, and 

 	a KDelimitedParserErrNoDelimiter panic if the delimiter has not been set. A re-parse is required to ensure 

 	that the parser is valid.

 	@since			6.0

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

 	@pre 			The delimiter must have been set.

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

  */

 EXPORT_C void CDelimitedDataBase16::PushFrontL(const TDesC16& aSegment)

 	{

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

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

 	iParser.Parse(*iDataBuf);

 	// Insert the segment

 	DoInsertL(aSegment);

 	// Make sure that a re-parse is required

 	iParser.iMode = EDelimitedDataNotParsed;

 	}

 /**

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

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

 	parsed, and a KDelimitedParserErrNoDelimiter panic if the delimiter has not been set. A re-parse 

 	is required to ensure that the parser is valid.

 	@since			6.0

 	@pre 			The delimiter must have been set.

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

  */

 EXPORT_C void CDelimitedDataBase16::PopFrontL()

 	{

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

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

 	iParser.Parse(*iDataBuf);

 	// Remove the current segment

 	DoRemoveL();

 	// Make sure that a re-parse is required

 	iParser.iMode = EDelimitedDataNotParsed;

 	}

 /**

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

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

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

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

 	@since			6.0

 	@pre 			The delimiter must have been set.

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

  */

 EXPORT_C void CDelimitedDataBase16::TrimFrontDelimiterL()

 	{

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

 	// Search for delimiter

 	if( iParser.FrontDelimiter() )

 		{

 		// Remove front delimiter and update member data

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

 		}

 	// Make sure that a re-parse is required

 	iParser.iMode = EDelimitedDataNotParsed;

 	}

 /**

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

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

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

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

 	@since			6.0

 	@pre 			The delimiter must have been set.

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

  */

 EXPORT_C void CDelimitedDataBase16::AddFrontDelimiterL()

 	{

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

 	if( !iParser.FrontDelimiter() )

 		{

 		// Create a new buffer of correct size

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

 		TPtr16 str = buf->Des();

 		// Append a delimiter, then append the current string

 		str.Append(iParser.iDelimiter);

 		str.Append(iParser.iDataDes);

 		// Set buffer to this new string

 		SetData(buf);

 		}

 	// Make sure that a re-parse is required

 	iParser.iMode = EDelimitedDataNotParsed;

 	}

 /**

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

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

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

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

 	@since			6.0

 	@pre 			The delimiter must have been set.

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

  */

 EXPORT_C void CDelimitedDataBase16::TrimBackDelimiterL()

 	{

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

 	// Search for delimiter

 	if( iParser.BackDelimiter() )

 		{

 		// Remove back delimiter and update member data

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

 		}

 	// Make sure that a re-parse is required

 	iParser.iMode = EDelimitedDataNotParsed;

 	}

 /**

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

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

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

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

 	@since			6.0

 	@pre 			The delimiter must have been set.

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

  */

 EXPORT_C void CDelimitedDataBase16::AddBackDelimiterL()

 	{

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

 	if( !iParser.BackDelimiter() )

 		{

 		// Create a new buffer of correct size

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

 		TPtr16 str = buf->Des();

 		// Append the current string, then append a delimiter

 		str.Append(iParser.iDataDes);

 		str.Append(iParser.iDelimiter);

 		// Set buffer to this new string

 		SetData(buf);

 		}

 	// Make sure that a re-parse is required

 	iParser.iMode = EDelimitedDataNotParsed;

 	}

 /**

 	This parses the data into segments from left to right.

 	@warning		There will be a KDelimitedParserErrNoDelimiter panic if the delimiter

 	has not been set.

 	@since			6.0

 	@pre 			The delimiter must have been set.

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

 	parsing is set from left to right (EDelimitedDataFroward).

  */

 EXPORT_C void CDelimitedDataBase16::Parse()

 	{

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

 	iParser.Parse(*iDataBuf);

 	}

 /**

 	This parses the string into segments from right to left.

 	@since			6.0

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

 	the delimiter has not been initialized.

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

  */

 EXPORT_C void CDelimitedDataBase16::ParseReverse()

 	{

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

 	iParser.ParseReverse(*iDataBuf);

 	}

 /**

 	Retrieves a const reference to the delimited data parser.

 	@since			6.0

 	@return			A const reference to the delimited data parser.

  */

 EXPORT_C const TDelimitedParserBase16& CDelimitedDataBase16::Parser() const

 	{

 	return iParser;

 	}

 /**

 	Sets the delimiting character.

 	@since			6.0

 	@param			aDelimiter	The delimiting character.

 	@post			The delimiting character is updated.

  */

 EXPORT_C void CDelimitedDataBase16::SetDelimiter(TChar aDelimiter)

 	{

 	iParser.SetDelimiter(aDelimiter);

 	}

 /**

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

 	@since			6.0

  */

 EXPORT_C CDelimitedDataBase16::CDelimitedDataBase16()

 	{

 	}

 /**

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

 	the object.

 	@since			6.0

 	@param			aData	A descriptor with the initial string.

 	@pre 			First phase of construction is complete.

 	@post			The object is fully constructed.

  */

 EXPORT_C void CDelimitedDataBase16::ConstructL(const TDesC16& aData)

 	{

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

 	SetDataL(aData);

 	}

 /**

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

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

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

 	its current segment is the same one as before the insertion.

 	@since			6.0

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

 	@pre 			The string must have been parsed.

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

 	remain as the one before the insertion.

  */

 void CDelimitedDataBase16::DoInsertL(const TDesC16& aSegment)

 	{

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

 	TPtrC16 prefix = iParser.iDataDes.Left(prevPos);

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

 	TPtrC16 suffix = iParser.iDataDes.Right(suffixLength);

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

 		{

 		// Remove front delimiter on suffix

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

 		}	

 	// Check for delimiters...

 	TPtrC16 segment = aSegment;

 	TInt segmentLength = segment.Length();

 	// Check the last character in segment

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

 	if( segmentBackDelimiter )

 		{

 		// Remove back delimiter from the segment

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

 		}

 	// Check the first character in segment...

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

 		{

 		// Remove front delimiter from the segment

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

 		}

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

 	TInt extra = 1;

 	TBool needBackDelimiter = EFalse;

 	if( suffix.Length() || segmentBackDelimiter )

 		{

 		++extra;

 		needBackDelimiter = ETrue;

 		}

 	// Create space for new string

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

 	TPtr16 str = buf->Des();

 	// Form the new string

 	str.Append(prefix);

 	str.Append(iParser.iDelimiter);

 	str.Append(segment);

 	if( needBackDelimiter )

 		str.Append(iParser.iDelimiter);

 	str.Append(suffix);

 	// Update string data

 	SetData(buf);

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

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

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

 	if( iParser.iCurrentSegment.Ptr() )

 		{

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

 		iParser.iNextSegmentPos = prevPos;

 		if( iParser.iMode == EDelimitedDataForward )

 			{

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

 			iParser.iNextSegmentPos += segmentLength + 1;

 			}

 		// Get the next segment

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

 		}

 	}

 /**

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

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

 	the data.

 	@since			6.0

 	@pre 			The data must have been parsed.

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

 	is set to what was the next segment. If the removed segment was	the last segment, the parser is 

 	at the end of the data.

  */

 void CDelimitedDataBase16::DoRemoveL()

 	{

 	// Check if there is anything to remove

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

 		{

 		return;

 		}

 	// Find the previous delimiter

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

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

 	TInt endPos = iParser.iNextSegmentPos;

 	TInt startPos = iParser.iNextSegmentPos;

 	if( prev < iParser.iNextSegmentPos )

 		startPos = prev;

 	else

 		endPos = prev;

 	// Ok, get the prefix and suffix parts

 	TPtrC16 prefix = iParser.iDataDes.Left(startPos);

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

 	TPtrC16 suffix = iParser.iDataDes.Right(suffixLength);

 	// Create the space

 	HBufC16* buf = HBufC16::NewL(startPos + suffixLength);

 	TPtr16 str = buf->Des();

 	// Form the new string

 	str.Append(prefix);

 	str.Append(suffix);

 	// Update string data

 	SetData(buf);

 	// Ensure parser is in correct position

 	iParser.iNextSegmentPos = iParser.FindNextSegment(startPos);

 	}

 /**

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

 	@since			6.0

 	@param			aData	A descriptor with the new string.

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

 	parser is set to the new data.

  */

 void CDelimitedDataBase16::SetDataL(const TDesC16& aData)

 	{

 	// Cleanup old data and set new

 	HBufC16* buf =  aData.AllocL();

 	SetData(buf);

 	}

 /**

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

 	parser is set to the new data.

 	@since			6.0

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

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

 	is set to the data in the new buffer..

  */

 void CDelimitedDataBase16::SetData(HBufC16* aDataBuf)

 	{

 	delete iDataBuf;

 	iDataBuf = aDataBuf;

 	iParser.iDataDes.Set(*iDataBuf);

 	}

 //

 //

 // Implementation of LOCAL functions

 //

 //

 /**

 	Finds the position of the next delimiter in the data.

 	@since			6.0

 	@param			aData		A descriptor with the delimited data.

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

 	@param			aDelimiter	The delimiting character.

 	@param			aMode		The parsing mode.

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

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

 	@pre			None

 	@post			Unspecified

  */

 template<class TDesCType>

 TInt NextDelimiterPosition(const TDesCType& aData, TInt aStartPos, TInt aDelimiter, TDelimitedDataParseMode aMode)

 	{

 	if( aStartPos == KErrNotFound )

 		{

 		// Have got to the end - initialise the iterator

 		return InitialDelimiterPosition(aData, aMode);

 		}

 	TInt next = KErrNotFound;

 	switch( aMode )

 		{

 	case EDelimitedDataForward:

 		{

 		// Search parsed string for next delimiter

 		next = LeftDelimiterPosition(aData, aStartPos, aDelimiter);

 		} break;

 	case EDelimitedDataReverse:

 		{

 		// Search parsed string for next delimiter

 		next = RightDelimiterPosition(aData, aStartPos, aDelimiter);

 		} break;

 	default:

 		// Bad mode!

 		User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrBadDelimitedParserMode);

 		break;

 		}

 	return next;

 	}

 /**

 	Finds the position of the previous delimiter in the data from the given start position.

 	@since			6.0

 	@param			aData		A descriptor with the delimited data.

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

 	@param			aDelimiter	The delimiting character.

 	@param			aMode		The parsing mode.

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

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

 	@pre			None

 	@post			Unspecified

  */

 template<class TDesCType>

 TInt PrevDelimiterPosition(const TDesCType& aData, TInt aStartPos, TInt aDelimiter, TDelimitedDataParseMode aMode)

 	{

 	// Switch modes, then find the next delimiter, switch back

 	TDelimitedDataParseMode mode = aMode == EDelimitedDataForward ? EDelimitedDataReverse : EDelimitedDataForward;

 	return NextDelimiterPosition(aData, aStartPos, aDelimiter, mode);

 	}

 /**

 	Finds the position of the delimiter to the right of the given start position.

 	@since			6.0

 	@param			aData		A descriptor with the delimited data.

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

 	@param			aDelimiter	The delimiting character.

 	@return			The position of delimiter to the right of the specified start position, or 

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

 	@pre			None

 	@post			Unspecified

  */

 template<class TDesCType>

 TInt RightDelimiterPosition(const TDesCType& aData, TInt aStartPos, TInt aDelimiter)

 	{

 	// Find position of right-most delimiter in the descriptor data to left of aStartPos

 	if( aStartPos == 0 )

 		{

 		// There is no data

 		return KErrNotFound;

 		}

 	TInt rightDelimiterPos = aData.Left(aStartPos).LocateReverse(aDelimiter);

 	// See if a delimiter was found

 	if( rightDelimiterPos == KErrNotFound )

 		{

 		// No - start of string delimits

 		rightDelimiterPos = 0;

 		}

 	return rightDelimiterPos;

 	}

 /**

 	Finds the position of the delimiter to the left of the given start position.

 	@since			6.0

 	@param			aData		A descriptor with the delimited data.

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

 	@param			aDelimiter	The delimiting character.

 	@return			The position of delimiter to the left of the specified start position, or 

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

 	@pre			None

 	@post			Unspecified

  */

 template<class TDesCType>

 TInt LeftDelimiterPosition(const TDesCType& aData, TInt aStartPos, TInt aDelimiter)

 	{

 	// Find position of left-most delimiter in the descriptor data to right of aStartPos

 	const TInt length = aData.Length();

 	TInt rightLength = length - aStartPos;

 	if( rightLength == 0 )

 		{

 		// There is no data

 		return KErrNotFound;

 		}

 	// Ok there is some string to search - remove delimiter

 	--rightLength;

 	TInt leftDelimiterPos = aData.Right(rightLength).Locate(aDelimiter);

 	// See if a delimiter was found

 	if( leftDelimiterPos == KErrNotFound )

 		{

 		// No - end of string delimits

 		leftDelimiterPos = length;

 		}

 	else

 		{

 		// Offset the delimiter found - include delimiter that was removed

 		leftDelimiterPos += aStartPos + 1;

 		}

 	return leftDelimiterPos;

 	}

 /**

 	Retrieves the initial position for searching delimited data for a given parsing mode.

 	@since			6.0

 	@param			aData		A descriptor with the delimited data.

 	@param			aMode		The parsing mode.

 	@return			The initial position for parsing the data.

 	@pre			None

 	@post			Unspecified

  */

 template<class TDesCType>

 TInt InitialDelimiterPosition(const TDesCType& aData, TDelimitedDataParseMode aMode)

 //

 // Initialises iNextSegmentPos

 	{

 	TInt initPos = KErrNotFound;

 	switch( aMode )

 		{

 	case EDelimitedDataForward:

 		{

 		// Search parsed string for next delimiter

 		initPos = 0;

 		} break;

 	case EDelimitedDataReverse:

 		{

 		// Search parsed string for next delimiter

 		initPos = aData.Length();

 		} break;

 	default:

 		// Bad mode!

 		User::Panic(KDelimitedParserPanicCategory, KUriUtilsErrBadDelimitedParserMode);

 		break;

 		}

 	return initPos;

 	}