X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/760d3c7cd33a214ec4b3e09449b846e8eabde614..682214d5c6ec3e56dbdfd0c97d70d87e614b38c2:/include/wx/hashmap.h?ds=sidebyside diff --git a/include/wx/hashmap.h b/include/wx/hashmap.h index fbabe5b8f2..b8689b86f6 100644 --- a/include/wx/hashmap.h +++ b/include/wx/hashmap.h @@ -18,10 +18,35 @@ #include "wx/string.h" -#include // for ptrdiff_t +#if (defined(HAVE_EXT_HASH_MAP) || defined(HAVE_HASH_MAP)) \ + && (defined(HAVE_GNU_CXX_HASH_MAP) || defined(HAVE_STD_HASH_MAP)) + #define HAVE_STL_HASH_MAP +#endif + +#if wxUSE_STL && defined(HAVE_STL_HASH_MAP) + +#if defined(HAVE_EXT_HASH_MAP) + #include +#elif defined(HAVE_HASH_MAP) + #include +#endif + +#if defined(HAVE_GNU_CXX_HASH_MAP) + #define WX_HASH_MAP_NAMESPACE __gnu_cxx +#elif defined(HAVE_STD_HASH_MAP) + #define WX_HASH_MAP_NAMESPACE std +#endif + +#define _WX_DECLARE_HASH_MAP( KEY_T, VALUE_T, HASH_T, KEY_EQ_T, CLASSNAME, CLASSEXP ) \ + typedef WX_HASH_MAP_NAMESPACE::hash_map< KEY_T, VALUE_T, HASH_T, KEY_EQ_T > CLASSNAME; + +#else // !wxUSE_STL || !defined(HAVE_STL_HASH_MAP) + #ifdef __WXWINCE__ typedef int ptrdiff_t; +#else +#include // for ptrdiff_t #endif // private @@ -76,6 +101,10 @@ protected: { return (void **)calloc(sz, sizeof(void*)); } + static void FreeTable(void *table) + { + free(table); + } }; #define _WX_DECLARE_HASHTABLE( VALUE_T, KEY_T, HASH_T, KEY_EX_T, KEY_EQ_T, CLASSNAME, CLASSEXP, SHOULD_GROW, SHOULD_SHRINK ) \ @@ -118,8 +147,8 @@ public: \ value_type m_value; \ }; \ \ - struct Iterator; \ - friend struct Iterator; \ + CLASSEXP Iterator; \ + friend CLASSEXP Iterator; \ protected: \ static void DeleteNode( _wxHashTable_NodeBase* node ) \ { \ @@ -129,8 +158,9 @@ public: \ /* */ \ /* forward iterator */ \ /* */ \ - struct Iterator \ + CLASSEXP Iterator \ { \ + public: \ Node* m_node; \ Self* m_ht; \ \ @@ -161,8 +191,9 @@ public: \ }; \ \ public: \ - struct iterator:public Iterator \ + CLASSEXP iterator : public Iterator \ { \ + public: \ iterator() : Iterator() {} \ iterator( Node* node, Self* ht ) : Iterator( node, ht ) {} \ iterator& operator++() { PlusPlus(); return *this; } \ @@ -171,8 +202,9 @@ public: \ pointer operator ->() const { return &(m_node->m_value); } \ }; \ \ - struct const_iterator:public Iterator \ + CLASSEXP const_iterator : public Iterator \ { \ + public: \ const_iterator() : Iterator() {} \ const_iterator( Node* node, const Self* ht ) \ : Iterator( node, (Self*)ht ) {} \ @@ -220,7 +252,7 @@ public: \ { \ clear(); \ \ - free(m_table); \ + FreeTable(m_table); \ } \ \ hasher hash_funct() { return m_hasher; } \ @@ -270,7 +302,7 @@ protected: \ } \ static Node* CopyNode( Node* node ) { return new Node( *node ); } \ \ - Node* GetOrCreateNode( const value_type& value ) \ + Node* GetOrCreateNode( const value_type& value, bool& created ) \ { \ const const_key_type& key = m_getKey( value ); \ size_t bucket = m_hasher( key ) % m_tableBuckets; \ @@ -279,10 +311,14 @@ protected: \ while( node ) \ { \ if( m_equals( m_getKey( node->m_value ), key ) ) \ + { \ + created = false; \ return node; \ + } \ node = node->m_next(); \ } \ - return CreateNode( value , bucket); \ + created = true; \ + return CreateNode( value, bucket); \ }\ Node * CreateNode( const value_type& value, size_t bucket ) \ {\ @@ -297,19 +333,6 @@ protected: \ \ return node; \ } \ - void CreateNodeLast( const value_type& value ) \ - { \ - size_t bucket = m_hasher( m_getKey(value) ) % m_tableBuckets; \ - Node* curr = m_table[bucket], \ - * next = m_table[bucket]; \ - while( next ) { curr = next; next = next->m_next(); } \ - Node** ptr = curr ? (Node**)&curr->m_nxt : &m_table[bucket]; \ - *ptr = new Node( value ); \ - /* must be after the node is inserted */ \ - ++m_items; \ - if( SHOULD_GROW( m_tableBuckets, m_items ) ) \ - ResizeTable( m_tableBuckets ); \ - } \ void CreateNode( const value_type& value ) \ {\ CreateNode(value, m_hasher( m_getKey(value) ) % m_tableBuckets ); \ @@ -360,7 +383,7 @@ protected: \ this, (_wxHashTable_NodeBase**)m_table, \ (BucketFromNode)GetBucketForNode,\ (ProcessNode)&DummyProcessNode ); \ - free(srcTable); \ + FreeTable(srcTable); \ } \ \ /* this must be called _after_ m_table has been cleaned */ \ @@ -414,13 +437,15 @@ public: \ }; // grow/shrink predicates -inline bool never_grow( size_t, size_t ) { return FALSE; } -inline bool never_shrink( size_t, size_t ) { return FALSE; } +inline bool never_grow( size_t, size_t ) { return false; } +inline bool never_shrink( size_t, size_t ) { return false; } inline bool grow_lf70( size_t buckets, size_t items ) { return float(items)/float(buckets) >= 0.85; } +#endif // !wxUSE_STL || !defined(HAVE_STL_HASH_MAP) + // ---------------------------------------------------------------------------- // hashing and comparison functors // ---------------------------------------------------------------------------- @@ -429,6 +454,31 @@ inline bool grow_lf70( size_t buckets, size_t items ) // operators to suppress warnings about "statement with no effect" from gcc // in the hash table class assignment operator (where they're assigned) +#if wxUSE_STL && defined(HAVE_STL_HASH_MAP) + +// integer types +class WXDLLIMPEXP_BASE wxIntegerHash +{ + WX_HASH_MAP_NAMESPACE::hash longHash; + WX_HASH_MAP_NAMESPACE::hash ulongHash; + WX_HASH_MAP_NAMESPACE::hash intHash; + WX_HASH_MAP_NAMESPACE::hash uintHash; + WX_HASH_MAP_NAMESPACE::hash shortHash; + WX_HASH_MAP_NAMESPACE::hash ushortHash; +public: + wxIntegerHash() { } + size_t operator()( long x ) const { return longHash( x ); } + size_t operator()( unsigned long x ) const { return ulongHash( x ); } + size_t operator()( int x ) const { return intHash( x ); } + size_t operator()( unsigned int x ) const { return uintHash( x ); } + size_t operator()( short x ) const { return shortHash( x ); } + size_t operator()( unsigned short x ) const { return ushortHash( x ); } + + wxIntegerHash& operator=(const wxIntegerHash&) { return *this; } +}; + +#else // !wxUSE_STL || !defined(HAVE_STL_HASH_MAP) + // integer types class WXDLLIMPEXP_BASE wxIntegerHash { @@ -444,6 +494,8 @@ public: wxIntegerHash& operator=(const wxIntegerHash&) { return *this; } }; +#endif // !wxUSE_STL || !defined(HAVE_STL_HASH_MAP) + class WXDLLIMPEXP_BASE wxIntegerEqual { public: @@ -464,9 +516,11 @@ class WXDLLIMPEXP_BASE wxPointerHash public: wxPointerHash() { } - // TODO: this might not work well on architectures with 64 bit pointers but - // 32 bit longs, we should use % ULONG_MAX there - unsigned long operator()( const void* k ) const { return (unsigned long)wxPtrToULong(k); } +#if wxUSE_STL && defined(HAVE_STL_HASH_MAP) + size_t operator()( const void* k ) const { return (size_t)k; } +#else + wxUIntPtr operator()( const void* k ) const { return wxPtrToUInt(k); } +#endif wxPointerHash& operator=(const wxPointerHash&) { return *this; } }; @@ -515,6 +569,8 @@ public: wxStringEqual& operator=(const wxStringEqual&) { return *this; } }; +#if !wxUSE_STL || !defined(HAVE_STL_HASH_MAP) + #define _WX_DECLARE_HASH_MAP( KEY_T, VALUE_T, HASH_T, KEY_EQ_T, CLASSNAME, CLASSEXP ) \ _WX_DECLARE_PAIR( KEY_T, VALUE_T, CLASSNAME##_wxImplementation_Pair, CLASSEXP ) \ _WX_DECLARE_HASH_MAP_KEY_EX( KEY_T, CLASSNAME##_wxImplementation_Pair, CLASSNAME##_wxImplementation_KeyEx, CLASSEXP ) \ @@ -523,13 +579,19 @@ CLASSEXP CLASSNAME:public CLASSNAME##_wxImplementation_HashTable \ { \ public: \ typedef VALUE_T mapped_type; \ + _WX_DECLARE_PAIR( iterator, bool, Insert_Result, CLASSEXP ) \ \ - CLASSNAME( size_type hint = 100, hasher hf = hasher(), key_equal eq = key_equal() ) \ - : CLASSNAME##_wxImplementation_HashTable( hint, hf, eq, CLASSNAME##_wxImplementation_KeyEx() ) {} \ + wxEXPLICIT CLASSNAME( size_type hint = 100, hasher hf = hasher(), \ + key_equal eq = key_equal() ) \ + : CLASSNAME##_wxImplementation_HashTable( hint, hf, eq, \ + CLASSNAME##_wxImplementation_KeyEx() ) {} \ \ mapped_type& operator[]( const const_key_type& key ) \ { \ - return GetOrCreateNode( CLASSNAME##_wxImplementation_Pair( key, mapped_type() ) )->m_value.second; \ + bool created; \ + return GetOrCreateNode( \ + CLASSNAME##_wxImplementation_Pair( key, mapped_type() ), \ + created)->m_value.second; \ } \ \ const_iterator find( const const_key_type& key ) const \ @@ -542,7 +604,16 @@ public: \ return iterator( GetNode( key ), this ); \ } \ \ - void insert( const value_type& v ) { (*this)[v.first] = v.second; } \ + Insert_Result insert( const value_type& v ) \ + { \ + bool created; \ + Node *node = GetOrCreateNode( \ + CLASSNAME##_wxImplementation_Pair( v.first, v.second ), \ + created); \ + if ( !created ) \ + node->m_value.second = v.second; \ + return Insert_Result(iterator(node, this), created); \ + } \ \ size_type erase( const key_type& k ) \ { return CLASSNAME##_wxImplementation_HashTable::erase( k ); } \ @@ -554,6 +625,8 @@ public: \ { return GetNode( key ) ? 1 : 0; } \ } +#endif // !wxUSE_STL || !defined(HAVE_STL_HASH_MAP) + // these macros are to be used in the user code #define WX_DECLARE_HASH_MAP( KEY_T, VALUE_T, HASH_T, KEY_EQ_T, CLASSNAME) \ _WX_DECLARE_HASH_MAP( KEY_T, VALUE_T, HASH_T, KEY_EQ_T, CLASSNAME, class ) @@ -605,5 +678,12 @@ public: \ (hashmap).clear(); \ } +//--------------------------------------------------------------------------- +// Declarations of common hashmap classes + +WX_DECLARE_HASH_MAP_WITH_DECL( long, long, wxIntegerHash, wxIntegerEqual, + wxLongToLongHashMap, class WXDLLIMPEXP_BASE ); + + #endif // _WX_HASHMAP_H_