// 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();

	}