---

skHashTable.h

/*
  Copyright 1996-2003
  Simon Whiteside

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  $Id: skHashTable_8h-source.html,v 1.17 2004/12/17 21:31:14 sdw Exp $
*/
#ifndef skHASHTBL_H
#define skHASHTBL_H


#include "skGeneral.h"
#include "skAlist.h"

class  CLASSEXPORT skHashEntry 
{    
 public:
  skHashEntry(void * k,void * v) 
    : m_Key(k), m_Value(v) {
  }
  int   operator==(const skHashEntry& h) { 
    return this==&h; 
  }
  void * m_Key;
  void * m_Value;
};

typedef skTAList<skHashEntry> skHashEntryList;
typedef skTAListIterator<skHashEntry> skHashEntryListIterator;

class   CLASSEXPORT skHashTable 
#ifdef __SYMBIAN32__
: public CBase
#endif
{
 public:
  IMPORT_C void clear();
  IMPORT_C void clearAndDestroyKeys();
  IMPORT_C void clearAndDestroyValues();
  IMPORT_C void clearAndDestroy();
  inline USize entries() const;
  inline virtual ~skHashTable();
#ifdef __SYMBIAN32__

  operator TCleanupItem();
  static void Cleanup(TAny * s);
#endif
 protected:
  skHashTable(USize  size);
  IMPORT_C void insertKeyAndValue(void * key, void * value);
  void *  value(void * key) const;
  void del(void * key);
  void delKeyNotValue(const void * key);
  void remove(const void * key);
  virtual USize hashKey(const void * key) const=0;
  virtual int compareKeys(const void * key1, const void * key2) const=0;
  virtual void deleteKey(void * key)=0; 
  virtual void deleteValue(void * value)=0;
 private:
  skHashTable();
  skHashTable(const skHashTable&);
  skHashTable& operator=(const skHashTable&);
  skHashEntry * findEntry(const void * key,USize & slot) const;
  skHashEntry * findEntry(const void * key) const;
  void createSlots();
  skHashEntryList * m_Slots;
  USize m_Size;
  USize m_NumEntries;
  friend class skHashTableIterator;
};
class  CLASSEXPORT skHashTableIterator
#ifdef __SYMBIAN32__
: public CBase
#endif
{
 public:
  virtual ~skHashTableIterator();
  int operator()();
 protected:
  skHashTableIterator(const skHashTable&);
  void * key() const; 
  void * value() const;
 private:
  skHashTableIterator& operator=(const skHashTableIterator&);
  const skHashTable&    m_Table;
  USize  m_Slot;
  void * m_Value;
  void * m_Key;
  skHashEntryListIterator * m_ListIterator;
};
#define TT_PREFIX template <class TKey,class TValue> 

const int DEFAULT_skHashTable_SIZE=3;
template <class TKey,class TValue>  class  CLASSEXPORT skTHashTable: public skHashTable
{
 public:
  skTHashTable(USize  size);
  skTHashTable();
  ~skTHashTable();
  void insertKeyAndValue(TKey * key, TValue * value);
  TValue * value(const TKey * key);
  void del(const TKey * key);
  void delKeyNotValue(const TKey * key);
  void remove(const TKey * key);
    
 protected:
  int compareKeys(const void * key1, const void * key2) const;
  void deleteKey(void * key);
  void deleteValue(void * value);
  USize hashKey(const void * key) const;
};
template <class TKey,class TValue>  class CLASSEXPORT skTHashTableIterator: public skHashTableIterator
{
 public:
  skTHashTableIterator(const skTHashTable<TKey,TValue>&);
  TKey * key() const;
  TValue * value() const;
};

#include "skHashTable.inl"

#endif

---