// 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 "inetprottextutils.h"

 #include "inetprottextutilslocal.h"

 #include <uriutilscommon.h>

 // Panic category

 //

 #ifdef _DEBUG

 	_LIT(KTextUtilsPanicCategory, "IPTXTUTL"); 

 #endif

 const TUint KZeroChar		= '0';

 const TUint KAChar			= 'A';

 const TUint	KQuote			= '"';

 const TUint KMinusSign		= '-';

 const TInt KMaxTIntDecimalDigits = 11; // KMaxTInt  => "-2147483648" 

 const TInt KMaxTIntDividedByTen = KMaxTInt/10;

 #define KHorizTab 0x09

 #define KSpace 0x20

 #define KZero 0x30

 #define KNine 0x39

 #define KDecimal 0x2E

 const TInt KMaxNumberSize	= 32;	// includes '-' sign

 /**

 	Removes any contiguous whitespace at the extremes of the data, as specified

 	by aMode. Whitespace is defined by the functions TChar::IsSpace() - white

 	space includes spaces, tabs, and separators (e.g. new line).

 	@param			aData	A descriptor pointer with the data.

 	@param			aMode	The specified removal mode.

 	@return			The number of consumed whitespace characters. If the data is

 	empty or the data is all whitespace the error code KUriUtilsErrEmptyData is

 	returned.

 */

 EXPORT_C TInt InetProtTextUtils::RemoveWhiteSpace(TPtrC8& aData, TRemoveMode aMode)

 	{

 	TInt consumed = DoRemoveWhiteSpace(aData, aMode);

 	if( consumed == KUriUtilsErrEmptyData )

 		{

 		// Either empty data or all whitespace

 		aData.Set(KNullDesC8());

 		}

 	return consumed;

 	}

 /**

 	Removes any contiguous whitespace at the extremes of the data, as specified

 	by aMode. Whitespace is defined by the functions TChar::IsSpace() - white

 	space includes spaces, tabs, and separators (e.g. new line).

 	@param			aData	A descriptor pointer with the data.

 	@param			aMode	The specified removal mode.

 	@return			The number of consumed whitespace characters. If the data is

 	empty or the data is all whitespace the error code KUriUtilsErrEmptyData is

 	returned.

 */

 EXPORT_C TInt InetProtTextUtils::RemoveWhiteSpace(TPtrC16& aData, TRemoveMode aMode)

 	{

 	TInt consumed = DoRemoveWhiteSpace(aData, aMode);

 	if( consumed == KUriUtilsErrEmptyData )

 		{

 		// Either empty data or all whitespace

 		aData.Set(KNullDesC16());

 		}

 	return consumed;

 	}

 /**

 	Converts an integer value into its decimal character representation.

 	@param			aInt		An integer value.	

 	@param			aBuffer		An output argument of a pointer to a data buffer

 	that will contain the character representation of the integer value.

 */

 EXPORT_C void InetProtTextUtils::ConvertIntToDescriptorL(TInt aInt, HBufC8*& aBuffer)

 	{

 	DoConvertIntToDescriptorL(aInt, aBuffer, EDecimal);

 	}

 /**

 	Converts an integer value into its decimal character representation.

 	@param			aInt		An integer value.	

 	@param			aBuffer		An output argument of a pointer to a data buffer

 	that will contain the character representation of the integer value.

 */

 EXPORT_C void InetProtTextUtils::ConvertIntToDescriptorL(TInt aInt, HBufC16*& aBuffer)

 	{

 	DoConvertIntToDescriptorL(aInt, aBuffer, EDecimal);

 	}

 /**

 	Converts the character representation of an integer into its numeric value.

 	Preceeding whitespace is ignored and the integer is delimited by either the

 	end of the data, whitespace or any other character other than 0 to 9.

 	@param			aData	A descriptor pointer with the data.

 	@param			aInt	An output argument in which the numeric value of the

 	data is placed.

 	@return			The number of consumed characters that contributed to the 

 					integer value, including any whitespace before the integer. 

 					If the data is empty the error code KUriUtilsErrEmptyData 

 					is returned. If there are no digits at the beginning of the

 					data the error code KUriUtilsErrNoIntergerInData is returned.

 */

 EXPORT_C TInt InetProtTextUtils::ConvertDescriptorToInt(const TDesC8& aData, TInt& aInt)

 	{

 	// Do conversion and return number of consumed characters

 	return DoConvertDescriptorToInt(TPtrC8(aData), aInt, EDecimal);

 	}

 /**

 	Converts the character representation of an integer into its numeric value.

 	Preceeding whitespace is ignored and the integer is delimited by either the

 	end of the data, whitespace or any other character other than 0 to 9.

 	@param			aData	A descriptor pointer with the data.

 	@param			aInt	An output argument in which the numeric value of the

 	data is placed.

 	@return			The number of consumed characters that contributed to the 

 					integer value, including any whitespace before the integer.

 					If the data is empty the error code KUriUtilsErrEmptyData is

 					returned. If there are no digits at the beginning of the data

 					the error code KUriUtilsErrNoIntergerInData is returned.

 */

 EXPORT_C TInt InetProtTextUtils::ConvertDescriptorToInt(const TDesC16& aData, TInt& aInt)

 	{

 	// Do conversion and return number of consumed characters

 	return DoConvertDescriptorToInt(TPtrC16(aData), aInt, EDecimal);

 	}

 /**

 	@internalComponent

 	Converts an integer to its hex representation.

 	@param		aHex	The integer value to convert.

 	@param		aBuffer	An output argument that is set to the buffer containing 

 						the hex representation of aValue.

 	@panic		EInvariantFalse	The integer value was too big.

 */

 EXPORT_C void InetProtTextUtils::ConvertHexToDescriptorL(TInt aHex, HBufC8*& aBuffer)

 	{

 	DoConvertIntToDescriptorL(aHex, aBuffer, EHex);

 	}

 /**

 	@internalComponent

 	Converts an integer to its hex representation.

 	@param		aHex	The integer value to convert.

 	@param		aBuffer	An output argument that is set to the buffer containing 

 						the hex representation of aValue.

 	@panic		EInvariantFalse	The integer value was too big.

 */

 EXPORT_C void InetProtTextUtils::ConvertHexToDescriptorL(TInt aHex, HBufC16*& aBuffer)

 	{

 	DoConvertIntToDescriptorL(aHex, aBuffer, EHex);

 	}

 /**

 	@internalComponent

 	Descriptor to hex convertor. Searches the descriptor buffer for a hex number

 	representation at the start of the buffer. The hex number is deemed to have 

 	ended when the first non-hex character is found. The numeric value of the 

 	hex number is returned along with the number characters consumed in obtaining

 	the number. The amount of leading whitespace is included in the number of 

 	characters consumed.

 	@param		aData	The descriptor buffer to be parsed.

 	@param		aHex	An output argument set to the numeric value of the 

 						parsed hex number.

 	@return		The number of characters consumed in parsing the hex number. If 

 				the descriptor was empty then KUriUtilsErrEmptyData is returned.

 				If no hex number was parsed then KUriUtilsErrNoIntergerInData is

 				returned.

 */

 EXPORT_C TInt InetProtTextUtils::ConvertDescriptorToHex(const TDesC8& aData, TInt& aHex)

 	{

 	// Do conversion, returning the number of consumed characters

 	return DoConvertDescriptorToInt(TPtrC8(aData), aHex, EHex);

 	}

 /**

 	@internalComponent

 	Descriptor to hex convertor. Searches the descriptor buffer for a hex number

 	representation at the start of the buffer. The hex number is deemed to have 

 	ended when the first non-hex character is found. The numeric value of the 

 	hex number is returned along with the number characters consumed in obtaining

 	the number. The amount of leading whitespace is included in the number of 

 	characters consumed.

 	@param		aData	The descriptor buffer to be parsed.

 	@param		aHex	An output argument set to the numeric value of the 

 						parsed hex number.

 	@return		The number of characters consumed in parsing the hex number. If 

 				the descriptor was empty then KUriUtilsErrEmptyData is returned.

 				If no hex number was parsed then KUriUtilsErrNoIntergerInData is

 				returned.

 */

 EXPORT_C TInt InetProtTextUtils::ConvertDescriptorToHex(const TDesC16& aData, TInt& aHex)

 	{

 	// Do conversion, returning the number of consumed characters

 	return DoConvertDescriptorToInt(TPtrC16(aData), aHex, EHex);

 	}

 /** 

 	Extract a token from the head of the supplied buffer, which is assumed to be

 	a token-list. The tokens are separated by the specified character. Any white

 	space surrounding the token is stripped out.  The number of characters 

 	consumed from the buffer are returned. The buffer is updated to not include

 	the extracted token including the separator.

 	@param			aBuffer		The buffer containing the token-list.

 	@param			aToken		An output argument containing the extracted token.

 	@param			aSeparator	The separator character.

 	@return			The number of characters consumed from the buffer.

 */

 EXPORT_C TInt InetProtTextUtils::ExtractNextTokenFromList(TPtrC8& aBuffer, TPtrC8& aToken, TChar aSeparator)

 	{

 	return DoExtractNextTokenFromList(aBuffer, aToken, aSeparator);

 	}

 /** 

 	Extract a token from the head of the supplied buffer, which is assumed to be

 	a token-list. The tokens are separated by the specified character. Any white

 	space surrounding the token is stripped out.  The number of characters 

 	consumed from the buffer are returned. The buffer is updated to not include

 	the extracted token including the separator.

 	@param			aBuffer		The buffer containing the token-list.

 	@param			aToken		An output argument containing the extracted token.

 	@param			aSeparator	The separator character.

 	@return			The number of characters consumed from the buffer.

 */

 EXPORT_C TInt InetProtTextUtils::ExtractNextTokenFromList(TPtrC16& aBuffer, TPtrC16& aToken, TChar aSeparator)

 	{

 	return DoExtractNextTokenFromList(aBuffer, aToken, aSeparator);

 	}

 /** 

 	Extract a token from the head of the supplied buffer, which is assumed to be

 	a token-list. The tokens are separated by one of the specified characters. 

 	Any white space surrounding the token is stripped out.  The number of 

 	characters consumed from the buffer are returned. The buffer is updated to 

 	not include the extracted token including the separator.

 	@param			aBuffer		The buffer containing the token-list.

 	@param			aToken		An output argument containing the extracted token.

 	@param			aSeparators	The list of separator characters.

 	@return			The number of characters consumed from the buffer.

 */

 EXPORT_C TInt InetProtTextUtils::ExtractNextTokenFromList(TPtrC8& aBuffer, TPtrC8& aToken, const TDesC8& aSeparators)

 	{

 	TPtrC8 separators = aSeparators;

 	return DoExtractNextTokenFromList(aBuffer, aToken, separators);

 	}

 /** 

 	Extract a token from the head of the supplied buffer, which is assumed to be

 	a token-list. The tokens are separated by one of the specified characters. 

 	Any white space surrounding the token is stripped out.  The number of 

 	characters consumed from the buffer are returned. The buffer is updated to 

 	not include the extracted token including the separator.

 	@param			aBuffer		The buffer containing the token-list.

 	@param			aToken		An output argument containing the extracted token.

 	@param			aSeparators	The list of separator characters.

 	@return			The number of characters consumed from the buffer.

 */

 EXPORT_C TInt InetProtTextUtils::ExtractNextTokenFromList(TPtrC16& aBuffer, TPtrC16& aToken, const TDesC16& aSeparators)

 	{

 	TPtrC16 separators = aSeparators;

 	return DoExtractNextTokenFromList(aBuffer, aToken, separators);

 	}

 /**	

 	Extract a quoted string value from the head of the supplied buffer. Anything

 	outside the quotes is discarded and the quotes themselves are not included 

 	in the returned string.

 	@param			aBuffer			The buffer containing the quoted.

 	@param			aQuotedString	An output argument containing the extracted

 									string.

 	@return			The number of characters consumed from the buffer.

 */

 EXPORT_C TInt InetProtTextUtils::ExtractQuotedStringL(TPtrC8& aBuffer, TPtrC8& aQuotedString)

 	{

 	return DoExtractQuotedStringL(aBuffer, aQuotedString);

 	}

 /**	

 	Extract a quoted string value from the head of the supplied buffer. Anything

 	outside the quotes is discarded and the quotes themselves are not included 

 	in the returned string.

 	@param			aBuffer			The buffer containing the quoted.

 	@param			aQuotedString	An output argument containing the extracted

 									string.

 	@return			The number of characters consumed from the buffer.

 */

 EXPORT_C TInt InetProtTextUtils::ExtractQuotedStringL(TPtrC16& aBuffer, TPtrC16& aQuotedString)

 	{

 	return DoExtractQuotedStringL(aBuffer, aQuotedString);

 	}

 /**	

 	@internalTechnology

 	Extract an integer value from the head of the supplied buffer.

 	@param			aBuffer	The buffer containing the integer value.

 	@param			aIntVal	An output argument in which extracted integer value

 							is placed.

 	@param			aAllowNonWsTerminator	If set to true whitespace is considered as the 

 									terminator, if set to false a non-decimal charecter

 									is considered as terminator.

 	@return			The number of characters in aBuffer after the integer.

 	@leave			KUriUtilsErrMalformedInteger if the value in aBuffer is not an integer 

 					(ie, contains non-decimal characters, or is too big to fit in a TInt)

 */

 EXPORT_C TInt InetProtTextUtils::ExtractIntegerValueL(TPtrC8& aBuffer, TInt& aIntVal, TBool aAllowNonWsTerminator)

 	{

 	// Anticipate an empty token by default

 	TPtrC8 data(aBuffer);

 	// Trim out any whitespace to the left the integer and check there's something left!

 	InetProtTextUtils::RemoveWhiteSpace(data, InetProtTextUtils::ERemoveLeft);

 	const TInt len = data.Length();

 	TInt retVal = aBuffer.Length() -  len; // the amount of WS consumed

 	if (len == 0)

 		{

 		// No integer was found - the supplied buffer was all WS!

 		aIntVal = 0;

 		retVal = aBuffer.Length();

 		aBuffer.Set(data);

 		}

 	else

 		{

 		// Got some data to work with... find out how many digits are present. Assume that the integer

 		// required is a contiguous set of decimal digits followed by WS or the end of the buffer

 		TInt numDigits = 0;

 		TChar ch = KZero; // default most significant digit to zero without affecting the result

 		TBool done = EFalse;

 		while (!done)

 			{

 			// check for the end of the integer. This depends on what is allowed to terminate it.

 			if (aAllowNonWsTerminator)

 				{

 				done = (numDigits == data.Length());

 				if (!done)

 					{

 					ch = data[numDigits];

 					done = ((ch < KZero) || (ch > KNine));

 					}

 				}

 			else

 				{

 				done = (numDigits == data.Length());

 				if (!done)

 					{

 					ch = data[numDigits];

 					done = ((ch == KSpace) || (ch == KHorizTab) || (ch == KDecimal));

 					}

 				}

 			// Check that we're getting digits

 			if (!done)

 				{

 				if ((ch < KZero) || (ch > KNine)) // digits 0-9

 					User::Leave(KUriUtilsErrMalformedInteger);

 				++numDigits;

 				}

 			}

 		// Make sure there's no overflow (trivial check)

 		if(numDigits>KMaxTIntDecimalDigits)

 			User::Leave(KUriUtilsErrMalformedInteger);

 		// Now work back, building up the integer

 		aIntVal = 0;

 		for (TInt pos = 0; pos < numDigits; pos++)

 			{

 			// double check no overflow (

 			if(aIntVal>KMaxTIntDividedByTen   ||  //works except for 2147483648 and ...49)

 				( (aIntVal == KMaxTIntDividedByTen)  && (data[pos] >= (KNine-1)) ) // covers those two cases

 				)  

 				User::Leave(KUriUtilsErrMalformedInteger);

 			aIntVal = (data[pos] - KZero) + (aIntVal * 10); // decimal, innit?

 			}

 		// work out how much this has consumed

 		retVal += numDigits;

 		// Finally ensure the buffer has had the correct amount of data consumed

 		if (len == aBuffer.Length())

 			aBuffer.Set(KNullDesC8()); // there was nothing to the right of the integer

 		else

 			aBuffer.Set(aBuffer.Mid(retVal));

 		}

 	return retVal;

 	}

 /*

  *	Local methods

  */

 /**

 	@internalComponent

 	Does the whitespace removal. Checks the mode and then calls the appropriate

 	functions.

 	@warning		Will panic will KUriUtilsErrBadTExtRemoveMode if aMode not valid.

 	@param			aData	A descriptor pointer with the data.

 	@param			aMode	The specified removal mode.

 	@return			The number of consumed whitespace characters. If the data is

 					empty or the data is all whitespace the error code 

 					KUriUtilsErrEmptyData is returned.

 */

 template<class TPtrCType>

 TInt DoRemoveWhiteSpace(TPtrCType& aData, InetProtTextUtils::TRemoveMode aMode)

 	{

 	TInt consumed = 0;

 	switch( aMode )

 		{

 	case InetProtTextUtils::ERemoveLeft:

 		{

 		consumed = FindWhiteSpaceLeft(aData);

 		if( consumed > 0 )

 			{

 			// Found some whitespace

 			aData.Set(aData.Mid(consumed));

 			}

 		} break;

 	case InetProtTextUtils::ERemoveRight:

 		{

 		consumed = FindWhiteSpaceRight(aData);

 		if( consumed > 0 )

 			{

 			// Found some whitespace

 			aData.Set(aData.Left(aData.Length() - consumed));

 			}

 		} break;

 	case InetProtTextUtils::ERemoveBoth:

 		{

 		// Remove from left first...

 		consumed = FindWhiteSpaceLeft(aData);

  		if( consumed != KUriUtilsErrEmptyData )

 			{

 			// Found some whitespace - set the pointer then remove from right

 			aData.Set(aData.Mid(consumed));

 			TInt consumedRight = FindWhiteSpaceRight(aData);

 			// To get this far descriptor is non-empty and not all whitespace - no check

 			aData.Set(aData.Left(aData.Length() - consumedRight));

 			consumed += consumedRight;

 			}

 		} break;

 	default:

 		__ASSERT_DEBUG(EFalse, User::Panic(KTextUtilsPanicCategory, KUriUtilsErrBadTextRemoveMode));

 		}

 	return consumed;

 	}

 /**

 	@internalComponent

 	Finds the number of contiguous whitespace characters at the 

 	beginning of the data.

 	@param			aData	A descriptor pointer with the data.

 	@return			The number of consumed whitespace characters. If the data is

 					empty or the data is all whitespace the error code 

 					KTextUtilsErrEmptyData is returned.

  */

 template<class TPtrCType>

 TInt FindWhiteSpaceLeft(const TPtrCType& aData)

 	{

 	const TInt length = aData.Length();

 	if( length == 0 )

 		return KUriUtilsErrEmptyData;

 	TInt i = 0;

 	TBool done = EFalse;

 	while( !done && i < length )

 		{

 		TChar current = aData[i];

 		done  = !current.IsSpace();

 		if( !done )

 			++i;

 		}

 	if( i == length )

 		return KUriUtilsErrEmptyData;

 	return i;

 	}

 /**

 	@internalComponent

 	Finds the number of contiguous whitespace characters at the end of the data.

 	@param			aData	A descriptor pointer with the data.

 	@return			The number of consumed whitespace characters. If the data is

 					empty or the data is all whitespace the error code 

 					KTextUtilsErrEmptyData is returned.

 */

 template<class TPtrCType>

 TInt FindWhiteSpaceRight(const TPtrCType& aData)

 	{

 	const TInt length = aData.Length();

 	if( length == 0 )

 		return KUriUtilsErrEmptyData;

 	TInt i = 0;

 	TBool done = EFalse;

 	while( !done && i < length )

 		{

 		TChar current = aData[(length-1) - i];

 		done  = !current.IsSpace();

 		if( !done )

 			++i;

 		}

 	if( i == length )

 		return KUriUtilsErrEmptyData;

 	return i;

 	}

 /** 

 	Extracts next token from the buffer.

 	@param			aBuffer		The buffer containing the token-list.

 	@param			aToken		An output argument containing the extracted token.

 	@param			aSeparator	The separator character.

 	@return			The number of characters consumed from the buffer.

 */

 template<class TPtrCType>

 TInt DoExtractNextTokenFromList(TPtrCType& aBuffer, TPtrCType& aToken, TChar aSeparator)

 	{

 	// Anticipate an empty token by default.

 	TInt consumed = 0;

 	// Search for the separator

 	const TInt pos = aBuffer.Locate(aSeparator);

 	// If the separator was found, take chars upto it. Otherwise use the whole

 	// remaining buffer - implies the last token in the list.

 	if( pos == KErrNotFound )

 		{

 		// Last token - take the whole lot

 		aToken.Set(aBuffer);

 		consumed = aBuffer.Length();

 		}

 	else

 		{

 		// Take upto the separator position for the token, and move the buffer 

 		// past the token.

 		aToken.Set(aBuffer.Left(pos));

 		consumed = pos + 1;	// include the separator

 		}

 	// Set the buffer to move past the extracted token.

 	aBuffer.Set(aBuffer.Mid(consumed));

 	// Trim out any whitespace surrounding the token, and return how many charas

 	// were consumed.

 	InetProtTextUtils::RemoveWhiteSpace(aToken, InetProtTextUtils::ERemoveBoth);

 	return consumed;

 	}

 /** 

 	Extracts next token from the buffer.

 	@param			aBuffer		The buffer containing the token-list.

 	@param			aToken		An output argument containing the extracted token.

 	@param			aSeparator	The separator.

 	@return			The number of characters consumed from the buffer.

 */

 template<class TPtrCType>

 TInt DoExtractNextTokenFromList(TPtrCType& aBuffer, TPtrCType& aToken, const TPtrCType& aSeparator)

 	{

 	// Finds the next token in the list, where all the characters in

 	// the separator array are considered to be separators.

 	// Anticipate an empty token by default.

 	TInt consumed = 0;

 	// Search for separator...

 	const TInt length = aBuffer.Length();

 	TInt pos = 0;

 	TBool found = EFalse;

 	while( !found && pos < length )

 		{

 		// If we find a quoted string, skip over it (and any token

 		// separators within it)

 		if( aBuffer[pos] == KQuote )

 			{

 			for( ++pos; pos < length && aBuffer[pos] != KQuote; ++pos )

 				{}

 			if (pos == length)

 				break; // end of string reached

 			}

 		if( aSeparator.Locate(aBuffer[pos]) != KErrNotFound )

 			found = ETrue;

 		else

 			++pos;

 		}

 	// If the separator was found, take chars upto it. Otherwise use the whole

 	// remaining buffer - implies the last token in the list.

 	if( found )

 		{

 		// Take upto the separator position for the token, and move the buffer 

 		// past the token.

 		aToken.Set(aBuffer.Left(pos));

 		consumed = pos + 1;

 		}

 	else

 		{

 		// Last token - take the whole lot

 		aToken.Set(aBuffer);

 		consumed = aBuffer.Length();

 		}

 	// Set the buffer to move past the extracted token.

 	aBuffer.Set(aBuffer.Mid(consumed));

 	// Trim out any whitespace surrounding the token, and return how

 	// many characters were extracted.

 	InetProtTextUtils::RemoveWhiteSpace(aToken, InetProtTextUtils::ERemoveBoth);

 	return consumed;

 	}

 /**	

 	Extract a quoted string value from the buffer. 

 	@param			aBuffer			The buffer containing the quoted.

 	@param			aQuotedString	An output argument containing the extracted

 									string.

 	@return			The number of characters consumed from the buffer.

 */

 template<class TPtrCType>

 TInt DoExtractQuotedStringL(TPtrCType& aBuffer, TPtrCType& aQuotedString)

 	{

 	// Find the opening "

 	TInt quotePos1 = aBuffer.Locate(KQuote);

 	if( quotePos1 == KErrNotFound )

 		User::Leave(KUriUtilsErrDecodeMalformedQuotedString);

 	// Find the closing "

 	TPtrCType temp = aBuffer.Mid(quotePos1 + 1);	// ignore the "

 	TInt quotePos2 = temp.LocateReverse(KQuote);

 	if( quotePos2 == KErrNotFound )

 		User::Leave(KUriUtilsErrDecodeMalformedQuotedString);

 	// return what's between them and consume the right number of characters from the buffer

 	aQuotedString.Set(temp.Left(quotePos2));

 	TInt consumed = quotePos1 + quotePos2 + 2; // +2 is to consume the quotes themselves

 	aBuffer.Set(aBuffer.Mid(consumed));

 	return consumed;

 	}

 /**

 	Converts an integer value into its decimal character representation.

 	@param			aInt		An integer value.	

 	@param			aBuffer		An output argument of a pointer to a data buffer

 	that will contain the character representation of the integer value.

 	@param			aRadix		enum value.	

 */

 template<class HBufCType>

 void DoConvertIntToDescriptorL(TInt aInt, HBufCType*& aBuffer, TRadix aRadix)

 	{

 	// Create the buffer - max possible size for binary number is 32

 	TBuf8<KMaxNumberSize> buf;

 	buf.SetMax();

 	// Is the number -ve?

 	TUint value = aInt;

 	TBool negative = EFalse;

 	if( aInt < 0 )

 		{

 		negative = ETrue;

 		value = -aInt;

 		}

 	// Now form the number...

 	TInt index = KMaxNumberSize;

 	do	

 		{

 		// Update the index

 		--index;

 		__ASSERT_DEBUG( index > 0, User::Invariant() );

 		// Find the value of the least significant digit

 		TUint q = value/aRadix;

 		TUint c = value - (q*aRadix);

 		// Convert digit to character and insert into the buffer.

 		( c > 9 ) ? c += (KAChar-10) : c += KZeroChar;

 		buf[index] = STATIC_CAST(TUint8, c);

 		// Update the value left to convert.

 		value = q;

 		} while( value > 0 );

 	// Add the '-' sign if number was negative

 	if( negative )

 		buf[--index] = KMinusSign;

 	// Create the output buffer...

 	TPtrC8 number = buf.Mid(index);

 	aBuffer = HBufCType::NewL(number.Length());

 	aBuffer->Des().Copy(number);

 	}

 /**

 	Converts the character representation of an integer into its numeric value.

 	Preceeding whitespace is ignored and the integer is delimited by either the

 	end of the data, whitespace or any other character other than 0 to 9.

 	@param			aData	A descriptor pointer with the data.

 	@param			aInt	An output argument in which the numeric value of the

 	data is placed.

 	@param			aRadix		enum value.	

 	@return			The number of consumed characters that contributed to the 

 					integer value, including any whitespace before the integer. 

 					If the data is empty the error code KUriUtilsErrEmptyData 

 					is returned. If there are no digits at the beginning of the

 					data the error code KUriUtilsErrNoIntergerInData is returned.

 */

 template<class TPtrCType>

 TInt DoConvertDescriptorToInt(const TPtrCType& aData, TInt& aInt, TRadix aRadix)

 	{

 	// Remove any whitespace before the digits

 	TPtrCType data = aData;

 	TInt consumed = InetProtTextUtils::RemoveWhiteSpace(data, InetProtTextUtils::ERemoveLeft);

 	// Ensure that there are some digits to convert

 	TInt length = data.Length();

 	if( length == 0 )

 		{

 		return KUriUtilsErrEmptyData;

 		}

 	// Search for digits and calculate value - stop when non-digit found

 	TInt value = 0;

 	TBool done = EFalse;

 	TBool negative=EFalse;

 	if(data[0]==KMinusSign)

 	   {

 		negative=ETrue;

 	   }	

 	TInt i=0;

 	// Length is verifying as user input may be just only '-' sign.

 	if( negative && length > 1 )

 		{

 		i = 1;	

 		}

 	while( !done )

 		{

 		// Get the current char and see if it is a digit

 		TChar c = data[i];

 		if( c.IsHexDigit() )

 			{

 			// Need to convert char to its numeric value

 			TInt digit = c - KZeroChar;

 			// Was the char in the A-F range?

 			if( digit > 9 )

 				digit = c.GetUpperCase() - (KAChar - 10);

 			if( digit > aRadix )

 				{

 				// The character is too large for the radix - end of data.

 				done = ETrue;

 				}

 			else

 				{

 				// Update running total

 				value *= aRadix;

 				value += digit;

 				}

 			}

 		else

 			{

 			// Non-digit found - we're done!

 			done = ETrue;

 			}

 		// Check for end of data

 		done = done || !(++i < length);

 		}

 	// Set up outputs

 	if( i == 0 )

 		{

 		// No digits found in data - do not set aInt

 		return KUriUtilsErrNoIntegerInData;

 		}

 	// Set the value of the interger

 	if( negative )

 		aInt = -value;

 	else

 		aInt = value;

 	// Return consumed characters

 	return i + consumed;

 	}