src/common/hash.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        hash.cpp
// Purpose:     wxHashTable implementation
// Author:      Julian Smart
// Modified by: VZ at 25.02.00: type safe hashes with WX_DECLARE_HASH()
// Created:     01/02/97
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart and Markus Holzem
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

#ifdef __GNUG__
#pragma implementation "hash.h"
#endif

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#ifndef WX_PRECOMP
#include "wx/list.h"
#endif

#include "wx/hash.h"

#include <string.h>
#include <stdarg.h>

// ----------------------------------------------------------------------------
// wxWin macros
// ----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxHashTable, wxObject)

// ============================================================================
// implementation
// ============================================================================

// ----------------------------------------------------------------------------
// wxHashTablleBase for working with "void *" data
// ----------------------------------------------------------------------------

wxHashTableBase::wxHashTableBase()
{
    m_deleteContents = FALSE;
    m_hashTable = (wxListBase **)NULL;
    m_hashSize = 0;
    m_count = 0;
    m_keyType = wxKEY_NONE;
}

void wxHashTableBase::Create(wxKeyType keyType, size_t size)
{
    Destroy();

    m_hashSize = size;
    m_keyType = keyType;
    m_hashTable = new wxListBase *[size];
    for ( size_t n = 0; n < m_hashSize; n++ )
    {
        m_hashTable[n] = (wxListBase *) NULL;
    }
}

void wxHashTableBase::Destroy()
{
    if ( m_hashTable )
    {
        for ( size_t n = 0; n < m_hashSize; n++ )
        {
            delete m_hashTable[n];
        }

        delete [] m_hashTable;

        m_hashTable = (wxListBase **)NULL;

        m_count = 0;
    }
}

void wxHashTableBase::DeleteContents(bool flag)
{
    m_deleteContents = flag;
    for ( size_t n = 0; n < m_hashSize; n++ )
    {
        if ( m_hashTable[n] )
        {
            m_hashTable[n]->DeleteContents(flag);
        }
    }
}

wxNodeBase *wxHashTableBase::GetNode(long key, long value) const
{
    size_t slot = (size_t)abs(key % m_hashSize);

    wxNodeBase *node;
    if ( m_hashTable[slot] )
    {
        node = m_hashTable[slot]->Find(wxListKey(value));
    }
    else
    {
        node = (wxNodeBase *)NULL;
    }

    return node;
}

// ----------------------------------------------------------------------------
// wxHashTableLong
// ----------------------------------------------------------------------------

wxHashTableLong::~wxHashTableLong()
{
    Destroy();
}

void wxHashTableLong::Init(size_t size)
{
    m_hashSize = size;
    m_values = new wxArrayLong *[size];
    m_keys = new wxArrayLong *[size];

    for ( size_t n = 0; n < m_hashSize; n++ )
    {
        m_values[n] =
        m_keys[n] = (wxArrayLong *)NULL;
    }

    m_count = 0;
}

void wxHashTableLong::Destroy()
{
    for ( size_t n = 0; n < m_hashSize; n++ )
    {
        delete m_values[n];
        delete m_keys[n];
    }

    delete [] m_values;
    delete [] m_keys;
    m_hashSize = 0;
    m_count = 0;
}

void wxHashTableLong::Put(long key, long value)
{
    wxCHECK_RET( m_hashSize, _T("must call Create() first") );

    size_t slot = (size_t)abs(key % m_hashSize);

    if ( !m_keys[slot] )
    {
        m_keys[slot] = new wxArrayLong;
        m_values[slot] = new wxArrayLong;
    }

    m_keys[slot]->Add(key);
    m_values[slot]->Add(value);

    m_count++;
}

long wxHashTableLong::Get(long key) const
{
    wxCHECK_MSG( m_hashSize, wxNOT_FOUND, _T("must call Create() first") );

    size_t slot = (size_t)abs(key % m_hashSize);

    wxArrayLong *keys = m_keys[slot];
    if ( keys )
    {
        size_t count = keys->GetCount();
        for ( size_t n = 0; n < count; n++ )
        {
            if ( keys->Item(n) == key )
            {
                return m_values[slot]->Item(n);
            }
        }
    }

    return wxNOT_FOUND;
}

long wxHashTableLong::Delete(long key)
{
    wxCHECK_MSG( m_hashSize, wxNOT_FOUND, _T("must call Create() first") );

    size_t slot = (size_t)abs(key % m_hashSize);

    wxArrayLong *keys = m_keys[slot];
    if ( keys )
    {
        size_t count = keys->GetCount();
        for ( size_t n = 0; n < count; n++ )
        {
            if ( keys->Item(n) == key )
            {
                long val = m_values[slot]->Item(n);

                keys->RemoveAt(n);
                m_values[slot]->RemoveAt(n);

                m_count--;

                return val;
            }
        }
    }

    return wxNOT_FOUND;
}

// ----------------------------------------------------------------------------
// old not type safe wxHashTable
// ----------------------------------------------------------------------------

wxHashTable::wxHashTable (int the_key_type, int size)
{
  n = 0;
  hash_table = (wxList**) NULL;
  Create(the_key_type, size);
  m_count = 0;
  m_deleteContents = FALSE;
/*
  n = size;
  current_position = -1;
  current_node = (wxNode *) NULL;

  key_type = the_key_type;
  hash_table = new wxList *[size];
  int i;
  for (i = 0; i < size; i++)
    hash_table[i] = (wxList *) NULL;
*/
}

wxHashTable::~wxHashTable ()
{
  Destroy();
}

void wxHashTable::Destroy()
{
  if (!hash_table) return;
  int i;
  for (i = 0; i < n; i++)
    if (hash_table[i])
      delete hash_table[i];
  delete[] hash_table;
  hash_table = NULL;
}

bool wxHashTable::Create(int the_key_type, int size)
{
  Destroy();

  n = size;
  current_position = -1;
  current_node = (wxNode *) NULL;

  key_type = the_key_type;
  hash_table = new wxList *[size];
  int i;
  for (i = 0; i < size; i++)
    hash_table[i] = (wxList *) NULL;
  return TRUE;
}


void wxHashTable::DoCopy(const wxHashTable& table)
{
  n = table.n;
  current_position = table.current_position;
  current_node = NULL; // doesn't matter - Next() will reconstruct it
  key_type = table.key_type;

  hash_table = new wxList *[n];
  for (int i = 0; i < n; i++) {
    if (table.hash_table[i] == NULL)
      hash_table[i] = NULL;
    else {
      hash_table[i] = new wxList(key_type);
      *(hash_table[i]) = *(table.hash_table[i]);
    }
  }
}

void wxHashTable::Put (long key, long value, wxObject * object)
{
  // Should NEVER be
  long k = (long) key;

  int position = (int) (k % n);
  if (position < 0) position = -position;

  if (!hash_table[position])
  {
    hash_table[position] = new wxList (wxKEY_INTEGER);
    if (m_deleteContents) hash_table[position]->DeleteContents(TRUE);
  }

  hash_table[position]->Append (value, object);
  m_count++;
}

void wxHashTable::Put (long key, const wxChar *value, wxObject * object)
{
  // Should NEVER be
  long k = (long) key;

  int position = (int) (k % n);
  if (position < 0) position = -position;

  if (!hash_table[position])
  {
    hash_table[position] = new wxList (wxKEY_INTEGER);
    if (m_deleteContents) hash_table[position]->DeleteContents(TRUE);
  }

  hash_table[position]->Append (value, object);
  m_count++;
}

void wxHashTable::Put (long key, wxObject * object)
{
  // Should NEVER be
  long k = (long) key;

  int position = (int) (k % n);
  if (position < 0) position = -position;

  if (!hash_table[position])
  {
    hash_table[position] = new wxList (wxKEY_INTEGER);
    if (m_deleteContents) hash_table[position]->DeleteContents(TRUE);
  }

  hash_table[position]->Append (k, object);
  m_count++;
}

void wxHashTable::Put (const wxChar *key, wxObject * object)
{
  int position = (int) (MakeKey (key) % n);
  if (position < 0) position = -position;

  if (!hash_table[position])
  {
    hash_table[position] = new wxList (wxKEY_STRING);
    if (m_deleteContents) hash_table[position]->DeleteContents(TRUE);
  }

  hash_table[position]->Append (key, object);
  m_count++;
}

wxObject *wxHashTable::Get (long key, long value) const
{
  // Should NEVER be
  long k = (long) key;

  int position = (int) (k % n);
  if (position < 0) position = -position;

  if (!hash_table[position])
    return (wxObject *) NULL;
  else
    {
      wxNode *node = hash_table[position]->Find (value);
      if (node)
        return node->Data ();
      else
        return (wxObject *) NULL;
    }
}

wxObject *wxHashTable::Get (long key, const wxChar *value) const
{
  // Should NEVER be
  long k = (long) key;

  int position = (int) (k % n);
  if (position < 0) position = -position;

  if (!hash_table[position])
    return (wxObject *) NULL;
  else
    {
      wxNode *node = hash_table[position]->Find (value);
      if (node)
        return node->Data ();
      else
        return (wxObject *) NULL;
    }
}

wxObject *wxHashTable::Get (long key) const
{
  // Should NEVER be
  long k = (long) key;

  int position = (int) (k % n);
  if (position < 0) position = -position;

  if (!hash_table[position])
    return (wxObject *) NULL;
  else
    {
      wxNode *node = hash_table[position]->Find (k);
      return node ? node->Data () : (wxObject*)NULL;
    }
}

wxObject *wxHashTable::Get (const wxChar *key) const
{
  int position = (int) (MakeKey (key) % n);
  if (position < 0) position = -position;

  if (!hash_table[position])
    return (wxObject *) NULL;
  else
    {
      wxNode *node = hash_table[position]->Find (key);
      return node ? node->Data () : (wxObject*)NULL;
    }
}

wxObject *wxHashTable::Delete (long key)
{
  // Should NEVER be
  long k = (long) key;

  int position = (int) (k % n);
  if (position < 0) position = -position;

  if (!hash_table[position])
    return (wxObject *) NULL;
  else
    {
      wxNode *node = hash_table[position]->Find (k);
      if (node)
        {
          wxObject *data = node->Data ();
          delete node;
          m_count--;
          return data;
        }
      else
        return (wxObject *) NULL;
    }
}

wxObject *wxHashTable::Delete (const wxChar *key)
{
  int position = (int) (MakeKey (key) % n);
  if (position < 0) position = -position;

  if (!hash_table[position])
    return (wxObject *) NULL;
  else
    {
      wxNode *node = hash_table[position]->Find (key);
      if (node)
        {
          wxObject *data = node->Data ();
          delete node;
          m_count--;
          return data;
        }
      else
        return (wxObject *) NULL;
    }
}

wxObject *wxHashTable::Delete (long key, int value)
{
  // Should NEVER be
  long k = (long) key;

  int position = (int) (k % n);
  if (position < 0) position = -position;

  if (!hash_table[position])
    return (wxObject *) NULL;
  else
    {
      wxNode *node = hash_table[position]->Find (value);
      if (node)
        {
          wxObject *data = node->Data ();
          delete node;
          m_count--;
          return data;
        }
      else
        return (wxObject *) NULL;
    }
}

wxObject *wxHashTable::Delete (long key, const wxChar *value)
{
  int position = (int) (key % n);
  if (position < 0) position = -position;

  if (!hash_table[position])
    return (wxObject *) NULL;
  else
    {
      wxNode *node = hash_table[position]->Find (value);
      if (node)
        {
          wxObject *data = node->Data ();
          delete node;
          m_count--;
          return data;
        }
      else
        return (wxObject *) NULL;
    }
}

long wxHashTable::MakeKey (const wxChar *string) const
{
  long int_key = 0;

  while (*string)
    int_key += (wxUChar) *string++;

  return int_key;
}

void wxHashTable::BeginFind ()
{
  current_position = -1;
  current_node = (wxNode *) NULL;
}

wxNode *wxHashTable::Next ()
{
  wxNode *found = (wxNode *) NULL;
  bool end = FALSE;
  while (!end && !found)
    {
      if (!current_node)
        {
          current_position++;
          if (current_position >= n)
            {
              current_position = -1;
              current_node = (wxNode *) NULL;
              end = TRUE;
            }
          else
            {
              if (hash_table[current_position])
                {
                  current_node = hash_table[current_position]->First ();
                  found = current_node;
                }
            }
        }
      else
        {
          current_node = current_node->Next ();
          found = current_node;
        }
    }
  return found;
}

void wxHashTable::DeleteContents (bool flag)
{
  int i;
  m_deleteContents = flag;
  for (i = 0; i < n; i++)
    {
      if (hash_table[i])
        hash_table[i]->DeleteContents (flag);
    }
}

void wxHashTable::Clear ()
{
  int i;
  for (i = 0; i < n; i++)
    {
      if (hash_table[i])
        hash_table[i]->Clear ();
    }
  m_count = 0;
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: hash.cpp
	3	// Purpose: wxHashTable implementation
	4	// Author: Julian Smart
	5	// Modified by: VZ at 25.02.00: type safe hashes with WX_DECLARE_HASH()
	6	// Created: 01/02/97
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart and Markus Holzem
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// ============================================================================
	13	// declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19
	20	#ifdef __GNUG__
	21	#pragma implementation "hash.h"
	22	#endif
	23
	24	// For compilers that support precompilation, includes "wx.h".
	25	#include "wx/wxprec.h"
	26
	27	#ifdef __BORLANDC__
	28	#pragma hdrstop
	29	#endif
	30
	31	#ifndef WX_PRECOMP
	32	#include "wx/list.h"
	33	#endif
	34
	35	#include "wx/hash.h"
	36
	37	#include <string.h>
	38	#include <stdarg.h>
	39
	40	// ----------------------------------------------------------------------------
	41	// wxWin macros
	42	// ----------------------------------------------------------------------------
	43
	44	IMPLEMENT_DYNAMIC_CLASS(wxHashTable, wxObject)
	45
	46	// ============================================================================
	47	// implementation
	48	// ============================================================================
	49
	50	// ----------------------------------------------------------------------------
	51	// wxHashTablleBase for working with "void *" data
	52	// ----------------------------------------------------------------------------
	53
	54	wxHashTableBase::wxHashTableBase()
	55	{
	56	m_deleteContents = FALSE;
	57	m_hashTable = (wxListBase **)NULL;
	58	m_hashSize = 0;
	59	m_count = 0;
	60	m_keyType = wxKEY_NONE;
	61	}
	62
	63	void wxHashTableBase::Create(wxKeyType keyType, size_t size)
	64	{
	65	Destroy();
	66
	67	m_hashSize = size;
	68	m_keyType = keyType;
	69	m_hashTable = new wxListBase *[size];
	70	for ( size_t n = 0; n < m_hashSize; n++ )
	71	{
	72	m_hashTable[n] = (wxListBase *) NULL;
	73	}
	74	}
	75
	76	void wxHashTableBase::Destroy()
	77	{
	78	if ( m_hashTable )
	79	{
	80	for ( size_t n = 0; n < m_hashSize; n++ )
	81	{
	82	delete m_hashTable[n];
	83	}
	84
	85	delete [] m_hashTable;
	86
	87	m_hashTable = (wxListBase **)NULL;
	88
	89	m_count = 0;
	90	}
	91	}
	92
	93	void wxHashTableBase::DeleteContents(bool flag)
	94	{
	95	m_deleteContents = flag;
	96	for ( size_t n = 0; n < m_hashSize; n++ )
	97	{
	98	if ( m_hashTable[n] )
	99	{
	100	m_hashTable[n]->DeleteContents(flag);
	101	}
	102	}
	103	}
	104
	105	wxNodeBase *wxHashTableBase::GetNode(long key, long value) const
	106	{
	107	size_t slot = (size_t)abs(key % m_hashSize);
	108
	109	wxNodeBase *node;
	110	if ( m_hashTable[slot] )
	111	{
	112	node = m_hashTable[slot]->Find(wxListKey(value));
	113	}
	114	else
	115	{
	116	node = (wxNodeBase *)NULL;
	117	}
	118
	119	return node;
	120	}
	121
	122	// ----------------------------------------------------------------------------
	123	// wxHashTableLong
	124	// ----------------------------------------------------------------------------
	125
	126	wxHashTableLong::~wxHashTableLong()
	127	{
	128	Destroy();
	129	}
	130
	131	void wxHashTableLong::Init(size_t size)
	132	{
	133	m_hashSize = size;
	134	m_values = new wxArrayLong *[size];
	135	m_keys = new wxArrayLong *[size];
	136
	137	for ( size_t n = 0; n < m_hashSize; n++ )
	138	{
	139	m_values[n] =
	140	m_keys[n] = (wxArrayLong *)NULL;
	141	}
	142
	143	m_count = 0;
	144	}
	145
	146	void wxHashTableLong::Destroy()
	147	{
	148	for ( size_t n = 0; n < m_hashSize; n++ )
	149	{
	150	delete m_values[n];
	151	delete m_keys[n];
	152	}
	153
	154	delete [] m_values;
	155	delete [] m_keys;
	156	m_hashSize = 0;
	157	m_count = 0;
	158	}
	159
	160	void wxHashTableLong::Put(long key, long value)
	161	{
	162	wxCHECK_RET( m_hashSize, _T("must call Create() first") );
	163
	164	size_t slot = (size_t)abs(key % m_hashSize);
	165
	166	if ( !m_keys[slot] )
	167	{
	168	m_keys[slot] = new wxArrayLong;
	169	m_values[slot] = new wxArrayLong;
	170	}
	171
	172	m_keys[slot]->Add(key);
	173	m_values[slot]->Add(value);
	174
	175	m_count++;
	176	}
	177
	178	long wxHashTableLong::Get(long key) const
	179	{
	180	wxCHECK_MSG( m_hashSize, wxNOT_FOUND, _T("must call Create() first") );
	181
	182	size_t slot = (size_t)abs(key % m_hashSize);
	183
	184	wxArrayLong *keys = m_keys[slot];
	185	if ( keys )
	186	{
	187	size_t count = keys->GetCount();
	188	for ( size_t n = 0; n < count; n++ )
	189	{
	190	if ( keys->Item(n) == key )
	191	{
	192	return m_values[slot]->Item(n);
	193	}
	194	}
	195	}
	196
	197	return wxNOT_FOUND;
	198	}
	199
	200	long wxHashTableLong::Delete(long key)
	201	{
	202	wxCHECK_MSG( m_hashSize, wxNOT_FOUND, _T("must call Create() first") );
	203
	204	size_t slot = (size_t)abs(key % m_hashSize);
	205
	206	wxArrayLong *keys = m_keys[slot];
	207	if ( keys )
	208	{
	209	size_t count = keys->GetCount();
	210	for ( size_t n = 0; n < count; n++ )
	211	{
	212	if ( keys->Item(n) == key )
	213	{
	214	long val = m_values[slot]->Item(n);
	215
	216	keys->RemoveAt(n);
	217	m_values[slot]->RemoveAt(n);
	218
	219	m_count--;
	220
	221	return val;
	222	}
	223	}
	224	}
	225
	226	return wxNOT_FOUND;
	227	}
	228
	229	// ----------------------------------------------------------------------------
	230	// old not type safe wxHashTable
	231	// ----------------------------------------------------------------------------
	232
	233	wxHashTable::wxHashTable (int the_key_type, int size)
	234	{
	235	n = 0;
	236	hash_table = (wxList**) NULL;
	237	Create(the_key_type, size);
	238	m_count = 0;
	239	m_deleteContents = FALSE;
	240	/*
	241	n = size;
	242	current_position = -1;
	243	current_node = (wxNode *) NULL;
	244
	245	key_type = the_key_type;
	246	hash_table = new wxList *[size];
	247	int i;
	248	for (i = 0; i < size; i++)
	249	hash_table[i] = (wxList *) NULL;
	250	*/
	251	}
	252
	253	wxHashTable::~wxHashTable ()
	254	{
	255	Destroy();
	256	}
	257
	258	void wxHashTable::Destroy()
	259	{
	260	if (!hash_table) return;
	261	int i;
	262	for (i = 0; i < n; i++)
	263	if (hash_table[i])
	264	delete hash_table[i];
	265	delete[] hash_table;
	266	hash_table = NULL;
	267	}
	268
	269	bool wxHashTable::Create(int the_key_type, int size)
	270	{
	271	Destroy();
	272
	273	n = size;
	274	current_position = -1;
	275	current_node = (wxNode *) NULL;
	276
	277	key_type = the_key_type;
	278	hash_table = new wxList *[size];
	279	int i;
	280	for (i = 0; i < size; i++)
	281	hash_table[i] = (wxList *) NULL;
	282	return TRUE;
	283	}
	284
	285
	286	void wxHashTable::DoCopy(const wxHashTable& table)
	287	{
	288	n = table.n;
	289	current_position = table.current_position;
	290	current_node = NULL; // doesn't matter - Next() will reconstruct it
	291	key_type = table.key_type;
	292
	293	hash_table = new wxList *[n];
	294	for (int i = 0; i < n; i++) {
	295	if (table.hash_table[i] == NULL)
	296	hash_table[i] = NULL;
	297	else {
	298	hash_table[i] = new wxList(key_type);
	299	(hash_table[i]) = (table.hash_table[i]);
	300	}
	301	}
	302	}
	303
	304	void wxHashTable::Put (long key, long value, wxObject * object)
	305	{
	306	// Should NEVER be
	307	long k = (long) key;
	308
	309	int position = (int) (k % n);
	310	if (position < 0) position = -position;
	311
	312	if (!hash_table[position])
	313	{
	314	hash_table[position] = new wxList (wxKEY_INTEGER);
	315	if (m_deleteContents) hash_table[position]->DeleteContents(TRUE);
	316	}
	317
	318	hash_table[position]->Append (value, object);
	319	m_count++;
	320	}
	321
	322	void wxHashTable::Put (long key, const wxChar value, wxObject object)
	323	{
	324	// Should NEVER be
	325	long k = (long) key;
	326
	327	int position = (int) (k % n);
	328	if (position < 0) position = -position;
	329
	330	if (!hash_table[position])
	331	{
	332	hash_table[position] = new wxList (wxKEY_INTEGER);
	333	if (m_deleteContents) hash_table[position]->DeleteContents(TRUE);
	334	}
	335
	336	hash_table[position]->Append (value, object);
	337	m_count++;
	338	}
	339
	340	void wxHashTable::Put (long key, wxObject * object)
	341	{
	342	// Should NEVER be
	343	long k = (long) key;
	344
	345	int position = (int) (k % n);
	346	if (position < 0) position = -position;
	347
	348	if (!hash_table[position])
	349	{
	350	hash_table[position] = new wxList (wxKEY_INTEGER);
	351	if (m_deleteContents) hash_table[position]->DeleteContents(TRUE);
	352	}
	353
	354	hash_table[position]->Append (k, object);
	355	m_count++;
	356	}
	357
	358	void wxHashTable::Put (const wxChar key, wxObject object)
	359	{
	360	int position = (int) (MakeKey (key) % n);
	361	if (position < 0) position = -position;
	362
	363	if (!hash_table[position])
	364	{
	365	hash_table[position] = new wxList (wxKEY_STRING);
	366	if (m_deleteContents) hash_table[position]->DeleteContents(TRUE);
	367	}
	368
	369	hash_table[position]->Append (key, object);
	370	m_count++;
	371	}
	372
	373	wxObject *wxHashTable::Get (long key, long value) const
	374	{
	375	// Should NEVER be
	376	long k = (long) key;
	377
	378	int position = (int) (k % n);
	379	if (position < 0) position = -position;
	380
	381	if (!hash_table[position])
	382	return (wxObject *) NULL;
	383	else
	384	{
	385	wxNode *node = hash_table[position]->Find (value);
	386	if (node)
	387	return node->Data ();
	388	else
	389	return (wxObject *) NULL;
	390	}
	391	}
	392
	393	wxObject wxHashTable::Get (long key, const wxChar value) const
	394	{
	395	// Should NEVER be
	396	long k = (long) key;
	397
	398	int position = (int) (k % n);
	399	if (position < 0) position = -position;
	400
	401	if (!hash_table[position])
	402	return (wxObject *) NULL;
	403	else
	404	{
	405	wxNode *node = hash_table[position]->Find (value);
	406	if (node)
	407	return node->Data ();
	408	else
	409	return (wxObject *) NULL;
	410	}
	411	}
	412
	413	wxObject *wxHashTable::Get (long key) const
	414	{
	415	// Should NEVER be
	416	long k = (long) key;
	417
	418	int position = (int) (k % n);
	419	if (position < 0) position = -position;
	420
	421	if (!hash_table[position])
	422	return (wxObject *) NULL;
	423	else
	424	{
	425	wxNode *node = hash_table[position]->Find (k);
	426	return node ? node->Data () : (wxObject*)NULL;
	427	}
	428	}
	429
	430	wxObject wxHashTable::Get (const wxChar key) const
	431	{
	432	int position = (int) (MakeKey (key) % n);
	433	if (position < 0) position = -position;
	434
	435	if (!hash_table[position])
	436	return (wxObject *) NULL;
	437	else
	438	{
	439	wxNode *node = hash_table[position]->Find (key);
	440	return node ? node->Data () : (wxObject*)NULL;
	441	}
	442	}
	443
	444	wxObject *wxHashTable::Delete (long key)
	445	{
	446	// Should NEVER be
	447	long k = (long) key;
	448
	449	int position = (int) (k % n);
	450	if (position < 0) position = -position;
	451
	452	if (!hash_table[position])
	453	return (wxObject *) NULL;
	454	else
	455	{
	456	wxNode *node = hash_table[position]->Find (k);
	457	if (node)
	458	{
	459	wxObject *data = node->Data ();
	460	delete node;
	461	m_count--;
	462	return data;
	463	}
	464	else
	465	return (wxObject *) NULL;
	466	}
	467	}
	468
	469	wxObject wxHashTable::Delete (const wxChar key)
	470	{
	471	int position = (int) (MakeKey (key) % n);
	472	if (position < 0) position = -position;
	473
	474	if (!hash_table[position])
	475	return (wxObject *) NULL;
	476	else
	477	{
	478	wxNode *node = hash_table[position]->Find (key);
	479	if (node)
	480	{
	481	wxObject *data = node->Data ();
	482	delete node;
	483	m_count--;
	484	return data;
	485	}
	486	else
	487	return (wxObject *) NULL;
	488	}
	489	}
	490
	491	wxObject *wxHashTable::Delete (long key, int value)
	492	{
	493	// Should NEVER be
	494	long k = (long) key;
	495
	496	int position = (int) (k % n);
	497	if (position < 0) position = -position;
	498
	499	if (!hash_table[position])
	500	return (wxObject *) NULL;
	501	else
	502	{
	503	wxNode *node = hash_table[position]->Find (value);
	504	if (node)
	505	{
	506	wxObject *data = node->Data ();
	507	delete node;
	508	m_count--;
	509	return data;
	510	}
	511	else
	512	return (wxObject *) NULL;
	513	}
	514	}
	515
	516	wxObject wxHashTable::Delete (long key, const wxChar value)
	517	{
	518	int position = (int) (key % n);
	519	if (position < 0) position = -position;
	520
	521	if (!hash_table[position])
	522	return (wxObject *) NULL;
	523	else
	524	{
	525	wxNode *node = hash_table[position]->Find (value);
	526	if (node)
	527	{
	528	wxObject *data = node->Data ();
	529	delete node;
	530	m_count--;
	531	return data;
	532	}
	533	else
	534	return (wxObject *) NULL;
	535	}
	536	}
	537
	538	long wxHashTable::MakeKey (const wxChar *string) const
	539	{
	540	long int_key = 0;
	541
	542	while (*string)
	543	int_key += (wxUChar) *string++;
	544
	545	return int_key;
	546	}
	547
	548	void wxHashTable::BeginFind ()
	549	{
	550	current_position = -1;
	551	current_node = (wxNode *) NULL;
	552	}
	553
	554	wxNode *wxHashTable::Next ()
	555	{
	556	wxNode found = (wxNode ) NULL;
	557	bool end = FALSE;
	558	while (!end && !found)
	559	{
	560	if (!current_node)
	561	{
	562	current_position++;
	563	if (current_position >= n)
	564	{
	565	current_position = -1;
	566	current_node = (wxNode *) NULL;
	567	end = TRUE;
	568	}
	569	else
	570	{
	571	if (hash_table[current_position])
	572	{
	573	current_node = hash_table[current_position]->First ();
	574	found = current_node;
	575	}
	576	}
	577	}
	578	else
	579	{
	580	current_node = current_node->Next ();
	581	found = current_node;
	582	}
	583	}
	584	return found;
	585	}
	586
	587	void wxHashTable::DeleteContents (bool flag)
	588	{
	589	int i;
	590	m_deleteContents = flag;
	591	for (i = 0; i < n; i++)
	592	{
	593	if (hash_table[i])
	594	hash_table[i]->DeleteContents (flag);
	595	}
	596	}
	597
	598	void wxHashTable::Clear ()
	599	{
	600	int i;
	601	for (i = 0; i < n; i++)
	602	{
	603	if (hash_table[i])
	604	hash_table[i]->Clear ();
	605	}
	606	m_count = 0;
	607	}
	608