X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/655719367ac5e131d9642e5783f3ecf64d1a3385..c5d4360fc99a0b9bd512e9dc19087c96dc669345:/include/wx/hashset.h diff --git a/include/wx/hashset.h b/include/wx/hashset.h index 3cc80a8f5d..8cd1becf9b 100644 --- a/include/wx/hashset.h +++ b/include/wx/hashset.h @@ -4,7 +4,6 @@ // Author: Mattia Barbon // Modified by: // Created: 11/08/2003 -// RCS-ID: $Id$ // Copyright: (c) Mattia Barbon // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// @@ -14,7 +13,23 @@ #include "wx/hashmap.h" -#if wxUSE_STL && defined(HAVE_STL_HASH_MAP) +// see comment in wx/hashmap.h which also applies to different standard hash +// set classes + +#if wxUSE_STD_CONTAINERS && \ + (defined(HAVE_STD_UNORDERED_SET) || defined(HAVE_TR1_UNORDERED_SET)) + +#if defined(HAVE_STD_UNORDERED_SET) + #include + #define WX_HASH_SET_BASE_TEMPLATE std::unordered_set +#elif defined(HAVE_TR1_UNORDERED_SET) + #include + #define WX_HASH_SET_BASE_TEMPLATE std::tr1::unordered_set +#else + #error Update this code: unordered_set is available, but I do not know where. +#endif + +#elif wxUSE_STD_CONTAINERS && defined(HAVE_STL_HASH_MAP) #if defined(HAVE_EXT_HASH_MAP) #include @@ -22,10 +37,63 @@ #include #endif -#define _WX_DECLARE_HASH_SET( KEY_T, HASH_T, KEY_EQ_T, CLASSNAME, CLASSEXP )\ - typedef WX_HASH_MAP_NAMESPACE::hash_set< KEY_T, HASH_T, KEY_EQ_T > CLASSNAME; +#define WX_HASH_SET_BASE_TEMPLATE WX_HASH_MAP_NAMESPACE::hash_set -#else // !wxUSE_STL || !defined(HAVE_STL_HASH_MAP) +#endif // different hash_set/unordered_set possibilities + +#ifdef WX_HASH_SET_BASE_TEMPLATE + +// we need to define the class declared by _WX_DECLARE_HASH_SET as a class and +// not a typedef to allow forward declaring it +#define _WX_DECLARE_HASH_SET_IMPL( KEY_T, HASH_T, KEY_EQ_T, PTROP, CLASSNAME, CLASSEXP ) \ +CLASSEXP CLASSNAME \ + : public WX_HASH_SET_BASE_TEMPLATE< KEY_T, HASH_T, KEY_EQ_T > \ +{ \ +public: \ + explicit CLASSNAME(size_type n = 3, \ + const hasher& h = hasher(), \ + const key_equal& ke = key_equal(), \ + const allocator_type& a = allocator_type()) \ + : WX_HASH_SET_BASE_TEMPLATE< KEY_T, HASH_T, KEY_EQ_T >(n, h, ke, a) \ + {} \ + template \ + CLASSNAME(InputIterator f, InputIterator l, \ + const hasher& h = hasher(), \ + const key_equal& ke = key_equal(), \ + const allocator_type& a = allocator_type()) \ + : WX_HASH_SET_BASE_TEMPLATE< KEY_T, HASH_T, KEY_EQ_T >(f, l, h, ke, a)\ + {} \ + CLASSNAME(const WX_HASH_SET_BASE_TEMPLATE< KEY_T, HASH_T, KEY_EQ_T >& s) \ + : WX_HASH_SET_BASE_TEMPLATE< KEY_T, HASH_T, KEY_EQ_T >(s) \ + {} \ +} + +// In some standard library implementations (in particular, the libstdc++ that +// ships with g++ 4.7), std::unordered_set inherits privately from its hasher +// and comparator template arguments for purposes of empty base optimization. +// As a result, in the declaration of a class deriving from std::unordered_set +// the names of the hasher and comparator classes are interpreted as naming +// the base class which is inaccessible. +// The workaround is to prefix the class names with 'struct'; however, don't +// do this on MSVC because it causes a warning there if the class was +// declared as a 'class' rather than a 'struct' (and MSVC's std::unordered_set +// implementation does not suffer from the access problem). +#ifdef _MSC_VER +#define WX_MAYBE_PREFIX_WITH_STRUCT(STRUCTNAME) STRUCTNAME +#else +#define WX_MAYBE_PREFIX_WITH_STRUCT(STRUCTNAME) struct STRUCTNAME +#endif + +#define _WX_DECLARE_HASH_SET( KEY_T, HASH_T, KEY_EQ_T, PTROP, CLASSNAME, CLASSEXP ) \ + _WX_DECLARE_HASH_SET_IMPL( \ + KEY_T, \ + WX_MAYBE_PREFIX_WITH_STRUCT(HASH_T), \ + WX_MAYBE_PREFIX_WITH_STRUCT(KEY_EQ_T), \ + PTROP, \ + CLASSNAME, \ + CLASSEXP) + +#else // no appropriate STL class, use our own implementation // this is a complex way of defining an easily inlineable identity function... #define _WX_DECLARE_HASH_SET_KEY_EX( KEY_T, CLASSNAME, CLASSEXP ) \ @@ -45,20 +113,26 @@ public: \ CLASSNAME& operator=(const CLASSNAME&) { return *this; } \ }; -#define _WX_DECLARE_HASH_SET( KEY_T, HASH_T, KEY_EQ_T, CLASSNAME, CLASSEXP )\ +#define _WX_DECLARE_HASH_SET( KEY_T, HASH_T, KEY_EQ_T, PTROP, 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 ) \ +_WX_DECLARE_HASHTABLE( KEY_T, KEY_T, HASH_T, \ + CLASSNAME##_wxImplementation_KeyEx, KEY_EQ_T, PTROP, \ + CLASSNAME##_wxImplementation_HashTable, CLASSEXP, grow_lf70, never_shrink ) \ CLASSEXP CLASSNAME:public CLASSNAME##_wxImplementation_HashTable \ { \ public: \ + _WX_DECLARE_PAIR( iterator, bool, Insert_Result, CLASSEXP ) \ + \ wxEXPLICIT 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 ) \ + Insert_Result insert( const key_type& key ) \ { \ - GetOrCreateNode( key ); \ + bool created; \ + Node *node = GetOrCreateNode( key, created ); \ + return Insert_Result( iterator( node, this ), created ); \ } \ \ const_iterator find( const const_key_type& key ) const \ @@ -77,24 +151,35 @@ public: \ void erase( const const_iterator& it ) { erase( *it ); } \ \ /* count() == 0 | 1 */ \ - size_type count( const const_key_type& key ) \ + size_type count( const const_key_type& key ) const \ { return GetNode( key ) ? 1 : 0; } \ } -#endif // !wxUSE_STL || !defined(HAVE_STL_HASH_MAP) +#endif // STL/wx implementations + // 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 ) + _WX_DECLARE_HASH_SET( KEY_T, HASH_T, KEY_EQ_T, wxPTROP_NORMAL, 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 ) + _WX_DECLARE_HASH_SET( KEY_T, HASH_T, KEY_EQ_T, wxPTROP_NORMAL, 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 ) + CLASSNAME, class WXDLLIMPEXP_CORE ) + +// Finally these versions allow to define hash sets of non-objects (including +// pointers, hence the confusing but wxArray-compatible name) without +// operator->() which can't be used for them. This is mostly used inside the +// library itself to avoid warnings when using such hash sets with some less +// common compilers (notably Sun CC). +#define WX_DECLARE_HASH_SET_PTR( KEY_T, HASH_T, KEY_EQ_T, CLASSNAME) \ + _WX_DECLARE_HASH_SET( KEY_T, HASH_T, KEY_EQ_T, wxPTROP_NOP, CLASSNAME, class ) +#define WX_DECLARE_HASH_SET_WITH_DECL_PTR( KEY_T, HASH_T, KEY_EQ_T, CLASSNAME, DECL) \ + _WX_DECLARE_HASH_SET( KEY_T, HASH_T, KEY_EQ_T, wxPTROP_NOP, CLASSNAME, DECL ) // delete all hash elements // @@ -103,6 +188,11 @@ public: \ // 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) + { \ + type::iterator it, en; \ + for( it = (hashset).begin(), en = (hashset).end(); it != en; ++it ) \ + delete *it; \ + (hashset).clear(); \ + } #endif // _WX_HASHSET_H_