libstdc++-v3/include/profile/deque

   1 // Profiling deque implementation -*- C++ -*-
   2
   3 // Copyright (C) 2009-2018 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the
   7 // terms of the GNU General Public License as published by the
   8 // Free Software Foundation; either version 3, or (at your option)
   9 // any later version.
  10
  11 // This library is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15
  16 // Under Section 7 of GPL version 3, you are granted additional
  17 // permissions described in the GCC Runtime Library Exception, version
  18 // 3.1, as published by the Free Software Foundation.
  19
  20 // You should have received a copy of the GNU General Public License and
  21 // a copy of the GCC Runtime Library Exception along with this program;
  22 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23 // <http://www.gnu.org/licenses/>.
  24
  25 /** @file profile/deque
  26  *  This file is a GNU profile extension to the Standard C++ Library.
  27  */
  28
  29 #ifndef _GLIBCXX_PROFILE_DEQUE
  30 #define _GLIBCXX_PROFILE_DEQUE 1
  31
  32 #include <deque>
  33
  34 namespace std _GLIBCXX_VISIBILITY(default)
  35 {
  36 namespace __profile
  37 {
  38   /// Class std::deque wrapper with performance instrumentation.
  39   template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
  40     class deque
  41     : public _GLIBCXX_STD_C::deque<_Tp, _Allocator>
  42     {
  43       typedef  _GLIBCXX_STD_C::deque<_Tp, _Allocator> _Base;
  44
  45     public:
  46       typedef typename _Base::size_type                 size_type;
  47       typedef typename _Base::value_type                value_type;
  48
  49       // 23.2.1.1 construct/copy/destroy:
  50
  51 #if __cplusplus < 201103L
  52       deque()
  53       : _Base() { }
  54       deque(const deque& __x)
  55       : _Base(__x) { }
  56
  57       ~deque() { }
  58 #else
  59       deque() = default;
  60       deque(const deque&) = default;
  61       deque(deque&&) = default;
  62
  63       deque(const deque& __d, const _Allocator& __a)
  64       : _Base(__d, __a) { }
  65
  66       deque(deque&& __d, const _Allocator& __a)
  67       : _Base(std::move(__d), __a) { }
  68
  69       ~deque() = default;
  70
  71       deque(initializer_list<value_type> __l,
  72             const _Allocator& __a = _Allocator())
  73       : _Base(__l, __a) { }
  74 #endif
  75
  76       explicit
  77       deque(const _Allocator& __a)
  78       : _Base(__a) { }
  79
  80 #if __cplusplus >= 201103L
  81       explicit
  82       deque(size_type __n, const _Allocator& __a = _Allocator())
  83       : _Base(__n, __a) { }
  84
  85       deque(size_type __n, const _Tp& __value,
  86             const _Allocator& __a = _Allocator())
  87       : _Base(__n, __value, __a) { }
  88 #else
  89       explicit
  90       deque(size_type __n, const _Tp& __value = _Tp(),
  91             const _Allocator& __a = _Allocator())
  92       : _Base(__n, __value, __a) { }
  93 #endif
  94
  95 #if __cplusplus >= 201103L
  96       template<typename _InputIterator,
  97                typename = std::_RequireInputIter<_InputIterator>>
  98 #else
  99       template<typename _InputIterator>
 100 #endif
 101         deque(_InputIterator __first, _InputIterator __last,
 102               const _Allocator& __a = _Allocator())
 103         : _Base(__first, __last, __a)
 104         { }
 105
 106       deque(const _Base& __x)
 107       : _Base(__x) { }
 108
 109 #if __cplusplus < 201103L
 110       deque&
 111       operator=(const deque& __x)
 112       {
 113         _M_base() = __x;
 114         return *this;
 115       }
 116 #else
 117       deque&
 118       operator=(const deque&) = default;
 119
 120       deque&
 121       operator=(deque&&) = default;
 122
 123       deque&
 124       operator=(initializer_list<value_type> __l)
 125       {
 126         _M_base() = __l;
 127         return *this;
 128       }
 129 #endif
 130
 131       void
 132       swap(deque& __x)
 133       _GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
 134       { _Base::swap(__x); }
 135
 136       _Base&
 137       _M_base() _GLIBCXX_NOEXCEPT       { return *this; }
 138
 139       const _Base&
 140       _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
 141     };
 142
 143   template<typename _Tp, typename _Alloc>
 144     inline bool
 145     operator==(const deque<_Tp, _Alloc>& __lhs,
 146                const deque<_Tp, _Alloc>& __rhs)
 147     { return __lhs._M_base() == __rhs._M_base(); }
 148
 149   template<typename _Tp, typename _Alloc>
 150     inline bool
 151     operator!=(const deque<_Tp, _Alloc>& __lhs,
 152                const deque<_Tp, _Alloc>& __rhs)
 153     { return __lhs._M_base() != __rhs._M_base(); }
 154
 155   template<typename _Tp, typename _Alloc>
 156     inline bool
 157     operator<(const deque<_Tp, _Alloc>& __lhs,
 158               const deque<_Tp, _Alloc>& __rhs)
 159     { return __lhs._M_base() < __rhs._M_base(); }
 160
 161   template<typename _Tp, typename _Alloc>
 162     inline bool
 163     operator<=(const deque<_Tp, _Alloc>& __lhs,
 164                const deque<_Tp, _Alloc>& __rhs)
 165     { return __lhs._M_base() <= __rhs._M_base(); }
 166
 167   template<typename _Tp, typename _Alloc>
 168     inline bool
 169     operator>=(const deque<_Tp, _Alloc>& __lhs,
 170                const deque<_Tp, _Alloc>& __rhs)
 171     { return __lhs._M_base() >= __rhs._M_base(); }
 172
 173   template<typename _Tp, typename _Alloc>
 174     inline bool
 175     operator>(const deque<_Tp, _Alloc>& __lhs,
 176               const deque<_Tp, _Alloc>& __rhs)
 177     { return __lhs._M_base() > __rhs._M_base(); }
 178
 179   template<typename _Tp, typename _Alloc>
 180     inline void
 181     swap(deque<_Tp, _Alloc>& __lhs, deque<_Tp, _Alloc>& __rhs)
 182     _GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
 183     { __lhs.swap(__rhs); }
 184
 185 } // namespace __profile
 186 } // namespace std
 187
 188 #endif