/*

* Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

*

*/

#ifndef REMOVE_CAF1

#include <caf/caftypes.h>

#include <s32strm.h>

#include <caf/cafmimeheader.h>

#include "mimefieldanddata.h"

using namespace ContentAccess;

EXPORT_C CCafMimeHeader* CCafMimeHeader::NewL(const TDesC8 &aContentType)

	{

	CCafMimeHeader *self = new (ELeave) CCafMimeHeader();

	CleanupStack::PushL(self);

	self->ConstructL(aContentType);

	CleanupStack::Pop(self);

	return self;

	}

CCafMimeHeader::CCafMimeHeader() 

	{

	}

void CCafMimeHeader::ConstructL(const TDesC8 &aContentType) 

	{

	SetStandardMimeDataL(EContentType, aContentType);

	}

EXPORT_C CCafMimeHeader::~CCafMimeHeader()

	{

	TInt i=0;

	iNonStandardMimeHeaders.ResetAndDestroy();

	iNonStandardMimeHeaders.Close();

	for(i = 0; i < EMimeMax; i++)

		{

		delete iStandardMimeHeader[i];

		}

	}

EXPORT_C void CCafMimeHeader::SetStandardMimeDataL(const TMimeFields &aIndex, const TDesC8& aData)

	{

	HBufC8 *data = aData.AllocLC();

	// make sure mime types are lower case

	if(aIndex == EContentType)

		{

		data->Des().LowerCase();

		}

	// replace whatever value was there before

	delete iStandardMimeHeader[aIndex];

	iStandardMimeHeader[aIndex] = data;

	CleanupStack::Pop(data); 

	}

EXPORT_C TPtrC8 CCafMimeHeader::StandardMimeData(const TMimeFields &aIndex) const

	{

	// If the field value has not been set, return a null string

	if(iStandardMimeHeader[aIndex] == NULL)

		{

		return KNullDesC8();

		}

	return TPtrC8(iStandardMimeHeader[aIndex]->Des());

	}

EXPORT_C TInt CCafMimeHeader::NonStandardMimeCount() const

	{

	return iNonStandardMimeHeaders.Count();

	}

EXPORT_C void CCafMimeHeader::AddNonStandardMimeL(const TDesC8& aFieldName, const TDesC8& aData)

	{

	CMimeFieldAndData *mimeData = CMimeFieldAndData::NewL(aFieldName, aData);

	CleanupStack::PushL(mimeData);

	iNonStandardMimeHeaders.Append(mimeData);

	CleanupStack::Pop(mimeData);

	}

EXPORT_C TPtrC8 CCafMimeHeader::NonStandardMimeField(TInt aIndex) const

	{

	return iNonStandardMimeHeaders[aIndex]->FieldName();

	}

EXPORT_C TPtrC8 CCafMimeHeader::NonStandardMimeData(TInt aIndex) const

	{

	return iNonStandardMimeHeaders[aIndex]->Data();

	}

EXPORT_C void CCafMimeHeader::ExternalizeL(RWriteStream& aStream) const

	{

	TInt i=0;

	// Write the contents of this class out to a stream

	// Write the number of standard mime headers

	aStream.WriteInt32L(EMimeMax);

	// Write out the standard mime data, each one preceeded by it's length

	for(i = 0; i < EMimeMax; i++)

		{

		TInt length=0;

		// Length is zero if the mime field has not been set, 

		if(iStandardMimeHeader[i] == NULL)

			{

			length = 0;

			}

		else 

			{

			length = iStandardMimeHeader[i]->Length();

			}

		// write the field length

		aStream.WriteInt16L(length);

		if(length > 0)

			{

			// write the field value if length > 0

			aStream.WriteL(*iStandardMimeHeader[i]);

			}

		}

	aStream.WriteInt32L(iNonStandardMimeHeaders.Count());

	// Write out non standard mime headers and data, each Des preceeded by it's length

	for(i = 0; i < iNonStandardMimeHeaders.Count(); i++)

		{

		aStream.WriteInt16L(iNonStandardMimeHeaders[i]->FieldName().Length());

		if(iNonStandardMimeHeaders[i]->FieldName().Length() > 0)

			{

			aStream.WriteL(iNonStandardMimeHeaders[i]->FieldName());

			}

		aStream.WriteInt16L(iNonStandardMimeHeaders[i]->Data().Length());

		if(iNonStandardMimeHeaders[i]->Data().Length() > 0)

			{

			aStream.WriteL(iNonStandardMimeHeaders[i]->Data());

			}

		}

	}

EXPORT_C void CCafMimeHeader::InternalizeL(RReadStream& aStream)

	{

	TInt i=0;

	TInt fieldCount=0;

	TInt16 length=0;

	HBufC8 *field=NULL;

	HBufC8 *data=NULL;

	// clear any existing headers	

	iNonStandardMimeHeaders.ResetAndDestroy();

	for(i = 0; i < EMimeMax; i++)

		{

		// delete the existing data for the mime field

		delete iStandardMimeHeader[i];

		iStandardMimeHeader[i] = NULL;

		}

	fieldCount= aStream.ReadInt32L();

	if(fieldCount != EMimeMax)

		{

		// something is seriously wrong, should always be EMimeMax standard headers

		User::Leave(KErrGeneral);

		}

	for(i = 0; i < EMimeMax; i++)

		{

		// read the length from the stream

		length = aStream.ReadInt16L();

		if(length > 0)

			{

			// read in non zero fields, others will remain NULL

			data = HBufC8::NewLC(length);

			TPtr8 dataPtr = data->Des();

			aStream.ReadL(dataPtr,length);

			SetStandardMimeDataL(static_cast <TMimeFields>(i), dataPtr);

			CleanupStack::PopAndDestroy(data);

			}

		}

	fieldCount= aStream.ReadInt32L();

	for(i = 0; i < fieldCount; i++)

		{

		// Read mime field name

		length = aStream.ReadInt16L();

		if(length < 0)

			{

			User::Leave(KErrCorrupt);

			}

		field = HBufC8::NewLC(length);

		TPtr8 fieldPtr = field->Des();

		if(length > 0)

			{

			aStream.ReadL(fieldPtr,length);

			}

		// Read data

		length = aStream.ReadInt16L();

		if(length < 0)

			{

			User::Leave(KErrCorrupt);

			}

		data = HBufC8::NewLC(length);

		TPtr8 dataPtr = data->Des();

		if(length > 0)

			{

			aStream.ReadL(dataPtr,length);

			}

		// Add a new mime field and data to our array

		AddNonStandardMimeL(fieldPtr, dataPtr);

		// free memory allocated

		CleanupStack::PopAndDestroy(data);

		CleanupStack::PopAndDestroy(field); 

		}

	}

#endif // #ifndef REMOVE_CAF1