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

/**
	Function used to resolve a base path (aBasePath) against a reference path (aRefPath),
	as described by RFC2396.
						
	@since			6.0
	@param			aBasePath	A descriptor reference to the base path.
	@param			aRefPath	A descriptor reference to the reference path.
	@return			A pointer to a buffer containing the resolve path.
	@leave			KUriErrBadBasePath if the base path is not an absolute path and not empty.
*/
HBufC8* ResolvePathsL(const TDesC8& aBasePath, const TDesC8& aRefPath)
	{
	TInt refLength = aRefPath.Length();
	if( refLength && aRefPath[0] == KSlashDelimiter )
		{
		// Relative path is absolute - that is the resolved path
		return aRefPath.AllocL();
		}
	// Ok got work to do - base path must be absolute (check 1st char) or empty
	if( aBasePath.Length() && aBasePath[0] != KSlashDelimiter )
		{
		// Base path not empty and not abosolute - bad base path
		User::Leave(KUriUtilsErrBadBasePath);
		}
	// Create a modifiable path object for resolved path
	CDelimitedPath8* resolvedPath = CDelimitedPath8::NewLC(aBasePath);

	// Check for empty ref path - use all of base path if empty
	if( refLength )
		{
		// Not empty - ensure that base path's last segment is removed and add reference
		resolvedPath->PopBackL();
		resolvedPath->PushBackL(aRefPath);
		}
	// Clean up the path to resolve occurences of '..' and '.' - parser path first
	CleanResolvedPathL<TPtrC8>(resolvedPath);

	// Return pointer to HBufC with path
	HBufC8* path = resolvedPath->Parser().Des().AllocL();
	CleanupStack::PopAndDestroy(resolvedPath);
	return path;
	}

/**
	Function used to resolve a base path (aBasePath) against a reference path (aRefPath), 
	as described by RFC2396.
						
	@since			6.0
	@param			aBasePath	A descriptor reference to the base path.
	@param			aRefPath	A descriptor reference to the reference path.
	@return			A pointer to a buffer containing the resolve path.
	@leave			KUriErrBadBasePath if the base path is not an absolute path and not empty.
*/
HBufC16* ResolvePathsL(const TDesC16& aBasePath, const TDesC16& aRefPath)
	{
	TInt refLength = aRefPath.Length();
	if( refLength && aRefPath[0] == KSlashDelimiter )
		{
		// Relative path is absolute - that is the resolved path
		return aRefPath.AllocL();
		}
	// Ok got work to do - base path must be absolute (check 1st char) or empty
	if( aBasePath.Length() && aBasePath[0] != KSlashDelimiter )
		{
		// Base path not empty and not abosolute - bad base path
		User::Leave(KUriUtilsErrBadBasePath);
		}
	// Create a modifiable path object for resolved path
	CDelimitedPath16* resolvedPath = CDelimitedPath16::NewLC(aBasePath);

	// Check for empty ref path - use all of base path if empty
	if( refLength )
		{
		// Not empty - ensure that base path's last segment is removed and add reference
		resolvedPath->PopBackL();
		resolvedPath->PushBackL(aRefPath);
		}
	// Clean up the path to resolve occurences of '..' and '.' - parser path first
	CleanResolvedPathL<TPtrC16>(resolvedPath);

	// Return pointer to HBufC with path
	HBufC16* path = resolvedPath->Parser().Des().AllocL();
	CleanupStack::PopAndDestroy(resolvedPath);
	return path;
	}
	
/**
	Checks if the segment is '.' (8-bit version).
	
	@since			6.0
	@param			aSegment	A descriptor with the segment to check.
	@return			A boolean value of ETrue if the segment is '.', EFalse if not.
*/
TBool IsSameDir(const TDesC8& aSegment)
	{
	_LIT8(KSameDir, ".");
	return (aSegment.Compare(KSameDir) == 0);
	}
	
/**
	Checks if the segment is '.' (16-bit version).
	
	@since			6.0
	@param			aSegment	A descriptor with the segment to check.
	@return			A boolean value of ETrue if the segment is '.', EFalse if not.
*/
TBool IsSameDir(const TDesC16& aSegment)
	{
	_LIT16(KSameDir, ".");
	return (aSegment.Compare(KSameDir) == 0);
	}
	
/**
	Checks if the segment is '..' (8-bit version).
	
	@since			6.0
	@param			aSegment	A descriptor with the segment to check.
	@return			A boolean value of ETrue if the segment is '..', EFalse if not.
*/
TBool IsParentDir(const TDesC8& aSegment)
	{
	_LIT8(KParentDir, "..");
	return (aSegment.Compare(KParentDir) == 0);
	}

/**
	Checks if the segment is '..' (16-bit version).
	
	@since			6.0
	@param			aSegment	A descriptor with the segment to check.
	@return			A boolean value of ETrue if the segment is '..', EFalse if not.
*/
TBool IsParentDir(const TDesC16& aSegment)
	{
	_LIT16(KParentDir, "..");
	return (aSegment.Compare(KParentDir) == 0);
	}

/**
	Inserts the segment '..' at the current parsed position (8-bit version).
						
	@since			6.0
	@param			aResolvedPath	The delimited data object to have the segment
					inserted.
	@pre			The delimited data object must be parsed to the position where 
					the segment is to be inserted.
	@post			The segment '..' has been inserted at the current position.
*/
void InsertParentDirL(CDelimitedDataBase8* aResolvedPath)
	{
	_LIT8(KParentDir, "..");
	aResolvedPath->InsertCurrentL(KParentDir);
	}
	
/**
	Inserts the segment '..' at the current parsed position (16-bit version).
						
	@since			6.0
	@param			aResolvedPath	The delimited data object to have the segment
					inserted.
	@pre			The delimited data object must be parsed to the position where 
					the segment is to be inserted.
	@post			The segment '..' has been inserted at the current position.
*/
void InsertParentDirL(CDelimitedDataBase16* aResolvedPath)
	{
	_LIT16(KParentDir, "..");
	aResolvedPath->InsertCurrentL(KParentDir);
	}
	

//
//
// File URI Implementation - CUri8
//
//

/**
	Initializes the file URI components (scheme, empty hostname and path).	 
	
	It uses GenerateFileUriPathL() to generate a file Uri path using the filename and drive. 
	
	@since			9.1
	@param			aFileName	A reference to a filename 
	@param			aDrive		A drive number. This is a TFileUriFlags value.
	@param			aFlags		A flag to indicate if the file exists on a fixed drive or removable media drive.
					This is a TFileUriFlags value.
	@pre 			Object fully constructed
	@post			The object is initialized with file URI components.
 */
void CUri8::InitializeFileUriComponentsL(const TDesC& aFileName, TDriveNumber aDrive, TUint aFlags)
	{
	HBufC* uriPath16 = GenerateFileUriPathL(aFileName, aDrive, aFlags);
	CleanupStack::PushL(uriPath16);
	HBufC8* uriPath = EscapeUtils::ConvertFromUnicodeToUtf8L(*uriPath16);
	CleanupStack::PopAndDestroy(uriPath16);
	CleanupStack::PushL(uriPath);
	HBufC8* escpedUriPath = EscapeUtils::EscapeEncodeL(*uriPath, EscapeUtils::EEscapeNormal);
	CleanupStack::PopAndDestroy(uriPath);
	CleanupStack::PushL(escpedUriPath);
	
	//SetComponent is not used in order to increase efficiency, by avoiding overhead of length calculation, 
	//tmp buffer allocation and updation of internal uri object, internal buffer & descriptor pointer 
	//for each SetComponent call     
	iUri.iComponent[EUriPath].Set(*escpedUriPath);
	iUri.iComponent[EUriHost].Set(KNullDesC8);
	iUri.iComponent[EUriScheme].Set(KFileUriScheme8);
	FormUriL();
	
	CleanupStack::PopAndDestroy(escpedUriPath);
	}

/**
	Allocates and constructs a file URI object for a specified file.
	 
	- If the file exists on a fixed drive, then the file URI takes the form: 'file://\<drive-letter\>/\<filepath including filename\>'.	
	- If the file exists on a removable media drive, then the file URI takes the form: 'file://ext-media/\<filepath including filename\>'.
	
	@since			9.1
	@param			aFullFileName	A reference to a fully qualified filename 
	@param			aFlags			A flag to indicate if the file exists on a fixed drive or removable media drive.
									This is a TFileUriFlags value.
	@return			A pointer to the newly created file URI (CUri8) object. 
	@post			A fully constructed and initialized file URI (CUri8) object.
 */
EXPORT_C CUri8* CUri8::CreateFileUriL(const TDesC& aFullFileName, TUint aFlags)
	{
	//It should be called to construct a file URI for a public file stored on a fix drive 
	// or on a removable media drive only
	__ASSERT_ALWAYS( ((aFlags == 0) || (aFlags & EExtMedia)), User::Panic(KFileUriPanicCategory, KUriUtilsCannotConvert) );
		
	CUri8* self = CUri8::NewLC();
	self->InitializeFileUriComponentsL(aFullFileName, EDriveA, aFlags);
	CleanupStack::Pop(self);
	return self;
	}

/**
	Allocates and constructs a file URI object for a file that is private to the application.

	- If the file exists on a fixed drive, then the file URI takes the form 'file://private/\<drive-letter\>/<filepath including filename\>'.
	- If the file exists on a removable media drive, then the file URI takes the form 'file://private/ext-media/\<filepath including filename\>'.
	
	@since			9.1
	@param			aRelativeFileName	A reference to the filename relative to the application's private directory.
	@param			aDrive				Drive number, if the private file stored on fixed drive, otherwise not used
										This is a TDriveNumber value
	@param			aFlags				A flag to indicate if the file exists on a fixed drive or removable media drive.
										This is a TFileUriFlags value.
	@return			A pointer to the newly created file URI (CUri8) object. 
	@post			A fully constructed and initialized file URI (CUri8) object.
*/	


EXPORT_C CUri8* CUri8::CreatePrivateFileUriL(const TDesC& aRelativeFileName, TDriveNumber aDrive, TInt aFlags) 
	{
	//It should be called to construct a file URI for the application's private file stored on a fix drive 
	// or on a removable media drive only
	__ASSERT_ALWAYS( (((aFlags == 0) || (aFlags & EExtMedia)) && (aDrive >= EDriveA && aDrive <= EDriveZ)), User::Panic(KFileUriPanicCategory, KUriUtilsCannotConvert) );

	CUri8* self = CUri8::NewLC();
	self->InitializeFileUriComponentsL(aRelativeFileName, aDrive, aFlags|EPrivate);
	CleanupStack::Pop(self);
	return self;
	}


//
//
// File URI Implementation - CUri16
//
//

/**
	Initializes the file URI components (scheme, empty hostname and path).	 
	
	It uses GenerateFileUriPathL() to generate a file Uri path using the filename and drive. 
	
	@since			9.1
	@param			aFileName	A reference to a filename 
	@param			aDrive		A drive number. This is a TFileUriFlags value.
	@param			aFlags		A flag to indicate if the file exists on a fixed drive or removable media drive.
					This is a TFileUriFlags value.
	@pre 			Object fully constructed
	@post			The object is initialized with file URI components.
 */
void CUri16::InitializeFileUriComponentsL(const TDesC& aFileName, TDriveNumber aDrive, TUint aFlags)
	{	
	HBufC* uriPath = GenerateFileUriPathL(aFileName, aDrive, aFlags);
	CleanupStack::PushL(uriPath);

	HBufC8* uriPath8 = EscapeUtils::ConvertFromUnicodeToUtf8L(*uriPath);
	CleanupStack::PopAndDestroy(uriPath);
	CleanupStack::PushL(uriPath8);

	HBufC8* escapedUriPath8 = EscapeUtils::EscapeEncodeL(*uriPath8, EscapeUtils::EEscapeNormal);
	CleanupStack::PopAndDestroy(uriPath8);
	CleanupStack::PushL(escapedUriPath8);

	HBufC* escapedUriPath = HBufC::NewLC(escapedUriPath8->Length());
	escapedUriPath->Des().Copy(*escapedUriPath8); 
	
	//SetComponent is not used in order to increase efficiency, by avoiding overhead of length calculation, 
	//tmp buffer allocation and updation of internal uri object, internal buffer & descriptor pointer 
	//for each SetComponent call     
	iUri.iComponent[EUriPath].Set(*escapedUriPath);
	iUri.iComponent[EUriHost].Set(KNullDesC16);
	iUri.iComponent[EUriScheme].Set(KFileUriScheme16);
	FormUriL();
	
	CleanupStack::PopAndDestroy(escapedUriPath);
	CleanupStack::PopAndDestroy(escapedUriPath8);
	}

/**
	Allocates and constructs a file URI object for a specified file.
	 
	- If the file exists on a fixed drive, then the file URI takes the form: 'file://\<drive-letter\>/\<filepath including filename\>'.	
	- If the file exists on a removable media drive, then the file URI takes the form: 'file://ext-media/\<filepath including filename\>'.
	
	@since			9.1
	@param			aFullFileName	A reference to a fully qualified filename 
	@param			aFlags	A flag to indicate if the file exists on a fixed drive or removable media drive.
					This is a TFileUriFlags value.
	@return			A pointer to the newly created file URI (CUri16) object. 
	@post			A fully constructed and initialized file URI (CUri16) object.
 */
EXPORT_C CUri16* CUri16::CreateFileUriL(const TDesC& aFullFileName, TUint aFlags)
	{
	//It should be called to construct a file URI for a public file stored on a fix drive 
	// or on a removable media drive only
	__ASSERT_ALWAYS( ((aFlags == 0) || (aFlags & EExtMedia)), User::Panic(KFileUriPanicCategory, KUriUtilsCannotConvert) );
		
	CUri16* self = CUri16::NewLC();
	self->InitializeFileUriComponentsL(aFullFileName, EDriveA, aFlags);
	CleanupStack::Pop(self);
	return self;
	}
	
/**
	Allocates and constructs a file URI object for a file that is private to the application.

	- If the file exists on a fixed drive, then the file URI takes the form 'file://private/\<drive-letter\>/<filepath including filename\>'.
	- If the file exists on a removable media drive, then the file URI takes the form 'file://private/ext-media/\<filepath including filename\>'.
	
	@since			9.1
	@param			aRelativeFileName	A reference to the filename relative to the application's private directory.
	@param			aDrive				Drive number, if the private file stored on fixed drive, otherwise not used
										This is a TDriveNumber value
	@param			aFlags				A flag to indicate if the file exists on a fixed drive or removable media drive.
										This is a TFileUriFlags value.
	@return			A pointer to the newly created file URI (CUri16) object. 
	@post			A fully constructed and initialized file URI (CUri16) object.
*/


EXPORT_C CUri16* CUri16::CreatePrivateFileUriL(const TDesC& aRelativeFileName, TDriveNumber aDrive, TInt aFlags) 
	{
	//It should be called to construct a file URI for the application's private file stored on a fix drive 
	// or on a removable media drive only
	__ASSERT_ALWAYS( (((aFlags == 0) || (aFlags & EExtMedia)) && (aDrive >= EDriveA && aDrive <= EDriveZ)), User::Panic(KFileUriPanicCategory, KUriUtilsCannotConvert) );

	CUri16* self = CUri16::NewLC();
	self->InitializeFileUriComponentsL(aRelativeFileName, aDrive, aFlags|EPrivate);
	CleanupStack::Pop(self);
	return self;
	}


//
//
// Implemetation of LOCAL functions for the File URI
//
//
	
/**
	Function used to generate 16bit file uri using 1st parameter aFileName and 
	2nd parameter aDrive for the application's private or a public file.
	
	This is called by API CreateFileUri() and CreatePrivateFileUri()to 
	generate a filename.
	
	Note: The space allocated for the returned descriptor will likely be larger 
		  than the length of the descriptor
	
	@leave			KErrBadName	A provided Drivename or filename is not valid 
	@since			9.1
	@param			aFileName	A descriptor reference to the filename.
	@param			aDrive		A descriptor reference to drive letter.
	@param			aFlags		A flag to indicate the private or a public file exists on removable media or a fixed drive.
	@return			A pointer to a buffer containing the resolved fully qualified filename.
 */
HBufC* GenerateFileUriPathL(const TDesC& aFileName, TDriveNumber aDrive,  TUint aFlags)
	{
	TInt origLength = aFileName.Length();

	//Leaves with KErrBadName if filename length is out of range 
	if (origLength == 0 || origLength > KMaxFileName)
		{
		User::Leave(KErrBadName);	
		}
		
	TPtrC filename(aFileName);
	
	//extract drive letter and remove drive "x:" from filename
	TUint drive = filename[0];
	
	 // hasDrive means it begins with a drive, e.g. "c:"
	 const TBool hasDrive =  ((drive >= 'A' && drive <= 'Z') || (drive >= 'a' && drive <= 'z')) && (filename[1] == KDriveSeparator);
	 // hasTopPath means it begins with a \ (possibly after the drive)
	 const TBool hasTopPath = (hasDrive && (filename[2] == KFilePathSeparator)) || (!hasDrive && (drive == TUint(KFilePathSeparator) ));
 
	 TInt skip = KDefaultPath().Length(); //  skip leading "<drive>:\" by default
	 if(aFlags & TUint(EPrivate)) 
		{
		skip = (hasDrive ? (KDefaultPath().Length() - 1) : 0) + (hasTopPath ? 1 : 0) ;
		}
	 else
		{
		// if not private then it should have valid drive i.e. "<drive>:\"
		if (!(hasDrive && hasTopPath)) 
			{
			User::Leave(KErrBadName);
			}
		}
	
	if(skip)
		  {
		  filename.Set(aFileName.Right(origLength - skip));
		  } 	

	TInt uriLen = aFileName.Length() + KExtMedia().Length() + KPrivate().Length() + 1 /* for drive letter */;
	
	HBufC* fileUri = HBufC::NewLC(uriLen);
	TPtr fileUriPtr = fileUri->Des(); 
	fileUriPtr.Append(KUriPathSeparator);
	
	if (aFlags & TUint(EPrivate))
		{
		fileUriPtr.Append(KPrivate);
		drive = TInt16('A' + aDrive);
		}
		
	if (aFlags & EExtMedia)
		{
		fileUriPtr.Append(KExtMedia);			
		}
	else
		{
		fileUriPtr.Append(drive);
		fileUriPtr.Append(KUriPathSeparator);	
		}
		
	fileUriPtr.Append(filename);
		
	//Convert "\" to "/"
	ChangePathSeparator(fileUriPtr, KFilePathSeparator, KUriPathSeparator);

	//Handling "./" and "../" in the file URI path  or resolving the URI path 
	CDelimitedPath16* resolvedPath = CDelimitedPath16::NewLC(fileUriPtr);
 	// Clean up the path to resolve occurences of '..' and '.'
 	CleanResolvedPathL<TPtrC>(resolvedPath);
 	fileUriPtr.Copy(resolvedPath->Parser().Des()); // new path will always be shorter than old one
 	CleanupStack::PopAndDestroy(resolvedPath);
 		
	CleanupStack::Pop(fileUri);
	return fileUri;
	}