libstdc++-v3/include/profile/bitset

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