// Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of the License "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:

 // f32\sfsrv\cl_cdir.cpp

 // 

 //

 #include "cl_std.h"

 #include <collate.h>

 const TUint KCDirArrayGranularity=0x200;

 const TInt KPartKeyLength = 8;

 const TInt KCollationLevel0 = 0;

 const TInt KCollationLevelMax = 3;

 #define KCollationKeyAllocFail ((HBufC8*)-1)

 ///////////////////////////////////////////////////////////////////////////////

 /**

  * @class TEntry2

  * @description TEntry's variant with pointer to collation key buffers

  * @internalComponent

  */

 NONSHARABLE_CLASS(TEntry2)

     {

 public:

 	TEntry2(const TEntry& aEntry);

 	~TEntry2();

 public:

     TBool IsDir() const {return iEntry.IsDir();}

 #ifndef	SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

     TInt64 Size() {return MAKE_TINT64(0,iEntry.iSize);}

 #else

     TInt64 Size() {return iEntry.FileSize();}

 #endif

     TTime Modified() const {return iEntry.iModified;}

     const TUidType& Type() const {return iEntry.iType;}

     const TDesC& Name() const {return iEntry.iName;}

 private:

     TEntry2(const TEntry2& aEntry);

     TEntry2& operator=(const TEntry2& aEntry);

 public:

 	HBufC8* iPartKey;

 	HBufC8* iFullKey;

 	TEntry iEntry;

     };

 TEntry2::TEntry2(const TEntry& aEntry) : iPartKey(0), iFullKey(0), iEntry(aEntry)

 	{

 	}

 TEntry2::~TEntry2()

 	{

 	if (iPartKey != KCollationKeyAllocFail)

         delete iPartKey;

 	if (iFullKey != KCollationKeyAllocFail)

 	    delete iFullKey;

 	}

 inline TInt Entry2Size(const TEntry2& aEntry)

     {

     return sizeof(HBufC8*) * 2 + EntrySize(aEntry.iEntry, ETrue);

     }

 ///////////////////////////////////////////////////////////////////////////////

 NONSHARABLE_CLASS(TKeyDir) : public TKeyArrayVar

 	{

 public:

 	TKeyDir(TUint aKey);

 	virtual TInt Compare(TInt aLeft,TInt aRight) const;

 private:

 	TInt CompareByName(TEntry2& aLeft, TEntry2& aRight) const;

 private:

 	TCollationMethod iCollationMethod;

 	};

 TKeyDir::TKeyDir(TUint aKey)

 //

 // Constructor

 //

 	: TKeyArrayVar(0,(TKeyCmpText)(aKey&0xff),aKey&(EDirsFirst|EDirsLast|EDescending|EDirDescending))

 	{

 	//

 	// Create our own collation method to also consider punctuation when

 	// sorting filenames.

 	//

 	iCollationMethod = *Mem::GetDefaultMatchingTable();

 	iCollationMethod.iFlags |= TCollationMethod::EIgnoreNone | TCollationMethod::EFoldCase;

 	}

 TInt TKeyDir::Compare(TInt aLeft,TInt aRight) const

 //

 // Compare two directories for sorting.

 //

 	{

 	if (aLeft==aRight)

 		return(0);

 	TEntry2& left = *(TEntry2*)At(aLeft);

 	TEntry2& right = *(TEntry2*)At(aRight);

 	TInt ret=0;

 	if ((iKeyLength&EDirsFirst)==EDirsFirst)

 		{

 		if (left.IsDir())

 			{

 			if (!right.IsDir())

 				ret=(-1); // left is a dir, right is not

 			}

 		else if (right.IsDir())

 			ret=1; // right is a dir, left is not

 		}

 	else if ((iKeyLength&EDirsLast)==EDirsLast)

 		{

 		if (left.IsDir())

 			{

 			if (!right.IsDir())

 				ret=1; // left is a dir, right is not

 			}

 		else if (right.IsDir())

 			ret=(-1); // right is a dir, left is not

 		}

 	TInt cmpType=iCmpType;

 	TInt keyLength=iKeyLength;

 	TBool orderDirectories=(keyLength&EDirsFirst) || (keyLength&EDirsLast);

 	if (orderDirectories && left.IsDir() && right.IsDir())

 		{

 		cmpType=ESortByName;

 		if ((keyLength&EDirDescending)!=EDirDescending)

 			keyLength&=~EDescending;

 		else

 			keyLength|=EDescending;

 		}

 	if (ret==0) // Both are the same type

 		{

 		ret=(-1); // left before right by default

 		switch (cmpType)

 			{

 		case ESortNone:

 			ret=1;

 			break;

 		case ESortByDate:

 			if (left.Modified()>right.Modified())

 				ret=1;

 			else if (left.Modified()==right.Modified())

 				ret=0;

 			break;

 		case ESortBySize:

 #ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API

 		if (I64LOW(left.Size()) > I64LOW(right.Size()))

 			ret=1;

 		else if (I64LOW(left.Size())==I64LOW(right.Size()))

 			ret=0;

 #else

 			if (left.Size() > right.Size())

 				ret=1;

 			else if (left.Size()==right.Size())

 				ret=0;

 #endif

 			break;

 		case ESortByExt:

 			{

 			TInt i1 = KErrNotFound, i2 = KErrNotFound;

 			if (left.Name() != _L(".") && left.Name() != _L(".."))

 				i1 = left.Name().LocateReverse('.');

 			if (right.Name() != _L(".") && right.Name() != _L(".."))

 				i2 = right.Name().LocateReverse('.');

 			if (i1==KErrNotFound && i2!=KErrNotFound)

 				ret=(-1);

 			else if (i2==KErrNotFound && i1!=KErrNotFound)

 				ret=1;

 			else if ((i1==KErrNotFound && i2==KErrNotFound) || (ret=left.Name().Mid(i1).CompareC(right.Name().Mid(i2)))==0)

 				goto byName;

 			}

 			break;

 		case ESortByUid:

 			if (left.Type()[1]==right.Type()[1])

 				{

 				if (left.Type()[2]==right.Type()[2])

 					ret = CompareByName(left, right);

 				else if (left.Type()[2].iUid>right.Type()[2].iUid)

 					ret=1;

 				}

 			else if (left.Type()[1].iUid==0)

 				ret=1;

 			else if (right.Type()[1].iUid==0)

 				ret=-1;

 			else if (left.Type()[1].iUid>right.Type()[1].iUid)

 				ret=1;

 			break;

 		case ESortByName:

 byName:

 			// Force the maximum collation level here (i.e. 3) for sorting strings 

 			ret = CompareByName(left, right);

 			break;

 		default: // Default is bad news

 			Panic(ECDirBadSortType);

 			}

 		}

 	if ((keyLength&EDescending)==EDescending)

 		ret=(-ret); // Descending sort order

 	return(ret);

 	}

 TInt TKeyDir::CompareByName(TEntry2& aLeft, TEntry2& aRight) const

 //

 // Compare using collation key of entire name

 //

 	{

 	TInt ret = -1;

 	TInt r = KErrNone;

     // Allocate partial key first and handle potential error case

     // by calling old CompareC

 	// Note: only compare on the first collation level (KCollationLevel0) for partial keys, 

 	//       to avoid potential inconsistency between full key and partial key comparison.

 	if (!aLeft.iPartKey)

 		{

 		TRAP(r, aLeft.iPartKey = aLeft.Name().Left(KPartKeyLength).GetCollationKeysL(KCollationLevel0, &iCollationMethod));

 		if (r != KErrNone)

 		    aLeft.iPartKey = KCollationKeyAllocFail;

 		}

 	if (!aRight.iPartKey)

 		{

 		TRAP(r, aRight.iPartKey = aRight.Name().Left(KPartKeyLength).GetCollationKeysL(KCollationLevel0, &iCollationMethod));

 		if (r != KErrNone)

 		    aRight.iPartKey = KCollationKeyAllocFail;

 		}

 	if (aLeft.iPartKey == KCollationKeyAllocFail || aRight.iPartKey == KCollationKeyAllocFail)

 		return aLeft.Name().CompareC(aRight.Name());

 	// Compare by partial key first

     ret = aLeft.iPartKey->Compare(*aRight.iPartKey);

     if (ret != 0)

         return ret;

     // Compare by full key if partial keys are identical

 	if (!aLeft.iFullKey)

 		{

 		TRAP(r, aLeft.iFullKey = aLeft.Name().GetCollationKeysL(KCollationLevelMax, &iCollationMethod));

 		if (r != KErrNone)

 		    aLeft.iFullKey = KCollationKeyAllocFail;

 		}

 	if (!aRight.iFullKey)

 		{

 		TRAP(r, aRight.iFullKey = aRight.Name().GetCollationKeysL(KCollationLevelMax, &iCollationMethod));

 		if (r != KErrNone)

 		    aRight.iFullKey = KCollationKeyAllocFail;

 		}

 	if (aLeft.iFullKey == KCollationKeyAllocFail || aRight.iFullKey == KCollationKeyAllocFail)

 	    // Using old CompareC if partial key allocation failed

 		return aLeft.Name().CompareC(aRight.Name());

     // Compare using collation key of full names

     ret = aLeft.iFullKey->Compare(*aRight.iFullKey);

 	return ret;

 	}

 EXPORT_C CDir::CDir()

 /**

 Default constructor.

 */

 	{

 	}

 EXPORT_C CDir::~CDir()

 /**

 Destructor.

 Frees all resources owned by the object, prior to its destruction.

 */

 	{

 	delete iArray;

 	}

 EXPORT_C CDir* CDir::NewL()

 /**

 Allocates and constructs a directory object.

 This function is protected, which prevents objects of this class from being

 directly constructed.

 @return A pointer to the newly created object.

 */

 	{

 	CDir* pD=new(ELeave) CDir;

 	pD->iArray=new CArrayPakFlat<TEntry>(KCDirArrayGranularity);

 	if (pD->iArray==NULL)

 		{

 		delete pD;

 		User::LeaveNoMemory();

 		}

 	return(pD);

 	}

 EXPORT_C TInt CDir::Count() const

 /**

 Gets the number of entries in the array of directory

 entries.

 @return The number of entries in the array.

 */

 	{

 	return(iArray->Count());

 	}

 EXPORT_C const TEntry& CDir::operator[](TInt anIndex) const

 /**

 Gets an entry from the array of directory

 entries.

 @param anIndex of the desired entry within the array.

 @return A directory entry.

 */

 	{

 	return((*iArray)[anIndex]);

 	}

 /**

  * Utility class to manage dynamic array memory

  * @internalComponent

  */

 NONSHARABLE_CLASS(CAutoArray) : public CBase

     {

 public:

     ~CAutoArray();

 public:

     CArrayVarFlat<TEntry2>* iArray;

     };

 // Have to do this trick because CArrayVarFlat won't destroy element one by one

 CAutoArray::~CAutoArray()

     {

     if (iArray)

         for (TInt i=0; i<iArray->Count(); ++i)

             {

             TEntry2& e = (*iArray)[i];

            	if (e.iPartKey != KCollationKeyAllocFail)

                 delete e.iPartKey;

 	        if (e.iFullKey != KCollationKeyAllocFail)

 	            delete e.iFullKey;

             e.iPartKey = e.iFullKey = 0;

             }

     delete iArray;

     }

 EXPORT_C TInt CDir::Sort(TUint aKey)

 /**

 Sorts the array of directory entries.

 @param aKey A set of flags describing how the directory entries are to be sorted.

        The set of flags is defined by TEntryKey.

 @return KErrNone, if successful, otherwise one of the other	 system-wide error

         codes.

 @see TEntryKey

 */

 	{

 	CAutoArray autoArray;

 	#define array autoArray.iArray

 	// Create TEntry2 array from iArray.

 	array = new CArrayVarFlat<TEntry2>(KCDirArrayGranularity);

 	if (!array)

 		return KErrNoMemory;

 	TInt arrayCount = iArray->Count();

 	if (arrayCount == 0)

 		return KErrNone;

 	TEntry2* entry2 = new TEntry2((*iArray)[0]);

 	if (!entry2)

 		return KErrNoMemory;

 	TInt i, r;

 	for (i=0; i<arrayCount; ++i)

 		{

 		entry2->iEntry = (*iArray)[i];

 		// Pack here

 		TUint32* pSizeHighSrc = PtrAdd((TUint32*)&(entry2->iEntry), sizeof(TEntry) - 2 * sizeof(TInt));

 		TUint32* pSizeHighDst = PtrAdd((TUint32*)&(entry2->iEntry), EntrySize(entry2->iEntry, EFalse));

 		*pSizeHighDst++ = *pSizeHighSrc++;	// Pack iSizeHigh

 		*pSizeHighDst   = *pSizeHighSrc;	// Pack iReserved

 		entry2->iEntry.iAtt |= KEntryAttPacked;

 		TRAP(r, array->AppendL(*entry2, Entry2Size(*entry2)));

 		if (r != KErrNone)

 			{

 			delete entry2;	

 			return r;

 			}

 		}

 	// Sort new array

 	TKeyDir key(aKey);

 	r = array->Sort(key);

 	if (r != KErrNone)

 		{

 		delete entry2;

         return r;

 		}

 	// Copy sorted result back to iArray

 	iArray->Reset();

 	for (i=0; i<array->Count(); ++i)

 		{

 		entry2->iEntry = (*array)[i].iEntry;

 		// Pack here

 		TUint32* pSizeHighSrc = PtrAdd((TUint32*)&(entry2->iEntry), sizeof(TEntry) - 2 * sizeof(TInt));

 		TUint32* pSizeHighDst = PtrAdd((TUint32*)&(entry2->iEntry), EntrySize(entry2->iEntry, EFalse));

 		*pSizeHighDst++ = *pSizeHighSrc++;	// Pack iSizeHigh

 		*pSizeHighDst   = *pSizeHighSrc;	// Pack iReserved

 		entry2->iEntry.iAtt |= KEntryAttPacked;

 		TRAP(r, iArray->AppendL(entry2->iEntry, EntrySize(entry2->iEntry, ETrue)));

 		if (r != KErrNone)

 			{

 			delete entry2;	

 			return r;

 			}

 		}

 	delete entry2;

 	return r;

 	}

 EXPORT_C void CDir::AddL(const TEntry& aEntry)

 /**

 Adds the specified entry to the directory.

 Note that the function can leave.

 @param aEntry The directory entry to be added.

 */

 	{

 	if(aEntry.iAtt & KEntryAttPacked)

 		{

 		iArray->AppendL(aEntry,EntrySize(aEntry, ETrue));

 		}

 	else

 		{

 		TEntry entry = aEntry;

 		// Pack here

 		TUint32* pSizeHighSrc = PtrAdd((TUint32*)&entry, sizeof(TEntry) - 2 * sizeof(TInt));

 		TUint32* pSizeHighDst = PtrAdd((TUint32*)&entry, EntrySize(entry, EFalse));

 		*pSizeHighDst++ = *pSizeHighSrc++;	// Pack iSizeHigh

 		*pSizeHighDst   = *pSizeHighSrc;		// Pack iReserved

 		entry.iAtt |= KEntryAttPacked;

 		iArray->AppendL(entry,EntrySize(entry, ETrue));

 		}

 	}

 EXPORT_C void CDir::ExtractL(TBool aRemove,CDir* & aDir)

 /**

 Copies all directory entries from this directory array, and adds them to

 a new directory array.

 The directory entries in this array can be deleted.

 Note that the function can leave.

 @param aRemove If ETrue, the  directory entries in this array are

                to be deleted after extraction;

                if EFalse, the directory entries are not to be deleted.

 @param aDir    On return, a pointer to a CDir object containing

                the extracted directory entries.

 */

 	{

 	aDir=NULL;

 	aDir=CDir::NewL();

 	CArrayPakFlat<TEntry>& anArray=(*iArray);

 	TInt count=anArray.Count();

 	if (count == 0)

 		return;

 	TInt i=0;

 	while (i<count)

 		{

 		TEntry& e=anArray[i];

 		if (e.IsDir())

 			aDir->AddL(e);

 		i++;

 		}

 	if (aRemove)

 		{

 		i=0;

 		while (i<count)

 			{

 			if (anArray[i].IsDir())

 				{

 				anArray.Delete(i);

 				count--;

 				continue;

 				}

 			i++;

 			}

 		anArray.Compress();

 		}

 	aDir->Compress();

 	}

 EXPORT_C void CDir::Compress()

 /**

 Compresses the directory.

 This has the effect of potentially reducing the ammount of storage 

 space required on the media for that directory and the files it contains. 

 Some files are already compressed and will not compress further.

 A potential side effect of compression is that each file is required to 

 be uncompressed prior to use, generally increasing the time and 

 processing cycles required to access that file.

 */

 	{

 	iArray->Compress();

 	}