// Copyright (c) 2008-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 <e32std.h>

#include <http/framework/cheadercodec.h>

// Local includes

#include "CHeaders.h"

#include "CHeaderField.h"

CHeaderField* CHeaderField::NewL(RStringF aHeaderFieldName, CHeaders& aOwner)

	{

	return new(ELeave)CHeaderField(aHeaderFieldName, aOwner);

	}

/*

CHeaderField* CHeaderField::NewL(RStringF aHeaderFieldName, CHeaders& aOwner, THTTPHdrVal aVal)

	{

	CHeaderField* me = new(ELeave)CHeaderField(aHeaderFieldName, aOwner);

	CleanupStack::PushL(me);

	CHeaderFieldPart* part = CHeaderFieldPart::NewL(aVal);

	CleanupStack::PushL(part);

	me->AddPartL(part);

	CleanupStack::Pop(2);

	return me;

	}

*/

CHeaderField* CHeaderField::NewL(RStringF aHeaderFieldName, CHeaders& aOwner, const TDesC8& aRawData)

	{

	CHeaderField* me = new(ELeave)CHeaderField(aHeaderFieldName, aOwner);

	CleanupStack::PushL(me);

	me->ConstructL(aRawData);

	CleanupStack::Pop(me);

	return me;

	}

/** D'tor

*/

CHeaderField::~CHeaderField()

	{

	iName.Close();

	ClearParsedData();

	ClearRawData();

	}

/** Getter's

*/

/*

RStringF CHeaderField::Name() const

	{

	return iName;

	}

*/

TInt CHeaderField::NumPartsL()

	{

	// Convert, if necessary, to the parsed format

	ConvertToParsedFormatL();

	// Check the array exists first

	return iParts.Count();

	}

THeaderFieldPartIter CHeaderField::PartsL()

	{

	// Convert, if necessary, to the parsed format

	ConvertToParsedFormatL();

	// create an iterator initialised for this header

	return THeaderFieldPartIter(this);

	}

CHeaderFieldPart* CHeaderField::PartL(TInt aIndex)

	{

	// Convert, if necessary, to the parsed format

	ConvertToParsedFormatL();

	// Check the part is in range, if so return it

	if (aIndex < NumPartsL())

		return iParts[aIndex];

	else

		return NULL;

	}

EXPORT_C

void CHeaderField::RawDataL(TPtrC8& aRawData)

	{

	ConvertToRawFormatL();

	aRawData.Set(*iRawData);

	}

/** Setters

*/

/*

void CHeaderField::SetPartL(CHeaderFieldPart* aPart, TInt aIndex)

	{

	if (aIndex < iParts.Count())

		{

		CHeaderFieldPart* oldPart = iParts[aIndex];

		iParts[aIndex] = aPart;

		delete oldPart;

		}

	else

		User::LeaveIfError(iParts.Append(aPart));

	}

*/

void CHeaderField::BeginRawDataL(TInt aChunkSize)

	{

	iRawChunkSize = aChunkSize;

	// clear out any existing Raw data, but don't reallocate if not needed

	if (!iRawData)

		iRawData = HBufC8::NewL(iRawChunkSize);

	else

		{

		TPtr8 rawPtr = iRawData->Des();

		rawPtr.Zero();

		}

	}

void CHeaderField::WriteRawDataL(const TDesC8& aData)

	{

    // Check to see if the buffer needs to grow

	TInt maxLength  = iRawData->Des().MaxLength();

	TInt reqdLength = iRawData->Length() + aData.Length();

	if (reqdLength > maxLength)

		{

		// Yes - allocate a new buffer of a larger size, and copy the contents

		// of the old one over. This may need more than one extra chunk. Check

		// for partial chunks - add an extra one if necessary.

		TInt numChunksReqd = (reqdLength - maxLength)/iRawChunkSize;

		 if ( (reqdLength - maxLength)%iRawChunkSize > 0)

			++numChunksReqd;

		HBufC8* largerBuffer = iRawData->ReAllocL(maxLength + iRawChunkSize*numChunksReqd);

		// Switch buffers. The old one was removed by ReAlloc.

		iRawData = largerBuffer;

		}

	// Can now append confidently

	iRawData->Des().Append(aData);

	}

/*

void CHeaderField::WriteRawDataL(TChar aData)

	{

	// Check to see if the buffer descriptor needs to grow

	TInt maxLength  = iRawData->Des().MaxLength();

	TInt reqdLength = iRawData->Length() + 1;

	if (reqdLength > maxLength)

		{

		// Yes - allocate a new buffer of a larger size, and copy the contents

		// of the old one over. Since a single character is being added, one

		// chunk will be enough.

		HBufC8* largerBuffer = iRawData->ReAllocL(maxLength + iRawChunkSize);

		// Switch buffers. The old one was removed by ReAlloc.

		iRawData = largerBuffer;

		}

	// Can now append confidently

	iRawData->Des().Append(aData);

	}

*/

void CHeaderField::CommitRawData()

	{

	// Change state and remove the parsed form of the header data

	iDataParseState = EDataInRawForm;

	ClearParsedData();

	}

void CHeaderField::AddPartL(CHeaderFieldPart* aPart)

	{

	// Convert, if necessary, to the parsed format

	ConvertToParsedFormatL();

	// Append the item

	User::LeaveIfError(iParts.Append(aPart));

	}

/*

void CHeaderField::InsertPartL(CHeaderFieldPart* aPart, TInt aIndex)

	{

	// Convert, if necessary, to the parsed format

	ConvertToParsedFormatL();

	// If the array isn't yet constructed, or is empty, then use 'AddPart'

	if (!NumPartsL()) 

		AddPartL(aPart);

	else

		User::LeaveIfError(iParts.Insert(aPart, aIndex));

	}

*/

/*

TInt CHeaderField::RemovePartL(CHeaderFieldPart* aPart)

	{

	// Convert, if necessary, to the parsed format

	ConvertToParsedFormatL();

	// Sanity check - if no parts, then the part can't be removed...

	if (iParts.Count() == 0)

		return KErrNotFound;

	// Find the part.  

	TInt idx = iParts.Find(aPart);

	// Now remove by index

	iParts.Remove(idx);

	iParts.Compress();

	delete aPart;

	return KErrNone;

	}

*/

TInt CHeaderField::RemovePartL(TInt aIndex)

	{

	// Convert, if necessary, to the parsed format

	ConvertToParsedFormatL();

	// Sanity check - if no array exists or if the index supplied is out of the bounds

	// of the array, then the part can't be removed...

	if ((aIndex < 0) || (aIndex >= NumPartsL()))

		return KErrNotFound;

	// Note that the array doesn't actually delete the part itself. Also the array must be

	// compressed to close the 'gap' left by the deleted part

	CHeaderFieldPart* part = PartL(aIndex);

	iParts.Remove(aIndex);

	iParts.Compress();

	delete part;

	return KErrNone;

	}

/** Constructors and second-phase construction

*/

void CHeaderField::ConvertToRawFormatL()

	{

	if (iDataParseState != EDataParsedOK)

		return;

	RHeaderField rf(*this);

	// State change and removal of parsed data  is done when the Raw data is committed by the codec when it is encoded

	iCodec.EncodeHeaderL(rf);

	}

void CHeaderField::ConvertToParsedFormatL()

	{

	if (iDataParseState != EDataInRawForm)

		return;

	RHeaderField rf(*this);

	iCodec.DecodeHeaderL(rf);

	// If we haven't left, then it must have succeeded. Change state and remove the Raw data

	iDataParseState = EDataParsedOK;

	ClearRawData();

	}

CHeaderField::CHeaderField(RStringF aHeaderFieldName, CHeaders& aOwner)

	: iDataParseState(ENoDataSupplied), iOwner(&aOwner), iCodec(aOwner.Codec())

	{

	// Ensure that we maintain string references correctly with the header field name

	iName = aHeaderFieldName.Copy();

	iDataParseState = EDataParsedOK;

	}

void CHeaderField::ConstructL(const TDesC8& aRawData)

	{

	// Copy the data.  Set the state.

	iRawData = aRawData.AllocL();

	iDataParseState = EDataInRawForm;

	}

void CHeaderField::ClearParsedData()

	{

	// Clear and destroy parts array and its contents

	iParts.ResetAndDestroy();

	}

void CHeaderField::ClearRawData()

	{

	// Destroy any Raw data

	delete iRawData;

	iRawData = NULL;

	}

/** Implementation of CHeaderFieldPart class *************************************************

*/

/** Factory methods

*/

EXPORT_C

CHeaderFieldPart* CHeaderFieldPart::NewL(THTTPHdrVal aVal)

	{

	return new(ELeave)CHeaderFieldPart(aVal);

	}

/** D'tor

*/

CHeaderFieldPart::~CHeaderFieldPart()

	{

	// Remove the parameter list.  Parent class clears the part value.

	iParams.ResetAndDestroy();

	// If the part's value is a string, then it must be closed.

	if (iValue.Type() == THTTPHdrVal::KStrFVal)

		iValue.StrF().Close();

	if (iValue.Type() == THTTPHdrVal::KStrVal)

		iValue.Str().Close();

	}

/** Getter's

*/

EXPORT_C

THTTPHdrVal CHeaderFieldPart::Value() const

	{

	return iValue;

	}

EXPORT_C

TInt CHeaderFieldPart::NumParameters() const

	{

	// Check the array exists first

	return iParams.Count();

	}

EXPORT_C

THeaderFieldParamIter CHeaderFieldPart::Parameters() const

	{

	// create an iterator initialised for this part

	return THeaderFieldParamIter(this);

	}

/*

CHeaderFieldParam* CHeaderFieldPart::Parameter(TInt aIndex) const

	{

	// Check the parameter is in range, if so return it

	if (aIndex < NumParameters())

		return (CHeaderFieldParam*)iParams[aIndex];

	else

		return NULL;

	}

*/

CHeaderFieldParam* CHeaderFieldPart::Parameter(RStringF aParamName) const

	{

	// Iterate the parameter list looking for a name match

	THeaderFieldParamIter it(this);

	CHeaderFieldParam* retVal = NULL;

	const CHeaderFieldParam* nextParam = NULL;

	TBool done = EFalse;

	while (!done && !it.AtEnd())

		{

		nextParam = it();

		if (nextParam->Name() == aParamName)

			{

			retVal = CONST_CAST(CHeaderFieldParam*, nextParam);

			done = ETrue;

			}

		++it;

		}

	return retVal;

	}

/** Setter's

*/

/*

void CHeaderFieldPart::SetValue(THTTPHdrVal aVal)

	{

	// We must check for an existing string value since it will have to be closed

	if (iValue.Type() == THTTPHdrVal::KStrFVal)

		iValue.StrF().Close();

	if (iValue.Type() == THTTPHdrVal::KStrVal)

		iValue.Str().Close();

	iValue = aVal.Copy();

	}

*/

EXPORT_C

void CHeaderFieldPart::AddParamL(CHeaderFieldParam* aParam)

	{

	// Append the item

	User::LeaveIfError(iParams.Append(aParam));

	}

/*

TInt CHeaderFieldPart::RemoveParam(CHeaderFieldParam* aParam)

	{

	// Sanity check - if no array exists, then the part can't be removed...

	if (iParams.Count() == 0)

		return KErrNotFound;

	// Find the param. 

	TInt idx = iParams.Find(aParam);

	// Now remove by index. Note that the array doesn't actually delete the param itself. Also

	// the array must be compressed to close the 'gap' left by the deleted param

	if (idx != KErrNotFound)

		{

		iParams.Remove(idx);

		iParams.Compress();

		delete aParam;

		idx = KErrNone;

		}

	return idx;

	}

*/

/** c'tor

*/

CHeaderFieldPart::CHeaderFieldPart(THTTPHdrVal aVal)

	: iValue(aVal)

	{

	// Ensure that we've copied the HdrVal properly - strings must be Copy()d in order to

	// correctly maintain string references

	iValue = aVal.Copy();

	}

/** Implementation of CHeaderFieldParam class *************************************************

*/

/** Factory methods

*/

EXPORT_C

CHeaderFieldParam* CHeaderFieldParam::NewL(RStringF aParamName, THTTPHdrVal aVal)

	{

	return new(ELeave)CHeaderFieldParam(aParamName, aVal);

	}

/** D'tor

*/

CHeaderFieldParam::~CHeaderFieldParam()

	{

	// Close the parameter name and value, if it is a string.

	iName.Close();

	if (iValue.Type() == THTTPHdrVal::KStrVal)

		iValue.Str().Close();

	if (iValue.Type() == THTTPHdrVal::KStrFVal)

		iValue.StrF().Close();

	}

/** Getter's

*/

EXPORT_C

RStringF CHeaderFieldParam::Name() const

	{

	return iName;

	}

EXPORT_C

THTTPHdrVal CHeaderFieldParam::Value() const

	{

	return iValue;

	}

/** Setter's

*/

/*

void CHeaderFieldParam::SetValue(THTTPHdrVal aVal)

	{

	// We must check for an existing string value since it will have to be closed

	if (iValue.Type() == THTTPHdrVal::KStrFVal)

		iValue.StrF().Close();

	if (iValue.Type() == THTTPHdrVal::KStrVal)

		iValue.Str().Close();

	iValue = aVal.Copy();

	}

*/

/** c'tor

*/

CHeaderFieldParam::CHeaderFieldParam(RStringF aName, THTTPHdrVal aVal)

	: iValue(aVal)

	{

	// Ensure that we've copied the arguments properly - strings must be Copy()d in order to

	// correctly maintain string references

	iName = aName.Copy();

	iValue = aVal.Copy();

	}

/** Implementation of THeaderFieldPartIter class **********************************************

*/

/** Normal c'tor

*/

THeaderFieldPartIter::THeaderFieldPartIter(const CHeaderField* aHeader)

	: iHeader(aHeader)