URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libstdc++-v3/] [include/] [profile/] [deque] - Blame information for rev 775

Go to most recent revision | Details | Compare with Previous | View Log


// Profiling deque implementation -*- C++ -*-
 
// Copyright (C) 2009, 2010, 2011 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
 
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
 
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
 
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// .
 
/** @file profile/deque
 *  This file is a GNU profile extension to the Standard C++ Library.
 */
 
#ifndef _GLIBCXX_PROFILE_DEQUE
#define _GLIBCXX_PROFILE_DEQUE 1
 
#include 
 
namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __profile
{
  /// Class std::deque wrapper with performance instrumentation.
  template >
    class deque
    : public _GLIBCXX_STD_C::deque<_Tp, _Allocator>
    {
      typedef  _GLIBCXX_STD_C::deque<_Tp, _Allocator> _Base;
 
    public:
      typedef typename _Base::reference             reference;
      typedef typename _Base::const_reference       const_reference;
 
      typedef typename _Base::iterator             iterator;
      typedef typename _Base::const_iterator       const_iterator;
      typedef typename _Base::reverse_iterator     reverse_iterator;
      typedef typename _Base::const_reverse_iterator const_reverse_iterator;
 
      typedef typename _Base::size_type             size_type;
      typedef typename _Base::difference_type       difference_type;
 
      typedef _Tp                                   value_type;
      typedef _Allocator                            allocator_type;
      typedef typename _Base::pointer               pointer;
      typedef typename _Base::const_pointer         const_pointer;
 
      // 23.2.1.1 construct/copy/destroy:
      explicit
      deque(const _Allocator& __a = _Allocator())
      : _Base(__a) { }
 
#ifdef __GXX_EXPERIMENTAL_CXX0X__
      explicit
      deque(size_type __n)
      : _Base(__n) { }
 
      deque(size_type __n, const _Tp& __value,
            const _Allocator& __a = _Allocator())
      : _Base(__n, __value, __a) { }
#else
      explicit
      deque(size_type __n, const _Tp& __value = _Tp(),
            const _Allocator& __a = _Allocator())
      : _Base(__n, __value, __a) { }
#endif
 
      template
        deque(_InputIterator __first, _InputIterator __last,
              const _Allocator& __a = _Allocator())
        : _Base(__first, __last, __a)
        { }
 
      deque(const deque& __x)
      : _Base(__x) { }
 
      deque(const _Base& __x)
      : _Base(__x) { }
 
#ifdef __GXX_EXPERIMENTAL_CXX0X__
      deque(deque&& __x)
      : _Base(std::move(__x))
      { }
 
      deque(initializer_list __l,
            const allocator_type& __a = allocator_type())
      : _Base(__l, __a) { }
#endif
 
      ~deque() _GLIBCXX_NOEXCEPT { }
 
      deque&
      operator=(const deque& __x)
      {
        *static_cast<_Base*>(this) = __x;
        return *this;
      }
 
#ifdef __GXX_EXPERIMENTAL_CXX0X__
      deque&
      operator=(deque&& __x)
      {
        // NB: DR 1204.
        // NB: DR 675.
        this->clear();
        this->swap(__x);
        return *this;
      }
 
      deque&
      operator=(initializer_list __l)
      {
        *static_cast<_Base*>(this) = __l;
        return *this;
      }
#endif
 
      template
        void
        assign(_InputIterator __first, _InputIterator __last)
        {
          _Base::assign(__first, __last);
        }
 
      void
      assign(size_type __n, const _Tp& __t)
      {
        _Base::assign(__n, __t);
      }
 
#ifdef __GXX_EXPERIMENTAL_CXX0X__
      void
      assign(initializer_list __l)
      {
        _Base::assign(__l);
      }
#endif
 
      using _Base::get_allocator;
 
      // iterators:
      iterator
      begin() _GLIBCXX_NOEXCEPT
      { return iterator(_Base::begin()); }
 
      const_iterator
      begin() const _GLIBCXX_NOEXCEPT
      { return const_iterator(_Base::begin()); }
 
      iterator
      end() _GLIBCXX_NOEXCEPT
      { return iterator(_Base::end()); }
 
      const_iterator
      end() const _GLIBCXX_NOEXCEPT
      { return const_iterator(_Base::end()); }
 
      reverse_iterator
      rbegin() _GLIBCXX_NOEXCEPT
      { return reverse_iterator(end()); }
 
      const_reverse_iterator
      rbegin() const _GLIBCXX_NOEXCEPT
      { return const_reverse_iterator(end()); }
 
      reverse_iterator
      rend() _GLIBCXX_NOEXCEPT
      { return reverse_iterator(begin()); }
 
      const_reverse_iterator
      rend() const _GLIBCXX_NOEXCEPT
      { return const_reverse_iterator(begin()); }
 
#ifdef __GXX_EXPERIMENTAL_CXX0X__
      const_iterator
      cbegin() const noexcept
      { return const_iterator(_Base::begin()); }
 
      const_iterator
      cend() const noexcept
      { return const_iterator(_Base::end()); }
 
      const_reverse_iterator
      crbegin() const noexcept
      { return const_reverse_iterator(end()); }
 
      const_reverse_iterator
      crend() const noexcept
      { return const_reverse_iterator(begin()); }
#endif
 
      // 23.2.1.2 capacity:
      using _Base::size;
      using _Base::max_size;
 
#ifdef __GXX_EXPERIMENTAL_CXX0X__
      void
      resize(size_type __sz)
      {
        _Base::resize(__sz);
      }
 
      void
      resize(size_type __sz, const _Tp& __c)
      {
        _Base::resize(__sz, __c);
      }
#else
      void
      resize(size_type __sz, _Tp __c = _Tp())
      {
        _Base::resize(__sz, __c);
      }
#endif
 
#ifdef __GXX_EXPERIMENTAL_CXX0X__
      using _Base::shrink_to_fit;
#endif
 
      using _Base::empty;
 
      // element access:
      reference
      operator[](size_type __n)
      {
        return _M_base()[__n];
      }
 
      const_reference
      operator[](size_type __n) const
      {
        return _M_base()[__n];
      }
 
      using _Base::at;
 
      reference
      front()
      {
        return _Base::front();
      }
 
      const_reference
      front() const
      {
        return _Base::front();
      }
 
      reference
      back()
      {
        return _Base::back();
      }
 
      const_reference
      back() const
      {
        return _Base::back();
      }
 
      // 23.2.1.3 modifiers:
      void
      push_front(const _Tp& __x)
      {
        _Base::push_front(__x);
      }
 
      void
      push_back(const _Tp& __x)
      {
        _Base::push_back(__x);
      }
 
#ifdef __GXX_EXPERIMENTAL_CXX0X__
      void
      push_front(_Tp&& __x)
      { emplace_front(std::move(__x)); }
 
      void
      push_back(_Tp&& __x)
      { emplace_back(std::move(__x)); }
 
      template
        void
        emplace_front(_Args&&... __args)
        {
          _Base::emplace_front(std::forward<_Args>(__args)...);
        }
 
      template
        void
        emplace_back(_Args&&... __args)
        {
          _Base::emplace_back(std::forward<_Args>(__args)...);
        }
 
      template
        iterator
        emplace(iterator __position, _Args&&... __args)
        {
          typename _Base::iterator __res = _Base::emplace(__position,
                                            std::forward<_Args>(__args)...);
          return iterator(__res);
        }
#endif
 
      iterator
      insert(iterator __position, const _Tp& __x)
      {
        typename _Base::iterator __res = _Base::insert(__position, __x);
        return iterator(__res);
      }
 
#ifdef __GXX_EXPERIMENTAL_CXX0X__
      iterator
      insert(iterator __position, _Tp&& __x)
      { return emplace(__position, std::move(__x)); }
 
      void
      insert(iterator __p, initializer_list __l)
      {
        _Base::insert(__p, __l);
      }
#endif
 
      void
      insert(iterator __position, size_type __n, const _Tp& __x)
      {
        _Base::insert(__position, __n, __x);
      }
 
      template
        void
        insert(iterator __position,
               _InputIterator __first, _InputIterator __last)
        {
          _Base::insert(__position, __first, __last);
        }
 
      void
      pop_front()
      {
        _Base::pop_front();
      }
 
      void
      pop_back()
      {
        _Base::pop_back();
      }
 
      iterator
      erase(iterator __position)
      {
        if (__position == begin() || __position == end()-1)
          {
            return iterator(_Base::erase(__position));
          }
        else
          {
            typename _Base::iterator __res = _Base::erase(__position);
            return iterator(__res);
          }
      }
 
      iterator
      erase(iterator __first, iterator __last)
      {
        // _GLIBCXX_RESOLVE_LIB_DEFECTS
        // 151. can't currently clear() empty container
        return iterator(_Base::erase(__first, __last));
      }
 
      void
      swap(deque& __x)
      {
        _Base::swap(__x);
      }
 
      void
      clear() _GLIBCXX_NOEXCEPT
      {
        _Base::clear();
      }
 
      _Base&
      _M_base() _GLIBCXX_NOEXCEPT       { return *this; }
 
      const _Base&
      _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
    };
 
  template
    inline bool
    operator==(const deque<_Tp, _Alloc>& __lhs,
               const deque<_Tp, _Alloc>& __rhs)
    { return __lhs._M_base() == __rhs._M_base(); }
 
  template
    inline bool
    operator!=(const deque<_Tp, _Alloc>& __lhs,
               const deque<_Tp, _Alloc>& __rhs)
    { return __lhs._M_base() != __rhs._M_base(); }
 
  template
    inline bool
    operator<(const deque<_Tp, _Alloc>& __lhs,
              const deque<_Tp, _Alloc>& __rhs)
    { return __lhs._M_base() < __rhs._M_base(); }
 
  template
    inline bool
    operator<=(const deque<_Tp, _Alloc>& __lhs,
               const deque<_Tp, _Alloc>& __rhs)
    { return __lhs._M_base() <= __rhs._M_base(); }
 
  template
    inline bool
    operator>=(const deque<_Tp, _Alloc>& __lhs,
               const deque<_Tp, _Alloc>& __rhs)
    { return __lhs._M_base() >= __rhs._M_base(); }
 
  template
    inline bool
    operator>(const deque<_Tp, _Alloc>& __lhs,
              const deque<_Tp, _Alloc>& __rhs)
    { return __lhs._M_base() > __rhs._M_base(); }
 
  template
    inline void
    swap(deque<_Tp, _Alloc>& __lhs, deque<_Tp, _Alloc>& __rhs)
    { __lhs.swap(__rhs); }
 
} // namespace __profile
} // namespace std
 
#endif

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libstdc++-v3/] [include/] [profile/] [deque] - Blame information for rev 775

Line No.	Rev	Author	Line
1	742	jeremybenn	`// Profiling deque implementation -- C++ --`
2
3			`// Copyright (C) 2009, 2010, 2011 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			`// .`
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`
33
34			`namespace std _GLIBCXX_VISIBILITY(default)`
35			`{`
36			`namespace __profile`
37			`{`
38			`/// Class std::deque wrapper with performance instrumentation.`
39			`template >`
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::reference reference;`
47			`typedef typename _Base::const_reference const_reference;`
48
49			`typedef typename _Base::iterator iterator;`
50			`typedef typename _Base::const_iterator const_iterator;`
51			`typedef typename _Base::reverse_iterator reverse_iterator;`
52			`typedef typename _Base::const_reverse_iterator const_reverse_iterator;`
53
54			`typedef typename _Base::size_type size_type;`
55			`typedef typename _Base::difference_type difference_type;`
56
57			`typedef _Tp value_type;`
58			`typedef _Allocator allocator_type;`
59			`typedef typename _Base::pointer pointer;`
60			`typedef typename _Base::const_pointer const_pointer;`
61
62			`// 23.2.1.1 construct/copy/destroy:`
63			`explicit`
64			`deque(const _Allocator& __a = _Allocator())`
65			`: _Base(__a) { }`
66
67			`#ifdef __GXX_EXPERIMENTAL_CXX0X__`
68			`explicit`
69			`deque(size_type __n)`
70			`: _Base(__n) { }`
71
72			`deque(size_type __n, const _Tp& __value,`
73			`const _Allocator& __a = _Allocator())`
74			`: _Base(__n, __value, __a) { }`
75			`#else`
76			`explicit`
77			`deque(size_type __n, const _Tp& __value = _Tp(),`
78			`const _Allocator& __a = _Allocator())`
79			`: _Base(__n, __value, __a) { }`
80			`#endif`
81
82			`template`
83			`deque(_InputIterator __first, _InputIterator __last,`
84			`const _Allocator& __a = _Allocator())`
85			`: _Base(__first, __last, __a)`
86			`{ }`
87
88			`deque(const deque& __x)`
89			`: _Base(__x) { }`
90
91			`deque(const _Base& __x)`
92			`: _Base(__x) { }`
93
94			`#ifdef __GXX_EXPERIMENTAL_CXX0X__`
95			`deque(deque&& __x)`
96			`: _Base(std::move(__x))`
97			`{ }`
98
99			`deque(initializer_list __l,`
100			`const allocator_type& __a = allocator_type())`
101			`: _Base(__l, __a) { }`
102			`#endif`
103
104			`~deque() _GLIBCXX_NOEXCEPT { }`
105
106			`deque&`
107			`operator=(const deque& __x)`
108			`{`
109			`static_cast<_Base>(this) = __x;`
110			`return *this;`
111			`}`
112
113			`#ifdef __GXX_EXPERIMENTAL_CXX0X__`
114			`deque&`
115			`operator=(deque&& __x)`
116			`{`
117			`// NB: DR 1204.`
118			`// NB: DR 675.`
119			`this->clear();`
120			`this->swap(__x);`
121			`return *this;`
122			`}`
123
124			`deque&`
125			`operator=(initializer_list __l)`
126			`{`
127			`static_cast<_Base>(this) = __l;`
128			`return *this;`
129			`}`
130			`#endif`
131
132			`template`
133			`void`
134			`assign(_InputIterator __first, _InputIterator __last)`
135			`{`
136			`_Base::assign(__first, __last);`
137			`}`
138
139			`void`
140			`assign(size_type __n, const _Tp& __t)`
141			`{`
142			`_Base::assign(__n, __t);`
143			`}`
144
145			`#ifdef __GXX_EXPERIMENTAL_CXX0X__`
146			`void`
147			`assign(initializer_list __l)`
148			`{`
149			`_Base::assign(__l);`
150			`}`
151			`#endif`
152
153			`using _Base::get_allocator;`
154
155			`// iterators:`
156			`iterator`
157			`begin() _GLIBCXX_NOEXCEPT`
158			`{ return iterator(_Base::begin()); }`
159
160			`const_iterator`
161			`begin() const _GLIBCXX_NOEXCEPT`
162			`{ return const_iterator(_Base::begin()); }`
163
164			`iterator`
165			`end() _GLIBCXX_NOEXCEPT`
166			`{ return iterator(_Base::end()); }`
167
168			`const_iterator`
169			`end() const _GLIBCXX_NOEXCEPT`
170			`{ return const_iterator(_Base::end()); }`
171
172			`reverse_iterator`
173			`rbegin() _GLIBCXX_NOEXCEPT`
174			`{ return reverse_iterator(end()); }`
175
176			`const_reverse_iterator`
177			`rbegin() const _GLIBCXX_NOEXCEPT`
178			`{ return const_reverse_iterator(end()); }`
179
180			`reverse_iterator`
181			`rend() _GLIBCXX_NOEXCEPT`
182			`{ return reverse_iterator(begin()); }`
183
184			`const_reverse_iterator`
185			`rend() const _GLIBCXX_NOEXCEPT`
186			`{ return const_reverse_iterator(begin()); }`
187
188			`#ifdef __GXX_EXPERIMENTAL_CXX0X__`
189			`const_iterator`
190			`cbegin() const noexcept`
191			`{ return const_iterator(_Base::begin()); }`
192
193			`const_iterator`
194			`cend() const noexcept`
195			`{ return const_iterator(_Base::end()); }`
196
197			`const_reverse_iterator`
198			`crbegin() const noexcept`
199			`{ return const_reverse_iterator(end()); }`
200
201			`const_reverse_iterator`
202			`crend() const noexcept`
203			`{ return const_reverse_iterator(begin()); }`
204			`#endif`
205
206			`// 23.2.1.2 capacity:`
207			`using _Base::size;`
208			`using _Base::max_size;`
209
210			`#ifdef __GXX_EXPERIMENTAL_CXX0X__`
211			`void`
212			`resize(size_type __sz)`
213			`{`
214			`_Base::resize(__sz);`
215			`}`
216
217			`void`
218			`resize(size_type __sz, const _Tp& __c)`
219			`{`
220			`_Base::resize(__sz, __c);`
221			`}`
222			`#else`
223			`void`
224			`resize(size_type __sz, _Tp __c = _Tp())`
225			`{`
226			`_Base::resize(__sz, __c);`
227			`}`
228			`#endif`
229
230			`#ifdef __GXX_EXPERIMENTAL_CXX0X__`
231			`using _Base::shrink_to_fit;`
232			`#endif`
233
234			`using _Base::empty;`
235
236			`// element access:`
237			`reference`
238			`operator[](size_type __n)`
239			`{`
240			`return _M_base()[__n];`
241			`}`
242
243			`const_reference`
244			`operator[](size_type __n) const`
245			`{`
246			`return _M_base()[__n];`
247			`}`
248
249			`using _Base::at;`
250
251			`reference`
252			`front()`
253			`{`
254			`return _Base::front();`
255			`}`
256
257			`const_reference`
258			`front() const`
259			`{`
260			`return _Base::front();`
261			`}`
262
263			`reference`
264			`back()`
265			`{`
266			`return _Base::back();`
267			`}`
268
269			`const_reference`
270			`back() const`
271			`{`
272			`return _Base::back();`
273			`}`
274
275			`// 23.2.1.3 modifiers:`
276			`void`
277			`push_front(const _Tp& __x)`
278			`{`
279			`_Base::push_front(__x);`
280			`}`
281
282			`void`
283			`push_back(const _Tp& __x)`
284			`{`
285			`_Base::push_back(__x);`
286			`}`
287
288			`#ifdef __GXX_EXPERIMENTAL_CXX0X__`
289			`void`
290			`push_front(_Tp&& __x)`
291			`{ emplace_front(std::move(__x)); }`
292
293			`void`
294			`push_back(_Tp&& __x)`
295			`{ emplace_back(std::move(__x)); }`
296
297			`template`
298			`void`
299			`emplace_front(_Args&&... __args)`
300			`{`
301			`_Base::emplace_front(std::forward<_Args>(__args)...);`
302			`}`
303
304			`template`
305			`void`
306			`emplace_back(_Args&&... __args)`
307			`{`
308			`_Base::emplace_back(std::forward<_Args>(__args)...);`
309			`}`
310
311			`template`
312			`iterator`
313			`emplace(iterator __position, _Args&&... __args)`
314			`{`
315			`typename _Base::iterator __res = _Base::emplace(__position,`
316			`std::forward<_Args>(__args)...);`
317			`return iterator(__res);`
318			`}`
319			`#endif`
320
321			`iterator`
322			`insert(iterator __position, const _Tp& __x)`
323			`{`
324			`typename _Base::iterator __res = _Base::insert(__position, __x);`
325			`return iterator(__res);`
326			`}`
327
328			`#ifdef __GXX_EXPERIMENTAL_CXX0X__`
329			`iterator`
330			`insert(iterator __position, _Tp&& __x)`
331			`{ return emplace(__position, std::move(__x)); }`
332
333			`void`
334			`insert(iterator __p, initializer_list __l)`
335			`{`
336			`_Base::insert(__p, __l);`
337			`}`
338			`#endif`
339
340			`void`
341			`insert(iterator __position, size_type __n, const _Tp& __x)`
342			`{`
343			`_Base::insert(__position, __n, __x);`
344			`}`
345
346			`template`
347			`void`
348			`insert(iterator __position,`
349			`_InputIterator __first, _InputIterator __last)`
350			`{`
351			`_Base::insert(__position, __first, __last);`
352			`}`
353
354			`void`
355			`pop_front()`
356			`{`
357			`_Base::pop_front();`
358			`}`
359
360			`void`
361			`pop_back()`
362			`{`
363			`_Base::pop_back();`
364			`}`
365
366			`iterator`
367			`erase(iterator __position)`
368			`{`
369			`if (__position == begin() \|\| __position == end()-1)`
370			`{`
371			`return iterator(_Base::erase(__position));`
372			`}`
373			`else`
374			`{`
375			`typename _Base::iterator __res = _Base::erase(__position);`
376			`return iterator(__res);`
377			`}`
378			`}`
379
380			`iterator`
381			`erase(iterator __first, iterator __last)`
382			`{`
383			`// _GLIBCXX_RESOLVE_LIB_DEFECTS`
384			`// 151. can't currently clear() empty container`
385			`return iterator(_Base::erase(__first, __last));`
386			`}`
387
388			`void`
389			`swap(deque& __x)`
390			`{`
391			`_Base::swap(__x);`
392			`}`
393
394			`void`
395			`clear() _GLIBCXX_NOEXCEPT`
396			`{`
397			`_Base::clear();`
398			`}`
399
400			`_Base&`
401			`_M_base() _GLIBCXX_NOEXCEPT { return *this; }`
402
403			`const _Base&`
404			`_M_base() const _GLIBCXX_NOEXCEPT { return *this; }`
405			`};`
406
407			`template`
408			`inline bool`
409			`operator==(const deque<_Tp, _Alloc>& __lhs,`
410			`const deque<_Tp, _Alloc>& __rhs)`
411			`{ return __lhs._M_base() == __rhs._M_base(); }`
412
413			`template`
414			`inline bool`
415			`operator!=(const deque<_Tp, _Alloc>& __lhs,`
416			`const deque<_Tp, _Alloc>& __rhs)`
417			`{ return __lhs._M_base() != __rhs._M_base(); }`
418
419			`template`
420			`inline bool`
421			`operator<(const deque<_Tp, _Alloc>& __lhs,`
422			`const deque<_Tp, _Alloc>& __rhs)`
423			`{ return __lhs._M_base() < __rhs._M_base(); }`
424
425			`template`
426			`inline bool`
427			`operator<=(const deque<_Tp, _Alloc>& __lhs,`
428			`const deque<_Tp, _Alloc>& __rhs)`
429			`{ return __lhs._M_base() <= __rhs._M_base(); }`
430
431			`template`
432			`inline bool`
433			`operator>=(const deque<_Tp, _Alloc>& __lhs,`
434			`const deque<_Tp, _Alloc>& __rhs)`
435			`{ return __lhs._M_base() >= __rhs._M_base(); }`
436
437			`template`
438			`inline bool`
439			`operator>(const deque<_Tp, _Alloc>& __lhs,`
440			`const deque<_Tp, _Alloc>& __rhs)`
441			`{ return __lhs._M_base() > __rhs._M_base(); }`
442
443			`template`
444			`inline void`
445			`swap(deque<_Tp, _Alloc>& __lhs, deque<_Tp, _Alloc>& __rhs)`
446			`{ __lhs.swap(__rhs); }`
447
448			`} // namespace __profile`
449			`} // namespace std`
450
451			`#endif`