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

// Class for managing custom property lists

// @internalComponent

// 

//

#include "propertylist.h"

#include "repository.h"

CPropertyList* CPropertyList::NewL(CRepository& iRepository, CPropertyReg& aPropertyRegister, CPropertyReg::TPropertyGroup aGroup, TUint32 aIndexBase)

	{

	CPropertyList* self = new (ELeave) CPropertyList(iRepository, aPropertyRegister, aGroup, aIndexBase);

	return self;

	}

CPropertyList::CPropertyList(CRepository& iRepository, CPropertyReg& aPropertyRegister, CPropertyReg::TPropertyGroup aGroup, TUint32 aIndexBase)

	: CRepositoryAccessor(), iPropertyRegister(aPropertyRegister), iGroup(aGroup), iIndexBase(aIndexBase)

	{

	SetRepository(iRepository);

	}

CPropertyList::~CPropertyList()

	{

	Reset();

	}

void CPropertyList::Reset()

	{

	TInt index = iPropertyValues.Count() - 1;

	for (;index >= 0; --index)

		{

		delete iPropertyValues[index];

		}

	iPropertyValues.Reset();

	}

TInt CPropertyList::PropertyIndex(TUid aPropertyId, Bookmark::TPropertyType aType) const

	{

	TInt index = iPropertyRegister.PropertyIndex(iGroup, aPropertyId, aType);

	TInt count = iPropertyValues.Count();

	if (index == KErrNotFound || index >= count || !iPropertyValues[index])

		{

		index = KErrNotFound;

		}

	return index;

	}

TInt CPropertyList::GetCustomProperty(TUid aPropertyId, TInt& aValue) const

	{

	TInt index = PropertyIndex(aPropertyId, Bookmark::EDataTypeInt);

	if (index == KErrNotFound)

		{

		return KErrNotFound;

		}

	TInt* intPtr = static_cast<TInt*>(iPropertyValues[index]);

	aValue = *intPtr;

	return KErrNone;

	}

TInt CPropertyList::GetCustomProperty(TUid aPropertyId, TReal& aValue) const

	{

	TInt index = PropertyIndex(aPropertyId, Bookmark::EDataTypeReal);

	if (index == KErrNotFound)

		{

		return KErrNotFound;

		}

	TReal* realPtr = static_cast<TReal*>(iPropertyValues[index]);

	aValue = *realPtr;

	return KErrNone;

	}

TInt CPropertyList::GetCustomProperty(TUid aPropertyId, TDes& aValue) const

	{

	TInt index = PropertyIndex(aPropertyId, Bookmark::EDataTypeDes16);

	if (index == KErrNotFound)

		{

		return KErrNotFound;

		}

	TDes* descPtr = static_cast<TDes*>(iPropertyValues[index]);

	if (aValue.MaxLength() < descPtr->Length())

		{

		return KErrArgument;

		}

	aValue = *descPtr;

	return KErrNone;

	}

TInt CPropertyList::GetCustomProperty(TUid aPropertyId, TDes8& aValue) const

	{

	TInt index = PropertyIndex(aPropertyId, Bookmark::EDataTypeDes8);

	if (index == KErrNotFound)

		{

		return KErrNotFound;

		}

	TDes8* desc8Ptr = static_cast<TDes8*>(iPropertyValues[index]);

	if (aValue.MaxLength() < desc8Ptr->Length())

		{

		return KErrArgument;

		}

	aValue = *desc8Ptr;

	return KErrNone;

	}

void CPropertyList::SetCustomPropertyL(TUid aPropertyId, TInt aValue)

	{

	TInt index = iPropertyRegister.PropertyIndex(iGroup, aPropertyId, Bookmark::EDataTypeInt);

	if (index == KErrNotFound)

		{

		User::Leave(Bookmark::KErrNotRegistered);

		}

	UpdateValueListItemL(index, Bookmark::EDataTypeInt, &aValue);

	SetDirty();

	}

void CPropertyList::SetCustomPropertyL(TUid aPropertyId, TReal aValue)

	{

	TInt index = iPropertyRegister.PropertyIndex(iGroup, aPropertyId, Bookmark::EDataTypeReal);

	if (index == KErrNotFound)

		{

		User::Leave(Bookmark::KErrNotRegistered);

		}

	UpdateValueListItemL(index, Bookmark::EDataTypeReal, &aValue);

	SetDirty();

	}

void CPropertyList::SetCustomPropertyL(TUid aPropertyId, const TDesC& aValue)

	{

	// The aValue must be smaller that the maximim descriptor storage size

	__ASSERT_ALWAYS(aValue.Length() <= Bookmark::KMaxDescriptorLength, User::Panic(Bookmark::KBookmarkErrTooLong, KErrArgument));

	TInt index = iPropertyRegister.PropertyIndex(iGroup, aPropertyId, Bookmark::EDataTypeDes16);

	if (index == KErrNotFound)

		{

		User::Leave(Bookmark::KErrNotRegistered);

		}

	UpdateValueListItemL(index, Bookmark::EDataTypeDes16, &aValue);

	SetDirty();

	}

void CPropertyList::SetCustomPropertyL(TUid aPropertyId, const TDesC8& aValue)

	{

	// The aValue must be smaller that the maximim data storage size

	__ASSERT_ALWAYS(aValue.Length() <= Bookmark::KMaxDataLength, User::Panic(Bookmark::KBookmarkErrTooLong, KErrArgument));

	TInt index = iPropertyRegister.PropertyIndex(iGroup, aPropertyId, Bookmark::EDataTypeDes8);

	if (index == KErrNotFound)

		{

		User::Leave(Bookmark::KErrNotRegistered);

		}

	UpdateValueListItemL(index, Bookmark::EDataTypeDes8, &aValue);

	SetDirty();

	}

void CPropertyList::UpdateValueListItemL(TInt aIndex, Bookmark::TPropertyType aType, const TAny* aValue)

	{

	TInt lastIndex = iPropertyValues.Count() - 1;

	if (aIndex > lastIndex)

		{

		// create Null values in the property list.

		for (; lastIndex < aIndex; ++lastIndex)

			{

			iPropertyValues.AppendL(NULL);

			}

		}

	//Delete any previously allocated memory

	delete iPropertyValues[aIndex];

	iPropertyValues[aIndex] = NULL;	

	switch (aType)

		{

		case Bookmark::EDataTypeInt:

			{

			const TInt* intPtr = static_cast<const TInt*>(aValue);

			TInt* newInt = new (ELeave) TInt;

			*newInt = *intPtr;

			iPropertyValues[aIndex] = newInt;

			break;

			}

		case Bookmark::EDataTypeReal:

			{

			const TReal* realPtr = static_cast<const TReal*>(aValue);

			TReal* newReal = new (ELeave) TReal;

			*newReal = *realPtr;

			iPropertyValues[aIndex] = newReal;

			break;

			}

		case Bookmark::EDataTypeDes16:

			{

			const TDes* buffer16 = static_cast<const TDes*>(aValue);

			iPropertyValues[aIndex] = buffer16->AllocL();

			break;

			}

		case Bookmark::EDataTypeDes8:

			{

			const TDes8* buffer8 = static_cast<const TDes8*>(aValue);

			iPropertyValues[aIndex] = buffer8->AllocL();

			break;

			}

		default:

			// Should not get to here

			User::Leave(Bookmark::KErrCorrupt);

			break;

		}

	}

void CPropertyList::TransNewL()

	{

	TransSaveL();

	}

void CPropertyList::TransSaveL()

	{

	RArray<TUint32> entryList;

	TBool creating;

	TInt* intPtr = NULL;

	TReal* realPtr = NULL;

	TDesC* desc16Ptr = NULL;

	TDesC8* desc8Ptr = NULL;

	TInt index;

	Bookmark::TPropertyType type;

	for (index = iPropertyValues.Count() - 1; index >= 0; --index)

		{

		if (iPropertyValues[index])

			{

			if (iPropertyRegister.GetPropertyType(iGroup, index, type) != KErrNone)

				{

				User::Leave(Bookmark::KErrNotRegistered);

				}

			// if the index does not yet exist in the database we need to create it.

			creating = EFalse;

			if (KErrNotFound == iRepository->FindL(iIndexBase + index, KRepExactMask, entryList))

				{

				creating = ETrue;

				}

			entryList.Reset();

			switch (type)

				{

			case Bookmark::EDataTypeInt:

				intPtr = static_cast<TInt*>(iPropertyValues[index]);

				if (creating)

					{

					iRepository->Create(iIndexBase + index, *intPtr);

					}

				else

					{

					iRepository->Set(iIndexBase + index, *intPtr);

					}

				break;

			case Bookmark::EDataTypeReal:

				realPtr = static_cast<TReal*>(iPropertyValues[index]);

				if (creating)

					{

					iRepository->Create(iIndexBase + index, *realPtr);

					}

				else

					{

					iRepository->Set(iIndexBase + index, *realPtr);

					}

				break;

			case Bookmark::EDataTypeDes16:

				desc16Ptr = static_cast<TDes*>(iPropertyValues[index]);

				if (creating)

					{

					iRepository->Create(iIndexBase + index, *desc16Ptr);

					}

				else

					{

					iRepository->Set(iIndexBase + index, *desc16Ptr);

					}

				break;

			case Bookmark::EDataTypeDes8:

				desc8Ptr = static_cast<TDes8*>(iPropertyValues[index]);

				if (creating)

					{

					iRepository->Create(iIndexBase + index, *desc8Ptr);

					}

				else

					{

					iRepository->Set(iIndexBase + index, *desc8Ptr);

					}

				break;

			default:

				// Should not get to here

				User::Leave(Bookmark::KErrCorrupt);

				break;

				}

			}

		}

	}

void CPropertyList::TransLoadL()

	{

	RArray<TUint32> entryList;

	CleanupClosePushL ( entryList );

	iRepository->FindL(iIndexBase, KCusPropertyMask, entryList);

	TInt intValue = 0;

	TReal realValue = 0.0;

	HBufC* desc16Buffer = HBufC::NewLC(Bookmark::KMaxDescriptorLength);

	TPtr desc16Ptr = desc16Buffer->Des();

	HBufC8* desc8Buffer = HBufC8::NewLC(Bookmark::KMaxDataLength);

	TPtr8 desc8Ptr = desc8Buffer->Des();

	TInt valueIndex = 0;

	TInt index = 0;

	Bookmark::TPropertyType type;

	TInt count = entryList.Count();

	for (;index < count; ++index)

		{

		valueIndex = entryList[index] - iIndexBase;

		if (iPropertyRegister.GetPropertyType(iGroup, valueIndex, type) != KErrNone)

			{

			// remove redundant entries

			User::LeaveIfError(iRepository->Delete(entryList[index]));

			}

		else

			{

			switch (type)

				{

			case Bookmark::EDataTypeInt:

				User::LeaveIfError(iRepository->Get(entryList[index], intValue));

				UpdateValueListItemL(valueIndex, type, &intValue);

				break;

			case Bookmark::EDataTypeReal:

				User::LeaveIfError(iRepository->Get(entryList[index], realValue));

				UpdateValueListItemL(valueIndex, type, &realValue);

				break;

			case Bookmark::EDataTypeDes16:

				User::LeaveIfError(iRepository->Get(entryList[index], desc16Ptr));

				UpdateValueListItemL(valueIndex, type, &desc16Ptr);

				break;

			case Bookmark::EDataTypeDes8:

				User::LeaveIfError(iRepository->Get(entryList[index], desc8Ptr));

				UpdateValueListItemL(valueIndex, type, &desc8Ptr);

				break;

			default:

				// Should not get to here

				User::Leave(Bookmark::KErrCorrupt);

				break;

				}

			}

		}	

	CleanupStack::PopAndDestroy(desc8Buffer);

	CleanupStack::PopAndDestroy(desc16Buffer);

	CleanupStack::PopAndDestroy ( &entryList );

	SetClean();

	}

void CPropertyList::TransRemoveL()

	{

	TInt index = iPropertyValues.Count() - 1;

	for (;index >= 0; --index)

		{

		if (iPropertyValues[index])

			{

			iRepository->Delete(iIndexBase + index);

			}

		}

	}

TUint32 CPropertyList::IndexBase()

	{

	return iIndexBase;

	}

void CPropertyList::SetIdFromIndexBase(TUint32 aIndexBase)

	{

	iIndexBase = aIndexBase;

	}