/*

* Copyright (c) 2004 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:  Sources

*

*/

// INCLUDE FILES

#include <s32buf.h>

#include <s32file.h>

#include "nsmlxmlparser.h"

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// 

// -----------------------------------------------------------------------------

// CNSmlTruncatedData::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

EXPORT_C CNSmlTruncatedData* CNSmlTruncatedData::NewL()

	{

	CNSmlTruncatedData* self = CNSmlTruncatedData::NewLC();

	CleanupStack::Pop();

	return self;

	}

// -----------------------------------------------------------------------------

// CNSmlTruncatedData::NewLC

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

EXPORT_C CNSmlTruncatedData* CNSmlTruncatedData::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

// -----------------------------------------------------------------------------

// CNSmlTruncatedData::~CNSmlTruncatedData

// Destructor

// -----------------------------------------------------------------------------

//

EXPORT_C CNSmlTruncatedData::~CNSmlTruncatedData()

	{

	iAttachments.ResetAndDestroy();

	iAttachments.Close();

	iBodys.ResetAndDestroy();

	iBodys.Close();

	}

// -----------------------------------------------------------------------------

// CNSmlTruncatedData::AddAttachmentL

// Adds an attachment to iAttachments. Takes copies of buffers, caller must

// destroy the original buffers.

// -----------------------------------------------------------------------------

//

EXPORT_C void CNSmlTruncatedData::AddAttachmentL(HBufC8* aName, TInt aSize, HBufC8* aType)

	{

	CNSmlAttachmentTruncateInfo* attach = new (ELeave) CNSmlAttachmentTruncateInfo();

	CleanupStack::PushL(attach);

	attach->SetMembersL(aName, aType, aSize);

	iAttachments.Append(attach);

	CleanupStack::Pop(); // attach

	}

// -----------------------------------------------------------------------------

// CNSmlTruncatedData::AddBodyL

// Adds a body. Takes copies of buffers, caller must destroy the 

// original buffers.

// -----------------------------------------------------------------------------

//

EXPORT_C void CNSmlTruncatedData::AddBodyL(TInt aSize, HBufC8* aType)

	{

	CNSmlBodyTruncateInfo* body = new (ELeave) CNSmlBodyTruncateInfo();

	CleanupStack::PushL(body);

	body->SetMembersL(aType, aSize);

	iBodys.Append(body);

	CleanupStack::Pop(); // body

	}

// -----------------------------------------------------------------------------

// CNSmlTruncatedData::GenerateXmlL

// Generates truncate data xml

// -----------------------------------------------------------------------------

//

EXPORT_C void CNSmlTruncatedData::GenerateXmlL( TPtr8& aXml, const CNSmlXmlParser* aParser ) const

	{

	aParser->AppendElement(aXml, KTruncatedElement());

	TInt size = 0;

	HBufC8* type = 0;

	HBufC8* name = 0;

	for ( TInt j = 0; j < iBodys.Count(); ++j )

		{

		iBodys[j]->GetMembersL(type, size);

		aParser->AppendElement(aXml, KTruncatedBodyElement());

		if ( size != KErrNotFound )

			{

			aParser->AppendElement(aXml, KTruncatedSizeElement(), aParser->IntegerToString(size));

			}

		if ( type )

			{

			aParser->AppendElement(aXml, KTruncatedTypeElement(), *type);

			delete type; type = NULL;

			}

		aParser->AppendEndElement(aXml, KTruncatedBodyElement());

		}

	for ( TInt i = 0; i < iAttachments.Count(); ++i )

		{

		size = 0;

		type = NULL;

		name = NULL;

		iAttachments[i]->GetMembersL(name, type, size);

		aParser->AppendElement(aXml, KTruncatedAttachElement());

		if ( name )

			{

			aParser->AppendElement(aXml, KTruncatedNameElement(), *name);

			delete name; name = NULL;

			}

		if ( size != KErrNotFound )

			{

			aParser->AppendElement(aXml, KTruncatedSizeElement(), aParser->IntegerToString(size));

			}

		if ( type )

			{

			aParser->AppendElement(aXml, KTruncatedTypeElement(), *type);

			delete type; type = NULL;

			}

		aParser->AppendEndElement(aXml, KTruncatedAttachElement());

		}

	aParser->AppendEndElement(aXml, KTruncatedElement());

	}

// -----------------------------------------------------------------------------

// CNSmlTruncatedData::CountXmlSizeL

// Counts the size of truncate data xml if it was generated using current values

// in member variables.

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CNSmlTruncatedData::CountXmlSizeL( const CNSmlXmlParser* aParser ) const

	{

	TInt size = 0;

	size += aParser->SizeOfElements( KTruncatedElement() );

	for ( TInt j = 0; j < iBodys.Count(); ++j )

		{

		TInt bodySize = 0;

		HBufC8* bodyType = 0;

		iBodys[j]->GetMembersL(bodyType, bodySize);

		size += aParser->SizeOfElements( KTruncatedBodyElement() );

		if ( bodySize != KErrNotFound )

			{

			size += aParser->SizeOfInteger( KTruncatedSizeElement() );

			}

		if ( bodyType )

			{

			size += aParser->SizeOfString( bodyType, KTruncatedTypeElement() );

			delete bodyType; bodyType = NULL;

			}

		}

	for ( TInt i = 0; i < iAttachments.Count(); ++i )

		{

		TInt attachSize = 0;

		HBufC8* attachType = 0;

		HBufC8* attachName = 0;

		iAttachments[i]->GetMembersL(attachName, attachType, attachSize);

		size += aParser->SizeOfElements( KTruncatedAttachElement() );

		if ( attachName )

			{

			size += aParser->SizeOfString( attachName, KTruncatedNameElement() );

			delete attachName; attachName = NULL;

			}

		if ( attachSize != KErrNotFound )

			{

			size += aParser->SizeOfInteger( KTruncatedSizeElement() );

			}

		if ( attachType )

			{

			size += aParser->SizeOfString( attachType, KTruncatedTypeElement() );

			delete attachType; attachType = NULL;

			}

		}

	return size;

	}

// -----------------------------------------------------------------------------

// CNSmlTruncatedData::ConvertIntoEntitiesL

// Converts special characters in strings into entities.

// -----------------------------------------------------------------------------

//

EXPORT_C void CNSmlTruncatedData::ConvertIntoEntitiesL( const CNSmlXmlParser* aParser )

	{

	TInt size = 0;

	HBufC8* type = NULL;

	HBufC8* name = NULL;

	for ( TInt j = 0; j < iBodys.Count(); ++j )

		{

		iBodys[j]->GetMembersL(type, size);

		CleanupStack::PushL(type);

		if( type )

			aParser->CharactersToEntitiesL(type, 0, type->Length());

		iBodys[j]->SetMembersL(type, size);

		CleanupStack::Pop(); // type

		delete type; type = NULL;

		}

	for ( TInt i = 0; i < iAttachments.Count(); ++i )

		{

		iAttachments[i]->GetMembersL(name, type, size);

		CleanupStack::PushL(type);

		CleanupStack::PushL(name);

		if( name )

			{

			aParser->CharactersToEntitiesL(name, 0, name->Length());

			}

		if( type )

			{

			aParser->CharactersToEntitiesL(type, 0, type->Length());

			}

		iAttachments[i]->SetMembersL(name, type, size);

		CleanupStack::Pop(2); // name, type

		delete name; name = NULL;

		delete type; type = NULL;

		}

	}

// -----------------------------------------------------------------------------

// CNSmlTruncatedData::CNSmlTruncatedData

// Private constructor

// -----------------------------------------------------------------------------

//

CNSmlTruncatedData::CNSmlTruncatedData()

	{

	}

// -----------------------------------------------------------------------------

// CNSmlTruncatedData::ConstructL

// Second phase construction

// -----------------------------------------------------------------------------

//

void CNSmlTruncatedData::ConstructL()

	{

	iAttachments.Reset();

	iBodys.Reset();

	}

//  End of File