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 _GLIBCXX_VISIBILITY(default)
00035 {
00036 namespace __profile
00037 {
00038
00039 template<size_t _Nb>
00040 class bitset
00041 : public _GLIBCXX_STD_C::bitset<_Nb>
00042 {
00043 typedef _GLIBCXX_STD_C::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 _GLIBCXX_CONSTEXPR bitset() : _Base() { }
00099
00100 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00101 constexpr 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 template<typename _CharT>
00131 explicit
00132 bitset(const _CharT* __str,
00133 typename std::basic_string<_CharT>::size_type __n
00134 = std::basic_string<_CharT>::npos,
00135 _CharT __zero = _CharT('0'), _CharT __one = _CharT('1'))
00136 : _Base(__str, __n, __zero, __one) { }
00137 #endif
00138
00139
00140 bitset<_Nb>&
00141 operator&=(const bitset<_Nb>& __rhs)
00142 {
00143 _M_base() &= __rhs;
00144 return *this;
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<<=(size_t __pos)
00163 {
00164 _M_base() <<= __pos;
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 set()
00177 {
00178 _Base::set();
00179 return *this;
00180 }
00181
00182
00183
00184 bitset<_Nb>&
00185 set(size_t __pos, bool __val = true)
00186 {
00187 _Base::set(__pos, __val);
00188 return *this;
00189 }
00190
00191 bitset<_Nb>&
00192 reset()
00193 {
00194 _Base::reset();
00195 return *this;
00196 }
00197
00198 bitset<_Nb>&
00199 reset(size_t __pos)
00200 {
00201 _Base::reset(__pos);
00202 return *this;
00203 }
00204
00205 bitset<_Nb> operator~() const { return bitset(~_M_base()); }
00206
00207 bitset<_Nb>&
00208 flip()
00209 {
00210 _Base::flip();
00211 return *this;
00212 }
00213
00214 bitset<_Nb>&
00215 flip(size_t __pos)
00216 {
00217 _Base::flip(__pos);
00218 return *this;
00219 }
00220
00221
00222
00223
00224 reference
00225 operator[](size_t __pos)
00226 {
00227 return reference(_M_base()[__pos], this);
00228 }
00229
00230
00231
00232 bool
00233 operator[](size_t __pos) const
00234 {
00235 return _M_base()[__pos];
00236 }
00237
00238 using _Base::to_ulong;
00239 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00240 using _Base::to_ullong;
00241 #endif
00242
00243 template <typename _CharT, typename _Traits, typename _Alloc>
00244 std::basic_string<_CharT, _Traits, _Alloc>
00245 to_string() const
00246 { return _M_base().template to_string<_CharT, _Traits, _Alloc>(); }
00247
00248
00249
00250 template<class _CharT, class _Traits, class _Alloc>
00251 std::basic_string<_CharT, _Traits, _Alloc>
00252 to_string(_CharT __zero, _CharT __one = _CharT('1')) const
00253 {
00254 return _M_base().template
00255 to_string<_CharT, _Traits, _Alloc>(__zero, __one);
00256 }
00257
00258
00259
00260 template<typename _CharT, typename _Traits>
00261 std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
00262 to_string() const
00263 { return to_string<_CharT, _Traits, std::allocator<_CharT> >(); }
00264
00265
00266
00267 template<class _CharT, class _Traits>
00268 std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
00269 to_string(_CharT __zero, _CharT __one = _CharT('1')) const
00270 { return to_string<_CharT, _Traits,
00271 std::allocator<_CharT> >(__zero, __one); }
00272
00273 template<typename _CharT>
00274 std::basic_string<_CharT, std::char_traits<_CharT>,
00275 std::allocator<_CharT> >
00276 to_string() const
00277 {
00278 return to_string<_CharT, std::char_traits<_CharT>,
00279 std::allocator<_CharT> >();
00280 }
00281
00282 template<class _CharT>
00283 std::basic_string<_CharT, std::char_traits<_CharT>,
00284 std::allocator<_CharT> >
00285 to_string(_CharT __zero, _CharT __one = _CharT('1')) const
00286 {
00287 return to_string<_CharT, std::char_traits<_CharT>,
00288 std::allocator<_CharT> >(__zero, __one);
00289 }
00290
00291 std::basic_string<char, std::char_traits<char>, std::allocator<char> >
00292 to_string() const
00293 {
00294 return to_string<char,std::char_traits<char>,std::allocator<char> >();
00295 }
00296
00297 std::basic_string<char, std::char_traits<char>, std::allocator<char> >
00298 to_string(char __zero, char __one = '1') const
00299 {
00300 return to_string<char, std::char_traits<char>,
00301 std::allocator<char> >(__zero, __one);
00302 }
00303
00304 using _Base::count;
00305 using _Base::size;
00306
00307 bool
00308 operator==(const bitset<_Nb>& __rhs) const
00309 { return _M_base() == __rhs; }
00310
00311 bool
00312 operator!=(const bitset<_Nb>& __rhs) const
00313 { return _M_base() != __rhs; }
00314
00315 using _Base::test;
00316 using _Base::all;
00317 using _Base::any;
00318 using _Base::none;
00319
00320 bitset<_Nb>
00321 operator<<(size_t __pos) const
00322 { return bitset<_Nb>(_M_base() << __pos); }
00323
00324 bitset<_Nb>
00325 operator>>(size_t __pos) const
00326 { return bitset<_Nb>(_M_base() >> __pos); }
00327
00328 _Base&
00329 _M_base() { return *this; }
00330
00331 const _Base&
00332 _M_base() const { return *this; }
00333 };
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<size_t _Nb>
00346 bitset<_Nb>
00347 operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y)
00348 { return bitset<_Nb>(__x) ^= __y; }
00349
00350 template<typename _CharT, typename _Traits, size_t _Nb>
00351 std::basic_istream<_CharT, _Traits>&
00352 operator>>(std::basic_istream<_CharT, _Traits>& __is, bitset<_Nb>& __x)
00353 { return __is >> __x._M_base(); }
00354
00355 template<typename _CharT, typename _Traits, size_t _Nb>
00356 std::basic_ostream<_CharT, _Traits>&
00357 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
00358 const bitset<_Nb>& __x)
00359 { return __os << __x._M_base(); }
00360 }
00361
00362 #ifdef __GXX_EXPERIMENTAL_CXX0X__
00363
00364
00365 template<size_t _Nb>
00366 struct hash<__profile::bitset<_Nb>>
00367 : public __hash_base<size_t, __profile::bitset<_Nb>>
00368 {
00369 size_t
00370 operator()(const __profile::bitset<_Nb>& __b) const
00371 { return std::hash<_GLIBCXX_STD_C::bitset<_Nb>>()(__b._M_base()); }
00372 };
00373 #endif
00374
00375 }
00376
00377 #endif