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

//

/**

 @file 

 @internalTechnology

*/

#include <elements/metacontainer.h>

#include <elements/metadata.h>

namespace Meta

{

const TInt KContainerUid = 0x10205A04;

}

using namespace Meta;

EXPORT_C RMetaDataContainerBase::RMetaDataContainerBase()

/**

 * Constructor

 */

    {	

    }

EXPORT_C STypeId RMetaDataContainerBase::GetTypeId() const

	{

	return STypeId::CreateSTypeId( KContainerUid, KNetMetaTypeAny );

	}

EXPORT_C void RMetaDataContainerBase::Copy(const RMetaDataContainerBase& aMetaContainer)

/**

 * Copies a content of a meta container into this container.

 * Copies only pointers (does not do a deep copy).

 */

	{

	TUint count = aMetaContainer.Count();

	for (TUint i = 0; i < count; ++i)

		{

		Append(aMetaContainer[i]);

		}

	}

EXPORT_C TInt RMetaDataContainerBase::Store(TDes8& aDes) const

/**

 * Stores the content of this container in a descriptor.

 */

    {

	if (aDes.MaxLength()-aDes.Length() < this->Length())

		{

		return KErrArgument;

		}

	const STypeId& typeId = GetTypeId();

	aDes.Append((TUint8*)&typeId,sizeof(STypeId)); //store TID

    TInt count = Count();

	TInt length = Length();

	aDes.Append((TUint8*)&length, sizeof(TInt32));	// Store Length of container

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

        {

		SMetaData* element = (*this)[i];

		if (element)

			{

	        TInt ret = element->Store(aDes);    //store the object

			if (ret != KErrNone)

				{

				return ret;

				}

			}

		else

			{

			if (aDes.MaxLength() - aDes.Length() < (TInt) sizeof(TUint32))

				{

				return KErrOverflow;

				}

			const TUint32 KNullInt = 0;

			aDes.Append((TUint8*)&KNullInt, sizeof(TUint32));

			}

        }

	return KErrNone;

    }

EXPORT_C TInt RMetaDataContainerBase::Load(TPtrC8& aDes)

/**

 * Loads a content from a descriptor into this container.

 */

	{

	ResetAndDestroy();

    TInt32 containerLength;

    Mem::Copy(&containerLength, aDes.Ptr() ,sizeof(TInt32));

	if (containerLength < 0 || (containerLength - sizeof(STypeId))> aDes.Length())

		{

		// Fatal error, descriptor is corrupt

		return KErrArgument;

		}

	// Construct a buffer to work on for this container

	TPtrC8 containerBuffer(aDes.Ptr() + sizeof(TInt32),	

		containerLength - sizeof (STypeId) - sizeof (TInt32));

	// Move descriptor pointer past the container buffer

	aDes.Set(aDes.Ptr() + containerLength - sizeof (STypeId), aDes.Length() - containerLength + sizeof (STypeId));

	while (containerBuffer.Length() > 0)

		{

		if (containerBuffer.Length() < (TInt) sizeof(TUint32))

			{

			return KErrArgument;

			}

		// Check for a NULL pointer when stored (First four bytes == 0)

		TUint32 firstFourBytes;

        Mem::Copy(&firstFourBytes, containerBuffer.Ptr(), sizeof(TUint32));

		if (firstFourBytes == 0)

			{

			// The pointer was NULL when it was stored

			containerBuffer.Set(containerBuffer.Ptr() + sizeof(TUint32), containerBuffer.Length() - sizeof(TUint32));

			TRAPD(error, AppendL(NULL));

			if (error != KErrNone)

				{

				return error;

				}

			}

		else

			{

			SMetaData* containerItem = NULL;

			TRAPD(error, containerItem = LoadElementL(containerBuffer));

			if (error == KErrNone)

				{

				TRAP(error, AppendL(containerItem));

				}

			if (error != KErrNone && error != KErrNotFound)

				{

				delete containerItem;

				return error;

				}

			}

		}

	return KErrNone;

	}

EXPORT_C TInt RMetaDataContainerBase::Length() const

/**

 * Returns the length of the content of this container if it was to be stored.

 */

	{

    TInt length = 0, count = this->Count();

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

		{

		SMetaData* element = (*this)[i];

		if (element)

			{

			// UID + Object Type Id + Length Parameter + Length of Data

			length += element->Length();

			}

		else

			{

			// Add length of null word (Used to represent a NULL pointer)

			length += sizeof(TUint32);

			}

		}

	return length + sizeof(TInt32) + sizeof(STypeId);

	}