master
1// -*- C++ -*-
2//===----------------------------------------------------------------------===//
3//
4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef _LIBCPP_BITSET
11#define _LIBCPP_BITSET
12
13// clang-format off
14
15/*
16 bitset synopsis
17
18namespace std
19{
20
21namespace std {
22
23template <size_t N>
24class bitset
25{
26public:
27 // bit reference:
28 class reference
29 {
30 friend class bitset;
31 reference() noexcept;
32 public:
33 ~reference() noexcept;
34 reference& operator=(bool x) noexcept; // for b[i] = x;
35 reference& operator=(const reference&) noexcept; // for b[i] = b[j];
36 bool operator~() const noexcept; // flips the bit
37 operator bool() const noexcept; // for x = b[i];
38 reference& flip() noexcept; // for b[i].flip();
39 };
40
41 // 23.3.5.1 constructors:
42 constexpr bitset() noexcept;
43 constexpr bitset(unsigned long long val) noexcept;
44 template <class charT>
45 constexpr explicit bitset(const charT* str,
46 typename basic_string<charT>::size_type n = basic_string<charT>::npos,
47 charT zero = charT('0'), charT one = charT('1')); // until C++26, constexpr since C++23
48 template <class charT>
49 constexpr explicit bitset(const charT* str,
50 typename basic_string_view<charT>::size_type n = basic_string_view<charT>::npos,
51 charT zero = charT('0'), charT one = charT('1')); // since C++26
52 template<class charT, class traits>
53 explicit bitset(
54 const basic_string_view<charT,traits>& str,
55 typename basic_string_view<charT,traits>::size_type pos = 0,
56 typename basic_string_view<charT,traits>::size_type n = basic_string_view<charT,traits>::npos,
57 charT zero = charT('0'), charT one = charT('1')); // since C++26
58 template<class charT, class traits, class Allocator>
59 constexpr explicit bitset(
60 const basic_string<charT,traits,Allocator>& str,
61 typename basic_string<charT,traits,Allocator>::size_type pos = 0,
62 typename basic_string<charT,traits,Allocator>::size_type n = basic_string<charT,traits,Allocator>::npos,
63 charT zero = charT('0'), charT one = charT('1')); // constexpr since C++23
64
65 // 23.3.5.2 bitset operations:
66 bitset& operator&=(const bitset& rhs) noexcept; // constexpr since C++23
67 bitset& operator|=(const bitset& rhs) noexcept; // constexpr since C++23
68 bitset& operator^=(const bitset& rhs) noexcept; // constexpr since C++23
69 bitset& operator<<=(size_t pos) noexcept; // constexpr since C++23
70 bitset& operator>>=(size_t pos) noexcept; // constexpr since C++23
71 bitset& set() noexcept; // constexpr since C++23
72 bitset& set(size_t pos, bool val = true); // constexpr since C++23
73 bitset& reset() noexcept; // constexpr since C++23
74 bitset& reset(size_t pos); // constexpr since C++23
75 bitset operator~() const noexcept; // constexpr since C++23
76 bitset& flip() noexcept; // constexpr since C++23
77 bitset& flip(size_t pos); // constexpr since C++23
78
79 // element access:
80 constexpr bool operator[](size_t pos) const;
81 reference operator[](size_t pos); // constexpr since C++23
82 unsigned long to_ulong() const; // constexpr since C++23
83 unsigned long long to_ullong() const; // constexpr since C++23
84 template <class charT, class traits, class Allocator> // constexpr since C++23
85 basic_string<charT, traits, Allocator> to_string(charT zero = charT('0'), charT one = charT('1')) const;
86 template <class charT, class traits> // constexpr since C++23
87 basic_string<charT, traits, allocator<charT> > to_string(charT zero = charT('0'), charT one = charT('1')) const;
88 template <class charT> // constexpr since C++23
89 basic_string<charT, char_traits<charT>, allocator<charT> > to_string(charT zero = charT('0'), charT one = charT('1')) const;
90 basic_string<char, char_traits<char>, allocator<char> > to_string(char zero = '0', char one = '1') const; // constexpr since C++23
91 size_t count() const noexcept; // constexpr since C++23
92 constexpr size_t size() const noexcept; // constexpr since C++23
93 bool operator==(const bitset& rhs) const noexcept; // constexpr since C++23
94 bool operator!=(const bitset& rhs) const noexcept; // removed in C++20
95 bool test(size_t pos) const; // constexpr since C++23
96 bool all() const noexcept; // constexpr since C++23
97 bool any() const noexcept; // constexpr since C++23
98 bool none() const noexcept; // constexpr since C++23
99 bitset<N> operator<<(size_t pos) const noexcept; // constexpr since C++23
100 bitset<N> operator>>(size_t pos) const noexcept; // constexpr since C++23
101};
102
103// 23.3.5.3 bitset operators:
104template <size_t N>
105bitset<N> operator&(const bitset<N>&, const bitset<N>&) noexcept; // constexpr since C++23
106
107template <size_t N>
108bitset<N> operator|(const bitset<N>&, const bitset<N>&) noexcept; // constexpr since C++23
109
110template <size_t N>
111bitset<N> operator^(const bitset<N>&, const bitset<N>&) noexcept; // constexpr since C++23
112
113template <class charT, class traits, size_t N>
114basic_istream<charT, traits>&
115operator>>(basic_istream<charT, traits>& is, bitset<N>& x);
116
117template <class charT, class traits, size_t N>
118basic_ostream<charT, traits>&
119operator<<(basic_ostream<charT, traits>& os, const bitset<N>& x);
120
121template <size_t N> struct hash<std::bitset<N>>;
122
123} // std
124
125*/
126
127// clang-format on
128
129#if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
130# include <__cxx03/bitset>
131#else
132# include <__algorithm/copy.h>
133# include <__algorithm/copy_backward.h>
134# include <__algorithm/count.h>
135# include <__algorithm/equal.h>
136# include <__algorithm/fill.h>
137# include <__algorithm/fill_n.h>
138# include <__algorithm/find.h>
139# include <__algorithm/min.h>
140# include <__assert>
141# include <__bit/countr.h>
142# include <__bit/invert_if.h>
143# include <__bit_reference>
144# include <__config>
145# include <__cstddef/ptrdiff_t.h>
146# include <__cstddef/size_t.h>
147# include <__functional/hash.h>
148# include <__functional/identity.h>
149# include <__functional/unary_function.h>
150# include <__tuple/tuple_indices.h>
151# include <__type_traits/enable_if.h>
152# include <__type_traits/integral_constant.h>
153# include <__type_traits/is_char_like_type.h>
154# include <__utility/integer_sequence.h>
155# include <climits>
156# include <stdexcept>
157# include <string_view>
158# include <version>
159
160// standard-mandated includes
161
162// [bitset.syn]
163# include <iosfwd>
164# include <string>
165
166# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
167# pragma GCC system_header
168# endif
169
170_LIBCPP_PUSH_MACROS
171# include <__undef_macros>
172
173_LIBCPP_BEGIN_NAMESPACE_STD
174
175template <size_t _N_words, size_t _Size>
176class __bitset;
177
178template <size_t _N_words, size_t _Size>
179struct __has_storage_type<__bitset<_N_words, _Size> > {
180 static const bool value = true;
181};
182
183template <size_t _N_words, size_t _Size>
184class __bitset {
185public:
186 typedef size_t __storage_type;
187
188protected:
189 typedef __bitset __self;
190 typedef __storage_type* __storage_pointer;
191 typedef const __storage_type* __const_storage_pointer;
192 static const unsigned __bits_per_word = static_cast<unsigned>(sizeof(__storage_type) * CHAR_BIT);
193
194 friend class __bit_reference<__bitset>;
195 friend class __bit_const_reference<__bitset>;
196 friend class __bit_iterator<__bitset, false>;
197 friend class __bit_iterator<__bitset, true>;
198 friend struct __bit_array<__bitset>;
199
200 __storage_type __first_[_N_words];
201
202 typedef __bit_reference<__bitset> reference;
203 typedef __bit_const_reference<__bitset> __const_reference;
204 typedef __bit_iterator<__bitset, false> __iterator;
205 typedef __bit_iterator<__bitset, true> __const_iterator;
206
207 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __bitset() _NOEXCEPT;
208 _LIBCPP_HIDE_FROM_ABI explicit _LIBCPP_CONSTEXPR __bitset(unsigned long long __v) _NOEXCEPT;
209
210 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 reference __make_ref(size_t __pos) _NOEXCEPT {
211 return reference(__first_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);
212 }
213 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __const_reference __make_ref(size_t __pos) const _NOEXCEPT {
214 return __const_reference(__first_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);
215 }
216 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 __iterator __make_iter(size_t __pos) _NOEXCEPT {
217 return __iterator(__first_ + __pos / __bits_per_word, __pos % __bits_per_word);
218 }
219 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 __const_iterator __make_iter(size_t __pos) const _NOEXCEPT {
220 return __const_iterator(__first_ + __pos / __bits_per_word, __pos % __bits_per_word);
221 }
222
223 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void operator&=(const __bitset& __v) _NOEXCEPT;
224 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void operator|=(const __bitset& __v) _NOEXCEPT;
225 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void operator^=(const __bitset& __v) _NOEXCEPT;
226
227 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void flip() _NOEXCEPT;
228
229 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long to_ulong() const {
230 if _LIBCPP_CONSTEXPR (_Size > sizeof(unsigned long) * CHAR_BIT) {
231 if (auto __e = __make_iter(_Size); std::find(__make_iter(sizeof(unsigned long) * CHAR_BIT), __e, true) != __e)
232 std::__throw_overflow_error("__bitset<_N_words, _Size>::to_ulong overflow error");
233 }
234
235 static_assert(sizeof(__storage_type) >= sizeof(unsigned long),
236 "libc++ only supports platforms where sizeof(size_t) >= sizeof(unsigned long), such as 32-bit and "
237 "64-bit platforms. If you're interested in supporting a platform where that is not the case, please "
238 "contact the libc++ developers.");
239 return static_cast<unsigned long>(__first_[0]);
240 }
241
242 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long to_ullong() const {
243 // Check for overflow if _Size does not fit in unsigned long long
244 if _LIBCPP_CONSTEXPR (_Size > sizeof(unsigned long long) * CHAR_BIT) {
245 if (auto __e = __make_iter(_Size);
246 std::find(__make_iter(sizeof(unsigned long long) * CHAR_BIT), __e, true) != __e)
247 std::__throw_overflow_error("__bitset<_N_words, _Size>::to_ullong overflow error");
248 }
249
250 // At this point, the effective bitset size (excluding leading zeros) fits in unsigned long long
251
252 if _LIBCPP_CONSTEXPR (sizeof(__storage_type) >= sizeof(unsigned long long)) {
253 // If __storage_type is at least as large as unsigned long long, the result spans only one word
254 return static_cast<unsigned long long>(__first_[0]);
255 } else {
256 // Otherwise, the result spans multiple words which are concatenated
257 const size_t __ull_words = (sizeof(unsigned long long) - 1) / sizeof(__storage_type) + 1;
258 const size_t __n_words = _N_words < __ull_words ? _N_words : __ull_words;
259 unsigned long long __r = static_cast<unsigned long long>(__first_[0]);
260 for (size_t __i = 1; __i < __n_words; ++__i)
261 __r |= static_cast<unsigned long long>(__first_[__i]) << (__bits_per_word * __i);
262 return __r;
263 }
264 }
265
266 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool all() const _NOEXCEPT { return !__scan_bits(__bit_not()); }
267 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool any() const _NOEXCEPT {
268 return __scan_bits(std::__identity());
269 }
270 _LIBCPP_HIDE_FROM_ABI size_t __hash_code() const _NOEXCEPT;
271
272 template <bool _Sparse, class _CharT, class _Traits, class _Allocator>
273 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 basic_string<_CharT, _Traits, _Allocator>
274 __to_string(_CharT __zero, _CharT __one) const {
275 basic_string<_CharT, _Traits, _Allocator> __r(_Size, _Sparse ? __zero : __one);
276 for (size_t __i = 0, __bits = 0; __i < _N_words; ++__i, __bits += __bits_per_word) {
277 __storage_type __word = std::__invert_if<!_Sparse>(__first_[__i]);
278 if (__i == _N_words - 1 && _Size - __bits < __bits_per_word)
279 __word &= (__storage_type(1) << (_Size - __bits)) - 1;
280 for (; __word; __word &= (__word - 1))
281 __r[_Size - 1 - (__bits + std::__countr_zero(__word))] = _Sparse ? __one : __zero;
282 }
283
284 return __r;
285 }
286
287private:
288 struct __bit_not {
289 template <class _Tp>
290 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Tp operator()(const _Tp& __x) const _NOEXCEPT {
291 return ~__x;
292 }
293 };
294
295 template <typename _Proj>
296 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool __scan_bits(_Proj __proj) const _NOEXCEPT {
297 size_t __n = _Size;
298 __const_storage_pointer __p = __first_;
299 // do middle whole words
300 for (; __n >= __bits_per_word; ++__p, __n -= __bits_per_word)
301 if (__proj(*__p))
302 return true;
303 // do last partial word
304 if (__n > 0) {
305 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
306 if (__proj(*__p) & __m)
307 return true;
308 }
309 return false;
310 }
311
312# ifdef _LIBCPP_CXX03_LANG
313 void __init(unsigned long long __v, false_type) _NOEXCEPT;
314 _LIBCPP_HIDE_FROM_ABI void __init(unsigned long long __v, true_type) _NOEXCEPT;
315# else
316 template <size_t... _Indices>
317 _LIBCPP_HIDE_FROM_ABI constexpr __bitset(unsigned long long __v, std::__tuple_indices<_Indices...>) _NOEXCEPT
318 : __first_{static_cast<__storage_type>(__v >> (_Indices * __bits_per_word))...} {}
319# endif // _LIBCPP_CXX03_LANG
320};
321
322template <size_t _N_words, size_t _Size>
323inline _LIBCPP_CONSTEXPR __bitset<_N_words, _Size>::__bitset() _NOEXCEPT
324# ifndef _LIBCPP_CXX03_LANG
325 : __first_{0}
326# endif
327{
328# ifdef _LIBCPP_CXX03_LANG
329 std::fill_n(__first_, _N_words, __storage_type(0));
330# endif
331}
332
333# ifdef _LIBCPP_CXX03_LANG
334
335template <size_t _N_words, size_t _Size>
336void __bitset<_N_words, _Size>::__init(unsigned long long __v, false_type) _NOEXCEPT {
337 const size_t __n_words = std::min((sizeof(unsigned long long) - 1) / sizeof(__storage_type) + 1, _N_words);
338 for (size_t __i = 0; __i < __n_words; ++__i, __v >>= __bits_per_word)
339 __first_[__i] = static_cast<__storage_type>(__v);
340 std::fill(__first_ + __n_words, __first_ + _N_words, __storage_type(0));
341}
342
343template <size_t _N_words, size_t _Size>
344inline _LIBCPP_HIDE_FROM_ABI void __bitset<_N_words, _Size>::__init(unsigned long long __v, true_type) _NOEXCEPT {
345 __first_[0] = __v;
346 std::fill(__first_ + 1, __first_ + _N_words, __storage_type(0));
347}
348
349# endif // _LIBCPP_CXX03_LANG
350
351template <size_t _N_words, size_t _Size>
352inline _LIBCPP_CONSTEXPR __bitset<_N_words, _Size>::__bitset(unsigned long long __v) _NOEXCEPT
353# ifndef _LIBCPP_CXX03_LANG
354 : __bitset(__v,
355 std::__make_indices_imp< (_N_words < (sizeof(unsigned long long) - 1) / sizeof(__storage_type) + 1)
356 ? _N_words
357 : (sizeof(unsigned long long) - 1) / sizeof(__storage_type) + 1,
358 0>{})
359# endif
360{
361# ifdef _LIBCPP_CXX03_LANG
362 __init(__v, _BoolConstant<sizeof(unsigned long long) <= sizeof(__storage_type)>());
363# endif
364}
365
366template <size_t _N_words, size_t _Size>
367inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void
368__bitset<_N_words, _Size>::operator&=(const __bitset& __v) _NOEXCEPT {
369 for (size_t __i = 0; __i < _N_words; ++__i)
370 __first_[__i] &= __v.__first_[__i];
371}
372
373template <size_t _N_words, size_t _Size>
374inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void
375__bitset<_N_words, _Size>::operator|=(const __bitset& __v) _NOEXCEPT {
376 for (size_t __i = 0; __i < _N_words; ++__i)
377 __first_[__i] |= __v.__first_[__i];
378}
379
380template <size_t _N_words, size_t _Size>
381inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void
382__bitset<_N_words, _Size>::operator^=(const __bitset& __v) _NOEXCEPT {
383 for (size_t __i = 0; __i < _N_words; ++__i)
384 __first_[__i] ^= __v.__first_[__i];
385}
386
387template <size_t _N_words, size_t _Size>
388_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void __bitset<_N_words, _Size>::flip() _NOEXCEPT {
389 // do middle whole words
390 size_t __n = _Size;
391 __storage_pointer __p = __first_;
392 for (; __n >= __bits_per_word; ++__p, __n -= __bits_per_word)
393 *__p = ~*__p;
394 // do last partial word
395 // Ensure trailing padding bits are zeroed as part of the ABI for consistent hashing behavior. std::hash<bitset>
396 // assumes trailing bits are zeroed; otherwise, identical bitsets could hash differently.
397 if (__n > 0)
398 *__p ^= (__storage_type(1) << __n) - 1;
399}
400
401template <size_t _N_words, size_t _Size>
402inline size_t __bitset<_N_words, _Size>::__hash_code() const _NOEXCEPT {
403 size_t __h = 0;
404 for (size_t __i = 0; __i < _N_words; ++__i)
405 __h ^= __first_[__i];
406 return __h;
407}
408
409template <size_t _Size>
410class __bitset<1, _Size> {
411public:
412 typedef size_t __storage_type;
413
414protected:
415 typedef __bitset __self;
416 typedef __storage_type* __storage_pointer;
417 typedef const __storage_type* __const_storage_pointer;
418 static const unsigned __bits_per_word = static_cast<unsigned>(sizeof(__storage_type) * CHAR_BIT);
419
420 friend class __bit_reference<__bitset>;
421 friend class __bit_const_reference<__bitset>;
422 friend class __bit_iterator<__bitset, false>;
423 friend class __bit_iterator<__bitset, true>;
424 friend struct __bit_array<__bitset>;
425
426 __storage_type __first_;
427
428 typedef __bit_reference<__bitset> reference;
429 typedef __bit_const_reference<__bitset> __const_reference;
430 typedef __bit_iterator<__bitset, false> __iterator;
431 typedef __bit_iterator<__bitset, true> __const_iterator;
432
433 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __bitset() _NOEXCEPT;
434 _LIBCPP_HIDE_FROM_ABI explicit _LIBCPP_CONSTEXPR __bitset(unsigned long long __v) _NOEXCEPT;
435
436 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 reference __make_ref(size_t __pos) _NOEXCEPT {
437 return reference(&__first_, __storage_type(1) << __pos);
438 }
439 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __const_reference __make_ref(size_t __pos) const _NOEXCEPT {
440 return __const_reference(&__first_, __storage_type(1) << __pos);
441 }
442 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 __iterator __make_iter(size_t __pos) _NOEXCEPT {
443 // Allow the == case to accommodate the past-the-end iterator.
444 _LIBCPP_ASSERT_INTERNAL(__pos <= __bits_per_word, "Out of bounds access in the single-word bitset implementation.");
445 return __pos != __bits_per_word ? __iterator(&__first_, __pos) : __iterator(&__first_ + 1, 0);
446 }
447 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 __const_iterator __make_iter(size_t __pos) const _NOEXCEPT {
448 // Allow the == case to accommodate the past-the-end iterator.
449 _LIBCPP_ASSERT_INTERNAL(__pos <= __bits_per_word, "Out of bounds access in the single-word bitset implementation.");
450 return __pos != __bits_per_word ? __const_iterator(&__first_, __pos) : __const_iterator(&__first_ + 1, 0);
451 }
452
453 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void operator&=(const __bitset& __v) _NOEXCEPT;
454 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void operator|=(const __bitset& __v) _NOEXCEPT;
455 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void operator^=(const __bitset& __v) _NOEXCEPT;
456
457 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void flip() _NOEXCEPT;
458
459 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long to_ulong() const {
460 if _LIBCPP_CONSTEXPR (_Size > sizeof(unsigned long) * CHAR_BIT) {
461 if (auto __e = __make_iter(_Size); std::find(__make_iter(sizeof(unsigned long) * CHAR_BIT), __e, true) != __e)
462 __throw_overflow_error("__bitset<1, _Size>::to_ulong overflow error");
463 }
464 return static_cast<unsigned long>(__first_);
465 }
466
467 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long to_ullong() const {
468 // If _Size exceeds the size of unsigned long long, check for overflow
469 if _LIBCPP_CONSTEXPR (_Size > sizeof(unsigned long long) * CHAR_BIT) {
470 if (auto __e = __make_iter(_Size);
471 std::find(__make_iter(sizeof(unsigned long long) * CHAR_BIT), __e, true) != __e)
472 __throw_overflow_error("__bitset<1, _Size>::to_ullong overflow error");
473 }
474
475 // If _Size fits or no overflow, directly cast to unsigned long long
476 return static_cast<unsigned long long>(__first_);
477 }
478
479 template <bool _Sparse, class _CharT, class _Traits, class _Allocator>
480 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 basic_string<_CharT, _Traits, _Allocator>
481 __to_string(_CharT __zero, _CharT __one) const {
482 basic_string<_CharT, _Traits, _Allocator> __r(_Size, _Sparse ? __zero : __one);
483 __storage_type __word = std::__invert_if<!_Sparse>(__first_);
484 if (_Size < __bits_per_word)
485 __word &= (__storage_type(1) << _Size) - 1;
486 for (; __word; __word &= (__word - 1)) {
487 size_t __pos = std::__countr_zero(__word);
488 __r[_Size - 1 - __pos] = _Sparse ? __one : __zero;
489 }
490 return __r;
491 }
492
493 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool all() const _NOEXCEPT;
494 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool any() const _NOEXCEPT;
495
496 _LIBCPP_HIDE_FROM_ABI size_t __hash_code() const _NOEXCEPT;
497};
498
499template <size_t _Size>
500inline _LIBCPP_CONSTEXPR __bitset<1, _Size>::__bitset() _NOEXCEPT : __first_(0) {}
501
502template <size_t _Size>
503inline _LIBCPP_CONSTEXPR __bitset<1, _Size>::__bitset(unsigned long long __v) _NOEXCEPT
504 // TODO: We must refer to __bits_per_word in order to work around an issue with the GDB pretty-printers.
505 // Without it, the pretty-printers complain about a missing __bits_per_word member. This needs to
506 // be investigated further.
507 : __first_(_Size == __bits_per_word ? static_cast<__storage_type>(__v) : static_cast<__storage_type>(__v)) {}
508
509template <size_t _Size>
510inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void
511__bitset<1, _Size>::operator&=(const __bitset& __v) _NOEXCEPT {
512 __first_ &= __v.__first_;
513}
514
515template <size_t _Size>
516inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void
517__bitset<1, _Size>::operator|=(const __bitset& __v) _NOEXCEPT {
518 __first_ |= __v.__first_;
519}
520
521template <size_t _Size>
522inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void
523__bitset<1, _Size>::operator^=(const __bitset& __v) _NOEXCEPT {
524 __first_ ^= __v.__first_;
525}
526
527template <size_t _Size>
528inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void __bitset<1, _Size>::flip() _NOEXCEPT {
529 __first_ ^= ~__storage_type(0) >> (__bits_per_word - _Size);
530}
531
532template <size_t _Size>
533inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool __bitset<1, _Size>::all() const _NOEXCEPT {
534 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - _Size);
535 return !(~__first_ & __m);
536}
537
538template <size_t _Size>
539inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool __bitset<1, _Size>::any() const _NOEXCEPT {
540 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - _Size);
541 return __first_ & __m;
542}
543
544template <size_t _Size>
545inline size_t __bitset<1, _Size>::__hash_code() const _NOEXCEPT {
546 return __first_;
547}
548
549template <>
550class __bitset<0, 0> {
551public:
552 typedef size_t __storage_type;
553
554protected:
555 typedef __bitset __self;
556 typedef __storage_type* __storage_pointer;
557 typedef const __storage_type* __const_storage_pointer;
558 static const unsigned __bits_per_word = static_cast<unsigned>(sizeof(__storage_type) * CHAR_BIT);
559
560 friend class __bit_reference<__bitset>;
561 friend class __bit_const_reference<__bitset>;
562 friend class __bit_iterator<__bitset, false>;
563 friend class __bit_iterator<__bitset, true>;
564 friend struct __bit_array<__bitset>;
565
566 typedef __bit_reference<__bitset> reference;
567 typedef __bit_const_reference<__bitset> __const_reference;
568 typedef __bit_iterator<__bitset, false> __iterator;
569 typedef __bit_iterator<__bitset, true> __const_iterator;
570
571 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __bitset() _NOEXCEPT;
572 _LIBCPP_HIDE_FROM_ABI explicit _LIBCPP_CONSTEXPR __bitset(unsigned long long) _NOEXCEPT;
573
574 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 reference __make_ref(size_t) _NOEXCEPT {
575 return reference(nullptr, 1);
576 }
577 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __const_reference __make_ref(size_t) const _NOEXCEPT {
578 return __const_reference(nullptr, 1);
579 }
580 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 __iterator __make_iter(size_t) _NOEXCEPT {
581 return __iterator(nullptr, 0);
582 }
583 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 __const_iterator __make_iter(size_t) const _NOEXCEPT {
584 return __const_iterator(nullptr, 0);
585 }
586
587 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void operator&=(const __bitset&) _NOEXCEPT {}
588 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void operator|=(const __bitset&) _NOEXCEPT {}
589 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void operator^=(const __bitset&) _NOEXCEPT {}
590
591 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void flip() _NOEXCEPT {}
592
593 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long to_ulong() const { return 0; }
594 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long to_ullong() const { return 0; }
595
596 template <bool _Sparse, class _CharT, class _Traits, class _Allocator>
597 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 basic_string<_CharT, _Traits, _Allocator>
598 __to_string(_CharT, _CharT) const {
599 return basic_string<_CharT, _Traits, _Allocator>();
600 }
601
602 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool all() const _NOEXCEPT { return true; }
603 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool any() const _NOEXCEPT { return false; }
604
605 _LIBCPP_HIDE_FROM_ABI size_t __hash_code() const _NOEXCEPT { return 0; }
606};
607
608inline _LIBCPP_CONSTEXPR __bitset<0, 0>::__bitset() _NOEXCEPT {}
609
610inline _LIBCPP_CONSTEXPR __bitset<0, 0>::__bitset(unsigned long long) _NOEXCEPT {}
611
612template <size_t _Size>
613class bitset;
614template <size_t _Size>
615struct hash<bitset<_Size> >;
616
617template <size_t _Size>
618class bitset : private __bitset<_Size == 0 ? 0 : (_Size - 1) / (sizeof(size_t) * CHAR_BIT) + 1, _Size> {
619public:
620 static const unsigned __n_words = _Size == 0 ? 0 : (_Size - 1) / (sizeof(size_t) * CHAR_BIT) + 1;
621 typedef __bitset<__n_words, _Size> __base;
622 typedef typename __base::reference reference;
623 typedef typename __base::__const_reference __const_reference;
624
625 // 23.3.5.1 constructors:
626 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bitset() _NOEXCEPT {}
627 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bitset(unsigned long long __v) _NOEXCEPT
628 : __base(sizeof(unsigned long long) * CHAR_BIT <= _Size ? __v : __v & ((1ULL << _Size) - 1)) {}
629 template <class _CharT, __enable_if_t<_IsCharLikeType<_CharT>::value, int> = 0>
630 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 explicit bitset(
631 const _CharT* __str,
632 size_t __n = basic_string<_CharT>::npos,
633 _CharT __zero = _CharT('0'),
634 _CharT __one = _CharT('1')) {
635 if (__n == basic_string<_CharT>::npos)
636 __init_from_string_view(basic_string_view<_CharT>(__str), __zero, __one);
637 else
638 __init_from_string_view(basic_string_view<_CharT>(__str, __n), __zero, __one);
639 }
640# if _LIBCPP_STD_VER >= 26
641 template <class _CharT, class _Traits>
642 _LIBCPP_HIDE_FROM_ABI constexpr explicit bitset(
643 basic_string_view<_CharT, _Traits> __str,
644 typename basic_string_view<_CharT, _Traits>::size_type __pos = 0,
645 typename basic_string_view<_CharT, _Traits>::size_type __n = basic_string_view<_CharT, _Traits>::npos,
646 _CharT __zero = _CharT('0'),
647 _CharT __one = _CharT('1')) {
648 if (__pos > __str.size())
649 std::__throw_out_of_range("bitset string pos out of range");
650
651 size_t __rlen = std::min(__n, __str.size() - __pos);
652 __init_from_string_view(basic_string_view<_CharT, _Traits>(__str.data() + __pos, __rlen), __zero, __one);
653 }
654# endif
655 template <class _CharT, class _Traits, class _Allocator>
656 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 explicit bitset(
657 const basic_string<_CharT, _Traits, _Allocator>& __str,
658 typename basic_string<_CharT, _Traits, _Allocator>::size_type __pos = 0,
659 typename basic_string<_CharT, _Traits, _Allocator>::size_type __n =
660 basic_string<_CharT, _Traits, _Allocator>::npos,
661 _CharT __zero = _CharT('0'),
662 _CharT __one = _CharT('1')) {
663 if (__pos > __str.size())
664 std::__throw_out_of_range("bitset string pos out of range");
665
666 size_t __rlen = std::min(__n, __str.size() - __pos);
667 __init_from_string_view(basic_string_view<_CharT, _Traits>(__str.data() + __pos, __rlen), __zero, __one);
668 }
669
670 // 23.3.5.2 bitset operations:
671 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset& operator&=(const bitset& __rhs) _NOEXCEPT;
672 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset& operator|=(const bitset& __rhs) _NOEXCEPT;
673 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset& operator^=(const bitset& __rhs) _NOEXCEPT;
674 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset& operator<<=(size_t __pos) _NOEXCEPT;
675 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset& operator>>=(size_t __pos) _NOEXCEPT;
676 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset& set() _NOEXCEPT;
677 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset& set(size_t __pos, bool __val = true);
678 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset& reset() _NOEXCEPT;
679 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset& reset(size_t __pos);
680 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset operator~() const _NOEXCEPT;
681 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset& flip() _NOEXCEPT;
682 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset& flip(size_t __pos);
683
684 // element access:
685# ifdef _LIBCPP_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL
686 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator[](size_t __p) const {
687 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__p < _Size, "bitset::operator[] index out of bounds");
688 return __base::__make_ref(__p);
689 }
690# else
691 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __const_reference operator[](size_t __p) const {
692 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__p < _Size, "bitset::operator[] index out of bounds");
693 return __base::__make_ref(__p);
694 }
695# endif
696 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 reference operator[](size_t __p) {
697 _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__p < _Size, "bitset::operator[] index out of bounds");
698 return __base::__make_ref(__p);
699 }
700 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long to_ulong() const { return __base::to_ulong(); }
701 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long to_ullong() const {
702 return __base::to_ullong();
703 }
704 template <class _CharT, class _Traits, class _Allocator>
705 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 basic_string<_CharT, _Traits, _Allocator>
706 to_string(_CharT __zero = _CharT('0'), _CharT __one = _CharT('1')) const;
707 template <class _CharT, class _Traits>
708 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 basic_string<_CharT, _Traits, allocator<_CharT> >
709 to_string(_CharT __zero = _CharT('0'), _CharT __one = _CharT('1')) const;
710 template <class _CharT>
711 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 basic_string<_CharT, char_traits<_CharT>, allocator<_CharT> >
712 to_string(_CharT __zero = _CharT('0'), _CharT __one = _CharT('1')) const;
713 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 basic_string<char, char_traits<char>, allocator<char> >
714 to_string(char __zero = '0', char __one = '1') const;
715 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 size_t count() const _NOEXCEPT;
716 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR size_t size() const _NOEXCEPT { return _Size; }
717 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool operator==(const bitset& __rhs) const _NOEXCEPT;
718# if _LIBCPP_STD_VER <= 17
719 _LIBCPP_HIDE_FROM_ABI bool operator!=(const bitset& __rhs) const _NOEXCEPT;
720# endif
721 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool test(size_t __pos) const;
722 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool all() const _NOEXCEPT { return __base::all(); }
723 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool any() const _NOEXCEPT { return __base::any(); }
724 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool none() const _NOEXCEPT { return !any(); }
725 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset operator<<(size_t __pos) const _NOEXCEPT;
726 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset operator>>(size_t __pos) const _NOEXCEPT;
727
728private:
729 template <class _CharT, class _Traits>
730 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 void
731 __init_from_string_view(basic_string_view<_CharT, _Traits> __str, _CharT __zero, _CharT __one) {
732 for (size_t __i = 0; __i < __str.size(); ++__i)
733 if (!_Traits::eq(__str[__i], __zero) && !_Traits::eq(__str[__i], __one))
734 std::__throw_invalid_argument("bitset string ctor has invalid argument");
735
736 size_t __mp = std::min(__str.size(), _Size);
737 size_t __i = 0;
738 for (; __i < __mp; ++__i) {
739 _CharT __c = __str[__mp - 1 - __i];
740 (*this)[__i] = _Traits::eq(__c, __one);
741 }
742 }
743
744 _LIBCPP_HIDE_FROM_ABI size_t __hash_code() const _NOEXCEPT { return __base::__hash_code(); }
745
746 friend struct hash<bitset>;
747};
748
749template <size_t _Size>
750inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>&
751bitset<_Size>::operator&=(const bitset& __rhs) _NOEXCEPT {
752 __base::operator&=(__rhs);
753 return *this;
754}
755
756template <size_t _Size>
757inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>&
758bitset<_Size>::operator|=(const bitset& __rhs) _NOEXCEPT {
759 __base::operator|=(__rhs);
760 return *this;
761}
762
763template <size_t _Size>
764inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>&
765bitset<_Size>::operator^=(const bitset& __rhs) _NOEXCEPT {
766 __base::operator^=(__rhs);
767 return *this;
768}
769
770template <size_t _Size>
771_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>& bitset<_Size>::operator<<=(size_t __pos) _NOEXCEPT {
772 __pos = std::min(__pos, _Size);
773 std::copy_backward(__base::__make_iter(0), __base::__make_iter(_Size - __pos), __base::__make_iter(_Size));
774 std::fill_n(__base::__make_iter(0), __pos, false);
775 return *this;
776}
777
778template <size_t _Size>
779_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>& bitset<_Size>::operator>>=(size_t __pos) _NOEXCEPT {
780 __pos = std::min(__pos, _Size);
781 std::copy(__base::__make_iter(__pos), __base::__make_iter(_Size), __base::__make_iter(0));
782 std::fill_n(__base::__make_iter(_Size - __pos), __pos, false);
783 return *this;
784}
785
786template <size_t _Size>
787inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>& bitset<_Size>::set() _NOEXCEPT {
788 std::fill_n(__base::__make_iter(0), _Size, true);
789 return *this;
790}
791
792template <size_t _Size>
793_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>& bitset<_Size>::set(size_t __pos, bool __val) {
794 if (__pos >= _Size)
795 std::__throw_out_of_range("bitset set argument out of range");
796
797 (*this)[__pos] = __val;
798 return *this;
799}
800
801template <size_t _Size>
802inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>& bitset<_Size>::reset() _NOEXCEPT {
803 std::fill_n(__base::__make_iter(0), _Size, false);
804 return *this;
805}
806
807template <size_t _Size>
808_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>& bitset<_Size>::reset(size_t __pos) {
809 if (__pos >= _Size)
810 std::__throw_out_of_range("bitset reset argument out of range");
811
812 (*this)[__pos] = false;
813 return *this;
814}
815
816template <size_t _Size>
817inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size> bitset<_Size>::operator~() const _NOEXCEPT {
818 bitset __x(*this);
819 __x.flip();
820 return __x;
821}
822
823template <size_t _Size>
824inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>& bitset<_Size>::flip() _NOEXCEPT {
825 __base::flip();
826 return *this;
827}
828
829template <size_t _Size>
830_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>& bitset<_Size>::flip(size_t __pos) {
831 if (__pos >= _Size)
832 std::__throw_out_of_range("bitset flip argument out of range");
833
834 reference __r = __base::__make_ref(__pos);
835 __r = ~__r;
836 return *this;
837}
838
839template <size_t _Size>
840template <class _CharT, class _Traits, class _Allocator>
841_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 basic_string<_CharT, _Traits, _Allocator>
842bitset<_Size>::to_string(_CharT __zero, _CharT __one) const {
843 bool __sparse = size_t(std::count(__base::__make_iter(0), __base::__make_iter(_Size), true)) < _Size / 2;
844 if (__sparse)
845 return __base::template __to_string<true, _CharT, _Traits, _Allocator>(__zero, __one);
846 else
847 return __base::template __to_string<false, _CharT, _Traits, _Allocator>(__zero, __one);
848}
849
850template <size_t _Size>
851template <class _CharT, class _Traits>
852inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 basic_string<_CharT, _Traits, allocator<_CharT> >
853bitset<_Size>::to_string(_CharT __zero, _CharT __one) const {
854 return to_string<_CharT, _Traits, allocator<_CharT> >(__zero, __one);
855}
856
857template <size_t _Size>
858template <class _CharT>
859inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 basic_string<_CharT, char_traits<_CharT>, allocator<_CharT> >
860bitset<_Size>::to_string(_CharT __zero, _CharT __one) const {
861 return to_string<_CharT, char_traits<_CharT>, allocator<_CharT> >(__zero, __one);
862}
863
864template <size_t _Size>
865inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 basic_string<char, char_traits<char>, allocator<char> >
866bitset<_Size>::to_string(char __zero, char __one) const {
867 return to_string<char, char_traits<char>, allocator<char> >(__zero, __one);
868}
869
870template <size_t _Size>
871inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 size_t bitset<_Size>::count() const _NOEXCEPT {
872 return static_cast<size_t>(std::count(__base::__make_iter(0), __base::__make_iter(_Size), true));
873}
874
875template <size_t _Size>
876inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool
877bitset<_Size>::operator==(const bitset& __rhs) const _NOEXCEPT {
878 return std::equal(__base::__make_iter(0), __base::__make_iter(_Size), __rhs.__make_iter(0));
879}
880
881# if _LIBCPP_STD_VER <= 17
882
883template <size_t _Size>
884inline _LIBCPP_HIDE_FROM_ABI bool bitset<_Size>::operator!=(const bitset& __rhs) const _NOEXCEPT {
885 return !(*this == __rhs);
886}
887
888# endif
889
890template <size_t _Size>
891_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool bitset<_Size>::test(size_t __pos) const {
892 if (__pos >= _Size)
893 std::__throw_out_of_range("bitset test argument out of range");
894
895 return (*this)[__pos];
896}
897
898template <size_t _Size>
899inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>
900bitset<_Size>::operator<<(size_t __pos) const _NOEXCEPT {
901 bitset __r = *this;
902 __r <<= __pos;
903 return __r;
904}
905
906template <size_t _Size>
907inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>
908bitset<_Size>::operator>>(size_t __pos) const _NOEXCEPT {
909 bitset __r = *this;
910 __r >>= __pos;
911 return __r;
912}
913
914template <size_t _Size>
915inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>
916operator&(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT {
917 bitset<_Size> __r = __x;
918 __r &= __y;
919 return __r;
920}
921
922template <size_t _Size>
923inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>
924operator|(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT {
925 bitset<_Size> __r = __x;
926 __r |= __y;
927 return __r;
928}
929
930template <size_t _Size>
931inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>
932operator^(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT {
933 bitset<_Size> __r = __x;
934 __r ^= __y;
935 return __r;
936}
937
938template <size_t _Size>
939struct hash<bitset<_Size> > : public __unary_function<bitset<_Size>, size_t> {
940 _LIBCPP_HIDE_FROM_ABI size_t operator()(const bitset<_Size>& __bs) const _NOEXCEPT { return __bs.__hash_code(); }
941};
942
943template <class _CharT, class _Traits, size_t _Size>
944_LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
945operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x);
946
947template <class _CharT, class _Traits, size_t _Size>
948_LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
949operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x);
950
951_LIBCPP_END_NAMESPACE_STD
952
953_LIBCPP_POP_MACROS
954
955# if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
956# include <concepts>
957# include <cstdlib>
958# include <optional>
959# include <type_traits>
960# endif
961#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
962
963#endif // _LIBCPP_BITSET