// Copyright (c) 2008-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\sfat32\inc\sl_dir_cache.h

 // 

 //

 /**

  @file

  @internalTechnology

 */

 #ifndef SL_DIR_CACHE_H

 #define SL_DIR_CACHE_H

 #include "sf_memory_man.h"

 #include "sf_memory_client.h"

 #include "sl_cache.h"

 #include <e32hashtab.h>

 //---------------------------------------------------------------------------------------------------------------------------------

 class 	CDynamicDirCache;

 /**

 The dynamic directory cache page class

 */

 class TDynamicDirCachePage

     {

 public:

 	enum TPageType

 		{

 		EUnknown,

 		ELocked,

 		EUnlocked,

 		};

 public:

 	~TDynamicDirCachePage();

 	static TDynamicDirCachePage* NewL(CDynamicDirCache* aOwnerCache, TInt64 aStartMedPos, TUint8* aStartRamAddr);

 	inline void	SetLocked(TBool);

 	inline TBool	IsLocked() const;

 	inline TUint8*	StartPtr()	const;

 	inline void 	SetStartPtr(TUint8* aPtr);

 	inline void	SetValid(TBool aIsValid);

 	inline TBool	IsValid()	const;

 	inline void	SetPageType(TPageType aType);

 	inline TPageType PageType();

 	inline TUint32	PageSizeInBytes() const;

     inline TUint32	PageSizeInSegs() const;

     inline void	SetPos(TInt64 aPos);

     inline void	ResetPos();

 	inline TInt64	StartPos()	const;

 	inline TUint8*	PtrInPage(TInt64 aPos) const;

 	inline TBool	PosCachedInPage(TInt64 aPos) const;

 	inline void	Deque();

 private:

 	// declared to disable copying and assignment

 	TDynamicDirCachePage& operator=(const TDynamicDirCachePage&);

 	TDynamicDirCachePage(const TDynamicDirCachePage&);

 	// private constructor, as this class is not supposed to be created on stack

 	TDynamicDirCachePage(CDynamicDirCache* aOwnerCache, TInt64 aStartMedPos, TUint8* aStartRamAddr);

 public:

 	TDblQueLink			iLink;			///< the embedded link object, see TCachePageList

     TInt64  			iStartMedPos;	///< the starting media address that this page caches

     TUint8*				iStartRamAddr;	///< the starting ram address that thsi page lives

     CDynamicDirCache* 	iOwnerCache;	///< pointer to the cache that owns this page

     TBool				iValid 	:1;		///< flag to indicate the validity of the page content

 	TBool				iLocked :1;		///< flag to indicate if the page is locked or not

 	TPageType			iType;			///< page type, see TPageType

     };

 /**

 The lookup table entry class

 @see	CDynamicDirCache

 */

 class TLookupEntry

 	{

 	public:

 		TLookupEntry(): iPos(0), iRange(0), iPage(NULL) {};

 		TLookupEntry(TInt64 aPos, TUint32 aRange, TDynamicDirCachePage* aPage): iPos(aPos), iRange(aRange), iPage(aPage) {};

 	public:

 		TInt64 					iPos;

 		TUint32					iRange;

 		TDynamicDirCachePage* 	iPage;

 	};

 //---------------------------------------------------------------------------------------------------------------------------------

 typedef TDblQue<TDynamicDirCachePage> TCachePageList;

 /**

 Dynamic directory cache.

 For now it is directly derived from MWTCacheInterface.

 Provides caching FAT directory data.

 */

 class CDynamicDirCache : public CBase, public MWTCacheInterface

     {

 public:

 	~CDynamicDirCache();

 	static CDynamicDirCache* NewL(TDriveInterface& aDrive, TUint32 aMinPageNum, TUint32 aMaxPageNum, TUint32 aPageSizeLog2, const TDesC& aClientName);

 	//-- overloads from the base class

 	void    ReadL (TInt64 aPos, TInt aLength, TDes8& aDes);

 	void    WriteL(TInt64 aPos, const TDesC8& aDes);

 	void    InvalidateCache(void);

     void    InvalidateCachePage(TUint64 aPos);

 	TUint32 PosCached(const TInt64& aPosToSearch, TInt64& aCachedPosStart);

 	TUint32 CacheSizeInBytes()  const;

 	TInt    Control(TUint32 aFunction, TUint32 aParam1, TAny* aParam2);

 	void 	SetCacheBasePos(TInt64 aBasePos);

 	void 	MakePageMRU(TInt64 aPos);

 	TUint32	PageSizeInBytesLog2() const;

 	TUint32 PageSizeInSegs() const;

     // Debugging functions

 	void Dump();

 	void Info() const;

 protected:

 	CDynamicDirCache(TDriveInterface& aDrive, TUint32 aMinSizeInBytes, TUint32 aMaxSizeInBytes, TUint32 aPageSizeInBytesLog2);

 	void ConstructL(const TDesC& aClientName);

 	void ReadDataFromSinglePageL(TInt64 aPos, TInt aLength, TDes8& aDes);

 	void WriteDataOntoSinglePageL(TInt64 aPos, const TUint8* aData, TUint32 aDataLen);

 	TDynamicDirCachePage* FindPageByPos(TInt64 aPos);

 	TDynamicDirCachePage* UpdateActivePageL(TInt64 aPos);

 	TDynamicDirCachePage* AllocateAndLockNewPageL(TInt64 aStartMedPos);

 	TUint8* LockPage(TDynamicDirCachePage* aPage);

 	TInt 	UnlockPage(TDynamicDirCachePage* aPage);

 	TInt 	DecommitPage(TDynamicDirCachePage* aPage);

 	inline TInt64  CalcPageStartPos(TInt64 aPos) const;

 	void CheckThresholds();

 	inline TBool CacheIsFull() const;

 	inline TUint32 MaxCacheSizeInPages() const;

 	TInt DeQueue(TDynamicDirCachePage* aPage);

 	TInt AddFirstOntoQueue(TDynamicDirCachePage* aPage, TDynamicDirCachePage::TPageType aType);

 	TInt LookupTblRemove(TInt64 aPagePos);

 	TInt LookupTblAdd(TDynamicDirCachePage* aPage);

 	TDynamicDirCachePage* LookupTblFind(TInt64 aPos);

 	TInt ResetPagePos(TDynamicDirCachePage* aPage);

 	void MakePageLastLocked(TDynamicDirCachePage* aPage);

 	void DoMakePageMRU(TInt64 aPos);

 	void DoInvalidateCache(void);

 private:

 	TUint32				iPageSizeLog2;		///< log2 value of cache pages size in bytes

 	TUint32				iMinCacheSizeInBytes;	///< minimum cache data size

 	TUint32				iMaxCacheSizeInBytes;	///< maximum cache data size

 	TUint32				iMinSizeInPages;	///< minimum cache page number

 	TUint32				iMaxSizeInPages;	///< maximum cache page number

 	TUint32             iPageSizeInBytes;	///< cache page size in bytes

 	TInt64              iCacheBasePos; 		///< cache pages base position, used to align them at cluster size

 	TDriveInterface&    iDrive;        		///< reference to the driver for media access

 	TUint32             iCacheDisabled : 1; ///< if not 0 the cache is disabled totally and all reads and writes go via TDriveInterface directly

 	// data structures for LRU page list	

 	TCachePageList 	iLockedQ;				///< the locked queue that manages all locked pages, limited by minimum page number

 	TCachePageList 	iUnlockedQ;				///< the unlocked queue that manages all locked pages, limited by maximum page number - minimum page number

 	TUint32			iLockedQCount;

 	TUint32			iUnlockedQCount;

 	// data structures for look up table

 	THashFunction32<TLookupEntry> 	iHashFunction;

 	TIdentityRelation<TLookupEntry>	iIdentityFunction;

 	RHashSet<TLookupEntry> 			iLookupTable;	///< a lookup table that used to speed up page look up

 	CCacheMemoryClient*	iCacheMemoryClient;	///< interface to cache memory manager

 	TUint32 iPermanentlyAllocatedPageCount;	///< count of pages in locked queue that are never unlocked

     };

 #include"sl_dir_cache.inl"

 #endif //SL_DIR_CACHE_H