URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [tags/] [gnu-src/] [gcc-4.5.1/] [gcc-4.5.1-or32-1.0rc3/] [libstdc++-v3/] [include/] [profile/] [deque] - Blame information for rev 516

Details | Compare with Previous | View Log


// Profiling deque implementation -*- C++ -*-
 
// Copyright (C) 2009, 2010 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
{
namespace __profile
{
  /// Class std::deque wrapper with performance instrumentation.
  template >
    class deque
    : public _GLIBCXX_STD_D::deque<_Tp, _Allocator>
    {
      typedef  _GLIBCXX_STD_D::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) { }
 
      explicit deque(size_type __n, const _Tp& __value = _Tp(),
                     const _Allocator& __a = _Allocator())
      : _Base(__n, __value, __a) { }
 
      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::forward(__x))
      { }
 
      deque(initializer_list __l,
            const allocator_type& __a = allocator_type())
      : _Base(__l, __a) { }
#endif
 
      ~deque() { }
 
      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()
      { return iterator(_Base::begin()); }
 
      const_iterator
      begin() const
      { return const_iterator(_Base::begin()); }
 
      iterator
      end()
      { return iterator(_Base::end()); }
 
      const_iterator
      end() const
      { return const_iterator(_Base::end()); }
 
      reverse_iterator
      rbegin()
      { return reverse_iterator(end()); }
 
      const_reverse_iterator
      rbegin() const
      { return const_reverse_iterator(end()); }
 
      reverse_iterator
      rend()
      { return reverse_iterator(begin()); }
 
      const_reverse_iterator
      rend() const
      { return const_reverse_iterator(begin()); }
 
#ifdef __GXX_EXPERIMENTAL_CXX0X__
      const_iterator
      cbegin() const
      { return const_iterator(_Base::begin()); }
 
      const_iterator
      cend() const
      { return const_iterator(_Base::end()); }
 
      const_reverse_iterator
      crbegin() const
      { return const_reverse_iterator(end()); }
 
      const_reverse_iterator
      crend() const
      { return const_reverse_iterator(begin()); }
#endif
 
      // 23.2.1.2 capacity:
      using _Base::size;
      using _Base::max_size;
 
      void
      resize(size_type __sz, _Tp __c = _Tp())
      {
        _Base::resize(__sz, __c);
      }
 
#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()
      {
        _Base::clear();
      }
 
      _Base&
      _M_base()       { return *this; }
 
      const _Base&
      _M_base() const { 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_2011-10-31

[/] [openrisc/] [tags/] [gnu-src/] [gcc-4.5.1/] [gcc-4.5.1-or32-1.0rc3/] [libstdc++-v3/] [include/] [profile/] [deque] - Blame information for rev 516

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