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
00031
#ifndef _GLIBCXX_DEBUG_BITSET
00032
#define _GLIBCXX_DEBUG_BITSET
00033
00034
#include <bitset>
00035
#include <debug/safe_sequence.h>
00036
#include <debug/safe_iterator.h>
00037
00038
namespace __gnu_debug_def
00039 {
00040
template<size_t _Nb>
00041
class bitset
00042 :
public _GLIBCXX_STD::bitset<_Nb>,
00043
public __gnu_debug::_Safe_sequence_base
00044 {
00045
typedef _GLIBCXX_STD::bitset<_Nb> _Base;
00046
typedef __gnu_debug::_Safe_sequence_base _Safe_base;
00047
00048
public:
00049
00050
class reference
00051 :
private _Base::reference,
public __gnu_debug::_Safe_iterator_base
00052 {
00053
typedef typename _Base::reference _Base_ref;
00054
00055
friend class bitset;
00056 reference();
00057
00058 reference(
const _Base_ref& __base, bitset* __seq)
00059 : _Base_ref(__base), _Safe_iterator_base(__seq, false)
00060 { }
00061
00062
public:
00063 reference(
const reference& __x)
00064 : _Base_ref(__x), _Safe_iterator_base(__x, false)
00065 { }
00066
00067 reference&
00068 operator=(
bool __x)
00069 {
00070 _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
00071 _M_message(::__gnu_debug::__msg_bad_bitset_write)
00072 ._M_iterator(*
this));
00073 *static_cast<_Base_ref*>(
this) = __x;
00074
return *
this;
00075 }
00076
00077 reference&
00078 operator=(
const reference& __x)
00079 {
00080 _GLIBCXX_DEBUG_VERIFY(! __x._M_singular(),
00081 _M_message(::__gnu_debug::__msg_bad_bitset_read)
00082 ._M_iterator(__x));
00083 _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
00084 _M_message(::__gnu_debug::__msg_bad_bitset_write)
00085 ._M_iterator(*
this));
00086 *static_cast<_Base_ref*>(
this) = __x;
00087
return *
this;
00088 }
00089
00090
bool
00091 operator~()
const
00092
{
00093 _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
00094 _M_message(::__gnu_debug::__msg_bad_bitset_read)
00095 ._M_iterator(*
this));
00096
return ~(*static_cast<const _Base_ref*>(
this));
00097 }
00098
00099 operator bool()
const
00100
{
00101 _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
00102 _M_message(::__gnu_debug::__msg_bad_bitset_read)
00103 ._M_iterator(*
this));
00104
return *static_cast<const _Base_ref*>(
this);
00105 }
00106
00107 reference&
00108 flip()
00109 {
00110 _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
00111 _M_message(::__gnu_debug::__msg_bad_bitset_flip)
00112 ._M_iterator(*
this));
00113 _Base_ref::flip();
00114
return *
this;
00115 }
00116 };
00117
00118
00119
bitset() : _Base() { }
00120
00121
bitset(
unsigned long __val) : _Base(__val) { }
00122
00123
template<
typename _CharT,
typename _Traits,
typename _Allocator>
00124
explicit
00125
bitset(
const std::basic_string<_CharT,_Traits,_Allocator>& __str,
00126
typename std::basic_string<_CharT,_Traits,_Allocator>::size_type
00127 __pos = 0,
00128
typename std::basic_string<_CharT,_Traits,_Allocator>::size_type
00129 __n = (
std::basic_string<_CharT,_Traits,_Allocator>::npos))
00130 : _Base(__str, __pos, __n) { }
00131
00132
bitset(
const _Base& __x) : _Base(__x), _Safe_base() { }
00133
00134
00135 bitset<_Nb>&
00136 operator&=(
const bitset<_Nb>& __rhs)
00137 {
00138 _M_base() &= __rhs;
00139
return *
this;
00140 }
00141
00142 bitset<_Nb>&
00143 operator|=(
const bitset<_Nb>& __rhs)
00144 {
00145 _M_base() |= __rhs;
00146
return *
this;
00147 }
00148
00149 bitset<_Nb>&
00150 operator^=(
const bitset<_Nb>& __rhs)
00151 {
00152 _M_base() ^= __rhs;
00153
return *
this;
00154 }
00155
00156 bitset<_Nb>&
00157 operator<<=(size_t __pos)
00158 {
00159 _M_base() <<= __pos;
00160
return *
this;
00161 }
00162
00163 bitset<_Nb>&
00164 operator>>=(size_t __pos)
00165 {
00166 _M_base() >>= __pos;
00167
return *
this;
00168 }
00169
00170 bitset<_Nb>&
00171 set()
00172 {
00173 _Base::set();
00174
return *
this;
00175 }
00176
00177
00178
00179 bitset<_Nb>&
00180 set(size_t __pos,
bool __val =
true)
00181 {
00182 _Base::set(__pos, __val);
00183
return *
this;
00184 }
00185
00186 bitset<_Nb>&
00187 reset()
00188 {
00189 _Base::reset();
00190
return *
this;
00191 }
00192
00193 bitset<_Nb>&
00194 reset(size_t __pos)
00195 {
00196 _Base::reset(__pos);
00197
return *
this;
00198 }
00199
00200 bitset<_Nb> operator~()
const {
return bitset(~_M_base()); }
00201
00202 bitset<_Nb>&
00203 flip()
00204 {
00205 _Base::flip();
00206
return *
this;
00207 }
00208
00209 bitset<_Nb>&
00210 flip(size_t __pos)
00211 {
00212 _Base::flip(__pos);
00213
return *
this;
00214 }
00215
00216
00217
00218
00219 reference
00220 operator[](size_t __pos)
00221 {
00222 __glibcxx_check_subscript(__pos);
00223
return reference(_M_base()[__pos],
this);
00224 }
00225
00226
00227
00228
bool
00229 operator[](size_t __pos)
const
00230
{
00231 __glibcxx_check_subscript(__pos);
00232
return _M_base()[__pos];
00233 }
00234
00235
using _Base::to_ulong;
00236
00237
template <
typename _CharT,
typename _Traits,
typename _Allocator>
00238
std::basic_string<_CharT, _Traits, _Allocator>
00239 to_string()
const
00240
{
return _M_base().template to_string<_CharT, _Traits, _Allocator>(); }
00241
00242
using _Base::count;
00243
using _Base::size;
00244
00245
bool
00246 operator==(
const bitset<_Nb>& __rhs)
const
00247
{
return _M_base() == __rhs; }
00248
00249
bool
00250 operator!=(
const bitset<_Nb>& __rhs)
const
00251
{
return _M_base() != __rhs; }
00252
00253
using _Base::test;
00254
using _Base::any;
00255
using _Base::none;
00256
00257 bitset<_Nb>
00258
operator<<(size_t __pos)
const
00259
{
return bitset<_Nb>(_M_base() << __pos); }
00260
00261 bitset<_Nb>
00262
operator>>(size_t __pos)
const
00263
{
return bitset<_Nb>(_M_base() >> __pos); }
00264
00265 _Base&
00266 _M_base() {
return *
this; }
00267
00268
const _Base&
00269 _M_base()
const {
return *
this; }
00270 };
00271
00272
template<size_t _Nb>
00273 bitset<_Nb>
00274 operator&(
const bitset<_Nb>& __x,
const bitset<_Nb>& __y)
00275 {
return bitset<_Nb>(__x) &= __y; }
00276
00277
template<size_t _Nb>
00278 bitset<_Nb>
00279 operator|(
const bitset<_Nb>& __x,
const bitset<_Nb>& __y)
00280 {
return bitset<_Nb>(__x) |= __y; }
00281
00282
template<size_t _Nb>
00283 bitset<_Nb>
00284 operator^(
const bitset<_Nb>& __x,
const bitset<_Nb>& __y)
00285 {
return bitset<_Nb>(__x) ^= __y; }
00286
00287
template<
typename _CharT,
typename _Traits, size_t _Nb>
00288
std::basic_istream<_CharT, _Traits>&
00289
operator>>(
std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x)
00290 {
return __is >> __x._M_base(); }
00291
00292
template<
typename _CharT,
typename _Traits, size_t _Nb>
00293
std::basic_ostream<_CharT, _Traits>&
00294 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
00295
const bitset<_Nb>& __x)
00296 {
return __os << __x._M_base(); }
00297 }
00298
00299
#endif