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 #ifndef _GLIBCXX_PROFILE_BITSET
00030 #define _GLIBCXX_PROFILE_BITSET
00031
00032 #include <bitset>
00033
00034 namespace std
00035 {
00036 namespace __profile
00037 {
00038
00039 template<size_t _Nb>
00040 class bitset
00041 : public _GLIBCXX_STD_D::bitset<_Nb>
00042 {
00043 typedef _GLIBCXX_STD_D::bitset<_Nb> _Base;
00044
00045 public:
00046
00047 class reference
00048 : private _Base::reference
00049 {
00050 typedef typename _Base::reference _Base_ref;
00051
00052 friend class bitset;
00053 reference();
00054
00055 reference(const _Base_ref& __base, bitset* __seq)
00056 : _Base_ref(__base)
00057 { }
00058
00059 public:
00060 reference(const reference& __x)
00061 : _Base_ref(__x)
00062 { }
00063
00064 reference&
00065 operator=(bool __x)
00066 {
00067 *static_cast<_Base_ref*>(this) = __x;
00068 return *this;
00069 }
00070
00071 reference&
00072 operator=(const reference& __x)
00073 {
00074 *static_cast<_Base_ref*>(this) = __x;
00075 return *this;
00076 }
00077
00078 bool
00079 operator~() const
00080 {
00081 return ~(*static_cast<const _Base_ref*>(this));
00082 }
00083
00084 operator bool() const
00085 {
00086 return *static_cast<const _Base_ref*>(this);
00087 }
00088
00089 reference&
00090 flip()
00091 {
00092 _Base_ref::flip();
00093 return *this;
00094 }
00095 };
00096
00097
00098 bitset() : _Base() { }
00099
00100 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00101 bitset(unsigned long long __val)
00102 #else
00103 bitset(unsigned long __val)
00104 #endif
00105 : _Base(__val) { }
00106
00107 template<typename _CharT, typename _Traits, typename _Alloc>
00108 explicit
00109 bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str,
00110 typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
00111 __pos = 0,
00112 typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
00113 __n = (std::basic_string<_CharT, _Traits, _Alloc>::npos))
00114 : _Base(__str, __pos, __n) { }
00115
00116
00117
00118 template<class _CharT, class _Traits, class _Alloc>
00119 bitset(const std::basic_string<_CharT, _Traits, _Alloc>& __str,
00120 typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
00121 __pos,
00122 typename std::basic_string<_CharT, _Traits, _Alloc>::size_type
00123 __n,
00124 _CharT __zero, _CharT __one = _CharT('1'))
00125 : _Base(__str, __pos, __n, __zero, __one) { }
00126
00127 bitset(const _Base& __x) : _Base(__x) { }
00128
00129 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00130 explicit
00131 bitset(const char* __str) : _Base(__str) { }
00132 #endif
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 return reference(_M_base()[__pos], this);
00223 }
00224
00225
00226
00227 bool
00228 operator[](size_t __pos) const
00229 {
00230 return _M_base()[__pos];
00231 }
00232
00233 using _Base::to_ulong;
00234 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00235 using _Base::to_ullong;
00236 #endif
00237
00238 template <typename _CharT, typename _Traits, typename _Alloc>
00239 std::basic_string<_CharT, _Traits, _Alloc>
00240 to_string() const
00241 { return _M_base().template to_string<_CharT, _Traits, _Alloc>(); }
00242
00243
00244
00245 template<class _CharT, class _Traits, class _Alloc>
00246 std::basic_string<_CharT, _Traits, _Alloc>
00247 to_string(_CharT __zero, _CharT __one = _CharT('1')) const
00248 {
00249 return _M_base().template
00250 to_string<_CharT, _Traits, _Alloc>(__zero, __one);
00251 }
00252
00253
00254
00255 template<typename _CharT, typename _Traits>
00256 std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
00257 to_string() const
00258 { return to_string<_CharT, _Traits, std::allocator<_CharT> >(); }
00259
00260
00261
00262 template<class _CharT, class _Traits>
00263 std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
00264 to_string(_CharT __zero, _CharT __one = _CharT('1')) const
00265 { return to_string<_CharT, _Traits,
00266 std::allocator<_CharT> >(__zero, __one); }
00267
00268 template<typename _CharT>
00269 std::basic_string<_CharT, std::char_traits<_CharT>,
00270 std::allocator<_CharT> >
00271 to_string() const
00272 {
00273 return to_string<_CharT, std::char_traits<_CharT>,
00274 std::allocator<_CharT> >();
00275 }
00276
00277 template<class _CharT>
00278 std::basic_string<_CharT, std::char_traits<_CharT>,
00279 std::allocator<_CharT> >
00280 to_string(_CharT __zero, _CharT __one = _CharT('1')) const
00281 {
00282 return to_string<_CharT, std::char_traits<_CharT>,
00283 std::allocator<_CharT> >(__zero, __one);
00284 }
00285
00286 std::basic_string<char, std::char_traits<char>, std::allocator<char> >
00287 to_string() const
00288 {
00289 return to_string<char,std::char_traits<char>,std::allocator<char> >();
00290 }
00291
00292 std::basic_string<char, std::char_traits<char>, std::allocator<char> >
00293 to_string(char __zero, char __one = '1') const
00294 {
00295 return to_string<char, std::char_traits<char>,
00296 std::allocator<char> >(__zero, __one);
00297 }
00298
00299 using _Base::count;
00300 using _Base::size;
00301
00302 bool
00303 operator==(const bitset<_Nb>& __rhs) const
00304 { return _M_base() == __rhs; }
00305
00306 bool
00307 operator!=(const bitset<_Nb>& __rhs) const
00308 { return _M_base() != __rhs; }
00309
00310 using _Base::test;
00311 using _Base::all;
00312 using _Base::any;
00313 using _Base::none;
00314
00315 bitset<_Nb>
00316 operator<<(size_t __pos) const
00317 { return bitset<_Nb>(_M_base() << __pos); }
00318
00319 bitset<_Nb>
00320 operator>>(size_t __pos) const
00321 { return bitset<_Nb>(_M_base() >> __pos); }
00322
00323 _Base&
00324 _M_base() { return *this; }
00325
00326 const _Base&
00327 _M_base() const { return *this; }
00328 };
00329
00330 template<size_t _Nb>
00331 bitset<_Nb>
00332 operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
00333 { return bitset<_Nb>(__x) &= __y; }
00334
00335 template<size_t _Nb>
00336 bitset<_Nb>
00337 operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
00338 { return bitset<_Nb>(__x) |= __y; }
00339
00340 template<size_t _Nb>
00341 bitset<_Nb>
00342 operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
00343 { return bitset<_Nb>(__x) ^= __y; }
00344
00345 template<typename _CharT, typename _Traits, size_t _Nb>
00346 std::basic_istream<_CharT, _Traits>&
00347 operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x)
00348 { return __is >> __x._M_base(); }
00349
00350 template<typename _CharT, typename _Traits, size_t _Nb>
00351 std::basic_ostream<_CharT, _Traits>&
00352 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
00353 const bitset<_Nb>& __x)
00354 { return __os << __x._M_base(); }
00355 }
00356
00357 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00358
00359
00360 template<size_t _Nb>
00361 struct hash<__profile::bitset<_Nb>>
00362 : public std::unary_function<__profile::bitset<_Nb>, size_t>
00363 {
00364 size_t
00365 operator()(const __profile::bitset<_Nb>& __b) const
00366 { return std::hash<_GLIBCXX_STD_D::bitset<_Nb>>()(__b._M_base()); }
00367 };
00368 #endif
00369
00370 }
00371
00372 #endif