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

//

// System includes

#include <uri8.h>

#include <uri16.h>

#include "TUriCInternal.h"

#include <uriutilscommon.h>

#include <uriutils.h>

#include "UriUtilsInternal.h"

#include "TValidator.h"

#include "TEquiv.h"

#include <escapeutils.h>

// Panic category

//

_LIT(KUriPanicCategory,"URI-BASE");

//

//

// Implementation of TUriC8

//

//

/**

  Constructor.

  @since			6.0

 */

EXPORT_C TUriC8::TUriC8()

	{

	// Reset the component table and the Uri

	Reset();

	}

/**

  Retrieves the specified component in the uri.

  @since			6.0

  @param			aComponent	The enum specifying the component.

  @return			A constant reference to a descriptor pointer to the specified 

  component.

 */

EXPORT_C const TDesC8& TUriC8::Extract(TUriComponent aComponent) const

	{

	__ASSERT_ALWAYS(aComponent<EUriMaxComponents && aComponent >EUriComplete, User::Panic(KUriPanicCategory, KUriUtilsErrBadComponentIndex));

	return iComponent[aComponent];

	}

/**

  Indicates whether the specified component is present in the uri.

  @since			6.0

  @param			aComponent	The enum specifying the component.

  @return			A boolean value of ETrue if the desired component is present, 

  or EFalse if the desired component is not present.

 */

EXPORT_C TBool TUriC8::IsPresent(TUriComponent aComponent) const

	{

	__ASSERT_ALWAYS(aComponent<EUriMaxComponents && aComponent >EUriComplete, User::Panic(KUriPanicCategory, KUriUtilsErrBadComponentIndex));

	return TBool(iComponent[aComponent].Ptr());

	}

/**

  Checks the scheme to be valid. If there is no scheme then the return value 

  indicates an invalid scheme.

  @since			6.0

  @return			A boolean value of ETrue if the scheme is valid, or EFalse if

  the scheme is not.

 */

EXPORT_C TBool TUriC8::IsSchemeValid() const

	{

	if( !IsPresent(EUriScheme) )

		{

		return EFalse;

		}

	return HasValidSchemeChars(iComponent[EUriScheme]);

	}

/**

  Compares the specified component against the one in the uri passed in.

  @since			6.0

  @param			aUri		The uri to compare components against.

  @param			aComponent	The enum specifying the component to compare.

  @return			An integer value of zero if the components are the same,

  any other value if the components are not the same.

 */

EXPORT_C TInt TUriC8::Compare(const TUriC8& aUri, TUriComponent aComponent) const

	{

	__ASSERT_ALWAYS(aComponent<EUriMaxComponents && aComponent >EUriComplete, User::Panic(KUriPanicCategory, KUriUtilsErrBadComponentIndex));

	// Does the component exist in both the Uri's

	if( IsPresent(aComponent) && aUri.IsPresent(aComponent) )

		{

		if( aComponent == EUriScheme || aComponent == EUriHost )

			{

			// Do case insensitive compare for scheme and host

			return (iComponent[aComponent].CompareF(aUri.iComponent[aComponent]));

			}

		else

			{

			// Do case sensitive compare for all other components

			return (iComponent[aComponent].Compare(aUri.iComponent[aComponent]));

			}

		}

	else

		return KErrNotFound;

	}

/**

  Retrieves the descriptor for the entire uri.

  @since			6.0

  @return			A const reference to a descriptor pointer to the uri.

 */

EXPORT_C const TDesC8& TUriC8::UriDes() const

	{

	return iUriDes;

	}

/**

  @publishedPartner

  @released

  Ensures that all components of the URI are valid. If the method	returns 

  KUriUtilsErrInvalidUri then one or more components are not valid. It is

  possible for URIs declared valid by this method to be, on detailed inspection, 

  invalid.

  @return	KErrNone for vaild URIs, KUriUtilsErrInvalidUri for invalid URIs or KErrNotSupported.

 */

EXPORT_C TInt TUriC8::Validate() const

	{

	return DoValidate(*this);

	}

/**

  Compares the given URI to determine if it is equivalent to this URI. It is possible

  for URIs declared NOT equivalent by this method to be equvalent to a level not checked 

  by this method.

  @publishedPartner

  @released

  @param			aUri	Contains URI to compare 

  @return			ETrue if the two URIs are equivalent otherwise EFalse

 */

EXPORT_C TInt TUriC8::Equivalent(const TUriC8& aUri) const

	{

	TInt result = EFalse;

	TRAPD(error, result = DoEquivalenceL(*this, aUri));

	if (error != KErrNone)

		{

		result = error;

		}

	return result;

	}

/**

  Retrieves the uri without the fragment component.

  @since			6.0

  @param			aUriNoFrag	An output parameter which is set the non-reference 

  version of the uri.

 */

EXPORT_C void TUriC8::UriWithoutFragment(TPtrC8& aUriNoFrag) const

	{

	if( IsPresent(EUriFragment) )

		{

		// There is a fragment, find where it starts

		TInt fragmentStartPos = iUriDes.Locate(KFragmentDelimiter);

		aUriNoFrag.Set(iUriDes.Left(fragmentStartPos));

		}

	else{

		aUriNoFrag.Set(iUriDes);

		}

	}

/** 

  Create a new HBufC descriptor containing the desired component or the full URI.

  @param    aComponent  The component to convert into Unicode (EUriScheme - EUriFragment),  or

  the full URI (EUriComplete -- the default).

  @return    The descriptor containing the desired component. 

 */

EXPORT_C HBufC* TUriC8::DisplayFormL(TUriComponent aComponent) const

	{

	TPtrC8 component;	

	if (aComponent == EUriComplete) 

		{

		component.Set(iUriDes);

		}

	else 

		{  // extract the specified component, will Panic if invalid

		component.Set( Extract(aComponent) );

		}

	// convert descriptor from UTF-8 into Unicode

	return EscapeUtils::ConvertToUnicodeFromUtf8L(component);

	}

/**

  @internalComponent

  Resets the descriptor pointers for the uri components and the uri.

  @since		6.0

  @post			All uri component information is removed and the uri descriptor is 

  set to NULL.

 */

void TUriC8::Reset()

	{

	// Set descriptor pointers to NULL and lengths to zero

	for( TInt i=0; i<EUriMaxComponents; ++i )

		{

		iComponent[i].Set(NULL,0);

		}

	iUriDes.Set(NULL,0);

	}

//

//

// Implementation of TUriC16

//

//

/**

  Constructor.

  @since		6.0

  @deprecated 	Deprecated in 9.1

 */

EXPORT_C TUriC16::TUriC16()

	{

	// Reset the component table and the Uri

	Reset();

	}

/**

  Retrieves the specified component in the uri.

  @since			6.0

  @deprecated 		Deprecated in 9.1

  @param			aComponent	The enum specifying the component.

  @return			A constant reference to a descriptor pointer to the specified component.

 */

EXPORT_C const TDesC16& TUriC16::Extract(TUriComponent aComponent) const

	{

	__ASSERT_ALWAYS(aComponent<EUriMaxComponents && aComponent >EUriComplete, User::Panic(KUriPanicCategory, KUriUtilsErrBadComponentIndex));

	return iComponent[aComponent];

	}

/**

  Indicates whether the specified component is present in the uri.

  @since			6.0

  @deprecated Deprecated in 9.1

  @param			aComponent	The enum specifying the component.

  @return			A boolean value of ETrue if the desired component is present, 

  or EFalse if the desired component is not present.

 */

EXPORT_C TBool TUriC16::IsPresent(TUriComponent aComponent) const

	{

	__ASSERT_ALWAYS(aComponent<EUriMaxComponents && aComponent >EUriComplete, User::Panic(KUriPanicCategory, KUriUtilsErrBadComponentIndex));

	return TBool(iComponent[aComponent].Ptr());

	}

/**

  Checks to see if the scheme is valid. If there is no scheme then the return value 

  indicates an invalid scheme (EFalse).

  @since		6.0

  @deprecated 	Deprecated in 9.1

  @return		A boolean value of ETrue if the scheme is valid, or EFalse if

  the scheme is not.

 */

EXPORT_C TBool TUriC16::IsSchemeValid() const

	{

	if( !IsPresent(EUriScheme) )

		{

		return EFalse;

		}

	return HasValidSchemeChars(iComponent[EUriScheme]);

	}

/**

  Compares the specified component against the one in the uri passed in.

  @since		6.0

  @deprecated 	Deprecated in 9.1

  @param		aUri		The uri to compare components against.

  @param		aComponent	The enum specifying the component to compare.

  @return		An integer value of zero if the components are the same, any other

  value if the components are not the same.

 */

EXPORT_C TBool TUriC16::Compare(const TUriC16& aUri, TUriComponent aComponent) const

	{

	__ASSERT_ALWAYS(aComponent<EUriMaxComponents && aComponent >EUriComplete, User::Panic(KUriPanicCategory, KUriUtilsErrBadComponentIndex));

	// Does the component exist in both the Uri's

	if( IsPresent(aComponent) && aUri.IsPresent(aComponent) )

		{

		if( aComponent == EUriScheme || aComponent == EUriHost )

			{

			// Do case insensitive compare for scheme and host

			return (iComponent[aComponent].CompareF(aUri.iComponent[aComponent]));

			}

		else

			{

			// Do case sensitive compare for all other components

			return (iComponent[aComponent].Compare(aUri.iComponent[aComponent]));

			}

		}

	else

		return KErrNotFound;

	}

/**

  Retrieves the descriptor for the entire uri.

  @since			6.0

  @deprecated Deprecated in 9.1

  @return			A const reference to a descriptor pointer to the uri.

 */

EXPORT_C const TDesC16& TUriC16::UriDes() const

	{

	return iUriDes;

	}

/**

  @deprecated Deprecated in 9.1 -- provided for compatibility

  Ensures that all components of the URI are valid. If the method	returns 

  KUriUtilsErrInvalidUri then one or more components are not valid. It is possible

  for URIs declared valid by this method to be, on detailed inspection, invalid.

  @return			KErrNone for vaild URIs, KUriUtilsErrInvalidUri for invalid URIs or KErrNotSupported.

 */

EXPORT_C TInt TUriC16::Validate() const

	{

	TInt result = KErrNone;

	TRAPD(error, result = ValidateL());

	if (error)

		{

		// problem allocating resourses 

		return error;

		}

	return result;

	}

/**

  @deprecated Deprecated in 9.1 -- provided for compatibility

  Compares the given URI to determine if it is equivalent to this URI. It is possible

  for URIs declared NOT equivalent by this method to be equvalent to a level not checked 

  by this method.

  @param			aUri	Contains URI to compare 

  @return			ETrue if the two URIs are equivalent otherwise EFalse

 */

EXPORT_C TInt TUriC16::Equivalent(const TUriC16& aUri) const

	{

	TInt result = KErrNone;

	TRAPD(error, result = EquivalentL(aUri.UriDes()));

	if (error)

		{

		// problem allocating resourses 

		return error;

		}

	return result;

	}

/**

  Retrieves the uri without the fragment component.

  @since			6.0

  @deprecated Deprecated in 9.1

  @param			aUriNoFrag	An output parameter which is set the non-reference 

  version of the uri.

 */

EXPORT_C void TUriC16::UriWithoutFragment(TPtrC16& aUriNoFrag) const

	{

	if( IsPresent(EUriFragment) )

		{

		// There is a fragment, find where it starts

		TInt fragmentStartPos = iUriDes.Locate(KFragmentDelimiter);

		aUriNoFrag.Set(iUriDes.Left(fragmentStartPos));

		}

	else{

		aUriNoFrag.Set(iUriDes);

		}

	}

/** 

  Create a new HBufC descriptor containing the desired component or the full URI.

  @deprecated Deprecated in 9.1 - provided for compatibility	

  @param aComponent  The component to convert into Unicode (EUriScheme - EUriFragment),  or

  the full URI (EUriComplete -- the default).

  @return The descriptor containing the desired component. 

 */

EXPORT_C HBufC* TUriC16::DisplayFormL(TUriComponent aComponent) const

	{

	if ( aComponent == EUriComplete) // extract the full URI

		{

		return iUriDes.AllocL();	

		}

	return Extract(aComponent).AllocL();

	}

/**	

  @internalComponent

  Resets the descriptor pointers for the uri components and the uri.

  @since			6.0

  @post			All uri component information is removed and the uri descriptor is 

  set to NULL.

 */

void TUriC16::Reset()

	{

	// Set descriptor pointers to NULL and lengths to zero

	for( TInt i=0; i<EUriMaxComponents; ++i )

		{

		iComponent[i].Set(NULL,0);

		}

	iUriDes.Set(NULL,0);

	}

/**

  @deprecated Deprecated in 9.1 

  Ensures that all components of the URI are valid. If the method	returns 

  KUriUtilsErrInvalidUri then one or more components are not valid. It is possible

  for URIs declared valid by this method to be, on detailed inspection, invalid.

  @return			KErrNone for vaild URIs, KUriUtilsErrInvalidUri for invalid URIs or KErrNotSupported.

 */

TInt TUriC16::ValidateL() const

	{

	TInt result;

	HBufC8* uri8 = CreateUri8LC(UriDes());

	TUriParser8 uriParser;		

	if(uriParser.Parse(*uri8) != KErrNone)

		{

		result = KUriUtilsErrInvalidUri;

		}

	else		

		{

		result = DoValidate(uriParser);		

		}

	CleanupStack::PopAndDestroy(uri8);

	return result;	

	}

/**

  @deprecated Deprecated in 9.1 

  Compares the given URI to determine if it is equivalent to this URI. It is possible

  for URIs declared NOT equivalent by this method to be equvalent to a level not checked 

  by this method.

  @param			aUri	Contains URI to compare 

  @return			ETrue if the two URIs are equivalent otherwise EFalse

 */

TBool TUriC16::EquivalentL(const TDesC16& aUri) const

	{

	HBufC8* lhs = CreateUri8LC(UriDes());

	HBufC8* rhs = CreateUri8LC(aUri);

	TUriParser8 lhsParser;		

	if(lhsParser.Parse(*lhs) != KErrNone)

		{

		User::Leave(KUriUtilsErrInvalidUri);

		}

	TUriParser8 rhsParser;		

	if(rhsParser.Parse(*rhs) != KErrNone)

		{

		User::Leave(KUriUtilsErrInvalidUri);

		}

	TBool result = DoEquivalenceL(lhsParser, rhsParser);		

	CleanupStack::PopAndDestroy(2);

	return result;	

	}

//

//

// Implementation of LOCAL functions

//

//

/**

	Checks the scheme for invalid characters. The scheme is invalid if it is empty.

	@since			6.0

	@param			aScheme	The descriptor with the scheme.

	@return			A boolean value of ETrue if all the characters in the scheme

	are valid, otherwise EFalse.

*/

template<class TPtrCType>

LOCAL_C TBool HasValidSchemeChars(const TPtrCType& aScheme)

	{

	TInt length = aScheme.Length();

	TBool valid = ( length && TChar(aScheme[0]).IsAlpha() );

	// Start checking from the second character

	TInt i=1;

	while( valid && i<length )

		{

		TChar c = aScheme[i];

		valid = c.IsAlphaDigit() || c==KPlusChar || c==KMinusChar || c==KPeriodChar;