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

Subversion Repositories altor32

[/] [altor32/] [trunk/] [gcc-x64/] [or1knd-elf/] [or1knd-elf/] [include/] [c++/] [4.8.0/] [profile/] [deque] - Blame information for rev 35

Details | Compare with Previous | View Log


// Profiling deque implementation -*- C++ -*-
 
// Copyright (C) 2009-2012 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) { }
 
#if __cplusplus >= 201103L
      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
 
#if __cplusplus >= 201103L
      template
               typename = std::_RequireInputIter<_InputIterator>>
#else
      template
#endif
        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) { }
 
#if __cplusplus >= 201103L
      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;
      }
 
#if __cplusplus >= 201103L
      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
 
#if __cplusplus >= 201103L
      template
               typename = std::_RequireInputIter<_InputIterator>>
#else
      template
#endif
        void
        assign(_InputIterator __first, _InputIterator __last)
        {
          _Base::assign(__first, __last);
        }
 
      void
      assign(size_type __n, const _Tp& __t)
      {
        _Base::assign(__n, __t);
      }
 
#if __cplusplus >= 201103L
      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()); }
 
#if __cplusplus >= 201103L
      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;
 
#if __cplusplus >= 201103L
      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
 
#if __cplusplus >= 201103L
      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);
      }
 
#if __cplusplus >= 201103L
      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);
      }
 
#if __cplusplus >= 201103L
      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);
      }
 
#if __cplusplus >= 201103L
      template
               typename = std::_RequireInputIter<_InputIterator>>
#else
      template
#endif
        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 altor32

[/] [altor32/] [trunk/] [gcc-x64/] [or1knd-elf/] [or1knd-elf/] [include/] [c++/] [4.8.0/] [profile/] [deque] - Blame information for rev 35

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