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 #ifndef _GLIBCXX_PROFILE_MULTIMAP_H
00030 #define _GLIBCXX_PROFILE_MULTIMAP_H 1
00031
00032 #include <utility>
00033
00034 namespace std _GLIBCXX_VISIBILITY(default)
00035 {
00036 namespace __profile
00037 {
00038
00039 template<typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
00040 typename _Allocator = std::allocator<std::pair<const _Key, _Tp> > >
00041 class multimap
00042 : public _GLIBCXX_STD_C::multimap<_Key, _Tp, _Compare, _Allocator>
00043 {
00044 typedef _GLIBCXX_STD_C::multimap<_Key, _Tp, _Compare, _Allocator> _Base;
00045
00046 public:
00047
00048 typedef _Key key_type;
00049 typedef _Tp mapped_type;
00050 typedef std::pair<const _Key, _Tp> value_type;
00051 typedef _Compare key_compare;
00052 typedef _Allocator allocator_type;
00053 typedef typename _Base::reference reference;
00054 typedef typename _Base::const_reference const_reference;
00055
00056 typedef typename _Base::iterator iterator;
00057 typedef typename _Base::const_iterator const_iterator;
00058 typedef typename _Base::reverse_iterator reverse_iterator;
00059 typedef typename _Base::const_reverse_iterator const_reverse_iterator;
00060
00061 typedef typename _Base::size_type size_type;
00062 typedef typename _Base::difference_type difference_type;
00063 typedef typename _Base::pointer pointer;
00064 typedef typename _Base::const_pointer const_pointer;
00065
00066
00067 explicit multimap(const _Compare& __comp = _Compare(),
00068 const _Allocator& __a = _Allocator())
00069 : _Base(__comp, __a) { }
00070
00071 template<typename _InputIterator>
00072 multimap(_InputIterator __first, _InputIterator __last,
00073 const _Compare& __comp = _Compare(),
00074 const _Allocator& __a = _Allocator())
00075 : _Base(__first, __last, __comp, __a) { }
00076
00077 multimap(const multimap& __x)
00078 : _Base(__x) { }
00079
00080 multimap(const _Base& __x)
00081 : _Base(__x) { }
00082
00083 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00084 multimap(multimap&& __x)
00085 : _Base(std::move(__x))
00086 { }
00087
00088 multimap(initializer_list<value_type> __l,
00089 const _Compare& __c = _Compare(),
00090 const allocator_type& __a = allocator_type())
00091 : _Base(__l, __c, __a) { }
00092 #endif
00093
00094 ~multimap() { }
00095
00096 multimap&
00097 operator=(const multimap& __x)
00098 {
00099 *static_cast<_Base*>(this) = __x;
00100 return *this;
00101 }
00102
00103 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00104 multimap&
00105 operator=(multimap&& __x)
00106 {
00107
00108
00109 this->clear();
00110 this->swap(__x);
00111 return *this;
00112 }
00113
00114 multimap&
00115 operator=(initializer_list<value_type> __l)
00116 {
00117 this->clear();
00118 this->insert(__l);
00119 return *this;
00120 }
00121 #endif
00122
00123 using _Base::get_allocator;
00124
00125
00126 iterator
00127 begin()
00128 { return iterator(_Base::begin()); }
00129
00130 const_iterator
00131 begin() const
00132 { return const_iterator(_Base::begin()); }
00133
00134 iterator
00135 end()
00136 { return iterator(_Base::end()); }
00137
00138 const_iterator
00139 end() const
00140 { return const_iterator(_Base::end()); }
00141
00142 reverse_iterator
00143 rbegin()
00144 { return reverse_iterator(end()); }
00145
00146 const_reverse_iterator
00147 rbegin() const
00148 { return const_reverse_iterator(end()); }
00149
00150 reverse_iterator
00151 rend()
00152 { return reverse_iterator(begin()); }
00153
00154 const_reverse_iterator
00155 rend() const
00156 { return const_reverse_iterator(begin()); }
00157
00158 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00159 const_iterator
00160 cbegin() const
00161 { return const_iterator(_Base::begin()); }
00162
00163 const_iterator
00164 cend() const
00165 { return const_iterator(_Base::end()); }
00166
00167 const_reverse_iterator
00168 crbegin() const
00169 { return const_reverse_iterator(end()); }
00170
00171 const_reverse_iterator
00172 crend() const
00173 { return const_reverse_iterator(begin()); }
00174 #endif
00175
00176
00177 using _Base::empty;
00178 using _Base::size;
00179 using _Base::max_size;
00180
00181
00182 iterator
00183 insert(const value_type& __x)
00184 { return iterator(_Base::insert(__x)); }
00185
00186 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00187 template<typename _Pair, typename = typename
00188 std::enable_if<std::is_convertible<_Pair,
00189 value_type>::value>::type>
00190 iterator
00191 insert(_Pair&& __x)
00192 { return iterator(_Base::insert(std::forward<_Pair>(__x))); }
00193 #endif
00194
00195 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00196 void
00197 insert(std::initializer_list<value_type> __list)
00198 { _Base::insert(__list); }
00199 #endif
00200
00201 iterator
00202 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00203 insert(const_iterator __position, const value_type& __x)
00204 #else
00205 insert(iterator __position, const value_type& __x)
00206 #endif
00207 { return iterator(_Base::insert(__position, __x)); }
00208
00209 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00210 template<typename _Pair, typename = typename
00211 std::enable_if<std::is_convertible<_Pair,
00212 value_type>::value>::type>
00213 iterator
00214 insert(const_iterator __position, _Pair&& __x)
00215 { return iterator(_Base::insert(__position,
00216 std::forward<_Pair>(__x))); }
00217 #endif
00218
00219 template<typename _InputIterator>
00220 void
00221 insert(_InputIterator __first, _InputIterator __last)
00222 { _Base::insert(__first, __last); }
00223
00224 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00225 iterator
00226 erase(const_iterator __position)
00227 { return iterator(_Base::erase(__position)); }
00228 #else
00229 void
00230 erase(iterator __position)
00231 { _Base::erase(__position); }
00232 #endif
00233
00234 size_type
00235 erase(const key_type& __x)
00236 {
00237 std::pair<iterator, iterator> __victims = this->equal_range(__x);
00238 size_type __count = 0;
00239 while (__victims.first != __victims.second)
00240 {
00241 iterator __victim = __victims.first++;
00242 _Base::erase(__victim);
00243 ++__count;
00244 }
00245 return __count;
00246 }
00247
00248 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00249 iterator
00250 erase(const_iterator __first, const_iterator __last)
00251 { return iterator(_Base::erase(__first, __last)); }
00252 #else
00253 void
00254 erase(iterator __first, iterator __last)
00255 { _Base::erase(__first, __last); }
00256 #endif
00257
00258 void
00259 swap(multimap& __x)
00260 { _Base::swap(__x); }
00261
00262 void
00263 clear()
00264 { this->erase(begin(), end()); }
00265
00266
00267 using _Base::key_comp;
00268 using _Base::value_comp;
00269
00270
00271 iterator
00272 find(const key_type& __x)
00273 { return iterator(_Base::find(__x)); }
00274
00275 const_iterator
00276 find(const key_type& __x) const
00277 { return const_iterator(_Base::find(__x)); }
00278
00279 using _Base::count;
00280
00281 iterator
00282 lower_bound(const key_type& __x)
00283 { return iterator(_Base::lower_bound(__x)); }
00284
00285 const_iterator
00286 lower_bound(const key_type& __x) const
00287 { return const_iterator(_Base::lower_bound(__x)); }
00288
00289 iterator
00290 upper_bound(const key_type& __x)
00291 { return iterator(_Base::upper_bound(__x)); }
00292
00293 const_iterator
00294 upper_bound(const key_type& __x) const
00295 { return const_iterator(_Base::upper_bound(__x)); }
00296
00297 std::pair<iterator,iterator>
00298 equal_range(const key_type& __x)
00299 {
00300 typedef typename _Base::iterator _Base_iterator;
00301 std::pair<_Base_iterator, _Base_iterator> __res =
00302 _Base::equal_range(__x);
00303 return std::make_pair(iterator(__res.first),
00304 iterator(__res.second));
00305 }
00306
00307 std::pair<const_iterator,const_iterator>
00308 equal_range(const key_type& __x) const
00309 {
00310 typedef typename _Base::const_iterator _Base_const_iterator;
00311 std::pair<_Base_const_iterator, _Base_const_iterator> __res =
00312 _Base::equal_range(__x);
00313 return std::make_pair(const_iterator(__res.first),
00314 const_iterator(__res.second));
00315 }
00316
00317 _Base&
00318 _M_base() { return *this; }
00319
00320 const _Base&
00321 _M_base() const { return *this; }
00322 };
00323
00324 template<typename _Key, typename _Tp,
00325 typename _Compare, typename _Allocator>
00326 inline bool
00327 operator==(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
00328 const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
00329 { return __lhs._M_base() == __rhs._M_base(); }
00330
00331 template<typename _Key, typename _Tp,
00332 typename _Compare, typename _Allocator>
00333 inline bool
00334 operator!=(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
00335 const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
00336 { return __lhs._M_base() != __rhs._M_base(); }
00337
00338 template<typename _Key, typename _Tp,
00339 typename _Compare, typename _Allocator>
00340 inline bool
00341 operator<(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
00342 const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
00343 { return __lhs._M_base() < __rhs._M_base(); }
00344
00345 template<typename _Key, typename _Tp,
00346 typename _Compare, typename _Allocator>
00347 inline bool
00348 operator<=(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
00349 const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
00350 { return __lhs._M_base() <= __rhs._M_base(); }
00351
00352 template<typename _Key, typename _Tp,
00353 typename _Compare, typename _Allocator>
00354 inline bool
00355 operator>=(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
00356 const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
00357 { return __lhs._M_base() >= __rhs._M_base(); }
00358
00359 template<typename _Key, typename _Tp,
00360 typename _Compare, typename _Allocator>
00361 inline bool
00362 operator>(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
00363 const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
00364 { return __lhs._M_base() > __rhs._M_base(); }
00365
00366 template<typename _Key, typename _Tp,
00367 typename _Compare, typename _Allocator>
00368 inline void
00369 swap(multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
00370 multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
00371 { __lhs.swap(__rhs); }
00372
00373 }
00374 }
00375
00376 #endif