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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [libstdc++-v3/] [include/] [profile/] [bitset] - Blame information for rev 855

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


// Profiling bitset 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/bitset
 *  This file is a GNU profile extension to the Standard C++ Library.
 */
 
#ifndef _GLIBCXX_PROFILE_BITSET
#define _GLIBCXX_PROFILE_BITSET
 
#include 
 
namespace std
{
namespace __profile
{
  /// Class std::bitset wrapper with performance instrumentation.
  template
    class bitset
    : public _GLIBCXX_STD_D::bitset<_Nb>
    {
      typedef _GLIBCXX_STD_D::bitset<_Nb> _Base;
 
    public:
      // bit reference:
      class reference
      : private _Base::reference
      {
        typedef typename _Base::reference _Base_ref;
 
        friend class bitset;
        reference();
 
        reference(const _Base_ref& __base, bitset* __seq)
        : _Base_ref(__base)
        { }
 
      public:
        reference(const reference& __x)
        : _Base_ref(__x)
        { }
 
        reference&
        operator=(bool __x)
        {
          *static_cast<_Base_ref*>(this) = __x;
          return *this;
        }
 
        reference&
        operator=(const reference& __x)
        {
          *static_cast<_Base_ref*>(this) = __x;
          return *this;
        }
 
        bool
        operator~() const
        {
          return ~(*static_cast(this));
        }
 
        operator bool() const
        {
          return *static_cast(this);
        }
 
        reference&
        flip()
        {
          _Base_ref::flip();
          return *this;
        }
      };
 
      // 23.3.5.1 constructors:
      bitset() : _Base() { }
 
#ifdef __GXX_EXPERIMENTAL_CXX0X__
      bitset(unsigned long long __val)
#else
      bitset(unsigned long __val)
#endif
      : _Base(__val) { }
 
      template
        explicit
        bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str,
               typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
               __pos = 0,
               typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
               __n = (std::basic_string<_CharT, _Traits, _Alloc>::npos))
        : _Base(__str, __pos, __n) { }
 
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 396. what are characters zero and one.
      template
        bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str,
               typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
               __pos,
               typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
               __n,
               _CharT __zero, _CharT __one = _CharT('1'))
        : _Base(__str, __pos, __n, __zero, __one) { }
 
      bitset(const _Base& __x) : _Base(__x) { }
 
#ifdef __GXX_EXPERIMENTAL_CXX0X__
      explicit
      bitset(const char* __str) : _Base(__str) { }
#endif
 
      // 23.3.5.2 bitset operations:
      bitset<_Nb>&
      operator&=(const bitset<_Nb>& __rhs)
      {
        _M_base() &= __rhs;
        return *this;
      }
 
      bitset<_Nb>&
      operator|=(const bitset<_Nb>& __rhs)
      {
        _M_base() |= __rhs;
        return *this;
      }
 
      bitset<_Nb>&
      operator^=(const bitset<_Nb>& __rhs)
      {
        _M_base() ^= __rhs;
        return *this;
      }
 
      bitset<_Nb>&
      operator<<=(size_t __pos)
      {
        _M_base() <<= __pos;
        return *this;
      }
 
      bitset<_Nb>&
      operator>>=(size_t __pos)
      {
        _M_base() >>= __pos;
        return *this;
      }
 
      bitset<_Nb>&
      set()
      {
        _Base::set();
        return *this;
      }
 
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 186. bitset::set() second parameter should be bool
      bitset<_Nb>&
      set(size_t __pos, bool __val = true)
      {
        _Base::set(__pos, __val);
        return *this;
      }
 
      bitset<_Nb>&
      reset()
      {
        _Base::reset();
        return *this;
      }
 
      bitset<_Nb>&
      reset(size_t __pos)
      {
        _Base::reset(__pos);
        return *this;
      }
 
      bitset<_Nb> operator~() const { return bitset(~_M_base()); }
 
      bitset<_Nb>&
      flip()
      {
        _Base::flip();
        return *this;
      }
 
      bitset<_Nb>&
      flip(size_t __pos)
      {
        _Base::flip(__pos);
        return *this;
      }
 
      // element access:
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 11. Bitset minor problems
      reference
      operator[](size_t __pos)
      {
        return reference(_M_base()[__pos], this);
      }
 
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 11. Bitset minor problems
      bool
      operator[](size_t __pos) const
      {
        return _M_base()[__pos];
      }
 
      using _Base::to_ulong;
#ifdef __GXX_EXPERIMENTAL_CXX0X__
      using _Base::to_ullong;
#endif
 
      template 
        std::basic_string<_CharT, _Traits, _Alloc>
        to_string() const
        { return _M_base().template to_string<_CharT, _Traits, _Alloc>(); }
 
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 396. what are characters zero and one.
      template
        std::basic_string<_CharT, _Traits, _Alloc>
        to_string(_CharT __zero, _CharT __one = _CharT('1')) const
        {
          return _M_base().template
            to_string<_CharT, _Traits, _Alloc>(__zero, __one);
        }
 
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 434. bitset::to_string() hard to use.
      template
        std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
        to_string() const
        { return to_string<_CharT, _Traits, std::allocator<_CharT> >(); }
 
      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 853. to_string needs updating with zero and one.
      template
        std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
        to_string(_CharT __zero, _CharT __one = _CharT('1')) const
        { return to_string<_CharT, _Traits,
                           std::allocator<_CharT> >(__zero, __one); }
 
      template
        std::basic_string<_CharT, std::char_traits<_CharT>,
                          std::allocator<_CharT> >
        to_string() const
        {
          return to_string<_CharT, std::char_traits<_CharT>,
                           std::allocator<_CharT> >();
        }
 
      template
        std::basic_string<_CharT, std::char_traits<_CharT>,
                          std::allocator<_CharT> >
        to_string(_CharT __zero, _CharT __one = _CharT('1')) const
        {
          return to_string<_CharT, std::char_traits<_CharT>,
                           std::allocator<_CharT> >(__zero, __one);
        }
 
      std::basic_string, std::allocator >
      to_string() const
      {
        return to_string,std::allocator >();
      }
 
      std::basic_string, std::allocator >
      to_string(char __zero, char __one = '1') const
      {
        return to_string,
                         std::allocator >(__zero, __one);
      }
 
      using _Base::count;
      using _Base::size;
 
      bool
      operator==(const bitset<_Nb>& __rhs) const
      { return _M_base() == __rhs; }
 
      bool
      operator!=(const bitset<_Nb>& __rhs) const
      { return _M_base() != __rhs; }
 
      using _Base::test;
      using _Base::all;
      using _Base::any;
      using _Base::none;
 
      bitset<_Nb>
      operator<<(size_t __pos) const
      { return bitset<_Nb>(_M_base() << __pos); }
 
      bitset<_Nb>
      operator>>(size_t __pos) const
      { return bitset<_Nb>(_M_base() >> __pos); }
 
      _Base&
      _M_base() { return *this; }
 
      const _Base&
      _M_base() const { return *this; }
    };
 
  template
    bitset<_Nb>
    operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
    { return bitset<_Nb>(__x) &= __y; }
 
  template
    bitset<_Nb>
    operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
    { return bitset<_Nb>(__x) |= __y; }
 
  template
    bitset<_Nb>
    operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
    { return bitset<_Nb>(__x) ^= __y; }
 
  template
    std::basic_istream<_CharT, _Traits>&
    operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x)
    { return __is >> __x._M_base(); }
 
  template
    std::basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
               const bitset<_Nb>& __x)
    { return __os << __x._M_base(); }
} // namespace __profile
 
#ifdef __GXX_EXPERIMENTAL_CXX0X__
  // DR 1182.
  /// std::hash specialization for bitset.
  template
    struct hash<__profile::bitset<_Nb>>
    : public std::unary_function<__profile::bitset<_Nb>, size_t>
    {
      size_t
      operator()(const __profile::bitset<_Nb>& __b) const
      { return std::hash<_GLIBCXX_STD_D::bitset<_Nb>>()(__b._M_base()); }
    };
#endif
 
} // namespace std
 
#endif

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [libstdc++-v3/] [include/] [profile/] [bitset] - Blame information for rev 855

Line No.	Rev	Author	Line
1	424	jeremybenn	`// Profiling bitset 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/bitset`
26			`* This file is a GNU profile extension to the Standard C++ Library.`
27			`*/`
28
29			`#ifndef _GLIBCXX_PROFILE_BITSET`
30			`#define _GLIBCXX_PROFILE_BITSET`
31
32			`#include`
33
34			`namespace std`
35			`{`
36			`namespace __profile`
37			`{`
38			`/// Class std::bitset wrapper with performance instrumentation.`
39			`template`
40			`class bitset`
41			`: public _GLIBCXX_STD_D::bitset<_Nb>`
42			`{`
43			`typedef _GLIBCXX_STD_D::bitset<_Nb> _Base;`
44
45			`public:`
46			`// bit reference:`
47			`class reference`
48			`: private _Base::reference`
49			`{`
50			`typedef typename _Base::reference _Base_ref;`
51
52			`friend class bitset;`
53			`reference();`
54
55			`reference(const _Base_ref& __base, bitset* __seq)`
56			`: _Base_ref(__base)`
57			`{ }`
58
59			`public:`
60			`reference(const reference& __x)`
61			`: _Base_ref(__x)`
62			`{ }`
63
64			`reference&`
65			`operator=(bool __x)`
66			`{`
67			`static_cast<_Base_ref>(this) = __x;`
68			`return *this;`
69			`}`
70
71			`reference&`
72			`operator=(const reference& __x)`
73			`{`
74			`static_cast<_Base_ref>(this) = __x;`
75			`return *this;`
76			`}`
77
78			`bool`
79			`operator~() const`
80			`{`
81			`return ~(*static_cast(this));`
82			`}`
83
84			`operator bool() const`
85			`{`
86			`return *static_cast(this);`
87			`}`
88
89			`reference&`
90			`flip()`
91			`{`
92			`_Base_ref::flip();`
93			`return *this;`
94			`}`
95			`};`
96
97			`// 23.3.5.1 constructors:`
98			`bitset() : _Base() { }`
99
100			`#ifdef __GXX_EXPERIMENTAL_CXX0X__`
101			`bitset(unsigned long long __val)`
102			`#else`
103			`bitset(unsigned long __val)`
104			`#endif`
105			`: _Base(__val) { }`
106
107			`template`
108			`explicit`
109			`bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str,`
110			`typename std::basic_string<_CharT, _Traits, _Alloc>::size_type`
111			`__pos = 0,`
112			`typename std::basic_string<_CharT, _Traits, _Alloc>::size_type`
113			`__n = (std::basic_string<_CharT, _Traits, _Alloc>::npos))`
114			`: _Base(__str, __pos, __n) { }`
115
116			`// _GLIBCXX_RESOLVE_LIB_DEFECTS`
117			`// 396. what are characters zero and one.`
118			`template`
119			`bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str,`
120			`typename std::basic_string<_CharT, _Traits, _Alloc>::size_type`
121			`__pos,`
122			`typename std::basic_string<_CharT, _Traits, _Alloc>::size_type`
123			`__n,`
124			`_CharT __zero, _CharT __one = _CharT('1'))`
125			`: _Base(__str, __pos, __n, __zero, __one) { }`
126
127			`bitset(const _Base& __x) : _Base(__x) { }`
128
129			`#ifdef __GXX_EXPERIMENTAL_CXX0X__`
130			`explicit`
131			`bitset(const char* __str) : _Base(__str) { }`
132			`#endif`
133
134			`// 23.3.5.2 bitset operations:`
135			`bitset<_Nb>&`
136			`operator&=(const bitset<_Nb>& __rhs)`
137			`{`
138			`_M_base() &= __rhs;`
139			`return *this;`
140			`}`
141
142			`bitset<_Nb>&`
143			`operator\|=(const bitset<_Nb>& __rhs)`
144			`{`
145			`_M_base() \|= __rhs;`
146			`return *this;`
147			`}`
148
149			`bitset<_Nb>&`
150			`operator^=(const bitset<_Nb>& __rhs)`
151			`{`
152			`_M_base() ^= __rhs;`
153			`return *this;`
154			`}`
155
156			`bitset<_Nb>&`
157			`operator<<=(size_t __pos)`
158			`{`
159			`_M_base() <<= __pos;`
160			`return *this;`
161			`}`
162
163			`bitset<_Nb>&`
164			`operator>>=(size_t __pos)`
165			`{`
166			`_M_base() >>= __pos;`
167			`return *this;`
168			`}`
169
170			`bitset<_Nb>&`
171			`set()`
172			`{`
173			`_Base::set();`
174			`return *this;`
175			`}`
176
177			`// _GLIBCXX_RESOLVE_LIB_DEFECTS`
178			`// 186. bitset::set() second parameter should be bool`
179			`bitset<_Nb>&`
180			`set(size_t __pos, bool __val = true)`
181			`{`
182			`_Base::set(__pos, __val);`
183			`return *this;`
184			`}`
185
186			`bitset<_Nb>&`
187			`reset()`
188			`{`
189			`_Base::reset();`
190			`return *this;`
191			`}`
192
193			`bitset<_Nb>&`
194			`reset(size_t __pos)`
195			`{`
196			`_Base::reset(__pos);`
197			`return *this;`
198			`}`
199
200			`bitset<_Nb> operator~() const { return bitset(~_M_base()); }`
201
202			`bitset<_Nb>&`
203			`flip()`
204			`{`
205			`_Base::flip();`
206			`return *this;`
207			`}`
208
209			`bitset<_Nb>&`
210			`flip(size_t __pos)`
211			`{`
212			`_Base::flip(__pos);`
213			`return *this;`
214			`}`
215
216			`// element access:`
217			`// _GLIBCXX_RESOLVE_LIB_DEFECTS`
218			`// 11. Bitset minor problems`
219			`reference`
220			`operator[](size_t __pos)`
221			`{`
222			`return reference(_M_base()[__pos], this);`
223			`}`
224
225			`// _GLIBCXX_RESOLVE_LIB_DEFECTS`
226			`// 11. Bitset minor problems`
227			`bool`
228			`operator[](size_t __pos) const`
229			`{`
230			`return _M_base()[__pos];`
231			`}`
232
233			`using _Base::to_ulong;`
234			`#ifdef __GXX_EXPERIMENTAL_CXX0X__`
235			`using _Base::to_ullong;`
236			`#endif`
237
238			`template`
239			`std::basic_string<_CharT, _Traits, _Alloc>`
240			`to_string() const`
241			`{ return _M_base().template to_string<_CharT, _Traits, _Alloc>(); }`
242
243			`// _GLIBCXX_RESOLVE_LIB_DEFECTS`
244			`// 396. what are characters zero and one.`
245			`template`
246			`std::basic_string<_CharT, _Traits, _Alloc>`
247			`to_string(_CharT __zero, _CharT __one = _CharT('1')) const`
248			`{`
249			`return _M_base().template`
250			`to_string<_CharT, _Traits, _Alloc>(__zero, __one);`
251			`}`
252
253			`// _GLIBCXX_RESOLVE_LIB_DEFECTS`
254			`// 434. bitset::to_string() hard to use.`
255			`template`
256			`std::basic_string<_CharT, _Traits, std::allocator<_CharT> >`
257			`to_string() const`
258			`{ return to_string<_CharT, _Traits, std::allocator<_CharT> >(); }`
259
260			`// _GLIBCXX_RESOLVE_LIB_DEFECTS`
261			`// 853. to_string needs updating with zero and one.`
262			`template`
263			`std::basic_string<_CharT, _Traits, std::allocator<_CharT> >`
264			`to_string(_CharT __zero, _CharT __one = _CharT('1')) const`
265			`{ return to_string<_CharT, _Traits,`
266			`std::allocator<_CharT> >(__zero, __one); }`
267
268			`template`
269			`std::basic_string<_CharT, std::char_traits<_CharT>,`
270			`std::allocator<_CharT> >`
271			`to_string() const`
272			`{`
273			`return to_string<_CharT, std::char_traits<_CharT>,`
274			`std::allocator<_CharT> >();`
275			`}`
276
277			`template`
278			`std::basic_string<_CharT, std::char_traits<_CharT>,`
279			`std::allocator<_CharT> >`
280			`to_string(_CharT __zero, _CharT __one = _CharT('1')) const`
281			`{`
282			`return to_string<_CharT, std::char_traits<_CharT>,`
283			`std::allocator<_CharT> >(__zero, __one);`
284			`}`
285
286			`std::basic_string, std::allocator >`
287			`to_string() const`
288			`{`
289			`return to_string,std::allocator >();`
290			`}`
291
292			`std::basic_string, std::allocator >`
293			`to_string(char __zero, char __one = '1') const`
294			`{`
295			`return to_string,`
296			`std::allocator >(__zero, __one);`
297			`}`
298
299			`using _Base::count;`
300			`using _Base::size;`
301
302			`bool`
303			`operator==(const bitset<_Nb>& __rhs) const`
304			`{ return _M_base() == __rhs; }`
305
306			`bool`
307			`operator!=(const bitset<_Nb>& __rhs) const`
308			`{ return _M_base() != __rhs; }`
309
310			`using _Base::test;`
311			`using _Base::all;`
312			`using _Base::any;`
313			`using _Base::none;`
314
315			`bitset<_Nb>`
316			`operator<<(size_t __pos) const`
317			`{ return bitset<_Nb>(_M_base() << __pos); }`
318
319			`bitset<_Nb>`
320			`operator>>(size_t __pos) const`
321			`{ return bitset<_Nb>(_M_base() >> __pos); }`
322
323			`_Base&`
324			`_M_base() { return *this; }`
325
326			`const _Base&`
327			`_M_base() const { return *this; }`
328			`};`
329
330			`template`
331			`bitset<_Nb>`
332			`operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y)`
333			`{ return bitset<_Nb>(__x) &= __y; }`
334
335			`template`
336			`bitset<_Nb>`
337			`operator\|(const bitset<_Nb>& __x, const bitset<_Nb>& __y)`
338			`{ return bitset<_Nb>(__x) \|= __y; }`
339
340			`template`
341			`bitset<_Nb>`
342			`operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y)`
343			`{ return bitset<_Nb>(__x) ^= __y; }`
344
345			`template`
346			`std::basic_istream<_CharT, _Traits>&`
347			`operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x)`
348			`{ return __is >> __x._M_base(); }`
349
350			`template`
351			`std::basic_ostream<_CharT, _Traits>&`
352			`operator<<(std::basic_ostream<_CharT, _Traits>& __os,`
353			`const bitset<_Nb>& __x)`
354			`{ return __os << __x._M_base(); }`
355			`} // namespace __profile`
356
357			`#ifdef __GXX_EXPERIMENTAL_CXX0X__`
358			`// DR 1182.`
359			`/// std::hash specialization for bitset.`
360			`template`
361			`struct hash<__profile::bitset<_Nb>>`
362			`: public std::unary_function<__profile::bitset<_Nb>, size_t>`
363			`{`
364			`size_t`
365			`operator()(const __profile::bitset<_Nb>& __b) const`
366			`{ return std::hash<_GLIBCXX_STD_D::bitset<_Nb>>()(__b._M_base()); }`
367			`};`
368			`#endif`
369
370			`} // namespace std`
371
372			`#endif`