00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035 #ifndef _GLIBCXX_DEBUG_UNORDERED_MAP
00036 #define _GLIBCXX_DEBUG_UNORDERED_MAP 1
00037
00038 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00039 # include <unordered_map>
00040 #else
00041 # include <c++0x_warning.h>
00042 #endif
00043 #include <debug/safe_association.h>
00044 #include <debug/safe_iterator.h>
00045
00046 #define _GLIBCXX_BASE unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>
00047 #define _GLIBCXX_STD_BASE _GLIBCXX_STD_D::_GLIBCXX_BASE
00048
00049 namespace std
00050 {
00051 namespace __debug
00052 {
00053 template<typename _Key, typename _Tp,
00054 typename _Hash = std::hash<_Key>,
00055 typename _Pred = std::equal_to<_Key>,
00056 typename _Alloc = std::allocator<_Key> >
00057 class unordered_map
00058 : public __gnu_debug::_Safe_association<_GLIBCXX_STD_BASE>,
00059 public __gnu_debug::_Safe_sequence<_GLIBCXX_BASE>
00060 {
00061 typedef typename _GLIBCXX_STD_BASE _Base;
00062 typedef __gnu_debug::_Safe_association<_Base> _Safe_assoc;
00063 typedef __gnu_debug::_Safe_sequence<unordered_map> _Safe_base;
00064
00065 public:
00066 typedef typename _Safe_assoc::size_type size_type;
00067 typedef typename _Safe_assoc::hasher hasher;
00068 typedef typename _Safe_assoc::key_equal key_equal;
00069 typedef typename _Safe_assoc::allocator_type allocator_type;
00070
00071 explicit
00072 unordered_map(size_type __n = 10,
00073 const hasher& __hf = hasher(),
00074 const key_equal& __eql = key_equal(),
00075 const allocator_type& __a = allocator_type())
00076 : _Safe_assoc(__n, __hf, __eql, __a)
00077 { }
00078
00079 template<typename _InputIterator>
00080 unordered_map(_InputIterator __f, _InputIterator __l,
00081 size_type __n = 10,
00082 const hasher& __hf = hasher(),
00083 const key_equal& __eql = key_equal(),
00084 const allocator_type& __a = allocator_type())
00085 : _Safe_assoc(__f, __l, __n, __hf, __eql, __a)
00086 { }
00087
00088 unordered_map(const _Safe_assoc& __x)
00089 : _Safe_assoc(__x), _Safe_base() { }
00090
00091 unordered_map(unordered_map&& __x)
00092 : _Safe_assoc(std::forward<_Safe_assoc>(__x)), _Safe_base() { }
00093
00094 unordered_map&
00095 operator=(unordered_map&& __x)
00096 {
00097
00098 clear();
00099 swap(__x);
00100 return *this;
00101 }
00102
00103 void
00104 swap(unordered_map&& __x)
00105 {
00106 _Safe_assoc::swap(__x);
00107 _Safe_base::_M_swap(__x);
00108 }
00109
00110 void
00111 clear()
00112 {
00113 _Base::clear();
00114 this->_M_invalidate_all();
00115 }
00116
00117 private:
00118 void
00119 _M_invalidate_all()
00120 {
00121 typedef typename _Base::const_iterator _Base_const_iterator;
00122 typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal;
00123 this->_M_invalidate_if(_Not_equal(this->_M_base().end()));
00124 }
00125 };
00126
00127 template<typename _Key, typename _Tp, typename _Hash,
00128 typename _Pred, typename _Alloc>
00129 inline void
00130 swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
00131 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
00132 { __x.swap(__y); }
00133
00134 template<typename _Key, typename _Tp, typename _Hash,
00135 typename _Pred, typename _Alloc>
00136 inline void
00137 swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&& __x,
00138 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
00139 { __x.swap(__y); }
00140
00141 template<typename _Key, typename _Tp, typename _Hash,
00142 typename _Pred, typename _Alloc>
00143 inline void
00144 swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
00145 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&& __y)
00146 { __x.swap(__y); }
00147
00148 #undef _GLIBCXX_BASE
00149 #undef _GLIBCXX_STD_BASE
00150 #define _GLIBCXX_STD_BASE _GLIBCXX_STD_D::_GLIBCXX_BASE
00151 #define _GLIBCXX_BASE unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>
00152
00153 template<typename _Key, typename _Tp,
00154 typename _Hash = std::hash<_Key>,
00155 typename _Pred = std::equal_to<_Key>,
00156 typename _Alloc = std::allocator<_Key> >
00157 class unordered_multimap
00158 : public __gnu_debug::_Safe_association<_GLIBCXX_STD_BASE>,
00159 public __gnu_debug::_Safe_sequence<_GLIBCXX_BASE>
00160 {
00161 typedef typename _GLIBCXX_STD_BASE _Base;
00162 typedef __gnu_debug::_Safe_association<_Base> _Safe_assoc;
00163 typedef __gnu_debug::_Safe_sequence<unordered_multimap> _Safe_base;
00164
00165 public:
00166 typedef typename _Safe_assoc::size_type size_type;
00167 typedef typename _Safe_assoc::hasher hasher;
00168 typedef typename _Safe_assoc::key_equal key_equal;
00169 typedef typename _Safe_assoc::allocator_type allocator_type;
00170
00171 explicit
00172 unordered_multimap(size_type __n = 10,
00173 const hasher& __hf = hasher(),
00174 const key_equal& __eql = key_equal(),
00175 const allocator_type& __a = allocator_type())
00176 : _Safe_assoc(__n, __hf, __eql, __a)
00177 { }
00178
00179 template<typename _InputIterator>
00180 unordered_multimap(_InputIterator __f, _InputIterator __l,
00181 size_type __n = 10,
00182 const hasher& __hf = hasher(),
00183 const key_equal& __eql = key_equal(),
00184 const allocator_type& __a = allocator_type())
00185 : _Safe_assoc(__f, __l, __n, __hf, __eql, __a)
00186 { }
00187
00188 unordered_multimap(const _Safe_assoc& __x)
00189 : _Safe_assoc(__x), _Safe_base() { }
00190
00191 unordered_multimap(unordered_multimap&& __x)
00192 : _Safe_assoc(std::forward<_Safe_assoc>(__x)), _Safe_base() { }
00193
00194 unordered_multimap&
00195 operator=(unordered_multimap&& __x)
00196 {
00197
00198 clear();
00199 swap(__x);
00200 return *this;
00201 }
00202
00203 void
00204 swap(unordered_multimap&& __x)
00205 {
00206 _Safe_assoc::swap(__x);
00207 _Safe_base::_M_swap(__x);
00208 }
00209
00210 void
00211 clear()
00212 {
00213 _Base::clear();
00214 this->_M_invalidate_all();
00215 }
00216
00217 private:
00218 void
00219 _M_invalidate_all()
00220 {
00221 typedef typename _Base::const_iterator _Base_const_iterator;
00222 typedef __gnu_debug::_Not_equal_to<_Base_const_iterator> _Not_equal;
00223 this->_M_invalidate_if(_Not_equal(this->_M_base().end()));
00224 }
00225 };
00226
00227 template<typename _Key, typename _Tp, typename _Hash,
00228 typename _Pred, typename _Alloc>
00229 inline void
00230 swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
00231 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
00232 { __x.swap(__y); }
00233
00234 template<typename _Key, typename _Tp, typename _Hash,
00235 typename _Pred, typename _Alloc>
00236 inline void
00237 swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&& __x,
00238 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
00239 { __x.swap(__y); }
00240
00241 template<typename _Key, typename _Tp, typename _Hash,
00242 typename _Pred, typename _Alloc>
00243 inline void
00244 swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
00245 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&& __y)
00246 { __x.swap(__y); }
00247
00248 }
00249 }
00250
00251 #undef _GLIBCXX_BASE
00252 #undef _GLIBCXX_STD_BASE
00253
00254 #endif