---

skSHashTable.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: skSHashTable_8h-source.html,v 1.7 2004/12/17 21:31:15 sdw Exp $
*/
#ifndef skSHASHTBL_H
#define skSHASHTBL_H


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

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

typedef skTAList<skSHashEntry> skSHashEntryList;
typedef skTAListIterator<skSHashEntry> skSHashEntryListIterator;

class CLASSEXPORT skSHashTable 
#ifdef __SYMBIAN32__
: public CBase
#endif
{
 public:
  IMPORT_C void clear();
  IMPORT_C void clearAndDestroyValues();
  IMPORT_C void clearAndDestroy();
  inline USize entries() const;
  virtual ~skSHashTable();
  IMPORT_C void del(const skString& key);
  IMPORT_C void remove(const skString& key);
#ifdef __SYMBIAN32__

  inline operator TCleanupItem();
  inline static void Cleanup(TAny * s);
#endif
 protected:
  skSHashTable(USize  size);
  IMPORT_C void insertKeyAndValue(const skString& key, void * value);
  void *  value(const skString& key) const;
  virtual void deleteValue(void * value)=0;
 private:
  skSHashTable();
  skSHashTable(const skSHashTable&);
  skSHashTable& operator=(const skSHashTable&);
  skSHashEntry * findEntry(const skString& key,USize & slot) const;
  skSHashEntry * findEntry(const skString& key) const;
  void createSlots();
  skSHashEntryList * m_Slots;
  USize m_Size;
  USize m_NumEntries;
  friend class skSHashTableIterator;
};
class  CLASSEXPORT skSHashTableIterator
#ifdef __SYMBIAN32__
: public CBase
#endif
{
 public:
  virtual ~skSHashTableIterator();
  IMPORT_C int operator()();
  inline skString key() const; 
 protected:
  skSHashTableIterator(const skSHashTable&);
  void * value() const;
 private:
  skSHashTableIterator& operator=(const skSHashTableIterator&);
  const skSHashTable&   m_Table;
  USize  m_Slot;
  void * m_Value;
  skString m_Key;
  skSHashEntryListIterator * m_ListIterator;
};
#define TTS_PREFIX template <class TValue> 

const int DEFAULT_skSHashTable_SIZE=3;
template <class TValue>  class CLASSEXPORT skTSHashTable: public skSHashTable
{
 public:
  skTSHashTable(USize  size);
  skTSHashTable();
  ~skTSHashTable();
  void insertKeyAndValue(const skString& key, TValue * value);
  TValue * value(const skString& key);
    
 protected:
  void deleteValue(void * value);
};
template <class TValue>  class CLASSEXPORT skTSHashTableIterator: public skSHashTableIterator
{
 public:
  skTSHashTableIterator(const skTSHashTable<TValue>&);
  TValue * value() const;
};

#include "skSHashTable.inl"

#endif

---