/*

* Copyright (c) 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 "CCdlEngine.h"

const TInt KCdlGranularity = 4;

//

// CCdlUids

//

EXPORT_C CCdlUids* CCdlUids::NewLC()

	{

	CCdlUids* self = new(ELeave) CCdlUids;

	CleanupStack::PushL(self);

	return self;

	}

EXPORT_C CCdlUids::CCdlUids()

: CArrayFixFlat<TUid>(KCdlGranularity)

	{

	}

EXPORT_C void CCdlUids::AddL(TUid aUid)

	{

	if (FindIndex(aUid) == KErrNotFound)

		AppendL(aUid);

	}

EXPORT_C void CCdlUids::AddL(const CCdlUids& aArray)

	{

	TInt count = aArray.Count();

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

		{

		TUid uid = aArray[ii];

		AddL(uid);

		}

	}

EXPORT_C void CCdlUids::Remove(const CCdlUids& aArray)

	{

	TInt count = aArray.Count();

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

		Remove(aArray[ii]);

	}

EXPORT_C void CCdlUids::Remove(TUid aUid)

	{

	TInt index = FindIndex(aUid);

	if (index != KErrNotFound)

		Delete(index);

	}

EXPORT_C TInt CCdlUids::FindIndex(TUid aUid) const

	{

	TInt count = Count();

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

		{

		if (At(ii) == aUid)

			return ii;

		}

	return KErrNotFound;

	}

EXPORT_C CCdlUids* CCdlUids::IntersectionLC(const CCdlUids& aArray) const

	{

	CCdlUids* array = CCdlUids::NewLC();

	TInt count = aArray.Count();

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

		{

		TUid uid = aArray[ii];

		if (FindIndex(uid) != KErrNotFound)

			array->AppendL(uid);

		}

	return array;

	}

EXPORT_C void CCdlUids::ImportL(const TDesC8& aDes)

	{

	TInt size = aDes.Size();

	ResizeL(size/sizeof(TUid));

	if (size)

		{

		Mem::Copy(&At(0), aDes.Ptr(), size);

		}

	}

EXPORT_C TPtrC8 CCdlUids::Export() const

	{

	TInt count = Count();

	const TUid* uids = count ? &At(0) : NULL;

	TPtrC8 ptr(reinterpret_cast<const TText8*>(uids), count*sizeof(TUid));

	return ptr;

	}

//

// CCdlNames

//

EXPORT_C CCdlNames* CCdlNames::NewLC()

	{

	CCdlNames* self = new(ELeave) CCdlNames;

	CleanupStack::PushL(self);

	return self;

	}

EXPORT_C CCdlNames::CCdlNames()

: CArrayPtrFlat<HBufC>(KCdlGranularity)

	{

	}

EXPORT_C CCdlNames::~CCdlNames()

	{

	ResetAndDestroy();

	}

EXPORT_C TInt CCdlNames::FindIndex(const TDesC& aName) const

	{

	TInt count = Count();

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

		{

		HBufC* name = At(ii);

		if (CdlEngine::CompareNames(*name, aName) == 0)

			return ii;

		}

	return KErrNotFound;

	}

EXPORT_C HBufC* CCdlNames::AddL(const TDesC& aName)

	{

	TInt pos = FindIndex(aName);

	if (pos != KErrNotFound)

		return At(pos);

	HBufC* name = aName.AllocLC();

	AppendL(name);

	CleanupStack::Pop(name);

	return name;

	}

EXPORT_C void CCdlNames::ImportL(const TDesC8& aDes)

	{

	TPtrC8 buf(aDes);

	TInt newCount=0;

	CdlUtils::Extract(buf, newCount);

	TInt arrayCount = Count();

	ResizeL(arrayCount + newCount, 0);

	CleanupStack::PushL(TCleanupItem(CleanupImport, this));

	for (TInt ii=0; ii<newCount; ii++)

		{

		TInt size=0;

		CdlUtils::Extract(buf, size);

		TPtrC name((TText*)buf.Ptr(), size/2);

		buf.Set(buf.Mid(size));

		if (FindIndex(name) == KErrNotFound)

			At(arrayCount++) = name.AllocL();

		}

	CleanupStack::Pop();	// cleanup import

	ResizeL(arrayCount);

	}

EXPORT_C HBufC8* CCdlNames::ExportL() const

	{

	HBufC8* buf = ExportLC();

	CleanupStack::Pop(buf);

	return buf;

	}

EXPORT_C HBufC8* CCdlNames::ExportLC() const

	{

	HBufC8* buf = HBufC8::NewLC(sizeof(TInt));

	// names count is first in the export descriptor

	TInt count = Count();

	CdlUtils::AppendLDC(buf, TPckgC<TInt>(count));

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

		{

		// for each name, place the size of the name, then the name in the export descriptor

		const TDesC& name = *At(ii);

		TInt size = name.Size();

		CdlUtils::AppendLDC(buf, TPckgC<TInt>(size));

		TPtrC8 name8((TText8*)name.Ptr(), size);

		CdlUtils::AppendLDC(buf, name8);

		}

	return buf;

	}

void CCdlNames::CleanupImport(TAny* aThis)

	{

	static_cast<CCdlNames*>(aThis)->DoCleanupImport();

	}

void CCdlNames::DoCleanupImport()

	{

	// count the number of used HBufCs and resize to that size.

	TInt count = Count();

	TInt used;

	for (used=0; used<count; used++)

		if (!At(used))

			break;

	if (used<count)

		ResizeL(used);	// will not leave because array is shrinking

	}