// Copyright (c) 1997-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 "Symbian Foundation License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//

#if !defined(__APSRECCACHE_H__)
#define __APSRECCACHE_H__

#include <e32base.h>
#include <apmrec.h>
#include "APSRECUTIL.H"

const TUint KFileHashMapEntries = 40;

/**
An entry for a recognized file in the recognition cache.
The entries is organized as single-linked list.
The recognition result itself is reference-counted.
@internalComponent
*/
class CRecognitionResultHashMapEntry : public CBase
	{
public:
	static CRecognitionResultHashMapEntry* NewL(const TDesC& aFileName, TTime aLastModified, const TDataRecognitionResult& aResult, CRecognitionResultHashMapEntry* aNext);
	~CRecognitionResultHashMapEntry();
	
	inline const CRecognitionResultHashMapEntry* Next() const { return iNext; }
	inline CRecognitionResultHashMapEntry* Next() { return iNext; }
	inline TTime LastModified() const { return iLastModified; }
	inline const TDesC& FileName() const { return iResult->FileName(); }
	inline CRecognitionResult* Result() const { iResult->Open(); return iResult; }
		
	void UpdateL(TTime aLastModified, const TDataRecognitionResult& aResult);
private:
	CRecognitionResultHashMapEntry(TTime aLastModified, CRecognitionResult* aResult, CRecognitionResultHashMapEntry* aNext);
private:
	TTime iLastModified;
	CRecognitionResult* iResult;
	CRecognitionResultHashMapEntry* iNext;
	};

/**
A hash map for finding and adding recognition results.

@internalComponent
*/
class CRecognitionResultHashMap : public CBase
	{
public:
	CRecognitionResultHashMap();
	~CRecognitionResultHashMap();
	CRecognitionResult* Get(const TDesC& aKey, TTime& aLastModified) const;
	TBool AddL(const TDesC& aKey, TTime aLastModified, const TDataRecognitionResult& aResult);
	inline TUint NumberOfEntries() const { return iNumberOfEntries; }
protected:
	TUint GetIndex(const TDesC& aKey) const;
private:
	inline CRecognitionResultHashMapEntry* Entry(TUint aIndex);
	inline const CRecognitionResultHashMapEntry* Entry(TUint aIndex) const;
	inline void SetEntry(TUint aIndex, CRecognitionResultHashMapEntry* aEntry);
private:
	TUint iNumberOfEntries;
	CRecognitionResultHashMapEntry* iEntries[KFileHashMapEntries];
	};

/**
A directory entry in the cache.
Such an entry doesn't necessarily hold all files of a directory, but
only the ones that have been recognized so far.
@internalComponent
*/
class CCacheDirectoryEntry : public CBase
	{
public:
	static CCacheDirectoryEntry* NewL(const TDesC& aDirectory);
	~CCacheDirectoryEntry();
	inline const TDesC& Directory() const { return *iDirectory; }
	inline CRecognitionResultHashMap& Files() { return iFiles; } //lint !e1536 Suppress exposing low access member
	inline TUint NumberOfEntries() const { return iFiles.NumberOfEntries(); }
private:
	CCacheDirectoryEntry();
public:
	static const TInt iOffset;
private:
	HBufC* iDirectory; // own copy!
	CRecognitionResultHashMap iFiles;
	TDblQueLink iDlink;
	friend class CApsRecognitionCache;
	};

/**
A recognition result cache.
The cache holds a list of directories (stored as an RPointerArray). Recently
used directories are stored on top of the list, rarely used directories are
stored at the bottom. 

This strategy improves performance: 
search for files is started at the top (principle of locality) 
and cleanup is done from the bottom.

The files themselves are stored in a hash map (within directories).
@internalComponent
*/
class CApsRecognitionCache : public CBase
	{
public:
	CApsRecognitionCache(RFs& aFs);
	~CApsRecognitionCache();
	void AddL(const TDesC& aDirectory, const TDesC& aFileName, const TDataRecognitionResult& aRecognitionResult);
	void AddL(const RFile& aFile, const TDesC& aDirectory, const TDesC& aFileName, const TDataRecognitionResult& aRecognitionResult);
	TBool Get(const TDesC& aDirectory, const TDesC& aFileName, TDataRecognitionResult& aRecognitionResult);
	CRecognitionResult* Get(const RFile& aFile, const TDesC& aDirectory, const TDesC& aFileName);
	void Flush();
private:
	void DoAddL(const TDesC& aDirectory, const TDesC& aFileName, const TTime& aLastModified, const TDataRecognitionResult& aRecognitionResult);
	CRecognitionResult* DoGet(const TDesC& aDirectory, const TDesC& aFileName, const TTime& aLastModified);
	TBool CompareDirectories(const TDesC& aDir1, const TDesC& aDir2) const;
	void Cleanup();
private: // data
	RFs& iFs;
	TDblQue<CCacheDirectoryEntry> iDirectoryHeader;
	TDblQueIter<CCacheDirectoryEntry> iIter;
	TUint iNumberOfEntries;
	};


//inlines

inline CRecognitionResultHashMapEntry* CRecognitionResultHashMap::Entry(TUint aIndex)
	{
	ASSERT(aIndex < KFileHashMapEntries);
	return iEntries[aIndex];
	}  //lint !e1762 Suppress member function could be made const

inline const CRecognitionResultHashMapEntry* CRecognitionResultHashMap::Entry(TUint aIndex) const
	{
	ASSERT(aIndex < KFileHashMapEntries);
	return iEntries[aIndex];
	}

inline void CRecognitionResultHashMap::SetEntry(TUint aIndex, CRecognitionResultHashMapEntry* aEntry)
	{
	ASSERT(Entry(aIndex) == aEntry->Next());
	iEntries[aIndex] = aEntry;
	}

#endif // __APSRECCACHE_H__