// stringhash.h
// 
// Copyright (c) 2010 Accenture. All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the "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:
// Accenture - Initial contribution
//
#ifndef FSHELL_STRINGHASH_H
#define FSHELL_STRINGHASH_H

#include <e32hashtab.h>

namespace LtkUtils
	{
	template <typename T> class TStringHashIter;
	template <typename T> struct SHashVal { HBufC* iKey; T iValue; };
	
	template <typename T>
	class RStringHash
		{
	public: // RHashMap-style
		inline RStringHash();
		inline T* Find(const TDesC& aKey);
		inline T FindPtr(const TDesC& aKey); // Only use if T is a pointer
		inline T& FindL(const TDesC& aKey);
		inline T const* Find(const TDesC& aKey) const;
		inline T const FindPtr(const TDesC& aKey) const; // Only use if T is a pointer
		inline T const& FindL(const TDesC& aKey) const;
		inline TInt Insert(const TDesC& aKey, const T& aValue);
		inline void InsertL(const TDesC& aKey, const T& aValue);
		inline TInt Remove(const TDesC& aKey);

		inline TInt Count() const;
		inline TInt Reserve(TInt aCount);
		inline void ReserveL(TInt aCount);
		inline void Close();

	protected:
		inline SHashVal<T>* DoFind(const TDesC& aKey);
		inline SHashVal<T> const* DoFind(const TDesC& aKey) const;
		friend class TStringHashIter<T>;

		RHashMap<TDesC*, SHashVal<T> > iHash;
		TAny* iSpare;
		TAny* iSpare2;
		};

	template <typename T>
	class TStringHashIter
		{
	public:
		inline TStringHashIter(const RStringHash<T>& aHash);
		inline const TDesC* CurrentKey() const;
		inline const TDesC* NextKey();
		inline T* CurrentValue();
		inline const T* NextValue();
		inline void RemoveCurrent();

	private:
		THashMapIter<TDesC*, SHashVal<T> > iIter;
		};

	inline TUint32 HashFn(TDesC* const& aKey);
	inline TBool IdFn(TDesC* const& aFirst, TDesC* const& aSecond);
	}


// Nothing to see here, move along move along

template <typename T>
LtkUtils::RStringHash<T>::RStringHash()
	: iHash(THashFunction32<TDesC*>(&HashFn), TIdentityRelation<TDesC*>(&IdFn)), iSpare(NULL), iSpare2(NULL)
	{
	}

inline TUint32 LtkUtils::HashFn(TDesC* const& aKey)
	{
	return DefaultHash::Des16(*aKey);
	}

inline TBool LtkUtils::IdFn(TDesC* const& aFirst, TDesC* const& aSecond)
	{
	return DefaultIdentity::Des16(*aFirst, *aSecond);
	}

template <typename T>
inline T* LtkUtils::RStringHash<T>::Find(const TDesC& aKey)
	{
	SHashVal<T>* res = DoFind(aKey);
	if (res) return &res->iValue;
	else return NULL;
	}


template <typename T>
inline T LtkUtils::RStringHash<T>::FindPtr(const TDesC& aKey)
	{
	T* res = Find(aKey);
	if (res) return *res;
	else return NULL;
	}


template <typename T>
inline T const* LtkUtils::RStringHash<T>::Find(const TDesC& aKey) const
	{
	SHashVal<T> const* res = DoFind(aKey);
	if (res) return &res->iValue;
	else return NULL;
	}

template <typename T>
inline T const LtkUtils::RStringHash<T>::FindPtr(const TDesC& aKey) const
	{
	T const* res = Find(aKey);
	if (res) return *res;
	else return NULL;
	}

template <typename T>
inline T& LtkUtils::RStringHash<T>::FindL(const TDesC& aKey)
	{
	T* res = Find(aKey);
	if (!res) User::Leave(KErrNotFound);
	return *res;
	}

template <typename T>
inline T const& LtkUtils::RStringHash<T>::FindL(const TDesC& aKey) const
	{
	T const* res = Find(aKey);
	if (!res) User::Leave(KErrNotFound);
	return *res;
	}

template <typename T>
TInt LtkUtils::RStringHash<T>::Insert(const TDesC& aKey, const T& aValue)
	{
	SHashVal<T>* valPtr = DoFind(aKey);
	if (valPtr)
		{
		// Just update the value, no need to realloc anything
		memcpy(&valPtr->iValue, &aValue, sizeof(T));
		return KErrNone;
		}

	HBufC* buf = aKey.Alloc();
	if (!buf) return KErrNoMemory;
	// Avoid declaring an SHashVal<T> as that requires T to have a default constructor
	TUint8 valBuf[sizeof(SHashVal<T>)];
	SHashVal<T>& val = *reinterpret_cast<SHashVal<T>*>(valBuf);
	val.iKey = buf;
	memcpy(&val.iValue, &aValue, sizeof(T));
	TInt err = iHash.Insert(buf, val);
	if (err)
		{
		delete buf;
		}
	return err;
	}

template <typename T>
inline TInt LtkUtils::RStringHash<T>::Remove(const TDesC& aKey)
	{
	SHashVal<T>* valPtr = DoFind(aKey);
	if (valPtr)
		{
		HBufC* key = valPtr->iKey;
		iHash.Remove(key);
		delete key;
		return KErrNone;
		}
	else
		{
		return KErrNotFound;
		}
	}

template <typename T>
inline void LtkUtils::RStringHash<T>::Close()
	{
	THashMapIter<TDesC*, SHashVal<T> > iter(iHash);
	while (iter.NextValue() != NULL)
		{
		SHashVal<T>* current = const_cast<SHashVal<T>*>(iter.CurrentValue()); // const_cast not needed except on 9.1
		HBufC* key = current->iKey;
		iter.RemoveCurrent();
		delete key;
		}
	iHash.Close();
	}

template <typename T>
inline void LtkUtils::RStringHash<T>::InsertL(const TDesC& aKey, const T& aValue)
	{
	User::LeaveIfError(Insert(aKey, aValue));
	}

template <typename T>
inline TInt LtkUtils::RStringHash<T>::Count() const
	{
	return iHash.Count();
	}

template <typename T>
inline TInt LtkUtils::RStringHash<T>::Reserve(TInt aCount)
	{
	return iHash.Reserve(aCount);
	}

template <typename T>
inline void LtkUtils::RStringHash<T>::ReserveL(TInt aCount)
	{
	User::LeaveIfError(Reserve(aCount));
	}

template <typename T>
inline LtkUtils::SHashVal<T>* LtkUtils::RStringHash<T>::DoFind(const TDesC& aKey)
	{
	return iHash.Find(const_cast<TDesC*>(&aKey));
	}

template <typename T>
inline LtkUtils::SHashVal<T> const* LtkUtils::RStringHash<T>::DoFind(const TDesC& aKey) const
	{
	return iHash.Find(const_cast<TDesC*>(&aKey));
	}

/// Iterator support

template <typename T>
inline const TDesC* LtkUtils::TStringHashIter<T>::CurrentKey() const
	{
	return *const_cast<TDesC**>(iIter.CurrentKey());
	}

template <typename T>
inline const TDesC* LtkUtils::TStringHashIter<T>::NextKey()
	{
	return *const_cast<TDesC**>(iIter.NextKey());
	}

template <typename T>
inline T* LtkUtils::TStringHashIter<T>::CurrentValue()
	{
	SHashVal<T>* val = const_cast<SHashVal<T>*>(iIter.CurrentValue()); // The const_cast isn't needed, except on 9.1
	if (val) return &val->iValue;
	return NULL;
	}

template <typename T>
inline const T* LtkUtils::TStringHashIter<T>::NextValue()
	{
	const SHashVal<T>* val = iIter.NextValue();
	if (val) return &val->iValue;
	return NULL;
	}

template <typename T>
inline void LtkUtils::TStringHashIter<T>::RemoveCurrent()
	{
	SHashVal<T>* val = iIter.CurrentValue();
	if (val)
		{
		HBufC* key = val->iKey;
		iIter.RemoveCurrent();
		delete key;
		}
	}

template <typename T>
inline LtkUtils::TStringHashIter<T>::TStringHashIter(const RStringHash<T>& aHash)
	: iIter(aHash.iHash)
	{}

#endif