# profile/set.h

Go to the documentation of this file.

    00001 // Profiling set implementation -*- C++ -*-
    00002
    00003 // Copyright (C) 2009, 2010 Free Software Foundation, Inc.
    00004 //
    00005 // This file is part of the GNU ISO C++ Library.  This library is free
    00006 // software; you can redistribute it and/or modify it under the
    00007 // terms of the GNU General Public License as published by the
    00008 // Free Software Foundation; either version 3, or (at your option)
    00009 // any later version.
    00010
    00011 // This library is distributed in the hope that it will be useful,
    00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of
    00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    00014 // GNU General Public License for more details.
    00015
    00016 // Under Section 7 of GPL version 3, you are granted additional
    00017 // permissions described in the GCC Runtime Library Exception, version
    00018 // 3.1, as published by the Free Software Foundation.
    00019
    00020 // You should have received a copy of the GNU General Public License and
    00021 // a copy of the GCC Runtime Library Exception along with this program;
    00022 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
    00023 // <http://www.gnu.org/licenses/>.
    00024
    00025 /** @file profile/set.h
    00026  *  This file is a GNU profile extension to the Standard C++ Library.
    00027  */
    00028
    00029 #ifndef _GLIBCXX_PROFILE_SET_H
    00030 #define _GLIBCXX_PROFILE_SET_H 1
    00031
    00032 #include <utility>
    00033
    00034 namespace std
    00035 {
    00036 namespace __profile
    00037 {
    00038   /// Class std::set wrapper with performance instrumentation.
    00039   template<typename _Key, typename _Compare = std::less<_Key>,
    00040        typename _Allocator = std::allocator<_Key> >
    00041     class set
    00042     : public _GLIBCXX_STD_D::set<_Key,_Compare,_Allocator>
    00043     {
    00044       typedef _GLIBCXX_STD_D::set<_Key, _Compare, _Allocator> _Base;
    00045
    00046     public:
    00047       // types:
    00048       typedef _Key                  key_type;
    00049       typedef _Key                  value_type;
    00050       typedef _Compare                  key_compare;
    00051       typedef _Compare                  value_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       // 23.3.3.1 construct/copy/destroy:
    00067       explicit set(const _Compare& __comp = _Compare(),
    00068            const _Allocator& __a = _Allocator())
    00069       : _Base(__comp, __a) { }
    00070
    00071       template<typename _InputIterator>
    00072         set(_InputIterator __first, _InputIterator __last,
    00073         const _Compare& __comp = _Compare(),
    00074         const _Allocator& __a = _Allocator())
    00075     : _Base(__first, __last, __comp, __a) { }
    00076
    00077       set(const set& __x)
    00078       : _Base(__x) { }
    00079
    00080       set(const _Base& __x)
    00081       : _Base(__x) { }
    00082
    00083 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00084       set(set&& __x)
    00085       : _Base(std::forward<set>(__x))
    00086       { }
    00087
    00088       set(initializer_list<value_type> __l,
    00089       const _Compare& __comp = _Compare(),
    00090       const allocator_type& __a = allocator_type())
    00091       : _Base(__l, __comp, __a) { }
    00092 #endif
    00093
    00094       ~set() { }
    00095
    00096       set&
    00097       operator=(const set& __x)
    00098       {
    00099     *static_cast<_Base*>(this) = __x;
    00100     return *this;
    00101       }
    00102
    00103 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00104       set&
    00105       operator=(set&& __x)
    00106       {
    00107     // NB: DR 1204.
    00108     // NB: DR 675.
    00109     this->clear();
    00110     this->swap(__x);
    00111     return *this;
    00112       }
    00113
    00114       set&
    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       // iterators:
    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       // capacity:
    00177       using _Base::empty;
    00178       using _Base::size;
    00179       using _Base::max_size;
    00180
    00181       // modifiers:
    00182       std::pair<iterator, bool>
    00183       insert(const value_type& __x)
    00184       {
    00185     typedef typename _Base::iterator _Base_iterator;
    00186     std::pair<_Base_iterator, bool> __res = _Base::insert(__x);
    00187     return std::pair<iterator, bool>(iterator(__res.first),
    00188                      __res.second);
    00189       }
    00190
    00191       iterator
    00192       insert(iterator __position, const value_type& __x)
    00193       {
    00194     return iterator(_Base::insert(__position, __x));
    00195       }
    00196
    00197       template <typename _InputIterator>
    00198         void
    00199         insert(_InputIterator __first, _InputIterator __last)
    00200         {
    00201       _Base::insert(__first, __last);
    00202     }
    00203
    00204 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00205       void
    00206       insert(initializer_list<value_type> __l)
    00207       { _Base::insert(__l); }
    00208 #endif
    00209
    00210 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00211       iterator
    00212       erase(iterator __position)
    00213       { return _Base::erase(__position); }
    00214 #else
    00215       void
    00216       erase(iterator __position)
    00217       { _Base::erase(__position); }
    00218 #endif
    00219
    00220       size_type
    00221       erase(const key_type& __x)
    00222       {
    00223     iterator __victim = find(__x);
    00224     if (__victim == end())
    00225           return 0;
    00226     else
    00227         {
    00228       _Base::erase(__victim);
    00229       return 1;
    00230         }
    00231       }
    00232
    00233 #ifdef __GXX_EXPERIMENTAL_CXX0X__
    00234       iterator
    00235       erase(iterator __first, iterator __last)
    00236       {
    00237     // _GLIBCXX_RESOLVE_LIB_DEFECTS
    00238     // 151. can't currently clear() empty container
    00239     while (__first != __last)
    00240       this->erase(__first++);
    00241     return __last;
    00242       }
    00243 #else
    00244       void
    00245       erase(iterator __first, iterator __last)
    00246       {
    00247     // _GLIBCXX_RESOLVE_LIB_DEFECTS
    00248     // 151. can't currently clear() empty container
    00249     while (__first != __last)
    00250       this->erase(__first++);
    00251       }
    00252 #endif
    00253
    00254       void
    00255       swap(set& __x)
    00256       {
    00257     _Base::swap(__x);
    00258       }
    00259
    00260       void
    00261       clear()
    00262       { this->erase(begin(), end()); }
    00263
    00264       // observers:
    00265       using _Base::key_comp;
    00266       using _Base::value_comp;
    00267
    00268       // set operations:
    00269       iterator
    00270       find(const key_type& __x)
    00271       { return iterator(_Base::find(__x)); }
    00272
    00273       // _GLIBCXX_RESOLVE_LIB_DEFECTS
    00274       // 214. set::find() missing const overload
    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       // _GLIBCXX_RESOLVE_LIB_DEFECTS
    00286       // 214. set::find() missing const overload
    00287       const_iterator
    00288       lower_bound(const key_type& __x) const
    00289       { return const_iterator(_Base::lower_bound(__x)); }
    00290
    00291       iterator
    00292       upper_bound(const key_type& __x)
    00293       { return iterator(_Base::upper_bound(__x)); }
    00294
    00295       // _GLIBCXX_RESOLVE_LIB_DEFECTS
    00296       // 214. set::find() missing const overload
    00297       const_iterator
    00298       upper_bound(const key_type& __x) const
    00299       { return const_iterator(_Base::upper_bound(__x)); }
    00300
    00301       std::pair<iterator,iterator>
    00302       equal_range(const key_type& __x)
    00303       {
    00304     typedef typename _Base::iterator _Base_iterator;
    00305     std::pair<_Base_iterator, _Base_iterator> __res =
    00306         _Base::equal_range(__x);
    00307     return std::make_pair(iterator(__res.first),
    00308                   iterator(__res.second));
    00309       }
    00310
    00311       // _GLIBCXX_RESOLVE_LIB_DEFECTS
    00312       // 214. set::find() missing const overload
    00313       std::pair<const_iterator,const_iterator>
    00314       equal_range(const key_type& __x) const
    00315       {
    00316     typedef typename _Base::const_iterator _Base_iterator;
    00317     std::pair<_Base_iterator, _Base_iterator> __res =
    00318         _Base::equal_range(__x);
    00319     return std::make_pair(const_iterator(__res.first),
    00320                   const_iterator(__res.second));
    00321       }
    00322
    00323       _Base&
    00324       _M_base() { return *this; }
    00325
    00326       const _Base&
    00327       _M_base() const { return *this; }
    00328
    00329     };
    00330
    00331   template<typename _Key, typename _Compare, typename _Allocator>
    00332     inline bool
    00333     operator==(const set<_Key, _Compare, _Allocator>& __lhs,
    00334            const set<_Key, _Compare, _Allocator>& __rhs)
    00335     { return __lhs._M_base() == __rhs._M_base(); }
    00336
    00337   template<typename _Key, typename _Compare, typename _Allocator>
    00338     inline bool
    00339     operator!=(const set<_Key, _Compare, _Allocator>& __lhs,
    00340            const set<_Key, _Compare, _Allocator>& __rhs)
    00341     { return __lhs._M_base() != __rhs._M_base(); }
    00342
    00343   template<typename _Key, typename _Compare, typename _Allocator>
    00344     inline bool
    00345     operator<(const set<_Key, _Compare, _Allocator>& __lhs,
    00346           const set<_Key, _Compare, _Allocator>& __rhs)
    00347     { return __lhs._M_base() < __rhs._M_base(); }
    00348
    00349   template<typename _Key, typename _Compare, typename _Allocator>
    00350     inline bool
    00351     operator<=(const set<_Key, _Compare, _Allocator>& __lhs,
    00352            const set<_Key, _Compare, _Allocator>& __rhs)
    00353     { return __lhs._M_base() <= __rhs._M_base(); }
    00354
    00355   template<typename _Key, typename _Compare, typename _Allocator>
    00356     inline bool
    00357     operator>=(const set<_Key, _Compare, _Allocator>& __lhs,
    00358            const set<_Key, _Compare, _Allocator>& __rhs)
    00359     { return __lhs._M_base() >= __rhs._M_base(); }
    00360
    00361   template<typename _Key, typename _Compare, typename _Allocator>
    00362     inline bool
    00363     operator>(const set<_Key, _Compare, _Allocator>& __lhs,
    00364           const set<_Key, _Compare, _Allocator>& __rhs)
    00365     { return __lhs._M_base() > __rhs._M_base(); }
    00366
    00367   template<typename _Key, typename _Compare, typename _Allocator>
    00368     void
    00369     swap(set<_Key, _Compare, _Allocator>& __x,
    00370      set<_Key, _Compare, _Allocator>& __y)
    00371     { return __x.swap(__y); }
    00372
    00373 } // namespace __profile
    00374 } // namespace std
    00375
    00376 #endif