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
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00061 #ifndef __GLIBCPP_INTERNAL_MULTIMAP_H
00062 #define __GLIBCPP_INTERNAL_MULTIMAP_H
00063
00064 #include <bits/concept_check.h>
00065
00066 namespace std
00067 {
00068
00069 template <class _Key, class _Tp,
00070 class _Compare = less<_Key>,
00071 class _Alloc = allocator<pair<const _Key, _Tp> > >
00072 class multimap;
00073
00074 template <class _Key, class _Tp, class _Compare, class _Alloc>
00075 inline bool operator==(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
00076 const multimap<_Key,_Tp,_Compare,_Alloc>& __y);
00077
00078 template <class _Key, class _Tp, class _Compare, class _Alloc>
00079 inline bool operator<(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
00080 const multimap<_Key,_Tp,_Compare,_Alloc>& __y);
00081
00090 template <class _Key, class _Tp, class _Compare, class _Alloc>
00091 class multimap
00092 {
00093
00094 __glibcpp_class_requires(_Tp, _SGIAssignableConcept)
00095 __glibcpp_class_requires4(_Compare, bool, _Key, _Key, _BinaryFunctionConcept);
00096
00097 public:
00098
00099
00100
00101 typedef _Key key_type;
00102 typedef _Tp data_type;
00103 typedef _Tp mapped_type;
00104 typedef pair<const _Key, _Tp> value_type;
00105 typedef _Compare key_compare;
00106
00107 class value_compare : public binary_function<value_type, value_type, bool> {
00108 friend class multimap<_Key,_Tp,_Compare,_Alloc>;
00109 protected:
00110 _Compare comp;
00111 value_compare(_Compare __c) : comp(__c) {}
00112 public:
00113 bool operator()(const value_type& __x, const value_type& __y) const {
00114 return comp(__x.first, __y.first);
00115 }
00116 };
00117
00118 private:
00119 typedef _Rb_tree<key_type, value_type,
00120 _Select1st<value_type>, key_compare, _Alloc> _Rep_type;
00121 _Rep_type _M_t;
00122 public:
00123 typedef typename _Rep_type::pointer pointer;
00124 typedef typename _Rep_type::const_pointer const_pointer;
00125 typedef typename _Rep_type::reference reference;
00126 typedef typename _Rep_type::const_reference const_reference;
00127 typedef typename _Rep_type::iterator iterator;
00128 typedef typename _Rep_type::const_iterator const_iterator;
00129 typedef typename _Rep_type::reverse_iterator reverse_iterator;
00130 typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
00131 typedef typename _Rep_type::size_type size_type;
00132 typedef typename _Rep_type::difference_type difference_type;
00133 typedef typename _Rep_type::allocator_type allocator_type;
00134
00135
00136
00137 multimap() : _M_t(_Compare(), allocator_type()) { }
00138 explicit multimap(const _Compare& __comp,
00139 const allocator_type& __a = allocator_type())
00140 : _M_t(__comp, __a) { }
00141
00142 template <class _InputIterator>
00143 multimap(_InputIterator __first, _InputIterator __last)
00144 : _M_t(_Compare(), allocator_type())
00145 { _M_t.insert_equal(__first, __last); }
00146
00147 template <class _InputIterator>
00148 multimap(_InputIterator __first, _InputIterator __last,
00149 const _Compare& __comp,
00150 const allocator_type& __a = allocator_type())
00151 : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); }
00152 multimap(const multimap<_Key,_Tp,_Compare,_Alloc>& __x) : _M_t(__x._M_t) { }
00153
00154 multimap<_Key,_Tp,_Compare,_Alloc>&
00155 operator=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x) {
00156 _M_t = __x._M_t;
00157 return *this;
00158 }
00159
00160
00161
00162 key_compare key_comp() const { return _M_t.key_comp(); }
00163 value_compare value_comp() const { return value_compare(_M_t.key_comp()); }
00164 allocator_type get_allocator() const { return _M_t.get_allocator(); }
00165
00170 iterator begin() { return _M_t.begin(); }
00171
00177 const_iterator begin() const { return _M_t.begin(); }
00178
00183 iterator end() { return _M_t.end(); }
00184
00190 const_iterator end() const { return _M_t.end(); }
00191
00197 reverse_iterator rbegin() { return _M_t.rbegin(); }
00198
00204 const_reverse_iterator rbegin() const { return _M_t.rbegin(); }
00205
00211 reverse_iterator rend() { return _M_t.rend(); }
00212
00218 const_reverse_iterator rend() const { return _M_t.rend(); }
00219
00221 bool empty() const { return _M_t.empty(); }
00222
00224 size_type size() const { return _M_t.size(); }
00225
00227 size_type max_size() const { return _M_t.max_size(); }
00228
00229 void swap(multimap<_Key,_Tp,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); }
00230
00231
00242 iterator insert(const value_type& __x) { return _M_t.insert_equal(__x); }
00243
00259 iterator insert(iterator __position, const value_type& __x) {
00260 return _M_t.insert_equal(__position, __x);
00261 }
00262
00270 template <class _InputIterator>
00271 void insert(_InputIterator __first, _InputIterator __last) {
00272 _M_t.insert_equal(__first, __last);
00273 }
00274
00284 void erase(iterator __position) { _M_t.erase(__position); }
00285
00297 size_type erase(const key_type& __x) { return _M_t.erase(__x); }
00298
00309 void erase(iterator __first, iterator __last)
00310 { _M_t.erase(__first, __last); }
00311
00317 void clear() { _M_t.clear(); }
00318
00319
00320
00332 iterator find(const key_type& __x) { return _M_t.find(__x); }
00333
00345 const_iterator find(const key_type& __x) const { return _M_t.find(__x); }
00346
00352 size_type count(const key_type& __x) const { return _M_t.count(__x); }
00353
00365 iterator lower_bound(const key_type& __x) {return _M_t.lower_bound(__x); }
00366
00378 const_iterator lower_bound(const key_type& __x) const {
00379 return _M_t.lower_bound(__x);
00380 }
00381
00387 iterator upper_bound(const key_type& __x) {return _M_t.upper_bound(__x); }
00388
00395 const_iterator upper_bound(const key_type& __x) const {
00396 return _M_t.upper_bound(__x);
00397 }
00398
00413 pair<iterator,iterator> equal_range(const key_type& __x) {
00414 return _M_t.equal_range(__x);
00415 }
00416
00431 pair<const_iterator,const_iterator> equal_range(const key_type& __x) const {
00432 return _M_t.equal_range(__x);
00433 }
00434
00435 template <class _K1, class _T1, class _C1, class _A1>
00436 friend bool operator== (const multimap<_K1, _T1, _C1, _A1>&,
00437 const multimap<_K1, _T1, _C1, _A1>&);
00438 template <class _K1, class _T1, class _C1, class _A1>
00439 friend bool operator< (const multimap<_K1, _T1, _C1, _A1>&,
00440 const multimap<_K1, _T1, _C1, _A1>&);
00441 };
00442
00443 template <class _Key, class _Tp, class _Compare, class _Alloc>
00444 inline bool operator==(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
00445 const multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
00446 return __x._M_t == __y._M_t;
00447 }
00448
00449 template <class _Key, class _Tp, class _Compare, class _Alloc>
00450 inline bool operator<(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
00451 const multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
00452 return __x._M_t < __y._M_t;
00453 }
00454
00455 template <class _Key, class _Tp, class _Compare, class _Alloc>
00456 inline bool operator!=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
00457 const multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
00458 return !(__x == __y);
00459 }
00460
00461 template <class _Key, class _Tp, class _Compare, class _Alloc>
00462 inline bool operator>(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
00463 const multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
00464 return __y < __x;
00465 }
00466
00467 template <class _Key, class _Tp, class _Compare, class _Alloc>
00468 inline bool operator<=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
00469 const multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
00470 return !(__y < __x);
00471 }
00472
00473 template <class _Key, class _Tp, class _Compare, class _Alloc>
00474 inline bool operator>=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x,
00475 const multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
00476 return !(__x < __y);
00477 }
00478
00479 template <class _Key, class _Tp, class _Compare, class _Alloc>
00480 inline void swap(multimap<_Key,_Tp,_Compare,_Alloc>& __x,
00481 multimap<_Key,_Tp,_Compare,_Alloc>& __y) {
00482 __x.swap(__y);
00483 }
00484
00485 }
00486
00487 #endif
00488
00489
00490
00491