// 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;

	}