contrib/gcc-4.4/libstdc++-v3/include/debug/bitset

   1 // Debugging bitset implementation -*- C++ -*-
   2
   3 // Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
   4 // Free Software Foundation, Inc.
   5 //
   6 // This file is part of the GNU ISO C++ Library.  This library is free
   7 // software; you can redistribute it and/or modify it under the
   8 // terms of the GNU General Public License as published by the
   9 // Free Software Foundation; either version 3, or (at your option)
  10 // any later version.
  11
  12 // This library is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU General Public License for more details.
  16
  17 // Under Section 7 of GPL version 3, you are granted additional
  18 // permissions described in the GCC Runtime Library Exception, version
  19 // 3.1, as published by the Free Software Foundation.
  20
  21 // You should have received a copy of the GNU General Public License and
  22 // a copy of the GCC Runtime Library Exception along with this program;
  23 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  24 // <http://www.gnu.org/licenses/>.
  25
  26 /** @file debug/bitset
  27  *  This file is a GNU debug extension to the Standard C++ Library.
  28  */
  29
  30 #ifndef _GLIBCXX_DEBUG_BITSET
  31 #define _GLIBCXX_DEBUG_BITSET
  32
  33 #include <bitset>
  34 #include <debug/safe_sequence.h>
  35 #include <debug/safe_iterator.h>
  36
  37 namespace std
  38 {
  39 namespace __debug
  40 {
  41   template<size_t _Nb>
  42     class bitset
  43     : public _GLIBCXX_STD_D::bitset<_Nb>,
  44       public __gnu_debug::_Safe_sequence_base
  45     {
  46       typedef _GLIBCXX_STD_D::bitset<_Nb> _Base;
  47       typedef __gnu_debug::_Safe_sequence_base  _Safe_base;
  48
  49     public:
  50       // bit reference:
  51       class reference
  52       : private _Base::reference, public __gnu_debug::_Safe_iterator_base
  53       {
  54         typedef typename _Base::reference _Base_ref;
  55
  56         friend class bitset;
  57         reference();
  58
  59         reference(const _Base_ref& __base, bitset* __seq)
  60         : _Base_ref(__base), _Safe_iterator_base(__seq, false)
  61         { }
  62
  63       public:
  64         reference(const reference& __x)
  65         : _Base_ref(__x), _Safe_iterator_base(__x, false)
  66         { }
  67
  68         reference&
  69         operator=(bool __x)
  70         {
  71           _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
  72                               _M_message(__gnu_debug::__msg_bad_bitset_write)
  73                                 ._M_iterator(*this));
  74           *static_cast<_Base_ref*>(this) = __x;
  75           return *this;
  76         }
  77
  78         reference&
  79         operator=(const reference& __x)
  80         {
  81           _GLIBCXX_DEBUG_VERIFY(! __x._M_singular(),
  82                                _M_message(__gnu_debug::__msg_bad_bitset_read)
  83                                 ._M_iterator(__x));
  84           _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
  85                               _M_message(__gnu_debug::__msg_bad_bitset_write)
  86                                 ._M_iterator(*this));
  87           *static_cast<_Base_ref*>(this) = __x;
  88           return *this;
  89         }
  90
  91         bool
  92         operator~() const
  93         {
  94           _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
  95                                _M_message(__gnu_debug::__msg_bad_bitset_read)
  96                                 ._M_iterator(*this));
  97           return ~(*static_cast<const _Base_ref*>(this));
  98         }
  99
 100         operator bool() const
 101         {
 102           _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
 103                               _M_message(__gnu_debug::__msg_bad_bitset_read)
 104                                 ._M_iterator(*this));
 105           return *static_cast<const _Base_ref*>(this);
 106         }
 107
 108         reference&
 109         flip()
 110         {
 111           _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
 112                               _M_message(__gnu_debug::__msg_bad_bitset_flip)
 113                                 ._M_iterator(*this));
 114           _Base_ref::flip();
 115           return *this;
 116         }
 117       };
 118
 119       // 23.3.5.1 constructors:
 120       bitset() : _Base() { }
 121
 122       bitset(unsigned long __val) : _Base(__val) { }
 123
 124       template<typename _CharT, typename _Traits, typename _Alloc>
 125         explicit
 126         bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str,
 127                typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
 128                __pos = 0,
 129                typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
 130                __n = (std::basic_string<_CharT, _Traits, _Alloc>::npos))
 131         : _Base(__str, __pos, __n) { }
 132
 133       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 134       // 396. what are characters zero and one.
 135       template<class _CharT, class _Traits, class _Alloc>
 136         bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str,
 137                typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
 138                __pos,
 139                typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
 140                __n,
 141                _CharT __zero, _CharT __one = _CharT('1'))
 142         : _Base(__str, __pos, __n, __zero, __one) { }
 143
 144       bitset(const _Base& __x) : _Base(__x), _Safe_base() { }
 145
 146       // 23.3.5.2 bitset operations:
 147       bitset<_Nb>&
 148       operator&=(const bitset<_Nb>& __rhs)
 149       {
 150         _M_base() &= __rhs;
 151         return *this;
 152       }
 153
 154       bitset<_Nb>&
 155       operator|=(const bitset<_Nb>& __rhs)
 156       {
 157         _M_base() |= __rhs;
 158         return *this;
 159       }
 160
 161       bitset<_Nb>&
 162       operator^=(const bitset<_Nb>& __rhs)
 163       {
 164         _M_base() ^= __rhs;
 165         return *this;
 166       }
 167
 168       bitset<_Nb>&
 169       operator<<=(size_t __pos)
 170       {
 171         _M_base() <<= __pos;
 172         return *this;
 173       }
 174
 175       bitset<_Nb>&
 176       operator>>=(size_t __pos)
 177       {
 178         _M_base() >>= __pos;
 179         return *this;
 180       }
 181
 182       bitset<_Nb>&
 183       set()
 184       {
 185         _Base::set();
 186         return *this;
 187       }
 188
 189       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 190       // 186. bitset::set() second parameter should be bool
 191       bitset<_Nb>&
 192       set(size_t __pos, bool __val = true)
 193       {
 194         _Base::set(__pos, __val);
 195         return *this;
 196       }
 197
 198       bitset<_Nb>&
 199       reset()
 200       {
 201         _Base::reset();
 202         return *this;
 203       }
 204
 205       bitset<_Nb>&
 206       reset(size_t __pos)
 207       {
 208         _Base::reset(__pos);
 209         return *this;
 210       }
 211
 212       bitset<_Nb> operator~() const { return bitset(~_M_base()); }
 213
 214       bitset<_Nb>&
 215       flip()
 216       {
 217         _Base::flip();
 218         return *this;
 219       }
 220
 221       bitset<_Nb>&
 222       flip(size_t __pos)
 223       {
 224         _Base::flip(__pos);
 225         return *this;
 226       }
 227
 228       // element access:
 229       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 230       // 11. Bitset minor problems
 231       reference
 232       operator[](size_t __pos)
 233       {
 234         __glibcxx_check_subscript(__pos);
 235         return reference(_M_base()[__pos], this);
 236       }
 237
 238       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 239       // 11. Bitset minor problems
 240       bool
 241       operator[](size_t __pos) const
 242       {
 243         __glibcxx_check_subscript(__pos);
 244         return _M_base()[__pos];
 245       }
 246
 247       using _Base::to_ulong;
 248
 249       template <typename _CharT, typename _Traits, typename _Alloc>
 250         std::basic_string<_CharT, _Traits, _Alloc>
 251         to_string() const
 252         { return _M_base().template to_string<_CharT, _Traits, _Alloc>(); }
 253
 254       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 255       // 396. what are characters zero and one.
 256       template<class _CharT, class _Traits, class _Alloc>
 257         std::basic_string<_CharT, _Traits, _Alloc>
 258         to_string(_CharT __zero, _CharT __one = _CharT('1')) const
 259         {
 260           return _M_base().template
 261             to_string<_CharT, _Traits, _Alloc>(__zero, __one);
 262         }
 263
 264       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 265       // 434. bitset::to_string() hard to use.
 266       template<typename _CharT, typename _Traits>
 267         std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
 268         to_string() const
 269         { return to_string<_CharT, _Traits, std::allocator<_CharT> >(); }
 270
 271       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 272       // 853. to_string needs updating with zero and one.
 273       template<class _CharT, class _Traits>
 274         std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
 275         to_string(_CharT __zero, _CharT __one = _CharT('1')) const
 276         { return to_string<_CharT, _Traits,
 277                            std::allocator<_CharT> >(__zero, __one); }
 278
 279       template<typename _CharT>
 280         std::basic_string<_CharT, std::char_traits<_CharT>,
 281                           std::allocator<_CharT> >
 282         to_string() const
 283         {
 284           return to_string<_CharT, std::char_traits<_CharT>,
 285                            std::allocator<_CharT> >();
 286         }
 287
 288       template<class _CharT>
 289         std::basic_string<_CharT, std::char_traits<_CharT>,
 290                           std::allocator<_CharT> >
 291         to_string(_CharT __zero, _CharT __one = _CharT('1')) const
 292         {
 293           return to_string<_CharT, std::char_traits<_CharT>,
 294                            std::allocator<_CharT> >(__zero, __one);
 295         }
 296
 297       std::basic_string<char, std::char_traits<char>, std::allocator<char> >
 298       to_string() const
 299       {
 300         return to_string<char,std::char_traits<char>,std::allocator<char> >();
 301       }
 302
 303       std::basic_string<char, std::char_traits<char>, std::allocator<char> >
 304       to_string(char __zero, char __one = '1') const
 305       {
 306         return to_string<char, std::char_traits<char>,
 307                          std::allocator<char> >(__zero, __one);
 308       }
 309
 310       using _Base::count;
 311       using _Base::size;
 312
 313       bool
 314       operator==(const bitset<_Nb>& __rhs) const
 315       { return _M_base() == __rhs; }
 316
 317       bool
 318       operator!=(const bitset<_Nb>& __rhs) const
 319       { return _M_base() != __rhs; }
 320
 321       using _Base::test;
 322       using _Base::all;
 323       using _Base::any;
 324       using _Base::none;
 325
 326       bitset<_Nb>
 327       operator<<(size_t __pos) const
 328       { return bitset<_Nb>(_M_base() << __pos); }
 329
 330       bitset<_Nb>
 331       operator>>(size_t __pos) const
 332       { return bitset<_Nb>(_M_base() >> __pos); }
 333
 334       _Base&
 335       _M_base() { return *this; }
 336
 337       const _Base&
 338       _M_base() const { return *this; }
 339     };
 340
 341   template<size_t _Nb>
 342     bitset<_Nb>
 343     operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
 344     { return bitset<_Nb>(__x) &= __y; }
 345
 346   template<size_t _Nb>
 347     bitset<_Nb>
 348     operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
 349     { return bitset<_Nb>(__x) |= __y; }
 350
 351   template<size_t _Nb>
 352     bitset<_Nb>
 353     operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
 354     { return bitset<_Nb>(__x) ^= __y; }
 355
 356   template<typename _CharT, typename _Traits, size_t _Nb>
 357     std::basic_istream<_CharT, _Traits>&
 358     operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x)
 359     { return __is >> __x._M_base(); }
 360
 361   template<typename _CharT, typename _Traits, size_t _Nb>
 362     std::basic_ostream<_CharT, _Traits>&
 363     operator<<(std::basic_ostream<_CharT, _Traits>& __os,
 364                const bitset<_Nb>& __x)
 365     { return __os << __x._M_base(); }
 366 } // namespace __debug
 367 } // namespace std
 368
 369 #endif