// 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:

// CMSVCACHEVISIBLEFOLDER.CPP

// 

//

#include "msvcachevisiblefolder.h"

#include "msventryfreepool.h"

#include "msvcacheindextableentry.h"

#include "msvdbadapter.h"

#include "msvcacheentry.h"

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)	

	#include "msvindexadapter.h"

#endif

#define BLOCK_SIZE 64

#define BLOCK_THRESHOLD 16

/**

Literal Definition

*/

_LIT8(KId, "id ");

_LIT8(KBetween, "between ");

_LIT8(KAnd, " and ");

_LIT8(KOr, " or ");

_LIT8(KIn, " in ");

_LIT8(KRtBrace, ") ");

_LIT8(KLtBrace, "( ");

_LIT8(KComma, ", ");

_LIT8(KSemiColon, ";");

_LIT8(KOrder, " order by id ASC");

/**

CMsvCacheVisibleFolder

*/

const TInt CMsvCacheVisibleFolder::iOffset = _FOFF(CMsvCacheVisibleFolder, iDlink);

/**

 NewL()

@param TMsvId: Visible Folder TMsvId.

@return The newly created Visible Folder.

It returns an instance of CMsvCacheVisibleFolder class. 

*/

CMsvCacheVisibleFolder* CMsvCacheVisibleFolder::NewL(TMsvId aId)

	{

	CMsvCacheVisibleFolder *self = new(ELeave) CMsvCacheVisibleFolder(aId);

	return self;

	}

/**

 NewL()

@param 	TMsvId: Visible Folder TMsvId.

@param 	RPointerArray<CMsvCacheEntry>: Rpointer Reference to children Entries

@return The newly created Visible Folder.

 		It returns an instance of CMsvCacheVisibleFolder class. 

*/

CMsvCacheVisibleFolder* CMsvCacheVisibleFolder::NewL(TMsvId aId, RPointerArray<CMsvCacheEntry>& aEntries)

	{

	CMsvCacheVisibleFolder *self = new(ELeave) CMsvCacheVisibleFolder(aId);

	CleanupStack::PushL(self);

	self->ConstructL(aEntries);

	CleanupStack::Pop();

	return self;

	}

/**

 ~CMsvCacheVisibleFolder()

@param 	None.

@return None.

 		Destructor for the CMsvCacheVisibleFolder class.

*/

CMsvCacheVisibleFolder::~CMsvCacheVisibleFolder()

	{

	iIndexTable.ResetAndDestroy();

	iIndexTable.Close();

	}

/**

 CMsvCacheVisibleFolder()

@param 	None.

@return None.

 		Constructor for the CMsvCacheVisibleFolder class. 

*/

CMsvCacheVisibleFolder::CMsvCacheVisibleFolder(TMsvId aId)

:iFlags(EMsvCacheVisibleFolderClearFlag)

	{

#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

	// Keep standard id unmasked.

	if(IsStandardId(aId))

		{

		iVisibleFolderId = UnmaskTMsvId(aId);

		}

	else

		{

		iVisibleFolderId = aId;

		}

	// Store drive id information.

	iDriveId = GetDriveId(aId);

#else

	iVisibleFolderId = aId;

#endif

	}

/**

 ConstructL()

@param 	RPointerArray<CMsvCacheEntry>& aEntries.

@return None.

 		Two Phase constructor for adding the entries passed during the creation

 		of the CMsvCacheVisibleFolder object. 

*/

void CMsvCacheVisibleFolder::ConstructL(RPointerArray<CMsvCacheEntry>& aEntries)

	{

	AddEntryListL(aEntries, ETrue);

	}

/**

 AddEntryL()

@param CMsvCacheEntry&: CMsvCacheEntry Reference.

@return none.

The function Adds an Entry into the cache block

01. check if the parent id of the entry exists; Incase if it is a child of a non-visible folder

	we cannot add it unless the parent is present

02. Check if The Parent Id of the Entry is same as the visible folder id.

02.1. If yes, Set the Flag to Update the ChildMsvId array of the parent.

03. If there is no Index Table created, Create a new index table entry

	and add the entry into the table

04. Iterate the Indextable entries and add the entry in the appropriate 

	IndexTable entry Block and update the child msvid array of the parent

	If the entry is not an immediate child.

05. In case index table is not yet created, then there is a possibility that entry Id does not fall in

 the first block range but it can be added before the first block. In such case, add the entry in the first

 block itself and update the first block range.

06. If the Entry doesnt fall in the range of any of the blocks add the Entry

	in the last block and update the child MsvId array if the entry is not an immediate child.

*/

void CMsvCacheVisibleFolder::AddEntryL(CMsvCacheEntry*& aEntry, TBool aReplace /* DEFAULT = EFalse */)

	{

	TBool updateChild=EFalse;

	TInt noOfIndexTableEntries  = iIndexTable.Count();

	TMsvId entryId = aEntry->Entry().Id();

	TMsvId parentId = aEntry->Entry().Parent();

	// 02. Check if The Parent Id of the Entry is same as the visible folder id.

	if(parentId != iVisibleFolderId)

		{

		// 02.1. If yes, Set the Flag to Update the ChildMsvId array of the parent.

		updateChild = ETrue;

		}

	// 03. If there is no Index Table created, Create a new index table entry

	//		and add the entry into the table

	if(NULL == noOfIndexTableEntries )

		{

		CMsvCacheIndexTableEntry* tableEntry = CMsvCacheIndexTableEntry::NewLC(aEntry);

		tableEntry->SetMinMsvIdRange(aEntry->GetId());

		tableEntry->SetMaxMsvIdRange(aEntry->GetId());

		if(aEntry->Entry().Parent() != iVisibleFolderId)

			{

			tableEntry->SetGrandChildPresent();

			}

		iIndexTable.AppendL(tableEntry);

		CleanupStack::Pop();		

		return;

		}

	// 04. Iterate the Indextable entries and add the entry in the appropriate 

	// 		IndexTable entry Block and update the child msvid array of the parent

	//		If the entry is not an immediate child.

	for(TInt index=0; index < noOfIndexTableEntries; ++index)

		{

	 	if(iIndexTable[index]->IsInRange(entryId))

	 		{

	 		iIndexTable[index]->AddEntryL(aEntry, aReplace);

	 		if(aEntry->Entry().Parent() != iVisibleFolderId)

				{

				iIndexTable[index]->SetGrandChildPresent();

				}	

	 		if(updateChild)

	 			{

	 			UpdateChildMsvIdsL(parentId, entryId);

	 			}

	 		return;

	 		}

		//05. In case index table is not yet created, then there is a possibility that entry Id does not fall in

		// the first block range but it can be added before the first block. In such case, add the entry in the first

		// block itself and update the first block range.

		if((NULL == index) && (entryId < iIndexTable[index]->GetMinMsvIdRange()))

			{

	 		iIndexTable[index]->AddEntryL(aEntry, aReplace);

	 		if(aEntry->Entry().Parent() != iVisibleFolderId)

				{

				iIndexTable[index]->SetGrandChildPresent();

				}	

	 		if(updateChild)

	 			{

	 			UpdateChildMsvIdsL(parentId, entryId);

	 			}

	 		return;

			}

		}

	// 06. If the Entry doesnt fall in the range of any of the blocks add the Entry

	// 		in the last block and update the child MsvId array if the entry is not an immediate child.

	iIndexTable[noOfIndexTableEntries-1]->AddEntryL(aEntry, aReplace);

	if(aEntry->Entry().Parent() != iVisibleFolderId)

		{

		iIndexTable[noOfIndexTableEntries-1]->SetGrandChildPresent();

		}

	if(entryId > iIndexTable[noOfIndexTableEntries-1]->GetMaxMsvIdRange())

		{

		iIndexTable[noOfIndexTableEntries-1]->SetMaxMsvIdRange(entryId);

		}

	if(updateChild)

		{

		UpdateChildMsvIdsL(parentId, entryId);

		}

	}

/**

 AddEntryListL()

@param RPointerArray<CMsvCacheEntry>&: Entries to be added under this visible folder which are in sorted order.

@param TBool: Set to true if the passed array of CMsvCacheEntry contains the complete childrens of VisibleFolder

@return none.

The function Adds a set of Entries into the cache

1. If entry list is NULL, return to the caller.

2.check if the IndexTable is not created then,

2.1 Yes, create the required number of index tables and append the entries in the appropriate blocks

2.2 No, Check if getchildren has already been performed on this VisibleFolder

2.2.1 Yes Assuming the input list is already sorted, Add the entries in the appropriate

 blocks depending on the range of each blocks

2.2.1.1 The remaining entries should be put in the last block

2.3 No, check if getchildren has'nt been performed on this VisibleFolder

2.3.1 Check If index table exists

2.3.1.1 Yes,Create a Copy of the existing index table entries

2.3.1.2 create the required number of index tables and append the entries in the appropriate blocks

2.3.1.3 check the copy of the previous list if any entry exists

2.3.1.3 copy back only the locked entries or entires

 which are not immediate childrens of the visible folder or

 entries which are locked and release the remaining entries

2.3.2 If indextable is not present add the entries in the appropriate blocks 

*/

void CMsvCacheVisibleFolder::AddEntryListL(RPointerArray<CMsvCacheEntry>& aEntries, TBool aIsCompleteChildOfFolder /*DEFAULT = EFalse */)

	{	

	//1. If entry list is NULL, return to the caller.

	TInt size = aEntries.Count();

	if(size <= 0)

		{

		if(!size && aIsCompleteChildOfFolder)

			{

			SetComplete(ETrue);

			}

		return;

		}

	TBool isGrandChildrenAdded = EFalse;

	if(aEntries[0]->Entry().Parent() != iVisibleFolderId)

		{

		isGrandChildrenAdded = ETrue;

		}

	//2.check if the IndexTable is not created then,

	if(0 == iIndexTable.Count())

		{

		//2.1 Yes, create the required number of index tables and append the entries in the appropriate blocks

		SplitAndAppendL(aEntries);

		}

	else

		{

		//2.2 No, Check if getchildren has already been performed on this VisibleFolder

		if(IsComplete())		

			{

			TInt tmpIndex = 0, index = 0;

			//2.2.1 Yes Assuming the input list is already sorted, Add the entries in the appropriate

			// blocks depending on the range of each blocks

			for(TInt tableIndex = 0; tableIndex < iIndexTable.Count(); ++tableIndex)

				{

				while((tmpIndex < size) && (iIndexTable[tableIndex]->GetMaxMsvIdRange() >= aEntries[tmpIndex]->GetId()))

					{

					++tmpIndex;

					}

				if(index != tmpIndex)

					{

					// No need to set Max/Min range, as IsComplete() is true.

					iIndexTable[tableIndex]->AddEntrySetL(aEntries, index, tmpIndex-index);

					if(isGrandChildrenAdded)

						{

						iIndexTable[tableIndex]->SetGrandChildPresent();

						}

					}	

				if(aIsCompleteChildOfFolder)

					{

					iIndexTable[tableIndex]->ClearDirty();

					}

				if( tmpIndex >= size )

					{

					break;

					}

				index = tmpIndex;

				}

			//2.2.1.1 The remaining entries should be put in the last block

			tmpIndex = size - tmpIndex;		// Amount of entries remaining.

			if(tmpIndex > BLOCK_THRESHOLD)

				{				

				SplitAndAppendL(aEntries, index);

				}

			else if(0 != tmpIndex)	

				{

				TMsvId maxId = aEntries[size-1]->GetId();

				iIndexTable[iIndexTable.Count()-1]->AddEntrySetL(aEntries, index, tmpIndex);

				if(isGrandChildrenAdded)

					{

					iIndexTable[iIndexTable.Count()-1]->SetGrandChildPresent();

					}

				iIndexTable[iIndexTable.Count()-1]->SetMaxMsvIdRange(maxId);

				}

			}

		//2.3 No, check if getchildren has'nt been performed on this VisibleFolder

		else

			{

			//2.3.1 Check If index table exists

			if(aIsCompleteChildOfFolder)

				{

				// 2.3.1.1 Yes,Create a Copy of the existing index table entries

				RPointerArray<CMsvCacheIndexTableEntry> tmpTable;

				CleanupClosePushL(tmpTable);

				for(TInt index=0; index<iIndexTable.Count(); index++)

					{

					tmpTable.AppendL(iIndexTable[index]);

					}

				iIndexTable.Reset();

				// 2.3.1.2 create the required number of index tables and append the entries in the appropriate blocks

				SplitAndAppendL(aEntries);

				// 2.3.1.3 check the copy of the previous list if any entry exists

				while(tmpTable.Count())					

					{

					if(tmpTable[0]->BlockPtr() != NULL)

						{

						RPointerArray<CMsvCacheEntry>* blockPtr = tmpTable[0]->BlockPtr();

						TInt count = blockPtr->Count();

						while(count--)

							{

							// 2.3.1.3 copy back only the locked entries or entires

							//which are not immediate childrens of the visible folder or

							//entries which are locked and release the remaining entries

							if( ((*blockPtr)[count]->Entry().Parent() != iVisibleFolderId) || !((*blockPtr)[count]->IsEntrySwappable()) )

								{

								AddEntryL((*blockPtr)[count], ETrue);

								}

							else

								{

								}

							}

						blockPtr->Reset();

						blockPtr->Close();

						}

					delete tmpTable[0];

					tmpTable.Remove(0);

					}

				tmpTable.Reset();	

				CleanupStack::PopAndDestroy();

				}

			//2.3.2 If indextable is not present add the entries in the appropriate blocks 

			else	

				{

				TInt size = aEntries.Count();

				while(size--)

					{

					AddEntryL(aEntries[size]);

					}

				}	

			}

		}

	if(aIsCompleteChildOfFolder)

		{

		SetComplete(ETrue);

		}

	}

/**

 SplitAndAppendL()

@param RPointerArray<CMsvCacheEntry>&: Entries to be added under this visible folder which are in sorted order.

@param TInt: Maximum range of the last block under this visible folder

@return none.

The function Adds a set Entries into the cache

1. Calculate the number of blocks to be created.

2. If remaining entries are less then BLOCK_THRESHOLD they will be appended to last block.

3. Create new indextable entries and then add the child entries into the appropriate blocks

4. If few entries are still left, append them to the last block.

*/

void CMsvCacheVisibleFolder::SplitAndAppendL(RPointerArray<CMsvCacheEntry>& aEntryList, TInt aInitIndex /*(DEFAULT=0)*/)

	{

	//1. Calculate the number of blocks to be created.

	TInt entriesToBeAdded = aEntryList.Count() - aInitIndex;

	TInt blocksToCreate = entriesToBeAdded /(TInt) BLOCK_SIZE;

	TInt aLastMaxRange = -1;

	TBool isGrandChildrenAdded = EFalse;

	TInt blocksCreated = iIndexTable.Count();

	if(blocksCreated != 0)

		{

		aLastMaxRange = iIndexTable[blocksCreated-1]->GetMaxMsvIdRange();

		}

	if( aEntryList[aInitIndex]->Entry().Parent() != iVisibleFolderId)

		{

		isGrandChildrenAdded = ETrue;

		}

	//2. If remaining entries are less then BLOCK_THRESHOLD they will be appended to last block.

	if( (BLOCK_THRESHOLD < (entriesToBeAdded % BLOCK_SIZE)) || 

		( (NULL == (blocksCreated+blocksToCreate)) && (entriesToBeAdded <= BLOCK_THRESHOLD) )

	  )

		{

		++ blocksToCreate;

		}

	TInt blockSize = entriesToBeAdded/blocksToCreate;

	//3. Create new indextable entries and then add the child entries into the appropriate blocks

	for(TInt index = 0; index < blocksToCreate; ++index)

		{

		CMsvCacheIndexTableEntry* newTableEntry = CMsvCacheIndexTableEntry::NewLC(aEntryList, aInitIndex, blockSize);

		if(isGrandChildrenAdded)

			{

			newTableEntry->SetGrandChildPresent();

			}

		TMsvId maxRange = aEntryList[aInitIndex+blockSize-1]->GetId();

		newTableEntry->SetMinMsvIdRange(++aLastMaxRange);

		newTableEntry->SetMaxMsvIdRange(maxRange);

		iIndexTable.AppendL(newTableEntry);

		aLastMaxRange = maxRange;

		aInitIndex += blockSize;

		CleanupStack::Pop();

		}

	//4. If few entries are still left, append them to the last block.

	entriesToBeAdded = aEntryList.Count() - aInitIndex;

	if(entriesToBeAdded > 0)	

		{

		CMsvCacheIndexTableEntry* newTableEntry = iIndexTable[iIndexTable.Count()-1];

		newTableEntry->AddEntrySetL(aEntryList, aInitIndex, entriesToBeAdded);

		if(isGrandChildrenAdded)

			{

			newTableEntry->SetGrandChildPresent();

			}

		if(newTableEntry->GetMaxMsvIdRange() < aEntryList[aEntryList.Count()-1]->GetId())

			{

			newTableEntry->SetMaxMsvIdRange(aEntryList[aEntryList.Count()-1]->GetId());

			}

		}

	}

/**

 GetEntry()

@param TMsvId: TMsvId for the Entry to be fetched

@param CMsvCacheEntry&: CMsvCacheEntry Reference.

@return TBool: Cache Hit or Cache Miss.

The function Gets an Entry from the cache block

1. Find the IndexTable entry where the Range of the TMsvId falls.

2. Get the Entry in the Block to which it belongs

*/

TBool CMsvCacheVisibleFolder::GetEntry(TMsvId aId, CMsvCacheEntry*& aEntry)

	{

	// 1. Find the IndexTable entry where the Range of the TMsvId falls.

	for(TInt index=0; index < iIndexTable.Count(); ++index)

		{

		if(iIndexTable[index]->IsInRange(aId))

	 		{

	 		//2. Get the Entry in the Block to which it belongs

			return(iIndexTable[index]->GetEntry(aId, aEntry));

	 		}

	 	}

	return EFalse;

	}

/**

 GetChildren()

@param TMsvId: TMsvId of the Parent Entry whose children are to be fetched.

@param RPointerArray<const CMsvCacheEntry>&: Array to fill childrens

@return TBool: Cache Hit or Cache Miss.

The function Gets the childrens of the parent from the cache

1. Check if the Parent Id is same as the Visible Folder

1.1 yes, check if getchildren has'nt already been performed on this visible folder entry

	or all the blocks present are dirty.

1.1.1 Then Fetch and fill all the childrens then return the same to the caller

1.2 yes, check if getchildren has beeb performed on this visible folder

1.2.1 yes, only few blocks are dirty, so fetch and fill the dirty blocks

2. If the if the Parent Id is not same as the Visible Folder