Added wxHashSet, with minimal tests.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@22779 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

diff --git a/include/wx/hashset.h b/include/wx/hashset.h
new file mode 100644 (file)
index 0000000..4e40bb7
--- /dev/null
+++ b/include/wx/hashset.h
@@ -0,0 +1,93 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/hashset.h
+// Purpose:     wxHashSet class
+// Author:      Mattia Barbon
+// Modified by:
+// Created:     11/08/2003
+// RCS-ID:      $Id$
+// Copyright:   (c) Mattia Barbon
+// Licence:     wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_HASHSET_H_
+#define _WX_HASHSET_H_
+
+#include "wx/hashmap.h"
+
+// this is a complex way of defining an easily inlineable identity function...
+#define _WX_DECLARE_HASH_SET_KEY_EX( KEY_T, CLASSNAME, CLASSEXP )            \
+CLASSEXP CLASSNAME                                                           \
+{                                                                            \
+    typedef KEY_T key_type;                                                  \
+    typedef const key_type const_key_type;                                   \
+    typedef const_key_type& const_key_reference;                             \
+public:                                                                      \
+    CLASSNAME() { }                                                          \
+    const_key_reference operator()( const_key_reference key ) const          \
+        { return key; }                                                      \
+                                                                             \
+    /* the dummy assignment operator is needed to suppress compiler */       \
+    /* warnings from hash table class' operator=(): gcc complains about */   \
+    /* "statement with no effect" without it */                              \
+    CLASSNAME& operator=(const CLASSNAME&) { return *this; }                 \
+};
+
+#define _WX_DECLARE_HASH_SET( KEY_T, HASH_T, KEY_EQ_T, CLASSNAME, CLASSEXP )\
+_WX_DECLARE_HASH_SET_KEY_EX( KEY_T, CLASSNAME##_wxImplementation_KeyEx, CLASSEXP ) \
+_WX_DECLARE_HASHTABLE( KEY_T, KEY_T, HASH_T, CLASSNAME##_wxImplementation_KeyEx, KEY_EQ_T, CLASSNAME##_wxImplementation_HashTable, CLASSEXP, grow_lf70, never_shrink ) \
+CLASSEXP CLASSNAME:public CLASSNAME##_wxImplementation_HashTable             \
+{                                                                            \
+public:                                                                      \
+    CLASSNAME( size_type hint = 100, hasher hf = hasher(),                   \
+               key_equal eq = key_equal() )                                  \
+        : CLASSNAME##_wxImplementation_HashTable( hint, hf, eq,              \
+                      CLASSNAME##_wxImplementation_KeyEx() ) {}              \
+                                                                             \
+    void insert( const key_type& key )                                       \
+    {                                                                        \
+        GetOrCreateNode( key );                                              \
+    }                                                                        \
+                                                                             \
+    const_iterator find( const const_key_type& key ) const                   \
+    {                                                                        \
+        return const_iterator( GetNode( key ), this );                       \
+    }                                                                        \
+                                                                             \
+    iterator find( const const_key_type& key )                               \
+    {                                                                        \
+        return iterator( GetNode( key ), this );                             \
+    }                                                                        \
+                                                                             \
+    size_type erase( const key_type& k )                                     \
+        { return CLASSNAME##_wxImplementation_HashTable::erase( k ); }       \
+    void erase( const iterator& it ) { erase( *it ); }                       \
+    void erase( const const_iterator& it ) { erase( *it ); }                 \
+                                                                             \
+    /* count() == 0 | 1 */                                                   \
+    size_type count( const const_key_type& key )                             \
+        { return GetNode( key ) ? 1 : 0; }                                   \
+}
+
+// these macros are to be used in the user code
+#define WX_DECLARE_HASH_SET( KEY_T, HASH_T, KEY_EQ_T, CLASSNAME) \
+    _WX_DECLARE_HASH_SET( KEY_T, HASH_T, KEY_EQ_T, CLASSNAME, class )
+
+// and these do exactly the same thing but should be used inside the
+// library
+#define WX_DECLARE_HASH_SET_WITH_DECL( KEY_T, HASH_T, KEY_EQ_T, CLASSNAME, DECL) \
+    _WX_DECLARE_HASH_SET( KEY_T, HASH_T, KEY_EQ_T, CLASSNAME, DECL )
+
+#define WX_DECLARE_EXPORTED_HASH_SET( KEY_T, HASH_T, KEY_EQ_T, CLASSNAME) \
+    WX_DECLARE_HASH_SET_WITH_DECL( KEY_T, HASH_T, KEY_EQ_T, \
+                                   CLASSNAME, class WXDLLEXPORT )
+
+// delete all hash elements
+//
+// NB: the class declaration of the hash elements must be visible from the
+//     place where you use this macro, otherwise the proper destructor may not
+//     be called (a decent compiler should give a warning about it, but don't
+//     count on it)!
+#define WX_CLEAR_HASH_SET(type, hashset)                                     \
+    WX_CLEAR_HASH_MAP(type, hashset)
+
+#endif // _WX_HASHSET_H_

diff --git a/samples/console/console.cpp b/samples/console/console.cpp
index 28087c3c70564fd8fc37816d4ae0e95640314cc4..7906063b3c83a74976a6c1105c78e511c146154f 100644 (file)
--- a/samples/console/console.cpp
+++ b/samples/console/console.cpp
@@ -66,6 +66,7 @@
     #define TEST_FTP
     #define TEST_HASH
     #define TEST_HASHMAP
     #define TEST_FTP
     #define TEST_HASH
     #define TEST_HASHMAP

+    #define TEST_HASHSET

     #define TEST_INFO_FUNCTIONS
     #define TEST_LIST
     #define TEST_LOCALE
     #define TEST_INFO_FUNCTIONS
     #define TEST_LIST
     #define TEST_LOCALE


@@ -96,7 +97,7 @@
     #undef TEST_ALL
     static const bool TEST_ALL = true;
 #else
     #undef TEST_ALL
     static const bool TEST_ALL = true;
 #else

-    #define TEST_HASHMAP
+    #define TEST_HASHSET

 
     static const bool TEST_ALL = false;
 #endif
 
     static const bool TEST_ALL = false;
 #endif


@@ -1387,6 +1388,100 @@ static void TestHashMap()
 
 #endif // TEST_HASHMAP
 
 
 #endif // TEST_HASHMAP
 

+// ----------------------------------------------------------------------------
+// wxHashSet
+// ----------------------------------------------------------------------------
+
+#ifdef TEST_HASHSET
+
+#include "wx/hashset.h"
+
+// test compilation of basic map types
+WX_DECLARE_HASH_SET( int*, wxPointerHash, wxPointerEqual, myPtrHashSet );
+WX_DECLARE_HASH_SET( long, wxIntegerHash, wxIntegerEqual, myLongHashSet );
+WX_DECLARE_HASH_SET( unsigned long, wxIntegerHash, wxIntegerEqual,
+                     myUnsignedHashSet );
+WX_DECLARE_HASH_SET( unsigned int, wxIntegerHash, wxIntegerEqual,
+                     myTestHashSet1 );
+WX_DECLARE_HASH_SET( int, wxIntegerHash, wxIntegerEqual,
+                     myTestHashSet2 );
+WX_DECLARE_HASH_SET( short, wxIntegerHash, wxIntegerEqual,
+                     myTestHashSet3 );
+WX_DECLARE_HASH_SET( unsigned short, wxIntegerHash, wxIntegerEqual,
+                     myTestHashSet4 );
+WX_DECLARE_HASH_SET( wxString, wxStringHash, wxStringEqual,
+                     myTestHashSet5 );
+
+struct MyStruct
+{
+    int* ptr;
+    wxString str;
+};
+
+class MyHash
+{
+public:
+    unsigned long operator()(const MyStruct& s) const
+        { return m_dummy(s.ptr); }
+    MyHash& operator=(const MyHash&) { return *this; }
+private:
+    wxPointerHash m_dummy;
+};
+
+class MyEqual
+{
+public:
+    bool operator()(const MyStruct& s1, const MyStruct& s2) const
+        { return s1.ptr == s2.ptr; }
+    MyEqual& operator=(const MyEqual&) { return *this; }
+};
+
+WX_DECLARE_HASH_SET( MyStruct, MyHash, MyEqual, mySet );
+
+typedef myTestHashSet5 wxStringHashSet;
+
+static void TestHashSet()
+{
+    wxPrintf(_T("*** Testing wxHashSet ***\n"));
+
+    wxStringHashSet set1;
+
+    set1.insert( _T("abc") );
+    set1.insert( _T("bbc") );
+    set1.insert( _T("cbc") );
+    set1.insert( _T("abc") );
+
+    if( set1.size() != 3 )
+        wxPrintf(_T("*** ERROR IN INSERT ***\n"));
+
+    mySet set2;
+    int dummy;
+    MyStruct tmp;
+
+    tmp.ptr = &dummy; tmp.str = _T("ABC");
+    set2.insert( tmp );
+    tmp.ptr = &dummy + 1;
+    set2.insert( tmp );
+    tmp.ptr = &dummy; tmp.str = _T("CDE");
+    set2.insert( tmp );
+
+    if( set2.size() != 2 )
+        wxPrintf(_T("*** ERROR IN INSERT - 2 ***\n"));
+
+    mySet::iterator it = set2.find( tmp );
+
+    if( it == set2.end() )
+        wxPrintf(_T("*** ERROR IN FIND - 1 ***\n"));
+    if( it->ptr != &dummy )
+        wxPrintf(_T("*** ERROR IN FIND - 2 ***\n"));
+    if( it->str != _T("ABC") )
+        wxPrintf(_T("*** ERROR IN INSERT - 3 ***\n"));
+
+    wxPrintf(_T("*** Finished testing wxHashSet ***\n"));
+}
+
+#endif // TEST_HASHSET
+

 // ----------------------------------------------------------------------------
 // wxList
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxList
 // ----------------------------------------------------------------------------


@@ -6930,6 +7025,10 @@ int main(int argc, char **argv)
     TestHashMap();
 #endif // TEST_HASHMAP
 
     TestHashMap();
 #endif // TEST_HASHMAP
 

+#ifdef TEST_HASHSET
+    TestHashSet();
+#endif // TEST_HASHSET
+

 #ifdef TEST_MIME
     wxLog::AddTraceMask(_T("mime"));
     if ( TEST_ALL )
 #ifdef TEST_MIME
     wxLog::AddTraceMask(_T("mime"));
     if ( TEST_ALL )