00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030 #ifndef _GLIBCXX_DEBUG_BITSET
00031 #define _GLIBCXX_DEBUG_BITSET
00032
00033 #include <bitset>
00034 #include <debug/safe_sequence.h>
00035 #include <debug/safe_iterator.h>
00036
00037 namespace std
00038 {
00039 namespace __debug
00040 {
00041 template<size_t _Nb>
00042 class bitset
00043 : public _GLIBCXX_STD_D::bitset<_Nb>,
00044 public __gnu_debug::_Safe_sequence_base
00045 {
00046 typedef _GLIBCXX_STD_D::bitset<_Nb> _Base;
00047 typedef __gnu_debug::_Safe_sequence_base _Safe_base;
00048
00049 public:
00050
00051 class reference
00052 : private _Base::reference, public __gnu_debug::_Safe_iterator_base
00053 {
00054 typedef typename _Base::reference _Base_ref;
00055
00056 friend class bitset;
00057 reference();
00058
00059 reference(const _Base_ref& __base, bitset* __seq)
00060 : _Base_ref(__base), _Safe_iterator_base(__seq, false)
00061 { }
00062
00063 public:
00064 reference(const reference& __x)
00065 : _Base_ref(__x), _Safe_iterator_base(__x, false)
00066 { }
00067
00068 reference&
00069 operator=(bool __x)
00070 {
00071 _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
00072 _M_message(__gnu_debug::__msg_bad_bitset_write)
00073 ._M_iterator(*this));
00074 *static_cast<_Base_ref*>(this) = __x;
00075 return *this;
00076 }
00077
00078 reference&
00079 operator=(const reference& __x)
00080 {
00081 _GLIBCXX_DEBUG_VERIFY(! __x._M_singular(),
00082 _M_message(__gnu_debug::__msg_bad_bitset_read)
00083 ._M_iterator(__x));
00084 _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
00085 _M_message(__gnu_debug::__msg_bad_bitset_write)
00086 ._M_iterator(*this));
00087 *static_cast<_Base_ref*>(this) = __x;
00088 return *this;
00089 }
00090
00091 bool
00092 operator~() const
00093 {
00094 _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
00095 _M_message(__gnu_debug::__msg_bad_bitset_read)
00096 ._M_iterator(*this));
00097 return ~(*static_cast<const _Base_ref*>(this));
00098 }
00099
00100 operator bool() const
00101 {
00102 _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
00103 _M_message(__gnu_debug::__msg_bad_bitset_read)
00104 ._M_iterator(*this));
00105 return *static_cast<const _Base_ref*>(this);
00106 }
00107
00108 reference&
00109 flip()
00110 {
00111 _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
00112 _M_message(__gnu_debug::__msg_bad_bitset_flip)
00113 ._M_iterator(*this));
00114 _Base_ref::flip();
00115 return *this;
00116 }
00117 };
00118
00119
00120 bitset() : _Base() { }
00121
00122 bitset(unsigned long __val) : _Base(__val) { }
00123
00124 template<typename _CharT, typename _Traits, typename _Alloc>
00125 explicit
00126 bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str,
00127 typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
00128 __pos = 0,
00129 typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
00130 __n = (std::basic_string<_CharT, _Traits, _Alloc>::npos))
00131 : _Base(__str, __pos, __n) { }
00132
00133
00134
00135 template<class _CharT, class _Traits, class _Alloc>
00136 bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str,
00137 typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
00138 __pos,
00139 typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
00140 __n,
00141 _CharT __zero, _CharT __one = _CharT('1'))
00142 : _Base(__str, __pos, __n, __zero, __one) { }
00143
00144 bitset(const _Base& __x) : _Base(__x), _Safe_base() { }
00145
00146
00147 bitset<_Nb>&
00148 operator&=(const bitset<_Nb>& __rhs)
00149 {
00150 _M_base() &= __rhs;
00151 return *this;
00152 }
00153
00154 bitset<_Nb>&
00155 operator|=(const bitset<_Nb>& __rhs)
00156 {
00157 _M_base() |= __rhs;
00158 return *this;
00159 }
00160
00161 bitset<_Nb>&
00162 operator^=(const bitset<_Nb>& __rhs)
00163 {
00164 _M_base() ^= __rhs;
00165 return *this;
00166 }
00167
00168 bitset<_Nb>&
00169 operator<<=(size_t __pos)
00170 {
00171 _M_base() <<= __pos;
00172 return *this;
00173 }
00174
00175 bitset<_Nb>&
00176 operator>>=(size_t __pos)
00177 {
00178 _M_base() >>= __pos;
00179 return *this;
00180 }
00181
00182 bitset<_Nb>&
00183 set()
00184 {
00185 _Base::set();
00186 return *this;
00187 }
00188
00189
00190
00191 bitset<_Nb>&
00192 set(size_t __pos, bool __val = true)
00193 {
00194 _Base::set(__pos, __val);
00195 return *this;
00196 }
00197
00198 bitset<_Nb>&
00199 reset()
00200 {
00201 _Base::reset();
00202 return *this;
00203 }
00204
00205 bitset<_Nb>&
00206 reset(size_t __pos)
00207 {
00208 _Base::reset(__pos);
00209 return *this;
00210 }
00211
00212 bitset<_Nb> operator~() const { return bitset(~_M_base()); }
00213
00214 bitset<_Nb>&
00215 flip()
00216 {
00217 _Base::flip();
00218 return *this;
00219 }
00220
00221 bitset<_Nb>&
00222 flip(size_t __pos)
00223 {
00224 _Base::flip(__pos);
00225 return *this;
00226 }
00227
00228
00229
00230
00231 reference
00232 operator[](size_t __pos)
00233 {
00234 __glibcxx_check_subscript(__pos);
00235 return reference(_M_base()[__pos], this);
00236 }
00237
00238
00239
00240 bool
00241 operator[](size_t __pos) const
00242 {
00243 __glibcxx_check_subscript(__pos);
00244 return _M_base()[__pos];
00245 }
00246
00247 using _Base::to_ulong;
00248
00249 template <typename _CharT, typename _Traits, typename _Alloc>
00250 std::basic_string<_CharT, _Traits, _Alloc>
00251 to_string() const
00252 { return _M_base().template to_string<_CharT, _Traits, _Alloc>(); }
00253
00254
00255
00256 template<class _CharT, class _Traits, class _Alloc>
00257 std::basic_string<_CharT, _Traits, _Alloc>
00258 to_string(_CharT __zero, _CharT __one = _CharT('1')) const
00259 {
00260 return _M_base().template
00261 to_string<_CharT, _Traits, _Alloc>(__zero, __one);
00262 }
00263
00264
00265
00266 template<typename _CharT, typename _Traits>
00267 std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
00268 to_string() const
00269 { return to_string<_CharT, _Traits, std::allocator<_CharT> >(); }
00270
00271
00272
00273 template<class _CharT, class _Traits>
00274 std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
00275 to_string(_CharT __zero, _CharT __one = _CharT('1')) const
00276 { return to_string<_CharT, _Traits,
00277 std::allocator<_CharT> >(__zero, __one); }
00278
00279 template<typename _CharT>
00280 std::basic_string<_CharT, std::char_traits<_CharT>,
00281 std::allocator<_CharT> >
00282 to_string() const
00283 {
00284 return to_string<_CharT, std::char_traits<_CharT>,
00285 std::allocator<_CharT> >();
00286 }
00287
00288 template<class _CharT>
00289 std::basic_string<_CharT, std::char_traits<_CharT>,
00290 std::allocator<_CharT> >
00291 to_string(_CharT __zero, _CharT __one = _CharT('1')) const
00292 {
00293 return to_string<_CharT, std::char_traits<_CharT>,
00294 std::allocator<_CharT> >(__zero, __one);
00295 }
00296
00297 std::basic_string<char, std::char_traits<char>, std::allocator<char> >
00298 to_string() const
00299 {
00300 return to_string<char,std::char_traits<char>,std::allocator<char> >();
00301 }
00302
00303 std::basic_string<char, std::char_traits<char>, std::allocator<char> >
00304 to_string(char __zero, char __one = '1') const
00305 {
00306 return to_string<char, std::char_traits<char>,
00307 std::allocator<char> >(__zero, __one);
00308 }
00309
00310 using _Base::count;
00311 using _Base::size;
00312
00313 bool
00314 operator==(const bitset<_Nb>& __rhs) const
00315 { return _M_base() == __rhs; }
00316
00317 bool
00318 operator!=(const bitset<_Nb>& __rhs) const
00319 { return _M_base() != __rhs; }
00320
00321 using _Base::test;
00322 using _Base::all;
00323 using _Base::any;
00324 using _Base::none;
00325
00326 bitset<_Nb>
00327 operator<<(size_t __pos) const
00328 { return bitset<_Nb>(_M_base() << __pos); }
00329
00330 bitset<_Nb>
00331 operator>>(size_t __pos) const
00332 { return bitset<_Nb>(_M_base() >> __pos); }
00333
00334 _Base&
00335 _M_base() { return *this; }
00336
00337 const _Base&
00338 _M_base() const { return *this; }
00339 };
00340
00341 template<size_t _Nb>
00342 bitset<_Nb>
00343 operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
00344 { return bitset<_Nb>(__x) &= __y; }
00345
00346 template<size_t _Nb>
00347 bitset<_Nb>
00348 operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
00349 { return bitset<_Nb>(__x) |= __y; }
00350
00351 template<size_t _Nb>
00352 bitset<_Nb>
00353 operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
00354 { return bitset<_Nb>(__x) ^= __y; }
00355
00356 template<typename _CharT, typename _Traits, size_t _Nb>
00357 std::basic_istream<_CharT, _Traits>&
00358 operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x)
00359 { return __is >> __x._M_base(); }
00360
00361 template<typename _CharT, typename _Traits, size_t _Nb>
00362 std::basic_ostream<_CharT, _Traits>&
00363 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
00364 const bitset<_Nb>& __x)
00365 { return __os << __x._M_base(); }
00366 }
00367 }
00368
00369 #endif