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

#include <uri8.h>

#include <uri16.h>

#include <delimitedpath8.h>

#include <delimitedpath16.h>

#include <uriutilscommon.h>

#include <uriutils.h>

#include "UriUtilsInternal.h"

#include "TUriCInternal.h"

#include "CUriInternal.h"

// Panic category

//

#ifdef _DEBUG

	_LIT(KUriPanicCategory,"URI-CURI"); 

#endif

// Constants

//

_LIT(KFileUriPanicCategory,"FILEURI-CURI");

//

//

// Implementation of CUri8

//

//

/**

	Static factory constructor. Uses two phase construction and leaves nothing on the 

	CleanupStack. Creates a uri object which is a copy of the input parameter aUri.

	@since			6.0

	@param			aUri	A reference to a parsed uri object.

	@return			A pointer to the newly created CUri8 object. 

	@post			A fully constructed and initialized CUri8 object.

 */

EXPORT_C CUri8* CUri8::NewL(const TUriC8& aUri)

	{

	CUri8* self = CUri8::NewLC(aUri);

	CleanupStack::Pop(self);

	return self;

	}

/**	

	Static factory constructor. Uses two phase construction and leaves a pointer to 

	created object on the CleanupStack. Creates a uri object which is a copy of the 

	input parameter aUri.

	@since			6.0

	@param			aUri	A reference to a parsed uri object.

	@return			A pointer to the newly created CUri8 object. 

	@post			A fully constructed and initialized CUri8 object.

 */

EXPORT_C CUri8* CUri8::NewLC(const TUriC8& aUri)

	{

	CUri8* self = new (ELeave) CUri8(aUri);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

/**	

	Static factory constructor. Uses two phase construction and leaves nothing on the 

	CleanupStack. Creates a uri object which is empty.

	@since			6.0

	@return			A pointer to the newly created CUri8 object. 

	@post			A fully constructed and initialized CUri8 object.

 */

EXPORT_C CUri8* CUri8::NewL()

	{

	CUri8* self = CUri8::NewLC();

	CleanupStack::Pop(self);

	return self;

	}

/**

	Static factory constructor. Uses two phase construction and leaves a pointer to created 

	object on the CleanupStack. Creates a uri object which is empty.

	@since			6.0

	@return			A pointer to the newly created CUri8 object. 

	@post			A fully constructed and initialized CUri8 object.

 */

EXPORT_C CUri8* CUri8::NewLC()

	{

	CUri8* self = new (ELeave) CUri8(TUriC8());

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

/**	

	Static factory constructor. This creates a CUri8 object that is an absolute uri resulting 

	from a reference uri being resolved against a base uri.

	@warning		Ownership of created CUri8 object is transferred to the caller.

	@leave			KUriErrBadBasePath if the base path is not an absolute path and not empty.

	@since			6.0

	@param			aBaseUri	A referece to the parsed base uri.

	@param			aRefUri		A referece to the parsed reference uri.

	@return			A pointer to the newly created CUri8 object.

	@pre 			The base uri must have an absolute or empty path, otherwise will leave

	with KUriErrBadBasePath.

	@post			A fully constructed and initialized CUri8 object.

 */

EXPORT_C CUri8* CUri8::ResolveL(const TUriC8& aBaseUri, const TUriC8& aRefUri)

	{

	// Check for a base Uri

	if( aBaseUri.UriDes().Compare(KNullDesC8) == 0 )

		{

		// Empty base Uri - resolved Uri is the reference Uri

		return NewL(aRefUri);

		}

	// See if ref has scheme and it is the same as base Uri

	if( aRefUri.IsPresent(EUriScheme) && (aRefUri.Compare(aBaseUri, EUriScheme) != 0) )

		{

		// Ref has a scheme different to base Uri's - it is an absolute Uri

		return NewL(aRefUri);

		}

	// Check for presence of components

	TBool useBaseQuery = EFalse;

	HBufC8* resolvedPath = FormResolvedPathLC<HBufC8>(aBaseUri, aRefUri, useBaseQuery);

	//Removes dot segemnts in Resolved uri as specified in RFC3986 section 5.2.

	RemoveExtraneousDotSegmentsL(resolvedPath);

	// Put the Uri together

	TUriC8 uri;

	FormResolvedUri(uri.iComponent, aBaseUri, aRefUri, resolvedPath, useBaseQuery);

	// Create the resolved Uri and cleanup

	CUri8* resolvedUri = NewL(uri);

	CleanupStack::PopAndDestroy(resolvedPath);

	return resolvedUri;

	}

/**	

	Destructor.

	@since			6.0

 */

EXPORT_C CUri8::~CUri8()

	{

	delete iUriBuf;

	}

/**	

	Provides a reference to the parsed uri. Allows access to the non-modifying API for TUriC8.

	@since			6.0

	@return			A const reference to the parsed uri object.

 */

EXPORT_C const TUriC8& CUri8::Uri() const

	{

	return iUri;

	}

/**	

	Intended Usage	:	Sets the specified component in the uri. The component is set to the value 

	given in the argument aData. If the specified component already exists  then it is replaced 

	with the new value.

	@warning		The userinfo and port components can only be set if the host component

	is present. Setting these components without a host component present will have no 

	effect on the uri.

	@since			6.0

	@param			aData		A descriptor pointer to the new value for the uri component.

	@param			aComponent	An enum specifying the component to be set.

	@pre 			Object is fully constructed.

	@post			The uri has the specified component set to the new value.

	@Leave          KErrArgument  If aComponent goes out of range.

 */

EXPORT_C void CUri8::SetComponentL(const TDesC8& aData, TUriComponent aComponent)

	{

	// Update the appropriate component table entry

	iUri.iComponent[aComponent].Set(aData);

	// Copy to the buffer by forming the uri

	FormUriL();

	}

/**	

	Removes the specified component from the uri. If the component does not exist then this function 

	does nothing.

	@warning		If host is removed, then userinfo and port components will also

	be removed.

	@since			6.0

	@param			aComponent	An enum specifying the component to be removed.

	@pre 			Object is fully constructed.

	@post			The uri is updated to exclude the specified component.

 */

EXPORT_C void CUri8::RemoveComponentL(TUriComponent aComponent)

	{

	if( iUri.IsPresent(aComponent) )

		{

		// Remove the component - set pointer to NULL and length to zero

		iUri.iComponent[aComponent].Set(NULL,0);

		// Re-form buffer and component table

		FormUriL();

		}

	}

/**	

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

	@since			6.0

	@param			aUri	The parsed uri component information from which to create 

	the uri.

*/

CUri8::CUri8(const TUriC8& aUri)

: CBase(), iUri(aUri)

	{

	}

/**	

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

	the object.

	@since			6.0

	@pre 			First phase of construction is complete.

	@post			The object is fully constructed and initialized.

 */

void CUri8::ConstructL()

	{

	// Create the HBufC

	FormUriL();

	}

/**	

	Forms the uri from the parsed uri information. A copy of the parsed uri is created. The parsed uri 

	is changed to refer to the copy.

	@since			6.0

	@pre 			The parsed uri information is set.

	@post			The uri buffer is updated with the parsed uri information.

 */

void CUri8::FormUriL()

	{

	TBool isIPv6Host;

	// Calculate length of of the Uri

	TInt length = CalculateUriLength(iUri.iComponent, isIPv6Host);

	// Create a temporary buffer and descriptor pointer to it

	HBufC8* buf = HBufC8::NewL(length);

	TPtr8 uri = buf->Des();

	// Create the uri, updating the internal uri object

	DoFormUri(uri, iUri.iComponent, isIPv6Host);

	// Update the internal buffer and descriptor pointer

	delete iUriBuf;

	iUriBuf = buf;

	iUri.iUriDes.Set(iUriBuf->Des());

	}

//

//

// Implementation of CUri16

//

//

/**	

	Static factory constructor. Uses two phase construction and leaves nothing on the CleanupStack. 

	Creates a uri object which is a copy of the input parameter aUri.

	@deprecated Deprecated in 9.1

	@since			6.0

	@param			aUri	A reference to a parsed uri object.

	@return			A pointer to the newly created CUri16 object. 

	@post			A fully constructed and initialized CUri16 object.

 */

EXPORT_C CUri16* CUri16::NewL(const TUriC16& aUri)

	{

	CUri16* self = CUri16::NewLC(aUri);

	CleanupStack::Pop(self);

	return self;

	}

/**	

	Static factory constructor. Uses two phase construction and leaves a pointer to created object on 

	the CleanupStack. Creates a uri object which is a copy of the input parameter aUri.

	@since			6.0

	@deprecated Deprecated in 9.1

	@param			aUri	A reference to a parsed uri object.

	@return			A pointer to the newly created CUri16 object. 

	@post			A fully constructed and initialized CUri16 object.

 */

EXPORT_C CUri16* CUri16::NewLC(const TUriC16& aUri)

	{

	CUri16* self = new (ELeave) CUri16(aUri);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

/**

	Static factory constructor. Uses two phase construction and leaves nothing on the CleanupStack. 

	Creates a uri object which is empty.

	@since			6.0

	@deprecated Deprecated in 9.1

	@return			A pointer to the newly created CUri16 object. 

	@post			A fully constructed and initialized CUri16 object.

 */

EXPORT_C CUri16* CUri16::NewL()

	{

	CUri16* self = CUri16::NewLC();

	CleanupStack::Pop(self);

	return self;

	}

/**

	Static factory constructor. Uses two phase construction and leaves a pointer to created object on 

	the CleanupStack. Creates a uri object which is empty.

	@since			6.0

	@deprecated Deprecated in 9.1

	@return			A pointer to the newly created CUri16 object. 

	@post			A fully constructed and initialized CUri16 object.

 */

EXPORT_C CUri16* CUri16::NewLC()

	{

	CUri16* self = new (ELeave) CUri16(TUriC16());

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

/**	

	Static factory constructor. This creates a CUri16 object that is an absolute uri resulting from a 

	reference uri being resolved against a base uri.

	@warning		Ownership of created CUri16 object is transferred to caller.

	@leave			KUriErrBadBasePath if the base path is not an absolute path and not empty.

	@since			6.0

	@deprecated Deprecated in 9.1

	@param			aBaseUri	A referece to the parsed base uri.

	@param			aRefUri		A referece to the parsed reference uri.

	@return			A pointer to the newly created CUri16 object.

	@pre 			The base uri must have an absolute or empty path, otherwise will leave

	with KUriErrBadBasePath.

	@post			A fully constructed and initialized CUri16 object.

 */

EXPORT_C CUri16* CUri16::ResolveL(const TUriC16& aBaseUri, const TUriC16& aRefUri)

	{

	// Check for a base Uri

	if( aBaseUri.UriDes().Compare(KNullDesC16) == 0 )

		{

		// Empty base Uri - resolved Uri is the reference Uri

		return NewL(aRefUri);

		}

	// See if ref has scheme and it is the same as base Uri

	if( aRefUri.IsPresent(EUriScheme) && aRefUri.Compare(aBaseUri, EUriScheme) != 0 )

		{

		// Ref has a scheme different to base Uri's - it is an absolute Uri

		return NewL(aRefUri);

		}

	// Check for presence of components

	TBool useBaseQuery = EFalse;

	HBufC16* resolvedPath = FormResolvedPathLC<HBufC16>(aBaseUri, aRefUri, useBaseQuery);

	// Put the Uri together

	TUriC16 uri;

	FormResolvedUri(uri.iComponent, aBaseUri, aRefUri, resolvedPath, useBaseQuery);

	// Create the resolved Uri and cleanup

	CUri16* resolvedUri = NewL(uri);

	CleanupStack::PopAndDestroy(resolvedPath);

	return resolvedUri;

	}

/**	

	Destructor.

	@since			6.0

	@deprecated Deprecated in 9.1

 */

EXPORT_C CUri16::~CUri16()

	{

	delete iUriBuf;

	}

/**	

	Provides a reference to the parsed uri. Allows access to the non-modifying API for TUriC16.

	@since			6.0

	@deprecated Deprecated in 9.1

	@return			A const reference to the parsed uri object.

 */

EXPORT_C const TUriC16& CUri16::Uri() const

	{

	return iUri;

	}

/**

	Sets the specified component in the uri. The component is set to the value given in the argument 

	aData. If the specified component already exists then it is replaced with the new value.

	@warning		The userinfo and port components can only be set if the host component

	is present. Setting these components without a host component present will have no 

	effect on the uri.

	@since			6.0

	@deprecated Deprecated in 9.1

	@param			aData		A descriptor pointer to the new value for the uri component.

	@param			aComponent	An enum specifying the component to be set.

	@pre 			Object is fully constructed.

	@post			The uri has the specified component set to the new value.

	@Leave          KErrArgument  If aComponent goes out of range.

 */

EXPORT_C void CUri16::SetComponentL(const TDesC16& aData, TUriComponent aComponent)

	{

	// Update the appropriate component table entry

	iUri.iComponent[aComponent].Set(aData);

	// Copy to the buffer by forming the uri

	FormUriL();

	}

/**

	Removes the specified component from the uri. If the component does not exist then this function 

	does nothing.

	@warning		If host is removed, then userinfo and port components will also

	be removed.

	@since			6.0

	@deprecated Deprecated in 9.1

	@param			aComponent	An enum specifying the component to be removed.

	@pre 			Object is fully constructed.

	@post			The uri is updated to exclude the specified component.

 */

EXPORT_C void CUri16::RemoveComponentL(TUriComponent aComponent)

	{

	if( iUri.IsPresent(aComponent) )

		{

		// Remove the component - set pointer to NULL and length to zero

		iUri.iComponent[aComponent].Set(NULL,0);

		// Re-form buffer and component table

		FormUriL();

		}

	}

/**

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

	@since			6.0

	@param			aUri	The parsed uri component information from which to create

	the uri.

 */

CUri16::CUri16(const TUriC16& aUri)

: CBase(), iUri(aUri)

	{

	}

/**

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

	the object.

	@since			6.0

	@pre 			First phase of construction is complete.

	@post			The object is fully constructed and initialized.

 */

void CUri16::ConstructL()

	{

	// Create the HBufC

	FormUriL();

	}

/**

	Forms the uri from the parsed uri information. A copy of the parsed uri is created. The parsed uri 

	is changed to refer to the copy.

	@since			6.0

	@pre 			The parsed uri information is set.

	@post			The uri buffer is updated with the parsed uri information.

 */

void CUri16::FormUriL()

	{

	TBool isIPv6Host;

	// Calculate length of of the Uri

	TInt length = CalculateUriLength(iUri.iComponent, isIPv6Host);

	// Create a temporary buffer and descriptor pointer to it

	HBufC16* buf = HBufC16::NewL(length);

	TPtr16 uri = buf->Des();

	// Create the uri, updating the internal uri object

	DoFormUri(uri, iUri.iComponent, isIPv6Host);

	// Update the internal buffer and descriptor pointer

	delete iUriBuf;

	iUriBuf = buf;

	iUri.iUriDes.Set(iUriBuf->Des());

	}

//

//

// Implementation of templated LOCAL functions

//

//

/**

	Calculates the length of the uri from a list of the components.

	@since			6.0

	@param			aComponent	The array of descriptor pointers to the uri 

					components.

	@param			aIsIPv6Host	ETrue if an IPv6 format host is used

	@return			The length of the uri including the required delimiters.	

*/

template<class TPtrCType>

TInt CalculateUriLength(const TPtrCType aComponent[], TBool& aIsIPv6Host)

	{

	TBool noAuthority = ETrue;

	TInt length=0;

	aIsIPv6Host=EFalse;

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

		{

		if( aComponent[i].Ptr() )

			{

			length += aComponent[i].Length();

			if( noAuthority && (i==EUriUserinfo || i==EUriHost || i==EUriPort) )

				{

				// There's an authority part...

				noAuthority = EFalse;

				}

			// Need to make space for a delimiter if not path or host

			if( i!=EUriHost && i!=EUriPath )

				++length;		

			// If it's an IPv6 hostname, need extra space for []

			if(i==EUriHost && (UriUtils::HostType(aComponent[i])==UriUtils::EIPv6Host))

				{

				length+=2;				

				aIsIPv6Host=ETrue;

				}

			}

		}

	if( !noAuthority && IsNetworkScheme(aComponent[EUriScheme]))

		{

		// Make space for authority delimiter

		length += KUriNetworkAuthorityDelimiterLength;

		}

	return length;

	}

/**

	Templated function to form a uri. The output argument aUri points to a descriptor 

	buffer large enough to hold the uri. The new uri component information is given by 

	the input/output argument aComponent. For each uri component that exists in aComponent,

	that component and its appropriate delimiters are appended to aUri. Then the components 

	in aComponent are updated to refer to the copies versions in aUri.

	@since			6.0

	@param			aUri		The descriptor pointer to buffer to be appended.

	@param			aComponent	The array of descriptor pointers to be copied and 

					then updated.

	@param			aIsIPv6Host	ETrue if an IPv6 format host is used

	@pre 			The buffer pointed to by aUri should be large enough to have the uri 

					components given in aNewComponent copied into it, as well as the required delimiters.

					This can be obtained using CalculateUriLength().

	@post			The uri buffer pointed to by aUri will have a copy of the uri defined 

					in aComponent, and then aComponent will refer to the copies of these components in aUri.

*/

template<class TPtrType, class TPtrCType>

void DoFormUri(TPtrType& aUri, TPtrCType aComponent[], TBool& aIsIPv6Host)

	{

	TBool isNetworkScheme = ETrue;

	if( aComponent[EUriScheme].Ptr() )

		{

		// Update the scheme

		SetScheme(aUri, aComponent[EUriScheme]);

		isNetworkScheme = IsNetworkScheme(aComponent[EUriScheme]);

		}

	if( aComponent[EUriHost].Ptr() )

		{

		// Update the authority - only needed if there is a host; update userinfo, host and port

		SetAuthority(aUri, aComponent[EUriUserinfo], aComponent[EUriHost], aComponent[EUriPort], aIsIPv6Host, isNetworkScheme);

		}

	else

		{

		// Ensure that there is no userinfo or port components if there is no host 

		// - set pointer to NULL and length to zero

		aComponent[EUriUserinfo].Set(NULL,0);

		aComponent[EUriPort].Set(NULL,0);

		}

	if( aComponent[EUriPath].Ptr() )

		{

		// Update the path

		SetPath(aUri, aComponent[EUriPath]);

		}

	if( aComponent[EUriQuery].Ptr() )

		{

		// Update the query

		SetQuery(aUri, aComponent[EUriQuery]);

		}

	if( aComponent[EUriFragment].Ptr() )

		{

		// Update the fragment

		SetFragment(aUri, aComponent[EUriFragment]);

		}

	}

/**

	Templated function to set the scheme in a uri. The output argument aUri points to the descriptor 

	buffer into which aScheme will be copied.The argument aScheme is then updated to point to the 

	copied version in aUri.

	@warning		This function will panic with KUriErrBufferOverflow if there is not

					enough space in the descriptor to append the scheme and the required delimiter.

	@since			6.0

	@param			aUri	The descriptor pointer to buffer to be appended.

	@param			aScheme	The descriptor pointer to the scheme component to be copied 

					and then updated.

	@pre 			The buffer pointed to by aUri should be large enough to have aNewScheme

					appended to it with the required delimiter. This can be obtained using CalculateUriLength().

	@post			The uri buffer now includes a copy of aScheme and aScheme points to the 

					copy of the scheme component in aUri.

*/

template<class TPtrType, class TPtrCType>

void SetScheme(TPtrType& aUri, TPtrCType& aScheme)

	{

	__ASSERT_DEBUG(aUri.Length() + aScheme.Length() + 1 <= aUri.MaxLength(), User::Panic(KUriPanicCategory, KUriUtilsErrBufferOverflow));

	// Append the scheme and delimiter

	aUri.Append(aScheme);

	aUri.Append(KSchemeDelimiter);

	// Update the component table to use the copy

	aScheme.Set(aUri.Left(aScheme.Length()));

	}

/**

	Templated function to set the authority in a uri. The output argument aUri points to the descriptor 

	buffer into which aUserinfo, aHost and aPort will be copied. The arguments aUserinfo, aHost and aPort 

	are updated to point to the copied versions in aUri.

	@warning		This function will panic with KUriErrBufferOverflow if there 

					is not enough space in the descriptor to append the components and any required 

					delimiters. 

	@since			6.0

	@param			aUri		The descriptor pointer to buffer to be appended.

	@param			aUserinfo	The descriptor pointer to the userinfo component to 

					be copied and then updated.

	@param			aHost		The descriptor pointer to the host component to 

					be copied and then updated.

	@param			aPort		The descriptor pointer to the port component to 

					be copied and then updated.

	@param			aIsIPv6Host	ETrue if an IPv6 format host is used

	@param			aUseNetworkDelimiter EFalse if this is a SIP scheme otherwise ETrue

	@pre 			The buffer pointed to by aUri should be large enough to have 

					aUserinfo, aHost and aPort appended to it with the required delimiters.

					This can be obtained using CalculateUriLength().

	@post			The uri buffer now includes a copy of aUserinfo, aHost and

					aPort, and aUserinfo, aHost and aPort will refer to the copies versions in aUri.

*/

template<class TPtrType, class TPtrCType>

void SetAuthority(TPtrType& aUri, TPtrCType& aUserinfo, TPtrCType& aHost, TPtrCType& aPort, TBool& aIsIPv6Host, TBool aUseNetworkDelimiter)

	{

	__ASSERT_DEBUG(aUri.Length() + aHost.Length() + (aUseNetworkDelimiter ? KUriNetworkAuthorityDelimiterLength:0) <= aUri.MaxLength(), User::Panic(KUriPanicCategory, KUriUtilsErrBufferOverflow));

	if (aUseNetworkDelimiter)

		{

		// If a network scheme append authority delimiter (TWO slash delimiters!)

		aUri.Append(KSlashDelimiter);

		aUri.Append(KSlashDelimiter);

		}

	// Check for userinfo

	if( aUserinfo.Ptr() )

		{

		__ASSERT_DEBUG(aUri.Length() + aUserinfo.Length() + aHost.Length() + 1 <= aUri.MaxLength(), User::Panic(KUriPanicCategory, KUriUtilsErrBufferOverflow));

		// Append userinfo and update the component table to use copy

		aUri.Append(aUserinfo);

		aUserinfo.Set(aUri.Right(aUserinfo.Length()));

		// Append delimiter

		aUri.Append(KUserinfoDelimiter);

		}

	// There's always a host - append and update the component table to use the copy

	// Check if it's an IPv6 address

	if ( aIsIPv6Host )

		{

		aUri.Append(KIPv6UriOpenBrace); 

		aUri.Append(aHost);

		aUri.Append(KIPv6UriCloseBrace);

		// Dont include the braces in the host

		// Position = (length of uri - length of host) - length of end brace

		aHost.Set( aUri.Mid((aUri.Length()-aHost.Length())-1, aHost.Length()) );

		}

	else

		{

		aUri.Append(aHost);

		aHost.Set(aUri.Right(aHost.Length()));

		}

	// Check for a port

	if( aPort.Ptr() )

		{

		__ASSERT_DEBUG(aUri.Length() + aPort.Length() + 1 <= aUri.MaxLength(), User::Panic(KUriPanicCategory, KUriUtilsErrBufferOverflow));

		// Append delimiter

		aUri.Append(KPortDelimiter);

		// Append port and update the component table to use copy

		aUri.Append(aPort);

		aPort.Set(aUri.Right(aPort.Length()));

		}

	}

/**

	Templated function to set the path in a uri. The output argument aUri points to the descriptor 

	buffer into which aPath will be copied.The argument aPath is then updated to point to the copied 

	version in aUri.

	@warning		This function will panic with KUriErrBufferOverflow if there 

					is not enough space in the descriptor to append the path.

	@since			6.0

	@param			aUri	The descriptor pointer to buffer to be appended.

	@param			aPath	The descriptor pointer to the path component to be copied 

					and then updated.

	@pre 			The buffer pointed to by aUri should be large enough to have 

					aPath appended to it. This can be obtained using CalculateUriLength().

	@post			The uri buffer now includes a copy of aPath and aPath points to the 

					copy of the path component in aUri.

*/

template<class TPtrType, class TPtrCType>

void SetPath(TPtrType& aUri, TPtrCType& aPath)

	{

	__ASSERT_DEBUG(aUri.Length() + aPath.Length() <= aUri.MaxLength(), User::Panic(KUriPanicCategory, KUriUtilsErrBufferOverflow));

	// Append the path

	aUri.Append(aPath);

	// Update the component table

	aPath.Set(aUri.Right(aPath.Length()));

	}

/**

	Templated function to set the query in a uri. The output argument aUri points to the descriptor 

	buffer into which aQuery will be copied. The argument aQuery is then updated to point to the copied 

	version in aUri.

	@warning		This function will panic with KUriErrBufferOverflow if there 

					is not enough space in the descriptor to append the query and the delimiter.

	@since			6.0

	@param			aUri	The descriptor pointer to buffer to be appended.

	@param			aQuery	The descriptor pointer to the query component to be copied 

					and then updated.

	@pre 			The buffer pointed to by aUri should be large enough to have 

					aQuery appended to it. This can be obtained using CalculateUriLength().

	@post			The uri buffer now includes a copy of aQuery and aQuery points to the 

					copy of the query component in aUri.

*/

template<class TPtrType, class TPtrCType>

void SetQuery(TPtrType& aUri, TPtrCType& aQuery)

	{

	__ASSERT_DEBUG(aUri.Length() + aQuery.Length() + 1 <= aUri.MaxLength(), User::Panic(KUriPanicCategory, KUriUtilsErrBufferOverflow));

	// Append delimiter and the query

	aUri.Append(KQueryDelimiter);

	aUri.Append(aQuery);

	// Update the component table

	aQuery.Set(aUri.Right(aQuery.Length()));

	}

/**

	Templated function to set the fragment in a uri. The output argument aUri points to the descriptor 

	buffer into which aFragment will be copied. The argument aFragment is then updated to point to the 

	copied version in aUri.

	@warning		This function will panic with KUriErrBufferOverflow if there 

					is not enough space in the descriptor to append the fragment and the delimiter.

	@since			6.0

	@param			aUri		The descriptor pointer to buffer to be appended.

	@param			aFragment	The descriptor pointer to the fragment component

					to be copied and then updated.

	@pre 			The buffer pointed to by aUri should be large enough to have 

					aFragment appended to it. This can be obtained using CalculateUriLength().

	@post			The uri buffer now includes a copy of aFragment and aFragment points 

					to the copy of the fragment component in aUri.

*/

template<class TPtrType, class TPtrCType>

void SetFragment(TPtrType& aUri, TPtrCType& aFragment)

	{

	__ASSERT_DEBUG(aUri.Length() + aFragment.Length() + 1 <= aUri.MaxLength(), User::Panic(KUriPanicCategory, KUriUtilsErrBufferOverflow));

	// Append delimiter and the fragment

	aUri.Append(KFragmentDelimiter);

	aUri.Append(aFragment);

	// Update the component table

	aFragment.Set(aUri.Right(aFragment.Length()));

	}

/**

	Forms the resolved path. Checks to see if the base query needs to be used in the resolved uri. 

	The pointer to the resolved path is left on the cleanup stack.

	@since			6.0

	@param			aBaseUri		The base uri.

	@param			aRefUri			The reference uri.

	@param			aUseBaseQuery	An output argument specifying whether the base

					query should be used in the resolved uri.

	@return			A pointer to a buffer that contains the resolved path.

*/

template<class HBufCType, class TUriCType>

HBufCType* FormResolvedPathLC(const TUriCType& aBaseUri, const TUriCType& aRefUri, TBool& aUseBaseQuery)

	{

	HBufCType* resolvedPath = NULL;

	if( !aRefUri.IsPresent(EUriScheme) && !aRefUri.IsPresent(EUriHost) && !aRefUri.Extract(EUriPath).Length() && !aRefUri.IsPresent(EUriQuery) )

		{

		// Ref is just a fragment

		aUseBaseQuery = ETrue;

		resolvedPath = aBaseUri.Extract(EUriPath).AllocLC();

		}

	else if( aRefUri.IsPresent(EUriHost) )

		{

		// Ref is a network path

		resolvedPath = aRefUri.Extract(EUriPath).AllocLC();

		}

	else

		{

		// Need to some path resolving...

		resolvedPath = ResolvePathsL(aBaseUri.Extract(EUriPath), aRefUri.Extract(EUriPath));

		CleanupStack::PushL(resolvedPath);

		}

	return resolvedPath;

	}

/**

	Cleans up a resolved path. This deals with occurences of '.' and '..' where these are complete 

	path segments.

	@since			6.0

	@param			aResolvedPath	The delimited data object that contains the 

					resolved path.

	@pre 			The input/output argument contains the path to be cleaned.

	@post			The resolved path has had all the occurences of '.' and '..' 

					processed and has been updated to contain the cleaned path.

 */

template<class TPtrCType, class CDelimitedDataBaseType>

void CleanResolvedPathL(CDelimitedDataBaseType* aResolvedPath)

	{

	// Create a modifiable path object for resolved path

	aResolvedPath->Parse();

	TBool done = EFalse;

	while( !done )

   		{

   		// Get the next segment

   		TPtrCType segment;

   		TInt more = aResolvedPath->Parser().Peek(segment);

   		if( more == KErrNotFound )

   			{

   			// No more segments - done

   			done = ETrue;

   			}

   		else if( IsParentDir(segment) )

   			{

   			// Found a '..' - remove '..' from path, and remove previous segment

			aResolvedPath->RemoveCurrentL();

			if( aResolvedPath->Parser().Dec() == KErrNotFound )

				{

				// No previous directory - put back '..' and stop

				InsertParentDirL(aResolvedPath);

				done = ETrue;

				}

			else

				{

				// Remove the parent directory

				aResolvedPath->RemoveCurrentL();

				if( aResolvedPath->Parser().Eos() )

					{

					// '..' is the last segment - add a '/' to the path (add empty segment)

					aResolvedPath->AddBackDelimiterL();

					done = ETrue;

					}

				}

			}

   		else if( IsSameDir(segment) )

   			{

   			// Found a '.' - remove -.- from the path

			aResolvedPath->RemoveCurrentL();

			if( aResolvedPath->Parser().Eos() )

				{

				// '..' is the last segment - add a '/' to the path (add empty segment)

				aResolvedPath->AddBackDelimiterL();

				done = ETrue;

				}

			}

   		else

   			{

   			// Segment wasn't '.' or '..' - parse to next segment

   			aResolvedPath->Parser().Inc();

   			}

   		}

	}

/**

	Forms the resolved uri. Sets the components for the resolved uri from those in the base uri and 

	the reference uri. The resolved path is given by the input argument aResolvedPath

	@since			6.0

	@param			aComponent		The array of components to be set for the resolved uri.

	@param			aBaseUri		The base uri.

	@param			aRefUri			The reference uri.

	@param			aResolvedPath	The resolved path.

	@param			aUseBaseQuery	A boolean indicating whether the base query 

					should be used.

*/

template<class TPtrCType, class TUriCType, class HBufCType>

void FormResolvedUri(TPtrCType aComponent[], const TUriCType& aBaseUri, const TUriCType& aRefUri, const HBufCType* aResolvedPath, TBool aUseBaseQuery)

	{

	// Scheme...

	if( aBaseUri.IsPresent(EUriScheme) )

		{

		// Use the base scheme

		aComponent[EUriScheme].Set(aBaseUri.Extract(EUriScheme));

		}

	// Authority

	if( aRefUri.IsPresent(EUriHost) )

		{

		// Use the ref host, userinfo and port - must set host first

		aComponent[EUriHost].Set(aRefUri.Extract(EUriHost));

		aComponent[EUriUserinfo].Set(aRefUri.Extract(EUriUserinfo));

		aComponent[EUriPort].Set(aRefUri.Extract(EUriPort));

		}

	else if( aBaseUri.IsPresent(EUriHost) )

		{

		// Use the base host, userinfo and port - must set host first

		aComponent[EUriHost].Set(aBaseUri.Extract(EUriHost));

		aComponent[EUriUserinfo].Set(aBaseUri.Extract(EUriUserinfo));

		aComponent[EUriPort].Set(aBaseUri.Extract(EUriPort));

		}

	// Path...

	aComponent[EUriPath].Set(*aResolvedPath);

	// Query...

	if( aUseBaseQuery && aBaseUri.IsPresent(EUriQuery) )

		{

		// Use the query from the base

		aComponent[EUriQuery].Set(aBaseUri.Extract(EUriQuery));

		}

	else if( aRefUri.IsPresent(EUriQuery) )

		{

		// Use the query from the ref

		aComponent[EUriQuery].Set(aRefUri.Extract(EUriQuery));

		}

	// Fragment

	if( aRefUri.IsPresent(EUriFragment) )

		{

		// Use the fragment from the ref

		aComponent[EUriFragment].Set(aRefUri.Extract(EUriFragment));

		}

	}

//

//

// Implemetation of LOCAL functions

//

//