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

*/