diff options
Diffstat (limited to 'contrib/libstdc++/stl/stl_multimap.h')
| -rw-r--r-- | contrib/libstdc++/stl/stl_multimap.h | 220 |
1 files changed, 119 insertions, 101 deletions
diff --git a/contrib/libstdc++/stl/stl_multimap.h b/contrib/libstdc++/stl/stl_multimap.h index b82159b..b7d3b87 100644 --- a/contrib/libstdc++/stl/stl_multimap.h +++ b/contrib/libstdc++/stl/stl_multimap.h @@ -35,143 +35,160 @@ __STL_BEGIN_NAMESPACE #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) #pragma set woff 1174 +#pragma set woff 1375 #endif #ifndef __STL_LIMITED_DEFAULT_TEMPLATES -template <class Key, class T, class Compare = less<Key>, class Alloc = alloc> +template <class _Key, class _Tp, class _Compare = less<_Key>, + class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) > #else -template <class Key, class T, class Compare, class Alloc = alloc> +template <class _Key, class _Tp, class _Compare, + class _Alloc = __STL_DEFAULT_ALLOCATOR(_Tp) > #endif class multimap { public: // typedefs: - typedef Key key_type; - typedef T data_type; - typedef T mapped_type; - typedef pair<const Key, T> value_type; - typedef Compare key_compare; + typedef _Key key_type; + typedef _Tp data_type; + typedef _Tp mapped_type; + typedef pair<const _Key, _Tp> value_type; + typedef _Compare key_compare; class value_compare : public binary_function<value_type, value_type, bool> { - friend class multimap<Key, T, Compare, Alloc>; + friend class multimap<_Key,_Tp,_Compare,_Alloc>; protected: - Compare comp; - value_compare(Compare c) : comp(c) {} + _Compare _M_comp; + value_compare(_Compare __c) : _M_comp(__c) {} public: - bool operator()(const value_type& x, const value_type& y) const { - return comp(x.first, y.first); + bool operator()(const value_type& __x, const value_type& __y) const { + return _M_comp(__x.first, __y.first); } }; private: - typedef rb_tree<key_type, value_type, - select1st<value_type>, key_compare, Alloc> rep_type; - rep_type t; // red-black tree representing multimap + typedef _Rb_tree<key_type, value_type, + _Select1st<value_type>, key_compare, _Alloc> _Rep_type; + _Rep_type _M_t; // red-black tree representing multimap public: - typedef typename rep_type::pointer pointer; - typedef typename rep_type::const_pointer const_pointer; - typedef typename rep_type::reference reference; - typedef typename rep_type::const_reference const_reference; - typedef typename rep_type::iterator iterator; - typedef typename rep_type::const_iterator const_iterator; - typedef typename rep_type::reverse_iterator reverse_iterator; - typedef typename rep_type::const_reverse_iterator const_reverse_iterator; - typedef typename rep_type::size_type size_type; - typedef typename rep_type::difference_type difference_type; + typedef typename _Rep_type::pointer pointer; + typedef typename _Rep_type::const_pointer const_pointer; + typedef typename _Rep_type::reference reference; + typedef typename _Rep_type::const_reference const_reference; + typedef typename _Rep_type::iterator iterator; + typedef typename _Rep_type::const_iterator const_iterator; + typedef typename _Rep_type::reverse_iterator reverse_iterator; + typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator; + typedef typename _Rep_type::size_type size_type; + typedef typename _Rep_type::difference_type difference_type; + typedef typename _Rep_type::allocator_type allocator_type; // allocation/deallocation - multimap() : t(Compare()) { } - explicit multimap(const Compare& comp) : t(comp) { } + multimap() : _M_t(_Compare(), allocator_type()) { } + explicit multimap(const _Compare& __comp, + const allocator_type& __a = allocator_type()) + : _M_t(__comp, __a) { } #ifdef __STL_MEMBER_TEMPLATES - template <class InputIterator> - multimap(InputIterator first, InputIterator last) - : t(Compare()) { t.insert_equal(first, last); } - - template <class InputIterator> - multimap(InputIterator first, InputIterator last, const Compare& comp) - : t(comp) { t.insert_equal(first, last); } + template <class _InputIterator> + multimap(_InputIterator __first, _InputIterator __last) + : _M_t(_Compare(), allocator_type()) + { _M_t.insert_equal(__first, __last); } + + template <class _InputIterator> + multimap(_InputIterator __first, _InputIterator __last, + const _Compare& __comp, + const allocator_type& __a = allocator_type()) + : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); } #else - multimap(const value_type* first, const value_type* last) - : t(Compare()) { t.insert_equal(first, last); } - multimap(const value_type* first, const value_type* last, - const Compare& comp) - : t(comp) { t.insert_equal(first, last); } - - multimap(const_iterator first, const_iterator last) - : t(Compare()) { t.insert_equal(first, last); } - multimap(const_iterator first, const_iterator last, const Compare& comp) - : t(comp) { t.insert_equal(first, last); } + multimap(const value_type* __first, const value_type* __last) + : _M_t(_Compare(), allocator_type()) + { _M_t.insert_equal(__first, __last); } + multimap(const value_type* __first, const value_type* __last, + const _Compare& __comp, + const allocator_type& __a = allocator_type()) + : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); } + + multimap(const_iterator __first, const_iterator __last) + : _M_t(_Compare(), allocator_type()) + { _M_t.insert_equal(__first, __last); } + multimap(const_iterator __first, const_iterator __last, + const _Compare& __comp, + const allocator_type& __a = allocator_type()) + : _M_t(__comp, __a) { _M_t.insert_equal(__first, __last); } #endif /* __STL_MEMBER_TEMPLATES */ - multimap(const multimap<Key, T, Compare, Alloc>& x) : t(x.t) { } - multimap<Key, T, Compare, Alloc>& - operator=(const multimap<Key, T, Compare, Alloc>& x) { - t = x.t; + multimap(const multimap<_Key,_Tp,_Compare,_Alloc>& __x) : _M_t(__x._M_t) { } + multimap<_Key,_Tp,_Compare,_Alloc>& + operator=(const multimap<_Key,_Tp,_Compare,_Alloc>& __x) { + _M_t = __x._M_t; return *this; } // accessors: - key_compare key_comp() const { return t.key_comp(); } - value_compare value_comp() const { return value_compare(t.key_comp()); } - iterator begin() { return t.begin(); } - const_iterator begin() const { return t.begin(); } - iterator end() { return t.end(); } - const_iterator end() const { return t.end(); } - reverse_iterator rbegin() { return t.rbegin(); } - const_reverse_iterator rbegin() const { return t.rbegin(); } - reverse_iterator rend() { return t.rend(); } - const_reverse_iterator rend() const { return t.rend(); } - bool empty() const { return t.empty(); } - size_type size() const { return t.size(); } - size_type max_size() const { return t.max_size(); } - void swap(multimap<Key, T, Compare, Alloc>& x) { t.swap(x.t); } + key_compare key_comp() const { return _M_t.key_comp(); } + value_compare value_comp() const { return value_compare(_M_t.key_comp()); } + allocator_type get_allocator() const { return _M_t.get_allocator(); } + + iterator begin() { return _M_t.begin(); } + const_iterator begin() const { return _M_t.begin(); } + iterator end() { return _M_t.end(); } + const_iterator end() const { return _M_t.end(); } + reverse_iterator rbegin() { return _M_t.rbegin(); } + const_reverse_iterator rbegin() const { return _M_t.rbegin(); } + reverse_iterator rend() { return _M_t.rend(); } + const_reverse_iterator rend() const { return _M_t.rend(); } + bool empty() const { return _M_t.empty(); } + size_type size() const { return _M_t.size(); } + size_type max_size() const { return _M_t.max_size(); } + void swap(multimap<_Key,_Tp,_Compare,_Alloc>& __x) { _M_t.swap(__x._M_t); } // insert/erase - iterator insert(const value_type& x) { return t.insert_equal(x); } - iterator insert(iterator position, const value_type& x) { - return t.insert_equal(position, x); + iterator insert(const value_type& __x) { return _M_t.insert_equal(__x); } + iterator insert(iterator __position, const value_type& __x) { + return _M_t.insert_equal(__position, __x); } #ifdef __STL_MEMBER_TEMPLATES - template <class InputIterator> - void insert(InputIterator first, InputIterator last) { - t.insert_equal(first, last); + template <class _InputIterator> + void insert(_InputIterator __first, _InputIterator __last) { + _M_t.insert_equal(__first, __last); } #else - void insert(const value_type* first, const value_type* last) { - t.insert_equal(first, last); + void insert(const value_type* __first, const value_type* __last) { + _M_t.insert_equal(__first, __last); } - void insert(const_iterator first, const_iterator last) { - t.insert_equal(first, last); + void insert(const_iterator __first, const_iterator __last) { + _M_t.insert_equal(__first, __last); } #endif /* __STL_MEMBER_TEMPLATES */ - void erase(iterator position) { t.erase(position); } - size_type erase(const key_type& x) { return t.erase(x); } - void erase(iterator first, iterator last) { t.erase(first, last); } - void clear() { t.clear(); } + void erase(iterator __position) { _M_t.erase(__position); } + size_type erase(const key_type& __x) { return _M_t.erase(__x); } + void erase(iterator __first, iterator __last) + { _M_t.erase(__first, __last); } + void clear() { _M_t.clear(); } // multimap operations: - iterator find(const key_type& x) { return t.find(x); } - const_iterator find(const key_type& x) const { return t.find(x); } - size_type count(const key_type& x) const { return t.count(x); } - iterator lower_bound(const key_type& x) {return t.lower_bound(x); } - const_iterator lower_bound(const key_type& x) const { - return t.lower_bound(x); + iterator find(const key_type& __x) { return _M_t.find(__x); } + const_iterator find(const key_type& __x) const { return _M_t.find(__x); } + size_type count(const key_type& __x) const { return _M_t.count(__x); } + iterator lower_bound(const key_type& __x) {return _M_t.lower_bound(__x); } + const_iterator lower_bound(const key_type& __x) const { + return _M_t.lower_bound(__x); } - iterator upper_bound(const key_type& x) {return t.upper_bound(x); } - const_iterator upper_bound(const key_type& x) const { - return t.upper_bound(x); + iterator upper_bound(const key_type& __x) {return _M_t.upper_bound(__x); } + const_iterator upper_bound(const key_type& __x) const { + return _M_t.upper_bound(__x); } - pair<iterator,iterator> equal_range(const key_type& x) { - return t.equal_range(x); + pair<iterator,iterator> equal_range(const key_type& __x) { + return _M_t.equal_range(__x); } - pair<const_iterator,const_iterator> equal_range(const key_type& x) const { - return t.equal_range(x); + pair<const_iterator,const_iterator> equal_range(const key_type& __x) const { + return _M_t.equal_range(__x); } friend bool operator== __STL_NULL_TMPL_ARGS (const multimap&, const multimap&); @@ -179,30 +196,31 @@ public: const multimap&); }; -template <class Key, class T, class Compare, class Alloc> -inline bool operator==(const multimap<Key, T, Compare, Alloc>& x, - const multimap<Key, T, Compare, Alloc>& y) { - return x.t == y.t; +template <class _Key, class _Tp, class _Compare, class _Alloc> +inline bool operator==(const multimap<_Key,_Tp,_Compare,_Alloc>& __x, + const multimap<_Key,_Tp,_Compare,_Alloc>& __y) { + return __x._M_t == __y._M_t; } -template <class Key, class T, class Compare, class Alloc> -inline bool operator<(const multimap<Key, T, Compare, Alloc>& x, - const multimap<Key, T, Compare, Alloc>& y) { - return x.t < y.t; +template <class _Key, class _Tp, class _Compare, class _Alloc> +inline bool operator<(const multimap<_Key,_Tp,_Compare,_Alloc>& __x, + const multimap<_Key,_Tp,_Compare,_Alloc>& __y) { + return __x._M_t < __y._M_t; } #ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER -template <class Key, class T, class Compare, class Alloc> -inline void swap(multimap<Key, T, Compare, Alloc>& x, - multimap<Key, T, Compare, Alloc>& y) { - x.swap(y); +template <class _Key, class _Tp, class _Compare, class _Alloc> +inline void swap(multimap<_Key,_Tp,_Compare,_Alloc>& __x, + multimap<_Key,_Tp,_Compare,_Alloc>& __y) { + __x.swap(__y); } #endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */ #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) #pragma reset woff 1174 +#pragma reset woff 1375 #endif __STL_END_NAMESPACE |
