42 #ifndef _GLIBCXX_BITSET
43 #define _GLIBCXX_BITSET 1
45 #pragma GCC system_header
53 #define _GLIBCXX_BITSET_BITS_PER_WORD (__CHAR_BIT__ * __SIZEOF_LONG__)
54 #define _GLIBCXX_BITSET_WORDS(__n) \
55 ((__n) / _GLIBCXX_BITSET_BITS_PER_WORD + \
56 ((__n) % _GLIBCXX_BITSET_BITS_PER_WORD == 0 ? 0 : 1))
58 #define _GLIBCXX_BITSET_BITS_PER_ULL (__CHAR_BIT__ * __SIZEOF_LONG_LONG__)
60 namespace std _GLIBCXX_VISIBILITY(default)
62 _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
73 typedef unsigned long _WordT;
81 #if __cplusplus >= 201103L
82 constexpr
_Base_bitset(
unsigned long long __val) noexcept
84 #if __SIZEOF_LONG_LONG__ > __SIZEOF_LONG__
85 , _WordT(__val >> _GLIBCXX_BITSET_BITS_PER_WORD)
89 _Base_bitset(
unsigned long __val)
94 static _GLIBCXX_CONSTEXPR
size_t
95 _S_whichword(
size_t __pos) _GLIBCXX_NOEXCEPT
96 {
return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; }
98 static _GLIBCXX_CONSTEXPR
size_t
99 _S_whichbyte(
size_t __pos) _GLIBCXX_NOEXCEPT
100 {
return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; }
102 static _GLIBCXX_CONSTEXPR
size_t
103 _S_whichbit(
size_t __pos) _GLIBCXX_NOEXCEPT
104 {
return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; }
106 static _GLIBCXX_CONSTEXPR _WordT
107 _S_maskbit(
size_t __pos) _GLIBCXX_NOEXCEPT
108 {
return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
111 _M_getword(
size_t __pos) _GLIBCXX_NOEXCEPT
112 {
return _M_w[_S_whichword(__pos)]; }
114 _GLIBCXX_CONSTEXPR _WordT
115 _M_getword(
size_t __pos)
const _GLIBCXX_NOEXCEPT
116 {
return _M_w[_S_whichword(__pos)]; }
118 #if __cplusplus >= 201103L
120 _M_getdata() const noexcept
125 _M_hiword() _GLIBCXX_NOEXCEPT
126 {
return _M_w[_Nw - 1]; }
128 _GLIBCXX_CONSTEXPR _WordT
129 _M_hiword() const _GLIBCXX_NOEXCEPT
130 {
return _M_w[_Nw - 1]; }
133 _M_do_and(
const _Base_bitset<_Nw>& __x) _GLIBCXX_NOEXCEPT
135 for (
size_t __i = 0; __i < _Nw; __i++)
136 _M_w[__i] &= __x._M_w[__i];
140 _M_do_or(
const _Base_bitset<_Nw>& __x) _GLIBCXX_NOEXCEPT
142 for (
size_t __i = 0; __i < _Nw; __i++)
143 _M_w[__i] |= __x._M_w[__i];
147 _M_do_xor(
const _Base_bitset<_Nw>& __x) _GLIBCXX_NOEXCEPT
149 for (
size_t __i = 0; __i < _Nw; __i++)
150 _M_w[__i] ^= __x._M_w[__i];
154 _M_do_left_shift(
size_t __shift) _GLIBCXX_NOEXCEPT;
157 _M_do_right_shift(
size_t __shift) _GLIBCXX_NOEXCEPT;
160 _M_do_flip() _GLIBCXX_NOEXCEPT
162 for (
size_t __i = 0; __i < _Nw; __i++)
167 _M_do_set() _GLIBCXX_NOEXCEPT
169 for (
size_t __i = 0; __i < _Nw; __i++)
170 _M_w[__i] = ~static_cast<_WordT>(0);
174 _M_do_reset() _GLIBCXX_NOEXCEPT
175 { __builtin_memset(
_M_w, 0, _Nw *
sizeof(_WordT)); }
178 _M_is_equal(
const _Base_bitset<_Nw>& __x)
const _GLIBCXX_NOEXCEPT
180 for (
size_t __i = 0; __i < _Nw; ++__i)
181 if (
_M_w[__i] != __x._M_w[__i])
188 _M_are_all() const _GLIBCXX_NOEXCEPT
190 for (
size_t __i = 0; __i < _Nw - 1; __i++)
191 if (
_M_w[__i] != ~static_cast<_WordT>(0))
193 return _M_hiword() == (~static_cast<_WordT>(0)
194 >> (_Nw * _GLIBCXX_BITSET_BITS_PER_WORD
199 _M_is_any() const _GLIBCXX_NOEXCEPT
201 for (
size_t __i = 0; __i < _Nw; __i++)
202 if (
_M_w[__i] != static_cast<_WordT>(0))
208 _M_do_count() const _GLIBCXX_NOEXCEPT
211 for (
size_t __i = 0; __i < _Nw; __i++)
212 __result += __builtin_popcountl(
_M_w[__i]);
217 _M_do_to_ulong()
const;
219 #if __cplusplus >= 201103L
221 _M_do_to_ullong()
const;
226 _M_do_find_first(
size_t) const _GLIBCXX_NOEXCEPT;
230 _M_do_find_next(
size_t,
size_t) const _GLIBCXX_NOEXCEPT;
236 _Base_bitset<_Nw>::_M_do_left_shift(
size_t __shift) _GLIBCXX_NOEXCEPT
238 if (__builtin_expect(__shift != 0, 1))
240 const size_t __wshift = __shift / _GLIBCXX_BITSET_BITS_PER_WORD;
241 const size_t __offset = __shift % _GLIBCXX_BITSET_BITS_PER_WORD;
244 for (
size_t __n = _Nw - 1; __n >= __wshift; --__n)
248 const size_t __sub_offset = (_GLIBCXX_BITSET_BITS_PER_WORD
250 for (
size_t __n = _Nw - 1; __n > __wshift; --__n)
251 _M_w[__n] = ((
_M_w[__n - __wshift] << __offset)
252 | (
_M_w[__n - __wshift - 1] >> __sub_offset));
253 _M_w[__wshift] =
_M_w[0] << __offset;
256 std::fill(
_M_w + 0,
_M_w + __wshift, static_cast<_WordT>(0));
262 _Base_bitset<_Nw>::_M_do_right_shift(
size_t __shift) _GLIBCXX_NOEXCEPT
264 if (__builtin_expect(__shift != 0, 1))
266 const size_t __wshift = __shift / _GLIBCXX_BITSET_BITS_PER_WORD;
267 const size_t __offset = __shift % _GLIBCXX_BITSET_BITS_PER_WORD;
268 const size_t __limit = _Nw - __wshift - 1;
271 for (
size_t __n = 0; __n <= __limit; ++__n)
275 const size_t __sub_offset = (_GLIBCXX_BITSET_BITS_PER_WORD
277 for (
size_t __n = 0; __n < __limit; ++__n)
278 _M_w[__n] = ((
_M_w[__n + __wshift] >> __offset)
279 | (
_M_w[__n + __wshift + 1] << __sub_offset));
280 _M_w[__limit] =
_M_w[_Nw-1] >> __offset;
283 std::fill(
_M_w + __limit + 1,
_M_w + _Nw, static_cast<_WordT>(0));
289 _Base_bitset<_Nw>::_M_do_to_ulong()
const
291 for (
size_t __i = 1; __i < _Nw; ++__i)
293 __throw_overflow_error(__N(
"_Base_bitset::_M_do_to_ulong"));
297 #if __cplusplus >= 201103L
300 _Base_bitset<_Nw>::_M_do_to_ullong()
const
302 const bool __dw =
sizeof(
unsigned long long) >
sizeof(
unsigned long);
303 for (
size_t __i = 1 + __dw; __i < _Nw; ++__i)
305 __throw_overflow_error(__N(
"_Base_bitset::_M_do_to_ullong"));
308 return _M_w[0] + (
static_cast<unsigned long long>(
_M_w[1])
309 << _GLIBCXX_BITSET_BITS_PER_WORD);
317 _M_do_find_first(
size_t __not_found)
const _GLIBCXX_NOEXCEPT
319 for (
size_t __i = 0; __i < _Nw; __i++)
321 _WordT __thisword =
_M_w[__i];
322 if (__thisword != static_cast<_WordT>(0))
323 return (__i * _GLIBCXX_BITSET_BITS_PER_WORD
324 + __builtin_ctzl(__thisword));
333 _M_do_find_next(
size_t __prev,
size_t __not_found)
const _GLIBCXX_NOEXCEPT
339 if (__prev >= _Nw * _GLIBCXX_BITSET_BITS_PER_WORD)
343 size_t __i = _S_whichword(__prev);
344 _WordT __thisword =
_M_w[__i];
347 __thisword &= (~static_cast<_WordT>(0)) << _S_whichbit(__prev);
349 if (__thisword != static_cast<_WordT>(0))
350 return (__i * _GLIBCXX_BITSET_BITS_PER_WORD
351 + __builtin_ctzl(__thisword));
355 for (; __i < _Nw; __i++)
357 __thisword =
_M_w[__i];
358 if (__thisword != static_cast<_WordT>(0))
359 return (__i * _GLIBCXX_BITSET_BITS_PER_WORD
360 + __builtin_ctzl(__thisword));
374 typedef unsigned long _WordT;
381 #if __cplusplus >= 201103L
382 constexpr
_Base_bitset(
unsigned long long __val) noexcept
389 static _GLIBCXX_CONSTEXPR
size_t
390 _S_whichword(
size_t __pos) _GLIBCXX_NOEXCEPT
391 {
return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; }
393 static _GLIBCXX_CONSTEXPR
size_t
394 _S_whichbyte(
size_t __pos) _GLIBCXX_NOEXCEPT
395 {
return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; }
397 static _GLIBCXX_CONSTEXPR
size_t
398 _S_whichbit(
size_t __pos) _GLIBCXX_NOEXCEPT
399 {
return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; }
401 static _GLIBCXX_CONSTEXPR _WordT
402 _S_maskbit(
size_t __pos) _GLIBCXX_NOEXCEPT
403 {
return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
406 _M_getword(
size_t) _GLIBCXX_NOEXCEPT
409 _GLIBCXX_CONSTEXPR _WordT
410 _M_getword(
size_t)
const _GLIBCXX_NOEXCEPT
413 #if __cplusplus >= 201103L
415 _M_getdata()
const noexcept
420 _M_hiword() _GLIBCXX_NOEXCEPT
423 _GLIBCXX_CONSTEXPR _WordT
424 _M_hiword()
const _GLIBCXX_NOEXCEPT
429 {
_M_w &= __x._M_w; }
433 {
_M_w |= __x._M_w; }
437 {
_M_w ^= __x._M_w; }
440 _M_do_left_shift(
size_t __shift) _GLIBCXX_NOEXCEPT
441 {
_M_w <<= __shift; }
444 _M_do_right_shift(
size_t __shift) _GLIBCXX_NOEXCEPT
445 {
_M_w >>= __shift; }
448 _M_do_flip() _GLIBCXX_NOEXCEPT
452 _M_do_set() _GLIBCXX_NOEXCEPT
453 {
_M_w = ~static_cast<_WordT>(0); }
456 _M_do_reset() _GLIBCXX_NOEXCEPT
461 {
return _M_w == __x._M_w; }
465 _M_are_all()
const _GLIBCXX_NOEXCEPT
466 {
return _M_w == (~static_cast<_WordT>(0)
467 >> (_GLIBCXX_BITSET_BITS_PER_WORD - _Nb)); }
470 _M_is_any()
const _GLIBCXX_NOEXCEPT
471 {
return _M_w != 0; }
474 _M_do_count()
const _GLIBCXX_NOEXCEPT
475 {
return __builtin_popcountl(
_M_w); }
478 _M_do_to_ulong()
const _GLIBCXX_NOEXCEPT
481 #if __cplusplus >= 201103L
483 _M_do_to_ullong()
const noexcept
488 _M_do_find_first(
size_t __not_found)
const _GLIBCXX_NOEXCEPT
491 return __builtin_ctzl(
_M_w);
498 _M_do_find_next(
size_t __prev,
size_t __not_found)
const
502 if (__prev >= ((
size_t) _GLIBCXX_BITSET_BITS_PER_WORD))
505 _WordT __x =
_M_w >> __prev;
507 return __builtin_ctzl(__x) + __prev;
521 typedef unsigned long _WordT;
526 #if __cplusplus >= 201103L
533 static _GLIBCXX_CONSTEXPR
size_t
534 _S_whichword(
size_t __pos) _GLIBCXX_NOEXCEPT
535 {
return __pos / _GLIBCXX_BITSET_BITS_PER_WORD; }
537 static _GLIBCXX_CONSTEXPR
size_t
538 _S_whichbyte(
size_t __pos) _GLIBCXX_NOEXCEPT
539 {
return (__pos % _GLIBCXX_BITSET_BITS_PER_WORD) / __CHAR_BIT__; }
541 static _GLIBCXX_CONSTEXPR
size_t
542 _S_whichbit(
size_t __pos) _GLIBCXX_NOEXCEPT
543 {
return __pos % _GLIBCXX_BITSET_BITS_PER_WORD; }
545 static _GLIBCXX_CONSTEXPR _WordT
546 _S_maskbit(
size_t __pos) _GLIBCXX_NOEXCEPT
547 {
return (static_cast<_WordT>(1)) << _S_whichbit(__pos); }
557 _M_getword(
size_t) _GLIBCXX_NOEXCEPT
559 __throw_out_of_range(__N(
"_Base_bitset::_M_getword"));
563 _GLIBCXX_CONSTEXPR _WordT
564 _M_getword(
size_t __pos)
const _GLIBCXX_NOEXCEPT
567 _GLIBCXX_CONSTEXPR _WordT
568 _M_hiword()
const _GLIBCXX_NOEXCEPT
584 _M_do_left_shift(
size_t) _GLIBCXX_NOEXCEPT
588 _M_do_right_shift(
size_t) _GLIBCXX_NOEXCEPT
592 _M_do_flip() _GLIBCXX_NOEXCEPT
596 _M_do_set() _GLIBCXX_NOEXCEPT
600 _M_do_reset() _GLIBCXX_NOEXCEPT
612 _M_are_all()
const _GLIBCXX_NOEXCEPT
616 _M_is_any()
const _GLIBCXX_NOEXCEPT
620 _M_do_count()
const _GLIBCXX_NOEXCEPT
624 _M_do_to_ulong()
const _GLIBCXX_NOEXCEPT
627 #if __cplusplus >= 201103L
629 _M_do_to_ullong()
const noexcept
636 _M_do_find_first(
size_t)
const _GLIBCXX_NOEXCEPT
640 _M_do_find_next(
size_t,
size_t)
const _GLIBCXX_NOEXCEPT
646 template<
size_t _Extrabits>
649 typedef unsigned long _WordT;
652 _S_do_sanitize(_WordT& __val) _GLIBCXX_NOEXCEPT
653 { __val &= ~((~static_cast<_WordT>(0)) << _Extrabits); }
659 typedef unsigned long _WordT;
662 _S_do_sanitize(_WordT) _GLIBCXX_NOEXCEPT { }
665 #if __cplusplus >= 201103L
666 template<
size_t _Nb,
bool = _Nb < _GLIBCXX_BITSET_BITS_PER_ULL>
669 static constexpr
unsigned long long
670 _S_do_sanitize_val(
unsigned long long __val)
675 struct _Sanitize_val<_Nb, true>
677 static constexpr
unsigned long long
678 _S_do_sanitize_val(
unsigned long long __val)
679 {
return __val & ~((~static_cast<
unsigned long long>(0)) << _Nb); }
750 :
private _Base_bitset<_GLIBCXX_BITSET_WORDS(_Nb)>
753 typedef _Base_bitset<_GLIBCXX_BITSET_WORDS(_Nb)> _Base;
754 typedef unsigned long _WordT;
756 template<
class _CharT,
class _Traits,
class _Alloc>
759 size_t __position)
const
761 if (__position > __s.
size())
762 __throw_out_of_range_fmt(__N(
"bitset::bitset: __position "
763 "(which is %zu) > __s.size() "
765 __position, __s.
size());
768 void _M_check(
size_t __position,
const char *__s)
const
770 if (__position >= _Nb)
771 __throw_out_of_range_fmt(__N(
"%s: __position (which is %zu) "
772 ">= _Nb (which is %zu)"),
773 __s, __position, _Nb);
777 _M_do_sanitize() _GLIBCXX_NOEXCEPT
779 typedef _Sanitize<_Nb % _GLIBCXX_BITSET_BITS_PER_WORD> __sanitize_type;
780 __sanitize_type::_S_do_sanitize(this->_M_hiword());
783 #if __cplusplus >= 201103L
784 template<
typename>
friend struct hash;
811 reference(bitset& __b,
size_t __pos) _GLIBCXX_NOEXCEPT
813 _M_wp = &__b._M_getword(__pos);
814 _M_bpos = _Base::_S_whichbit(__pos);
817 ~reference() _GLIBCXX_NOEXCEPT
822 operator=(
bool __x) _GLIBCXX_NOEXCEPT
825 *_M_wp |= _Base::_S_maskbit(_M_bpos);
827 *_M_wp &= ~_Base::_S_maskbit(_M_bpos);
833 operator=(
const reference& __j) _GLIBCXX_NOEXCEPT
835 if ((*(__j._M_wp) & _Base::_S_maskbit(__j._M_bpos)))
836 *_M_wp |= _Base::_S_maskbit(_M_bpos);
838 *_M_wp &= ~_Base::_S_maskbit(_M_bpos);
845 {
return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) == 0; }
848 operator bool() const _GLIBCXX_NOEXCEPT
849 {
return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) != 0; }
853 flip() _GLIBCXX_NOEXCEPT
855 *_M_wp ^= _Base::_S_maskbit(_M_bpos);
859 friend class reference;
863 _GLIBCXX_CONSTEXPR bitset() _GLIBCXX_NOEXCEPT
867 #if __cplusplus >= 201103L
868 constexpr bitset(
unsigned long long __val) noexcept
869 : _Base(_Sanitize_val<_Nb>::_S_do_sanitize_val(__val)) { }
871 bitset(
unsigned long __val)
873 { _M_do_sanitize(); }
885 template<
class _CharT,
class _Traits,
class _Alloc>
888 size_t __position = 0)
891 _M_check_initial_position(__s, __position);
892 _M_copy_from_string(__s, __position,
894 _CharT(
'0'), _CharT(
'1'));
907 template<
class _CharT,
class _Traits,
class _Alloc>
909 size_t __position,
size_t __n)
912 _M_check_initial_position(__s, __position);
913 _M_copy_from_string(__s, __position, __n, _CharT(
'0'), _CharT(
'1'));
918 template<
class _CharT,
class _Traits,
class _Alloc>
920 size_t __position,
size_t __n,
921 _CharT __zero, _CharT __one = _CharT(
'1'))
924 _M_check_initial_position(__s, __position);
925 _M_copy_from_string(__s, __position, __n, __zero, __one);
928 #if __cplusplus >= 201103L
938 template<
typename _CharT>
940 bitset(
const _CharT* __str,
941 typename std::basic_string<_CharT>::size_type __n
943 _CharT __zero = _CharT(
'0'), _CharT __one = _CharT(
'1'))
947 __throw_logic_error(__N(
"bitset::bitset(const _CharT*, ...)"));
951 _M_copy_from_ptr<_CharT, std::char_traits<_CharT>>(__str, __n, 0,
966 operator&=(
const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT
968 this->_M_do_and(__rhs);
973 operator|=(
const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT
975 this->_M_do_or(__rhs);
980 operator^=(
const bitset<_Nb>& __rhs) _GLIBCXX_NOEXCEPT
982 this->_M_do_xor(__rhs);
997 if (__builtin_expect(__position < _Nb, 1))
999 this->_M_do_left_shift(__position);
1000 this->_M_do_sanitize();
1003 this->_M_do_reset();
1010 if (__builtin_expect(__position < _Nb, 1))
1012 this->_M_do_right_shift(__position);
1013 this->_M_do_sanitize();
1016 this->_M_do_reset();
1030 this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);
1038 this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);
1040 this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);
1047 this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);
1054 this->_M_getword(__pos) ^= _Base::_S_maskbit(__pos);
1058 _GLIBCXX_CONSTEXPR
bool
1060 {
return ((this->_M_getword(__pos) & _Base::_S_maskbit(__pos))
1061 != static_cast<_WordT>(0)); }
1072 this->_M_do_sanitize();
1083 set(
size_t __position,
bool __val =
true)
1085 this->_M_check(__position, __N(
"bitset::set"));
1095 this->_M_do_reset();
1109 this->_M_check(__position, __N(
"bitset::reset"));
1120 this->_M_do_sanitize();
1132 this->_M_check(__position, __N(
"bitset::flip"));
1139 {
return bitset<_Nb>(*this).flip(); }
1158 {
return reference(*
this, __position); }
1160 _GLIBCXX_CONSTEXPR
bool
1173 {
return this->_M_do_to_ulong(); }
1175 #if __cplusplus >= 201103L
1178 {
return this->_M_do_to_ullong(); }
1189 template<
class _CharT,
class _Traits,
class _Alloc>
1194 _M_copy_to_string(__result, _CharT(
'0'), _CharT(
'1'));
1200 template<
class _CharT,
class _Traits,
class _Alloc>
1202 to_string(_CharT __zero, _CharT __one = _CharT(
'1'))
const
1205 _M_copy_to_string(__result, __zero, __one);
1211 template<
class _CharT,
class _Traits>
1214 {
return to_string<_CharT, _Traits, std::allocator<_CharT> >(); }
1218 template<
class _CharT,
class _Traits>
1220 to_string(_CharT __zero, _CharT __one = _CharT(
'1'))
const
1224 template<
class _CharT>
1229 return to_string<_CharT, std::char_traits<_CharT>,
1233 template<
class _CharT>
1236 to_string(_CharT __zero, _CharT __one = _CharT(
'1'))
const
1238 return to_string<_CharT, std::char_traits<_CharT>,
1245 return to_string<char, std::char_traits<char>,
1250 to_string(
char __zero,
char __one =
'1')
const
1252 return to_string<char, std::char_traits<char>,
1257 template<
class _CharT,
class _Traits>
1259 _M_copy_from_ptr(
const _CharT*,
size_t,
size_t,
size_t,
1262 template<
class _CharT,
class _Traits,
class _Alloc>
1265 _Traits, _Alloc>& __s,
size_t __pos,
size_t __n,
1266 _CharT __zero, _CharT __one)
1267 { _M_copy_from_ptr<_CharT, _Traits>(__s.
data(), __s.
size(), __pos, __n,
1270 template<
class _CharT,
class _Traits,
class _Alloc>
1273 _CharT, _CharT)
const;
1276 template<
class _CharT,
class _Traits,
class _Alloc>
1279 _Traits, _Alloc>& __s,
size_t __pos,
size_t __n)
1280 { _M_copy_from_string(__s, __pos, __n, _CharT(
'0'), _CharT(
'1')); }
1282 template<
class _CharT,
class _Traits,
class _Alloc>
1285 { _M_copy_to_string(__s, _CharT(
'0'), _CharT(
'1')); }
1290 {
return this->_M_do_count(); }
1293 _GLIBCXX_CONSTEXPR
size_t
1300 operator==(
const bitset<_Nb>& __rhs)
const _GLIBCXX_NOEXCEPT
1301 {
return this->_M_is_equal(__rhs); }
1304 operator!=(
const bitset<_Nb>& __rhs)
const _GLIBCXX_NOEXCEPT
1305 {
return !this->_M_is_equal(__rhs); }
1317 this->_M_check(__position, __N(
"bitset::test"));
1329 {
return this->
template _M_are_all<_Nb>(); }
1337 {
return this->_M_is_any(); }
1345 {
return !this->_M_is_any(); }
1351 {
return bitset<_Nb>(*this) <<= __position; }
1355 {
return bitset<_Nb>(*this) >>= __position; }
1366 {
return this->_M_do_find_first(_Nb); }
1377 {
return this->_M_do_find_next(__prev, _Nb); }
1381 template<
size_t _Nb>
1382 template<
class _CharT,
class _Traits>
1385 _M_copy_from_ptr(
const _CharT* __s,
size_t __len,
1386 size_t __pos,
size_t __n, _CharT __zero, _CharT __one)
1389 const size_t __nbits =
std::min(_Nb,
std::min(__n,
size_t(__len - __pos)));
1390 for (
size_t __i = __nbits; __i > 0; --__i)
1392 const _CharT __c = __s[__pos + __nbits - __i];
1393 if (_Traits::eq(__c, __zero))
1395 else if (_Traits::eq(__c, __one))
1398 __throw_invalid_argument(__N(
"bitset::_M_copy_from_ptr"));
1402 template<
size_t _Nb>
1403 template<
class _CharT,
class _Traits,
class _Alloc>
1407 _CharT __zero, _CharT __one)
const
1410 for (
size_t __i = _Nb; __i > 0; --__i)
1412 _Traits::assign(__s[_Nb - __i], __one);
1425 template<
size_t _Nb>
1427 operator&(
const bitset<_Nb>& __x,
const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT
1429 bitset<_Nb> __result(__x);
1434 template<
size_t _Nb>
1436 operator|(
const bitset<_Nb>& __x,
const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT
1438 bitset<_Nb> __result(__x);
1443 template <
size_t _Nb>
1445 operator^(
const bitset<_Nb>& __x,
const bitset<_Nb>& __y) _GLIBCXX_NOEXCEPT
1447 bitset<_Nb> __result(__x);
1462 template<
class _CharT,
class _Traits,
size_t _Nb>
1466 typedef typename _Traits::char_type char_type;
1468 typedef typename __istream_type::ios_base __ios_base;
1475 const char_type __zero = __is.
widen(
'0');
1476 const char_type __one = __is.
widen(
'1');
1478 typename __ios_base::iostate __state = __ios_base::goodbit;
1479 typename __istream_type::sentry __sentry(__is);
1484 for (
size_t __i = _Nb; __i > 0; --__i)
1486 static typename _Traits::int_type __eof = _Traits::eof();
1488 typename _Traits::int_type __c1 = __is.
rdbuf()->sbumpc();
1489 if (_Traits::eq_int_type(__c1, __eof))
1491 __state |= __ios_base::eofbit;
1496 const char_type __c2 = _Traits::to_char_type(__c1);
1497 if (_Traits::eq(__c2, __zero))
1499 else if (_Traits::eq(__c2, __one))
1502 eq_int_type(__is.
rdbuf()->sputbackc(__c2),
1505 __state |= __ios_base::failbit;
1513 __is._M_setstate(__ios_base::badbit);
1514 __throw_exception_again;
1517 { __is._M_setstate(__ios_base::badbit); }
1520 if (__tmp.
empty() && _Nb)
1521 __state |= __ios_base::failbit;
1523 __x._M_copy_from_string(__tmp, static_cast<size_t>(0), _Nb,
1530 template <
class _CharT,
class _Traits,
size_t _Nb>
1532 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1533 const bitset<_Nb>& __x)
1539 const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__os.getloc());
1540 __x._M_copy_to_string(__tmp, __ct.
widen(
'0'), __ct.
widen(
'1'));
1541 return __os << __tmp;
1545 _GLIBCXX_END_NAMESPACE_CONTAINER
1548 #undef _GLIBCXX_BITSET_WORDS
1549 #undef _GLIBCXX_BITSET_BITS_PER_WORD
1550 #undef _GLIBCXX_BITSET_BITS_PER_ULL
1552 #if __cplusplus >= 201103L
1556 namespace std _GLIBCXX_VISIBILITY(default)
1558 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1562 template<
size_t _Nb>
1563 struct hash<_GLIBCXX_STD_C::bitset<_Nb>>
1564 :
public __hash_base<size_t, _GLIBCXX_STD_C::bitset<_Nb>>
1567 operator()(
const _GLIBCXX_STD_C::bitset<_Nb>& __b)
const noexcept
1569 const size_t __clength = (_Nb + __CHAR_BIT__ - 1) / __CHAR_BIT__;
1570 return std::_Hash_impl::hash(__b._M_getdata(), __clength);
1575 struct hash<_GLIBCXX_STD_C::bitset<0>>
1576 :
public __hash_base<size_t, _GLIBCXX_STD_C::bitset<0>>
1579 operator()(
const _GLIBCXX_STD_C::bitset<0>&) const noexcept
1583 _GLIBCXX_END_NAMESPACE_VERSION
1588 #ifdef _GLIBCXX_DEBUG
1592 #ifdef _GLIBCXX_PROFILE
_GLIBCXX14_CONSTEXPR const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
constexpr bool _Unchecked_test(size_t __pos) const noexcept
Template class basic_ostream.
bitset< _Nb > & _Unchecked_flip(size_t __pos) noexcept
Primary class template hash.
bitset< _Nb > & set() noexcept
Sets every bit to true.
bitset< _Nb > & flip() noexcept
Toggles every bit to its opposite value.
bool any() const noexcept
Tests whether any of the bits are on.
void setstate(iostate __state)
Sets additional flags in the error state.
The standard allocator, as per [20.4].
unsigned long to_ulong() const
Returns a numerical interpretation of the bitset.
bitset< _Nb > operator>>(size_t __position) const noexcept
Self-explanatory.
size_t _Find_first() const noexcept
Finds the index of the first "on" bit.
Template class basic_istream.
void reserve(size_type __res_arg=0)
Attempt to preallocate enough memory for specified number of characters.
basic_string & assign(const basic_string &__str)
Set value to contents of another string.
Basis for explicit traits specializations.
bool test(size_t __position) const
Tests the value of a bit.
bitset< _Nb > operator&(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
char_type widen(char __c) const
Widen char to char_type.
bitset< _Nb > & _Unchecked_set(size_t __pos) noexcept
char_type widen(char __c) const
Widens characters.
std::basic_string< _CharT, _Traits, _Alloc > to_string() const
Returns a character interpretation of the bitset.
size_t count() const noexcept
Returns the number of bits which are set.
bitset< _Nb > operator|(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
_WordT _M_w[_Nw]
0 is the least significant word.
void push_back(_CharT __c)
Append a single character.
Managing sequences of characters and character-like objects.
size_type size() const noexcept
Returns the number of characters in the string, not including any null-termination.
Thrown as part of forced unwinding.A magic placeholder class that can be caught by reference to recog...
bitset< _Nb > & reset() noexcept
Sets every bit to false.
bool empty() const noexcept
bitset< _Nb > operator~() const noexcept
See the no-argument flip().
bitset< _Nb > operator^(const bitset< _Nb > &__x, const bitset< _Nb > &__y) noexcept
Global bitwise operations on bitsets.
reference operator[](size_t __position)
Array-indexing support.
bitset< _Nb > operator<<(size_t __position) const noexcept
Self-explanatory.
Primary class template ctype facet.This template class defines classification and conversion function...
bitset< _Nb > & _Unchecked_reset(size_t __pos) noexcept
const _CharT * data() const noexcept
Return const pointer to contents.
bool none() const noexcept
Tests whether any of the bits are on.
bool all() const noexcept
Tests whether all the bits are on.
bitset< _Nb > & operator>>=(size_t __position) noexcept
constexpr size_t size() const noexcept
Returns the total number of bits.
size_t _Find_next(size_t __prev) const noexcept
Finds the index of the next "on" bit after prev.
bitset< _Nb > & operator<<=(size_t __position) noexcept
basic_streambuf< _CharT, _Traits > * rdbuf() const
Accessing the underlying buffer.