rename the ID parameter

[wxWidgets.git] / include / wx / hash.h

diff --git a/include/wx/hash.h b/include/wx/hash.h
index 851ce62231b77d1c6234da2046c2715725b3a79b..a85d83c83b388e4947595c483b81e93af9d8090c 100644 (file)
--- a/include/wx/hash.h
+++ b/include/wx/hash.h
@@ -5,17 +5,13 @@
 // Modified by: VZ at 25.02.00: type safe hashes with WX_DECLARE_HASH()
 // Created:     01/02/97
 // RCS-ID:      $Id$
 // Modified by: VZ at 25.02.00: type safe hashes with WX_DECLARE_HASH()
 // Created:     01/02/97
 // RCS-ID:      $Id$

-// Copyright:   (c)
+// Copyright:   (c) Julian Smart

 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_HASH_H__
 #define _WX_HASH_H__
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 #ifndef _WX_HASH_H__
 #define _WX_HASH_H__
 

-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-#pragma interface "hash.h"
-#endif
-

 #include "wx/defs.h"
 
 #if !wxUSE_STL && WXWIN_COMPATIBILITY_2_4
 #include "wx/defs.h"
 
 #if !wxUSE_STL && WXWIN_COMPATIBILITY_2_4


@@ -111,6 +107,10 @@ union wxHashKeyValue
     wxChar *string;
 };
 
     wxChar *string;
 };
 

+// for some compilers (AIX xlC), defining it as friend inside the class is not
+// enough, so provide a real forward declaration
+class WXDLLIMPEXP_BASE wxHashTableBase;
+

 class WXDLLIMPEXP_BASE wxHashTableBase_Node
 {
     friend class WXDLLIMPEXP_BASE wxHashTableBase;
 class WXDLLIMPEXP_BASE wxHashTableBase_Node
 {
     friend class WXDLLIMPEXP_BASE wxHashTableBase;


@@ -159,7 +159,7 @@ public:
     typedef wxHashTableBase_Node Node;
 
     wxHashTableBase();
     typedef wxHashTableBase_Node Node;
 
     wxHashTableBase();

-    virtual ~wxHashTableBase();
+    virtual ~wxHashTableBase() { };

 
     void Create( wxKeyType keyType = wxKEY_INTEGER,
                  size_t size = wxHASH_SIZE_DEFAULT );
 
     void Create( wxKeyType keyType = wxKEY_INTEGER,
                  size_t size = wxHASH_SIZE_DEFAULT );


@@ -281,10 +281,10 @@ public:
     void Put(long key, const wxString& value);
 
     // get the string from the key: if not found, an empty string is returned
     void Put(long key, const wxString& value);
 
     // get the string from the key: if not found, an empty string is returned

-    // and the wasFound is set to FALSE if not NULL
+    // and the wasFound is set to false if not NULL

     wxString Get(long key, bool *wasFound = NULL) const;
 
     wxString Get(long key, bool *wasFound = NULL) const;
 

-    // remove the item, returning TRUE if the item was found and deleted
+    // remove the item, returning true if the item was found and deleted

     bool Delete(long key) const;
 
     // clean up
     bool Delete(long key) const;
 
     // clean up


@@ -344,39 +344,39 @@ public:
         : wxHashTableBase() { Create( keyType, size ); BeginFind(); }
     wxHashTable( const wxHashTable& table );
 
         : wxHashTableBase() { Create( keyType, size ); BeginFind(); }
     wxHashTable( const wxHashTable& table );
 

-    const wxHashTable& operator=( const wxHashTable& );
+    virtual ~wxHashTable() { Destroy(); }

 
 

-    void Destroy() { Clear(); }
+    const wxHashTable& operator=( const wxHashTable& );

 
     // key and value are the same
     void Put(long value, wxObject *object)
         { DoPut( value, value, object ); }
 
     // key and value are the same
     void Put(long value, wxObject *object)
         { DoPut( value, value, object ); }

-    void Put(long hash, long value, wxObject *object)
-        { DoPut( value, hash, object ); }
+    void Put(long lhash, long value, wxObject *object)
+        { DoPut( value, lhash, object ); }

     void Put(const wxChar *value, wxObject *object)
         { DoPut( value, MakeKey( value ), object ); }
     void Put(const wxChar *value, wxObject *object)
         { DoPut( value, MakeKey( value ), object ); }

-    void Put(long hash, const wxChar *value, wxObject *object)
-        { DoPut( value, hash, object ); }
+    void Put(long lhash, const wxChar *value, wxObject *object)
+        { DoPut( value, lhash, object ); }

 
     // key and value are the same
     wxObject *Get(long value) const
         { return (wxObject*)DoGet( value, value ); }
 
     // key and value are the same
     wxObject *Get(long value) const
         { return (wxObject*)DoGet( value, value ); }

-    wxObject *Get(long hash, long value) const
-        { return (wxObject*)DoGet( value, hash ); }
+    wxObject *Get(long lhash, long value) const
+        { return (wxObject*)DoGet( value, lhash ); }

     wxObject *Get(const wxChar *value) const
         { return (wxObject*)DoGet( value, MakeKey( value ) ); }
     wxObject *Get(const wxChar *value) const
         { return (wxObject*)DoGet( value, MakeKey( value ) ); }

-    wxObject *Get(long hash, const wxChar *value) const
-        { return (wxObject*)DoGet( value, hash ); }
+    wxObject *Get(long lhash, const wxChar *value) const
+        { return (wxObject*)DoGet( value, lhash ); }

 
     // Deletes entry and returns data if found
     wxObject *Delete(long key)
         { return (wxObject*)DoDelete( key, key ); }
 
     // Deletes entry and returns data if found
     wxObject *Delete(long key)
         { return (wxObject*)DoDelete( key, key ); }

-    wxObject *Delete(long hash, long key)
-        { return (wxObject*)DoDelete( key, hash ); }
+    wxObject *Delete(long lhash, long key)
+        { return (wxObject*)DoDelete( key, lhash ); }

     wxObject *Delete(const wxChar *key)
         { return (wxObject*)DoDelete( key, MakeKey( key ) ); }
     wxObject *Delete(const wxChar *key)
         { return (wxObject*)DoDelete( key, MakeKey( key ) ); }

-    wxObject *Delete(long hash, const wxChar *key)
-        { return (wxObject*)DoDelete( key, hash ); }
+    wxObject *Delete(long lhash, const wxChar *key)
+        { return (wxObject*)DoDelete( key, lhash ); }

 
     // Construct your own integer key from a string, e.g. in case
     // you need to combine it with something
 
     // Construct your own integer key from a string, e.g. in case
     // you need to combine it with something


@@ -393,8 +393,6 @@ public:
 
     size_t GetCount() const { return wxHashTableBase::GetCount(); }
 protected:
 
     size_t GetCount() const { return wxHashTableBase::GetCount(); }
 protected:

-    virtual void DoDeleteContents( wxHashTableBase_Node* node );
-

     // copy helper
     void DoCopy( const wxHashTable& copy );
 
     // copy helper
     void DoCopy( const wxHashTable& copy );
 


@@ -402,6 +400,8 @@ protected:
     // m_curr to it and m_currBucket to its bucket
     void GetNextNode( size_t bucketStart );
 private:
     // m_curr to it and m_currBucket to its bucket
     void GetNextNode( size_t bucketStart );
 private:

+    virtual void DoDeleteContents( wxHashTableBase_Node* node );
+

     // current node
     Node* m_curr;
 
     // current node
     Node* m_curr;
 


@@ -426,7 +426,7 @@ public:
 
     wxHashTable(int the_key_type = wxKEY_INTEGER,
                 int size = wxHASH_SIZE_DEFAULT);
 
     wxHashTable(int the_key_type = wxKEY_INTEGER,
                 int size = wxHASH_SIZE_DEFAULT);

-    ~wxHashTable();
+    virtual ~wxHashTable();

 
     // copy ctor and assignment operator
     wxHashTable(const wxHashTable& table) : wxObject()
 
     // copy ctor and assignment operator
     wxHashTable(const wxHashTable& table) : wxObject()


@@ -514,19 +514,18 @@ private:
                   size_t size = wxHASH_SIZE_DEFAULT)                          \
             : wxHashTableBase() { Create(keyType, size); }                    \
                                                                               \
                   size_t size = wxHASH_SIZE_DEFAULT)                          \
             : wxHashTableBase() { Create(keyType, size); }                    \
                                                                               \

-        ~hashclass() { Destroy(); }                                           \
+        virtual ~hashclass() { Destroy(); }                                   \

                                                                               \
                                                                               \

-        void Destroy() { Clear(); }                                           \

         void Put(long key, eltype *data) { DoPut(key, key, (void*)data); }    \
         void Put(long key, eltype *data) { DoPut(key, key, (void*)data); }    \

-        void Put(long hash, long key, eltype *data)                           \
-            { DoPut(key, hash, (void*)data); }                                \
+        void Put(long lhash, long key, eltype *data)                          \
+            { DoPut(key, lhash, (void*)data); }                               \

         eltype *Get(long key) const { return (eltype*)DoGet(key, key); }      \
         eltype *Get(long key) const { return (eltype*)DoGet(key, key); }      \

-        eltype *Get(long hash, long key) const                                \
-            { return (eltype*)DoGet(key, hash); }                             \
+        eltype *Get(long lhash, long key) const                               \
+            { return (eltype*)DoGet(key, lhash); }                            \

         eltype *Delete(long key) { return (eltype*)DoDelete(key, key); }      \
         eltype *Delete(long key) { return (eltype*)DoDelete(key, key); }      \

-        eltype *Delete(long hash, long key)                                   \
-            { return (eltype*)DoDelete(key, hash); }                          \
-    protected:                                                                \
+        eltype *Delete(long lhash, long key)                                  \
+            { return (eltype*)DoDelete(key, lhash); }                         \
+    private:                                                                  \

         virtual void DoDeleteContents( wxHashTableBase_Node* node )           \
             { delete (eltype*)node->GetData(); }                              \
                                                                               \
         virtual void DoDeleteContents( wxHashTableBase_Node* node )           \
             { delete (eltype*)node->GetData(); }                              \
                                                                               \


@@ -543,7 +542,7 @@ private:
                   size_t size = wxHASH_SIZE_DEFAULT)                           \
             { Create(keyType, size); }                                         \
                                                                                \
                   size_t size = wxHASH_SIZE_DEFAULT)                           \
             { Create(keyType, size); }                                         \
                                                                                \

-        ~hashclass() { Destroy(); }                                            \
+        virtual ~hashclass() { Destroy(); }                                            \

                                                                                \
         void Put(long key, long val, eltype *data) { DoPut(key, val, data); }  \
         void Put(long key, eltype *data) { DoPut(key, key, data); }            \
                                                                                \
         void Put(long key, long val, eltype *data) { DoPut(key, val, data); }  \
         void Put(long key, eltype *data) { DoPut(key, key, data); }            \


@@ -585,7 +584,7 @@ private:
             {                                                                  \
                 m_hashTable[slot] = new listclass(m_keyType);                  \
                 if ( m_deleteContents )                                        \
             {                                                                  \
                 m_hashTable[slot] = new listclass(m_keyType);                  \
                 if ( m_deleteContents )                                        \

-                    m_hashTable[slot]->DeleteContents(TRUE);                   \
+                    m_hashTable[slot]->DeleteContents(true);                   \

             }                                                                  \
                                                                                \
             ((listclass *)m_hashTable[slot])->Append(value, data);             \
             }                                                                  \
                                                                                \
             ((listclass *)m_hashTable[slot])->Append(value, data);             \