synchronize GTK2 minimum version in docs
[wxWidgets.git] / include / wx / hashset.h
CommitLineData
8142d704
MB
1/////////////////////////////////////////////////////////////////////////////
2// Name: wx/hashset.h
3// Purpose: wxHashSet class
4// Author: Mattia Barbon
5// Modified by:
6// Created: 11/08/2003
7// RCS-ID: $Id$
8// Copyright: (c) Mattia Barbon
65571936 9// Licence: wxWindows licence
8142d704
MB
10/////////////////////////////////////////////////////////////////////////////
11
12#ifndef _WX_HASHSET_H_
13#define _WX_HASHSET_H_
14
15#include "wx/hashmap.h"
16
f380544a
VZ
17// see comment in wx/hashmap.h which also applies to different standard hash
18// set classes
19
01871bf6 20#if wxUSE_STD_CONTAINERS && \
f380544a
VZ
21 (defined(HAVE_STD_UNORDERED_SET) || defined(HAVE_TR1_UNORDERED_SET))
22
23#if defined(HAVE_STD_UNORDERED_SET)
24 #include <unordered_set>
5e1d513e 25 #define WX_HASH_SET_BASE_TEMPLATE std::unordered_set
f380544a
VZ
26#elif defined(HAVE_TR1_UNORDERED_SET)
27 #include <tr1/unordered_set>
5e1d513e 28 #define WX_HASH_SET_BASE_TEMPLATE std::tr1::unordered_set
f380544a 29#else
5e1d513e 30 #error Update this code: unordered_set is available, but I do not know where.
f380544a
VZ
31#endif
32
01871bf6 33#elif wxUSE_STD_CONTAINERS && defined(HAVE_STL_HASH_MAP)
bdcade0a
MB
34
35#if defined(HAVE_EXT_HASH_MAP)
36 #include <ext/hash_set>
37#elif defined(HAVE_HASH_MAP)
38 #include <hash_set>
39#endif
40
5e1d513e
VZ
41#define WX_HASH_SET_BASE_TEMPLATE WX_HASH_MAP_NAMESPACE::hash_set
42
43#endif // different hash_set/unordered_set possibilities
44
45#ifdef WX_HASH_SET_BASE_TEMPLATE
bdcade0a 46
5e1d513e
VZ
47// we need to define the class declared by _WX_DECLARE_HASH_SET as a class and
48// not a typedef to allow forward declaring it
e4c8592e 49#define _WX_DECLARE_HASH_SET( KEY_T, HASH_T, KEY_EQ_T, PTROP, CLASSNAME, CLASSEXP ) \
5e1d513e
VZ
50CLASSEXP CLASSNAME \
51 : public WX_HASH_SET_BASE_TEMPLATE< KEY_T, HASH_T, KEY_EQ_T > \
52{ \
53public: \
54 explicit CLASSNAME(size_type n = 3, \
55 const hasher& h = hasher(), \
56 const key_equal& ke = key_equal(), \
57 const allocator_type& a = allocator_type()) \
58 : WX_HASH_SET_BASE_TEMPLATE< KEY_T, HASH_T, KEY_EQ_T >(n, h, ke, a) \
59 {} \
60 template <class InputIterator> \
61 CLASSNAME(InputIterator f, InputIterator l, \
62 const hasher& h = hasher(), \
63 const key_equal& ke = key_equal(), \
64 const allocator_type& a = allocator_type()) \
65 : WX_HASH_SET_BASE_TEMPLATE< KEY_T, HASH_T, KEY_EQ_T >(f, l, h, ke, a)\
66 {} \
67 CLASSNAME(const WX_HASH_SET_BASE_TEMPLATE< KEY_T, HASH_T, KEY_EQ_T >& s) \
68 : WX_HASH_SET_BASE_TEMPLATE< KEY_T, HASH_T, KEY_EQ_T >(s) \
69 {} \
70}
71
72#else // no appropriate STL class, use our own implementation
bdcade0a 73
8142d704
MB
74// this is a complex way of defining an easily inlineable identity function...
75#define _WX_DECLARE_HASH_SET_KEY_EX( KEY_T, CLASSNAME, CLASSEXP ) \
76CLASSEXP CLASSNAME \
77{ \
78 typedef KEY_T key_type; \
79 typedef const key_type const_key_type; \
80 typedef const_key_type& const_key_reference; \
81public: \
82 CLASSNAME() { } \
83 const_key_reference operator()( const_key_reference key ) const \
84 { return key; } \
85 \
86 /* the dummy assignment operator is needed to suppress compiler */ \
87 /* warnings from hash table class' operator=(): gcc complains about */ \
88 /* "statement with no effect" without it */ \
89 CLASSNAME& operator=(const CLASSNAME&) { return *this; } \
90};
91
e4c8592e 92#define _WX_DECLARE_HASH_SET( KEY_T, HASH_T, KEY_EQ_T, PTROP, CLASSNAME, CLASSEXP )\
8142d704 93_WX_DECLARE_HASH_SET_KEY_EX( KEY_T, CLASSNAME##_wxImplementation_KeyEx, CLASSEXP ) \
e4c8592e
VZ
94_WX_DECLARE_HASHTABLE( KEY_T, KEY_T, HASH_T, \
95 CLASSNAME##_wxImplementation_KeyEx, KEY_EQ_T, PTROP, \
96 CLASSNAME##_wxImplementation_HashTable, CLASSEXP, grow_lf70, never_shrink ) \
8142d704
MB
97CLASSEXP CLASSNAME:public CLASSNAME##_wxImplementation_HashTable \
98{ \
99public: \
d7ab66a1
MB
100 _WX_DECLARE_PAIR( iterator, bool, Insert_Result, CLASSEXP ) \
101 \
d8771ac7
MB
102 wxEXPLICIT CLASSNAME( size_type hint = 100, hasher hf = hasher(), \
103 key_equal eq = key_equal() ) \
8142d704
MB
104 : CLASSNAME##_wxImplementation_HashTable( hint, hf, eq, \
105 CLASSNAME##_wxImplementation_KeyEx() ) {} \
106 \
d7ab66a1 107 Insert_Result insert( const key_type& key ) \
8142d704 108 { \
d7ab66a1
MB
109 bool created; \
110 Node *node = GetOrCreateNode( key, created ); \
111 return Insert_Result( iterator( node, this ), created ); \
8142d704
MB
112 } \
113 \
114 const_iterator find( const const_key_type& key ) const \
115 { \
116 return const_iterator( GetNode( key ), this ); \
117 } \
118 \
119 iterator find( const const_key_type& key ) \
120 { \
121 return iterator( GetNode( key ), this ); \
122 } \
123 \
124 size_type erase( const key_type& k ) \
125 { return CLASSNAME##_wxImplementation_HashTable::erase( k ); } \
126 void erase( const iterator& it ) { erase( *it ); } \
127 void erase( const const_iterator& it ) { erase( *it ); } \
128 \
129 /* count() == 0 | 1 */ \
fa531da0 130 size_type count( const const_key_type& key ) const \
8142d704 131 { return GetNode( key ) ? 1 : 0; } \
3f5c62f9 132}
8142d704 133
5e1d513e
VZ
134#endif // STL/wx implementations
135
bdcade0a 136
8142d704
MB
137// these macros are to be used in the user code
138#define WX_DECLARE_HASH_SET( KEY_T, HASH_T, KEY_EQ_T, CLASSNAME) \
e4c8592e 139 _WX_DECLARE_HASH_SET( KEY_T, HASH_T, KEY_EQ_T, wxPTROP_NORMAL, CLASSNAME, class )
8142d704
MB
140
141// and these do exactly the same thing but should be used inside the
142// library
143#define WX_DECLARE_HASH_SET_WITH_DECL( KEY_T, HASH_T, KEY_EQ_T, CLASSNAME, DECL) \
e4c8592e 144 _WX_DECLARE_HASH_SET( KEY_T, HASH_T, KEY_EQ_T, wxPTROP_NORMAL, CLASSNAME, DECL )
8142d704
MB
145
146#define WX_DECLARE_EXPORTED_HASH_SET( KEY_T, HASH_T, KEY_EQ_T, CLASSNAME) \
147 WX_DECLARE_HASH_SET_WITH_DECL( KEY_T, HASH_T, KEY_EQ_T, \
53a2db12 148 CLASSNAME, class WXDLLIMPEXP_CORE )
8142d704 149
e4c8592e
VZ
150// Finally these versions allow to define hash sets of non-objects (including
151// pointers, hence the confusing but wxArray-compatible name) without
152// operator->() which can't be used for them. This is mostly used inside the
153// library itself to avoid warnings when using such hash sets with some less
154// common compilers (notably Sun CC).
155#define WX_DECLARE_HASH_SET_PTR( KEY_T, HASH_T, KEY_EQ_T, CLASSNAME) \
156 _WX_DECLARE_HASH_SET( KEY_T, HASH_T, KEY_EQ_T, wxPTROP_NOP, CLASSNAME, class )
157#define WX_DECLARE_HASH_SET_WITH_DECL_PTR( KEY_T, HASH_T, KEY_EQ_T, CLASSNAME, DECL) \
158 _WX_DECLARE_HASH_SET( KEY_T, HASH_T, KEY_EQ_T, wxPTROP_NOP, CLASSNAME, DECL )
159
8142d704
MB
160// delete all hash elements
161//
162// NB: the class declaration of the hash elements must be visible from the
163// place where you use this macro, otherwise the proper destructor may not
164// be called (a decent compiler should give a warning about it, but don't
165// count on it)!
166#define WX_CLEAR_HASH_SET(type, hashset) \
3115bfa8
VS
167 { \
168 type::iterator it, en; \
169 for( it = (hashset).begin(), en = (hashset).end(); it != en; ++it ) \
170 delete *it; \
171 (hashset).clear(); \
172 }
8142d704
MB
173
174#endif // _WX_HASHSET_H_