blob: 2ad9545f02d38577463fbdc0ff31f6395df608b6 [file] [log] [blame]
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001// -*- C++ -*-
2//===---------------------------- bitset ----------------------------------===//
3//
Howard Hinnantf5256e12010-05-11 21:36:01 +00004// The LLVM Compiler Infrastructure
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00005//
Howard Hinnantb64f8b02010-11-16 22:09:02 +00006// This file is dual licensed under the MIT and the University of Illinois Open
7// Source Licenses. See LICENSE.TXT for details.
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00008//
9//===----------------------------------------------------------------------===//
10
11#ifndef _LIBCPP_BITSET
12#define _LIBCPP_BITSET
13
14/*
15 bitset synopsis
16
17namespace std
18{
19
20namespace std {
21
22template <size_t N>
23class bitset
24{
25public:
26 // bit reference:
27 class reference
28 {
29 friend class bitset;
Howard Hinnant10f25d22011-05-27 20:52:28 +000030 reference() noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000031 public:
Howard Hinnant10f25d22011-05-27 20:52:28 +000032 ~reference() noexcept;
33 reference& operator=(bool x) noexcept; // for b[i] = x;
34 reference& operator=(const reference&) noexcept; // for b[i] = b[j];
35 bool operator~() const noexcept; // flips the bit
36 operator bool() const noexcept; // for x = b[i];
37 reference& flip() noexcept; // for b[i].flip();
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000038 };
39
40 // 23.3.5.1 constructors:
Howard Hinnant10f25d22011-05-27 20:52:28 +000041 constexpr bitset() noexcept;
42 constexpr bitset(unsigned long long val) noexcept;
Howard Hinnant34d6b192010-11-17 21:53:14 +000043 template <class charT>
44 explicit bitset(const charT* str,
45 typename basic_string<charT>::size_type n = basic_string<charT>::npos,
46 charT zero = charT('0'), charT one = charT('1'));
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000047 template<class charT, class traits, class Allocator>
48 explicit bitset(const basic_string<charT,traits,Allocator>& str,
49 typename basic_string<charT,traits,Allocator>::size_type pos = 0,
50 typename basic_string<charT,traits,Allocator>::size_type n =
51 basic_string<charT,traits,Allocator>::npos,
52 charT zero = charT('0'), charT one = charT('1'));
53
54 // 23.3.5.2 bitset operations:
Howard Hinnant10f25d22011-05-27 20:52:28 +000055 bitset& operator&=(const bitset& rhs) noexcept;
56 bitset& operator|=(const bitset& rhs) noexcept;
57 bitset& operator^=(const bitset& rhs) noexcept;
58 bitset& operator<<=(size_t pos) noexcept;
59 bitset& operator>>=(size_t pos) noexcept;
60 bitset& set() noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000061 bitset& set(size_t pos, bool val = true);
Howard Hinnant10f25d22011-05-27 20:52:28 +000062 bitset& reset() noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000063 bitset& reset(size_t pos);
Howard Hinnant10f25d22011-05-27 20:52:28 +000064 bitset operator~() const noexcept;
65 bitset& flip() noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000066 bitset& flip(size_t pos);
67
68 // element access:
69 constexpr bool operator[](size_t pos) const; // for b[i];
70 reference operator[](size_t pos); // for b[i];
71 unsigned long to_ulong() const;
72 unsigned long long to_ullong() const;
73 template <class charT, class traits, class Allocator>
74 basic_string<charT, traits, Allocator> to_string(charT zero = charT('0'), charT one = charT('1')) const;
75 template <class charT, class traits>
76 basic_string<charT, traits, allocator<charT> > to_string(charT zero = charT('0'), charT one = charT('1')) const;
77 template <class charT>
78 basic_string<charT, char_traits<charT>, allocator<charT> > to_string(charT zero = charT('0'), charT one = charT('1')) const;
79 basic_string<char, char_traits<char>, allocator<char> > to_string(char zero = '0', char one = '1') const;
Howard Hinnant10f25d22011-05-27 20:52:28 +000080 size_t count() const noexcept;
81 constexpr size_t size() const noexcept;
82 bool operator==(const bitset& rhs) const noexcept;
83 bool operator!=(const bitset& rhs) const noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000084 bool test(size_t pos) const;
Howard Hinnant10f25d22011-05-27 20:52:28 +000085 bool all() const noexcept;
86 bool any() const noexcept;
87 bool none() const noexcept;
88 bitset operator<<(size_t pos) const noexcept;
89 bitset operator>>(size_t pos) const noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000090};
91
92// 23.3.5.3 bitset operators:
93template <size_t N>
Howard Hinnant10f25d22011-05-27 20:52:28 +000094bitset<N> operator&(const bitset<N>&, const bitset<N>&) noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000095
96template <size_t N>
Howard Hinnant10f25d22011-05-27 20:52:28 +000097bitset<N> operator|(const bitset<N>&, const bitset<N>&) noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +000098
99template <size_t N>
Howard Hinnant10f25d22011-05-27 20:52:28 +0000100bitset<N> operator^(const bitset<N>&, const bitset<N>&) noexcept;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000101
102template <class charT, class traits, size_t N>
103basic_istream<charT, traits>&
104operator>>(basic_istream<charT, traits>& is, bitset<N>& x);
105
106template <class charT, class traits, size_t N>
107basic_ostream<charT, traits>&
108operator<<(basic_ostream<charT, traits>& os, const bitset<N>& x);
109
110template <size_t N> struct hash<std::bitset<N>>;
111
112} // std
113
114*/
115
Howard Hinnant08e17472011-10-17 20:05:10 +0000116#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000117#pragma GCC system_header
Howard Hinnant08e17472011-10-17 20:05:10 +0000118#endif
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000119
120#include <__config>
121#include <__bit_reference>
122#include <cstddef>
123#include <climits>
124#include <string>
125#include <stdexcept>
126#include <iosfwd>
127#include <__functional_base>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000128
Howard Hinnant66c6f972011-11-29 16:45:27 +0000129#include <__undef_min_max>
130
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000131_LIBCPP_BEGIN_NAMESPACE_STD
132
133template <size_t _N_words, size_t _Size>
Howard Hinnantf03c3b42011-07-02 20:33:23 +0000134class __bitset;
135
136template <size_t _N_words, size_t _Size>
137struct __has_storage_type<__bitset<_N_words, _Size> >
138{
139 static const bool value = true;
140};
141
142template <size_t _N_words, size_t _Size>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000143class __bitset
144{
145public:
146 typedef ptrdiff_t difference_type;
147 typedef size_t size_type;
Howard Hinnantf867f632012-05-07 16:50:38 +0000148 typedef size_type __storage_type;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000149protected:
150 typedef __bitset __self;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000151 typedef __storage_type* __storage_pointer;
152 typedef const __storage_type* __const_storage_pointer;
153 static const unsigned __bits_per_word = static_cast<unsigned>(sizeof(__storage_type) * CHAR_BIT);
154
155 friend class __bit_reference<__bitset>;
156 friend class __bit_const_reference<__bitset>;
157 friend class __bit_iterator<__bitset, false>;
158 friend class __bit_iterator<__bitset, true>;
Howard Hinnant4ae952a2012-08-17 17:10:18 +0000159 friend struct __bit_array<__bitset>;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000160
161 __storage_type __first_[_N_words];
162
163 typedef __bit_reference<__bitset> reference;
164 typedef __bit_const_reference<__bitset> const_reference;
165 typedef __bit_iterator<__bitset, false> iterator;
166 typedef __bit_iterator<__bitset, true> const_iterator;
167
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000168 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant90d87232012-07-07 17:04:52 +0000169 _LIBCPP_CONSTEXPR __bitset() _NOEXCEPT;
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000170 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant90d87232012-07-07 17:04:52 +0000171 explicit _LIBCPP_CONSTEXPR __bitset(unsigned long long __v) _NOEXCEPT;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000172
Howard Hinnant10f25d22011-05-27 20:52:28 +0000173 _LIBCPP_INLINE_VISIBILITY reference __make_ref(size_t __pos) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000174 {return reference(__first_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);}
Howard Hinnant90d87232012-07-07 17:04:52 +0000175 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR const_reference __make_ref(size_t __pos) const _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000176 {return const_reference(__first_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);}
Howard Hinnant10f25d22011-05-27 20:52:28 +0000177 _LIBCPP_INLINE_VISIBILITY iterator __make_iter(size_t __pos) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000178 {return iterator(__first_ + __pos / __bits_per_word, __pos % __bits_per_word);}
Howard Hinnant10f25d22011-05-27 20:52:28 +0000179 _LIBCPP_INLINE_VISIBILITY const_iterator __make_iter(size_t __pos) const _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000180 {return const_iterator(__first_ + __pos / __bits_per_word, __pos % __bits_per_word);}
181
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000182 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant10f25d22011-05-27 20:52:28 +0000183 void operator&=(const __bitset& __v) _NOEXCEPT;
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000184 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant10f25d22011-05-27 20:52:28 +0000185 void operator|=(const __bitset& __v) _NOEXCEPT;
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000186 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant10f25d22011-05-27 20:52:28 +0000187 void operator^=(const __bitset& __v) _NOEXCEPT;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000188
Howard Hinnant10f25d22011-05-27 20:52:28 +0000189 void flip() _NOEXCEPT;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000190 _LIBCPP_INLINE_VISIBILITY unsigned long to_ulong() const
191 {return to_ulong(integral_constant<bool, _Size < sizeof(unsigned long) * CHAR_BIT>());}
192 _LIBCPP_INLINE_VISIBILITY unsigned long long to_ullong() const
193 {return to_ullong(integral_constant<bool, _Size < sizeof(unsigned long long) * CHAR_BIT>());}
194
Howard Hinnant10f25d22011-05-27 20:52:28 +0000195 bool all() const _NOEXCEPT;
196 bool any() const _NOEXCEPT;
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000197 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant10f25d22011-05-27 20:52:28 +0000198 size_t __hash_code() const _NOEXCEPT;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000199private:
Howard Hinnant90d87232012-07-07 17:04:52 +0000200#ifdef _LIBCPP_HAS_NO_CONSTEXPR
Howard Hinnant10f25d22011-05-27 20:52:28 +0000201 void __init(unsigned long long __v, false_type) _NOEXCEPT;
Evgeniy Stepanov28c02db2015-12-09 22:32:36 +0000202 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant10f25d22011-05-27 20:52:28 +0000203 void __init(unsigned long long __v, true_type) _NOEXCEPT;
Howard Hinnant90d87232012-07-07 17:04:52 +0000204#endif // _LIBCPP_HAS_NO_CONSTEXPR
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000205 unsigned long to_ulong(false_type) const;
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000206 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000207 unsigned long to_ulong(true_type) const;
208 unsigned long long to_ullong(false_type) const;
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000209 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000210 unsigned long long to_ullong(true_type) const;
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000211 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000212 unsigned long long to_ullong(true_type, false_type) const;
213 unsigned long long to_ullong(true_type, true_type) const;
214};
215
216template <size_t _N_words, size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000217inline
Howard Hinnant90d87232012-07-07 17:04:52 +0000218_LIBCPP_CONSTEXPR
Howard Hinnant10f25d22011-05-27 20:52:28 +0000219__bitset<_N_words, _Size>::__bitset() _NOEXCEPT
Howard Hinnant90d87232012-07-07 17:04:52 +0000220#ifndef _LIBCPP_HAS_NO_CONSTEXPR
221 : __first_{0}
222#endif
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000223{
Howard Hinnant90d87232012-07-07 17:04:52 +0000224#ifdef _LIBCPP_HAS_NO_CONSTEXPR
Howard Hinnant0949eed2011-06-30 21:18:19 +0000225 _VSTD::fill_n(__first_, _N_words, __storage_type(0));
Howard Hinnant90d87232012-07-07 17:04:52 +0000226#endif
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000227}
228
Howard Hinnant90d87232012-07-07 17:04:52 +0000229#ifdef _LIBCPP_HAS_NO_CONSTEXPR
230
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000231template <size_t _N_words, size_t _Size>
232void
Howard Hinnantec3773c2011-12-01 20:21:04 +0000233__bitset<_N_words, _Size>::__init(unsigned long long __v, false_type) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000234{
235 __storage_type __t[sizeof(unsigned long long) / sizeof(__storage_type)];
236 for (size_t __i = 0; __i < sizeof(__t)/sizeof(__t[0]); ++__i, __v >>= __bits_per_word)
237 __t[__i] = static_cast<__storage_type>(__v);
Howard Hinnant0949eed2011-06-30 21:18:19 +0000238 _VSTD::copy(__t, __t + sizeof(__t)/sizeof(__t[0]), __first_);
239 _VSTD::fill(__first_ + sizeof(__t)/sizeof(__t[0]), __first_ + sizeof(__first_)/sizeof(__first_[0]),
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000240 __storage_type(0));
241}
242
243template <size_t _N_words, size_t _Size>
244inline _LIBCPP_INLINE_VISIBILITY
245void
Howard Hinnantec3773c2011-12-01 20:21:04 +0000246__bitset<_N_words, _Size>::__init(unsigned long long __v, true_type) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000247{
248 __first_[0] = __v;
Howard Hinnant0949eed2011-06-30 21:18:19 +0000249 _VSTD::fill(__first_ + 1, __first_ + sizeof(__first_)/sizeof(__first_[0]), __storage_type(0));
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000250}
251
Howard Hinnant90d87232012-07-07 17:04:52 +0000252#endif // _LIBCPP_HAS_NO_CONSTEXPR
253
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000254template <size_t _N_words, size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000255inline
Howard Hinnant90d87232012-07-07 17:04:52 +0000256_LIBCPP_CONSTEXPR
Howard Hinnant10f25d22011-05-27 20:52:28 +0000257__bitset<_N_words, _Size>::__bitset(unsigned long long __v) _NOEXCEPT
Howard Hinnant90d87232012-07-07 17:04:52 +0000258#ifndef _LIBCPP_HAS_NO_CONSTEXPR
Nico Weber0211e862014-06-04 15:46:56 +0000259#if __SIZEOF_SIZE_T__ == 8
Howard Hinnant90d87232012-07-07 17:04:52 +0000260 : __first_{__v}
Nico Weber0211e862014-06-04 15:46:56 +0000261#elif __SIZEOF_SIZE_T__ == 4
Howard Hinnant11a31d02013-03-06 17:30:26 +0000262 : __first_{__v, __v >> __bits_per_word}
Howard Hinnant31014742013-03-06 18:16:12 +0000263#else
Howard Hinnant11a31d02013-03-06 17:30:26 +0000264#error This constructor has not been ported to this platform
265#endif
Howard Hinnant90d87232012-07-07 17:04:52 +0000266#endif
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000267{
Howard Hinnant90d87232012-07-07 17:04:52 +0000268#ifdef _LIBCPP_HAS_NO_CONSTEXPR
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000269 __init(__v, integral_constant<bool, sizeof(unsigned long long) == sizeof(__storage_type)>());
Howard Hinnant90d87232012-07-07 17:04:52 +0000270#endif
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000271}
272
273template <size_t _N_words, size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000274inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000275void
Howard Hinnant10f25d22011-05-27 20:52:28 +0000276__bitset<_N_words, _Size>::operator&=(const __bitset& __v) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000277{
278 for (size_type __i = 0; __i < _N_words; ++__i)
279 __first_[__i] &= __v.__first_[__i];
280}
281
282template <size_t _N_words, size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000283inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000284void
Howard Hinnant10f25d22011-05-27 20:52:28 +0000285__bitset<_N_words, _Size>::operator|=(const __bitset& __v) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000286{
287 for (size_type __i = 0; __i < _N_words; ++__i)
288 __first_[__i] |= __v.__first_[__i];
289}
290
291template <size_t _N_words, size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000292inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000293void
Howard Hinnant10f25d22011-05-27 20:52:28 +0000294__bitset<_N_words, _Size>::operator^=(const __bitset& __v) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000295{
296 for (size_type __i = 0; __i < _N_words; ++__i)
297 __first_[__i] ^= __v.__first_[__i];
298}
299
300template <size_t _N_words, size_t _Size>
301void
Howard Hinnant10f25d22011-05-27 20:52:28 +0000302__bitset<_N_words, _Size>::flip() _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000303{
304 // do middle whole words
305 size_type __n = _Size;
306 __storage_pointer __p = __first_;
307 for (; __n >= __bits_per_word; ++__p, __n -= __bits_per_word)
308 *__p = ~*__p;
309 // do last partial word
310 if (__n > 0)
311 {
312 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
313 __storage_type __b = *__p & __m;
314 *__p &= ~__m;
315 *__p |= ~__b & __m;
316 }
317}
318
319template <size_t _N_words, size_t _Size>
320unsigned long
321__bitset<_N_words, _Size>::to_ulong(false_type) const
322{
323 const_iterator __e = __make_iter(_Size);
Howard Hinnant0949eed2011-06-30 21:18:19 +0000324 const_iterator __i = _VSTD::find(__make_iter(sizeof(unsigned long) * CHAR_BIT), __e, true);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000325 if (__i != __e)
Marshall Clow14c09a22016-08-25 15:09:01 +0000326 __throw_overflow_error("bitset to_ulong overflow error");
327
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000328 return __first_[0];
329}
330
331template <size_t _N_words, size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000332inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000333unsigned long
334__bitset<_N_words, _Size>::to_ulong(true_type) const
335{
336 return __first_[0];
337}
338
339template <size_t _N_words, size_t _Size>
340unsigned long long
341__bitset<_N_words, _Size>::to_ullong(false_type) const
342{
343 const_iterator __e = __make_iter(_Size);
Howard Hinnant0949eed2011-06-30 21:18:19 +0000344 const_iterator __i = _VSTD::find(__make_iter(sizeof(unsigned long long) * CHAR_BIT), __e, true);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000345 if (__i != __e)
Marshall Clow14c09a22016-08-25 15:09:01 +0000346 __throw_overflow_error("bitset to_ullong overflow error");
347
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000348 return to_ullong(true_type());
349}
350
351template <size_t _N_words, size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000352inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000353unsigned long long
354__bitset<_N_words, _Size>::to_ullong(true_type) const
355{
356 return to_ullong(true_type(), integral_constant<bool, sizeof(__storage_type) < sizeof(unsigned long long)>());
357}
358
359template <size_t _N_words, size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000360inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000361unsigned long long
362__bitset<_N_words, _Size>::to_ullong(true_type, false_type) const
363{
364 return __first_[0];
365}
366
367template <size_t _N_words, size_t _Size>
368unsigned long long
369__bitset<_N_words, _Size>::to_ullong(true_type, true_type) const
370{
371 unsigned long long __r = __first_[0];
372 for (std::size_t __i = 1; __i < sizeof(unsigned long long) / sizeof(__storage_type); ++__i)
373 __r |= static_cast<unsigned long long>(__first_[__i]) << (sizeof(__storage_type) * CHAR_BIT);
374 return __r;
375}
376
377template <size_t _N_words, size_t _Size>
378bool
Howard Hinnant10f25d22011-05-27 20:52:28 +0000379__bitset<_N_words, _Size>::all() const _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000380{
381 // do middle whole words
382 size_type __n = _Size;
383 __const_storage_pointer __p = __first_;
384 for (; __n >= __bits_per_word; ++__p, __n -= __bits_per_word)
385 if (~*__p)
386 return false;
387 // do last partial word
388 if (__n > 0)
389 {
390 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
391 if (~*__p & __m)
392 return false;
393 }
394 return true;
395}
396
397template <size_t _N_words, size_t _Size>
398bool
Howard Hinnant10f25d22011-05-27 20:52:28 +0000399__bitset<_N_words, _Size>::any() const _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000400{
401 // do middle whole words
402 size_type __n = _Size;
403 __const_storage_pointer __p = __first_;
404 for (; __n >= __bits_per_word; ++__p, __n -= __bits_per_word)
405 if (*__p)
406 return true;
407 // do last partial word
408 if (__n > 0)
409 {
410 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
411 if (*__p & __m)
412 return true;
413 }
414 return false;
415}
416
417template <size_t _N_words, size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000418inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000419size_t
Howard Hinnant10f25d22011-05-27 20:52:28 +0000420__bitset<_N_words, _Size>::__hash_code() const _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000421{
422 size_t __h = 0;
423 for (size_type __i = 0; __i < _N_words; ++__i)
424 __h ^= __first_[__i];
425 return __h;
426}
427
428template <size_t _Size>
429class __bitset<1, _Size>
430{
431public:
432 typedef ptrdiff_t difference_type;
433 typedef size_t size_type;
Howard Hinnantf867f632012-05-07 16:50:38 +0000434 typedef size_type __storage_type;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000435protected:
436 typedef __bitset __self;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000437 typedef __storage_type* __storage_pointer;
438 typedef const __storage_type* __const_storage_pointer;
439 static const unsigned __bits_per_word = static_cast<unsigned>(sizeof(__storage_type) * CHAR_BIT);
440
441 friend class __bit_reference<__bitset>;
442 friend class __bit_const_reference<__bitset>;
443 friend class __bit_iterator<__bitset, false>;
444 friend class __bit_iterator<__bitset, true>;
Howard Hinnant4ae952a2012-08-17 17:10:18 +0000445 friend struct __bit_array<__bitset>;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000446
447 __storage_type __first_;
448
449 typedef __bit_reference<__bitset> reference;
450 typedef __bit_const_reference<__bitset> const_reference;
451 typedef __bit_iterator<__bitset, false> iterator;
452 typedef __bit_iterator<__bitset, true> const_iterator;
453
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000454 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant90d87232012-07-07 17:04:52 +0000455 _LIBCPP_CONSTEXPR __bitset() _NOEXCEPT;
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000456 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant90d87232012-07-07 17:04:52 +0000457 explicit _LIBCPP_CONSTEXPR __bitset(unsigned long long __v) _NOEXCEPT;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000458
Howard Hinnant10f25d22011-05-27 20:52:28 +0000459 _LIBCPP_INLINE_VISIBILITY reference __make_ref(size_t __pos) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000460 {return reference(&__first_, __storage_type(1) << __pos);}
Howard Hinnant90d87232012-07-07 17:04:52 +0000461 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR const_reference __make_ref(size_t __pos) const _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000462 {return const_reference(&__first_, __storage_type(1) << __pos);}
Howard Hinnant10f25d22011-05-27 20:52:28 +0000463 _LIBCPP_INLINE_VISIBILITY iterator __make_iter(size_t __pos) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000464 {return iterator(&__first_ + __pos / __bits_per_word, __pos % __bits_per_word);}
Howard Hinnant10f25d22011-05-27 20:52:28 +0000465 _LIBCPP_INLINE_VISIBILITY const_iterator __make_iter(size_t __pos) const _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000466 {return const_iterator(&__first_ + __pos / __bits_per_word, __pos % __bits_per_word);}
467
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000468 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant10f25d22011-05-27 20:52:28 +0000469 void operator&=(const __bitset& __v) _NOEXCEPT;
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000470 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant10f25d22011-05-27 20:52:28 +0000471 void operator|=(const __bitset& __v) _NOEXCEPT;
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000472 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant10f25d22011-05-27 20:52:28 +0000473 void operator^=(const __bitset& __v) _NOEXCEPT;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000474
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000475 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant10f25d22011-05-27 20:52:28 +0000476 void flip() _NOEXCEPT;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000477
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000478 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000479 unsigned long to_ulong() const;
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000480 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000481 unsigned long long to_ullong() const;
482
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000483 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant10f25d22011-05-27 20:52:28 +0000484 bool all() const _NOEXCEPT;
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000485 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant10f25d22011-05-27 20:52:28 +0000486 bool any() const _NOEXCEPT;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000487
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000488 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant10f25d22011-05-27 20:52:28 +0000489 size_t __hash_code() const _NOEXCEPT;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000490};
491
492template <size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000493inline
Howard Hinnant90d87232012-07-07 17:04:52 +0000494_LIBCPP_CONSTEXPR
Howard Hinnant10f25d22011-05-27 20:52:28 +0000495__bitset<1, _Size>::__bitset() _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000496 : __first_(0)
497{
498}
499
500template <size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000501inline
Howard Hinnant90d87232012-07-07 17:04:52 +0000502_LIBCPP_CONSTEXPR
Howard Hinnant10f25d22011-05-27 20:52:28 +0000503__bitset<1, _Size>::__bitset(unsigned long long __v) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000504 : __first_(static_cast<__storage_type>(__v))
505{
506}
507
508template <size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000509inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000510void
Howard Hinnant10f25d22011-05-27 20:52:28 +0000511__bitset<1, _Size>::operator&=(const __bitset& __v) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000512{
513 __first_ &= __v.__first_;
514}
515
516template <size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000517inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000518void
Howard Hinnant10f25d22011-05-27 20:52:28 +0000519__bitset<1, _Size>::operator|=(const __bitset& __v) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000520{
521 __first_ |= __v.__first_;
522}
523
524template <size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000525inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000526void
Howard Hinnant10f25d22011-05-27 20:52:28 +0000527__bitset<1, _Size>::operator^=(const __bitset& __v) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000528{
529 __first_ ^= __v.__first_;
530}
531
532template <size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000533inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000534void
Howard Hinnant10f25d22011-05-27 20:52:28 +0000535__bitset<1, _Size>::flip() _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000536{
537 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - _Size);
538 __first_ = ~__first_;
539 __first_ &= __m;
540}
541
542template <size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000543inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000544unsigned long
545__bitset<1, _Size>::to_ulong() const
546{
547 return __first_;
548}
549
550template <size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000551inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000552unsigned long long
553__bitset<1, _Size>::to_ullong() const
554{
555 return __first_;
556}
557
558template <size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000559inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000560bool
Howard Hinnant10f25d22011-05-27 20:52:28 +0000561__bitset<1, _Size>::all() const _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000562{
563 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - _Size);
564 return !(~__first_ & __m);
565}
566
567template <size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000568inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000569bool
Howard Hinnant10f25d22011-05-27 20:52:28 +0000570__bitset<1, _Size>::any() const _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000571{
572 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - _Size);
573 return __first_ & __m;
574}
575
576template <size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000577inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000578size_t
Howard Hinnant10f25d22011-05-27 20:52:28 +0000579__bitset<1, _Size>::__hash_code() const _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000580{
581 return __first_;
582}
583
584template <>
585class __bitset<0, 0>
586{
587public:
588 typedef ptrdiff_t difference_type;
589 typedef size_t size_type;
Howard Hinnantf867f632012-05-07 16:50:38 +0000590 typedef size_type __storage_type;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000591protected:
592 typedef __bitset __self;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000593 typedef __storage_type* __storage_pointer;
594 typedef const __storage_type* __const_storage_pointer;
595 static const unsigned __bits_per_word = static_cast<unsigned>(sizeof(__storage_type) * CHAR_BIT);
596
597 friend class __bit_reference<__bitset>;
598 friend class __bit_const_reference<__bitset>;
599 friend class __bit_iterator<__bitset, false>;
600 friend class __bit_iterator<__bitset, true>;
Howard Hinnantec3773c2011-12-01 20:21:04 +0000601 friend struct __bit_array<__bitset>;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000602
603 typedef __bit_reference<__bitset> reference;
604 typedef __bit_const_reference<__bitset> const_reference;
605 typedef __bit_iterator<__bitset, false> iterator;
606 typedef __bit_iterator<__bitset, true> const_iterator;
607
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000608 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant90d87232012-07-07 17:04:52 +0000609 _LIBCPP_CONSTEXPR __bitset() _NOEXCEPT;
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000610 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant90d87232012-07-07 17:04:52 +0000611 explicit _LIBCPP_CONSTEXPR __bitset(unsigned long long) _NOEXCEPT;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000612
Howard Hinnant10f25d22011-05-27 20:52:28 +0000613 _LIBCPP_INLINE_VISIBILITY reference __make_ref(size_t) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000614 {return reference(0, 1);}
Howard Hinnant90d87232012-07-07 17:04:52 +0000615 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR const_reference __make_ref(size_t) const _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000616 {return const_reference(0, 1);}
Howard Hinnantec3773c2011-12-01 20:21:04 +0000617 _LIBCPP_INLINE_VISIBILITY iterator __make_iter(size_t) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000618 {return iterator(0, 0);}
Howard Hinnantec3773c2011-12-01 20:21:04 +0000619 _LIBCPP_INLINE_VISIBILITY const_iterator __make_iter(size_t) const _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000620 {return const_iterator(0, 0);}
621
Howard Hinnant10f25d22011-05-27 20:52:28 +0000622 _LIBCPP_INLINE_VISIBILITY void operator&=(const __bitset&) _NOEXCEPT {}
623 _LIBCPP_INLINE_VISIBILITY void operator|=(const __bitset&) _NOEXCEPT {}
624 _LIBCPP_INLINE_VISIBILITY void operator^=(const __bitset&) _NOEXCEPT {}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000625
Howard Hinnant10f25d22011-05-27 20:52:28 +0000626 _LIBCPP_INLINE_VISIBILITY void flip() _NOEXCEPT {}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000627
628 _LIBCPP_INLINE_VISIBILITY unsigned long to_ulong() const {return 0;}
629 _LIBCPP_INLINE_VISIBILITY unsigned long long to_ullong() const {return 0;}
630
Howard Hinnant10f25d22011-05-27 20:52:28 +0000631 _LIBCPP_INLINE_VISIBILITY bool all() const _NOEXCEPT {return true;}
632 _LIBCPP_INLINE_VISIBILITY bool any() const _NOEXCEPT {return false;}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000633
Howard Hinnant10f25d22011-05-27 20:52:28 +0000634 _LIBCPP_INLINE_VISIBILITY size_t __hash_code() const _NOEXCEPT {return 0;}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000635};
636
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000637inline
Howard Hinnant90d87232012-07-07 17:04:52 +0000638_LIBCPP_CONSTEXPR
Howard Hinnant10f25d22011-05-27 20:52:28 +0000639__bitset<0, 0>::__bitset() _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000640{
641}
642
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000643inline
Howard Hinnant90d87232012-07-07 17:04:52 +0000644_LIBCPP_CONSTEXPR
Howard Hinnant10f25d22011-05-27 20:52:28 +0000645__bitset<0, 0>::__bitset(unsigned long long) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000646{
647}
648
Howard Hinnant0f678bd2013-08-12 18:38:34 +0000649template <size_t _Size> class _LIBCPP_TYPE_VIS_ONLY bitset;
Eric Fiselier566bcb42016-04-21 22:54:21 +0000650template <size_t _Size> struct hash<bitset<_Size> >;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000651
652template <size_t _Size>
Howard Hinnant0f678bd2013-08-12 18:38:34 +0000653class _LIBCPP_TYPE_VIS_ONLY bitset
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000654 : private __bitset<_Size == 0 ? 0 : (_Size - 1) / (sizeof(size_t) * CHAR_BIT) + 1, _Size>
655{
Howard Hinnant11a31d02013-03-06 17:30:26 +0000656public:
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000657 static const unsigned __n_words = _Size == 0 ? 0 : (_Size - 1) / (sizeof(size_t) * CHAR_BIT) + 1;
658 typedef __bitset<__n_words, _Size> base;
659
Howard Hinnant324bb032010-08-22 00:02:43 +0000660public:
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000661 typedef typename base::reference reference;
662 typedef typename base::const_reference const_reference;
663
Howard Hinnant324bb032010-08-22 00:02:43 +0000664 // 23.3.5.1 constructors:
Howard Hinnant90d87232012-07-07 17:04:52 +0000665 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR bitset() _NOEXCEPT {}
666 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
667 bitset(unsigned long long __v) _NOEXCEPT : base(__v) {}
Howard Hinnant34d6b192010-11-17 21:53:14 +0000668 template<class _CharT>
669 explicit bitset(const _CharT* __str,
670 typename basic_string<_CharT>::size_type __n = basic_string<_CharT>::npos,
671 _CharT __zero = _CharT('0'), _CharT __one = _CharT('1'));
Howard Hinnant324bb032010-08-22 00:02:43 +0000672 template<class _CharT, class _Traits, class _Allocator>
673 explicit bitset(const basic_string<_CharT,_Traits,_Allocator>& __str,
674 typename basic_string<_CharT,_Traits,_Allocator>::size_type __pos = 0,
675 typename basic_string<_CharT,_Traits,_Allocator>::size_type __n =
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000676 (basic_string<_CharT,_Traits,_Allocator>::npos),
Howard Hinnant324bb032010-08-22 00:02:43 +0000677 _CharT __zero = _CharT('0'), _CharT __one = _CharT('1'));
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000678
Howard Hinnant324bb032010-08-22 00:02:43 +0000679 // 23.3.5.2 bitset operations:
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000680 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant10f25d22011-05-27 20:52:28 +0000681 bitset& operator&=(const bitset& __rhs) _NOEXCEPT;
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000682 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant10f25d22011-05-27 20:52:28 +0000683 bitset& operator|=(const bitset& __rhs) _NOEXCEPT;
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000684 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant10f25d22011-05-27 20:52:28 +0000685 bitset& operator^=(const bitset& __rhs) _NOEXCEPT;
686 bitset& operator<<=(size_t __pos) _NOEXCEPT;
687 bitset& operator>>=(size_t __pos) _NOEXCEPT;
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000688 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant10f25d22011-05-27 20:52:28 +0000689 bitset& set() _NOEXCEPT;
Howard Hinnant324bb032010-08-22 00:02:43 +0000690 bitset& set(size_t __pos, bool __val = true);
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000691 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant10f25d22011-05-27 20:52:28 +0000692 bitset& reset() _NOEXCEPT;
Howard Hinnant324bb032010-08-22 00:02:43 +0000693 bitset& reset(size_t __pos);
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000694 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant10f25d22011-05-27 20:52:28 +0000695 bitset operator~() const _NOEXCEPT;
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000696 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant10f25d22011-05-27 20:52:28 +0000697 bitset& flip() _NOEXCEPT;
Howard Hinnant324bb032010-08-22 00:02:43 +0000698 bitset& flip(size_t __pos);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000699
Howard Hinnant324bb032010-08-22 00:02:43 +0000700 // element access:
Howard Hinnant90d87232012-07-07 17:04:52 +0000701 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
702 const_reference operator[](size_t __p) const {return base::__make_ref(__p);}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000703 _LIBCPP_INLINE_VISIBILITY reference operator[](size_t __p) {return base::__make_ref(__p);}
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000704 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant324bb032010-08-22 00:02:43 +0000705 unsigned long to_ulong() const;
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000706 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant324bb032010-08-22 00:02:43 +0000707 unsigned long long to_ullong() const;
708 template <class _CharT, class _Traits, class _Allocator>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000709 basic_string<_CharT, _Traits, _Allocator> to_string(_CharT __zero = _CharT('0'),
Howard Hinnant324bb032010-08-22 00:02:43 +0000710 _CharT __one = _CharT('1')) const;
711 template <class _CharT, class _Traits>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000712 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000713 basic_string<_CharT, _Traits, allocator<_CharT> > to_string(_CharT __zero = _CharT('0'),
Howard Hinnant324bb032010-08-22 00:02:43 +0000714 _CharT __one = _CharT('1')) const;
715 template <class _CharT>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000716 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000717 basic_string<_CharT, char_traits<_CharT>, allocator<_CharT> > to_string(_CharT __zero = _CharT('0'),
Howard Hinnant324bb032010-08-22 00:02:43 +0000718 _CharT __one = _CharT('1')) const;
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000719 _LIBCPP_INLINE_VISIBILITY
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000720 basic_string<char, char_traits<char>, allocator<char> > to_string(char __zero = '0',
Howard Hinnant324bb032010-08-22 00:02:43 +0000721 char __one = '1') const;
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000722 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant10f25d22011-05-27 20:52:28 +0000723 size_t count() const _NOEXCEPT;
Howard Hinnant90d87232012-07-07 17:04:52 +0000724 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR size_t size() const _NOEXCEPT {return _Size;}
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000725 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant10f25d22011-05-27 20:52:28 +0000726 bool operator==(const bitset& __rhs) const _NOEXCEPT;
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000727 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant10f25d22011-05-27 20:52:28 +0000728 bool operator!=(const bitset& __rhs) const _NOEXCEPT;
Howard Hinnant324bb032010-08-22 00:02:43 +0000729 bool test(size_t __pos) const;
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000730 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant10f25d22011-05-27 20:52:28 +0000731 bool all() const _NOEXCEPT;
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000732 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant10f25d22011-05-27 20:52:28 +0000733 bool any() const _NOEXCEPT;
734 _LIBCPP_INLINE_VISIBILITY bool none() const _NOEXCEPT {return !any();}
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000735 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant10f25d22011-05-27 20:52:28 +0000736 bitset operator<<(size_t __pos) const _NOEXCEPT;
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000737 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant10f25d22011-05-27 20:52:28 +0000738 bitset operator>>(size_t __pos) const _NOEXCEPT;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000739
740private:
741
Howard Hinnant422a53f2010-09-21 21:28:23 +0000742 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant10f25d22011-05-27 20:52:28 +0000743 size_t __hash_code() const _NOEXCEPT {return base::__hash_code();}
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000744
745 friend struct hash<bitset>;
746};
747
748template <size_t _Size>
Howard Hinnant34d6b192010-11-17 21:53:14 +0000749template<class _CharT>
750bitset<_Size>::bitset(const _CharT* __str,
751 typename basic_string<_CharT>::size_type __n,
752 _CharT __zero, _CharT __one)
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000753{
Howard Hinnant0949eed2011-06-30 21:18:19 +0000754 size_t __rlen = _VSTD::min(__n, char_traits<_CharT>::length(__str));
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000755 for (size_t __i = 0; __i < __rlen; ++__i)
Howard Hinnant34d6b192010-11-17 21:53:14 +0000756 if (__str[__i] != __zero && __str[__i] != __one)
Marshall Clow14c09a22016-08-25 15:09:01 +0000757 __throw_invalid_argument("bitset string ctor has invalid argument");
758
Howard Hinnant99968442011-11-29 18:15:50 +0000759 size_t _Mp = _VSTD::min(__rlen, _Size);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000760 size_t __i = 0;
Howard Hinnant99968442011-11-29 18:15:50 +0000761 for (; __i < _Mp; ++__i)
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000762 {
Howard Hinnant99968442011-11-29 18:15:50 +0000763 _CharT __c = __str[_Mp - 1 - __i];
Howard Hinnant34d6b192010-11-17 21:53:14 +0000764 if (__c == __zero)
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000765 (*this)[__i] = false;
Howard Hinnant34d6b192010-11-17 21:53:14 +0000766 else
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000767 (*this)[__i] = true;
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000768 }
Howard Hinnant0949eed2011-06-30 21:18:19 +0000769 _VSTD::fill(base::__make_iter(__i), base::__make_iter(_Size), false);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000770}
771
772template <size_t _Size>
Howard Hinnant324bb032010-08-22 00:02:43 +0000773template<class _CharT, class _Traits, class _Allocator>
774bitset<_Size>::bitset(const basic_string<_CharT,_Traits,_Allocator>& __str,
775 typename basic_string<_CharT,_Traits,_Allocator>::size_type __pos,
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000776 typename basic_string<_CharT,_Traits,_Allocator>::size_type __n,
777 _CharT __zero, _CharT __one)
778{
779 if (__pos > __str.size())
Marshall Clow14c09a22016-08-25 15:09:01 +0000780 __throw_out_of_range("bitset string pos out of range");
781
Howard Hinnant0949eed2011-06-30 21:18:19 +0000782 size_t __rlen = _VSTD::min(__n, __str.size() - __pos);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000783 for (size_t __i = __pos; __i < __pos + __rlen; ++__i)
784 if (!_Traits::eq(__str[__i], __zero) && !_Traits::eq(__str[__i], __one))
Marshall Clow14c09a22016-08-25 15:09:01 +0000785 __throw_invalid_argument("bitset string ctor has invalid argument");
786
Howard Hinnant99968442011-11-29 18:15:50 +0000787 size_t _Mp = _VSTD::min(__rlen, _Size);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000788 size_t __i = 0;
Howard Hinnant99968442011-11-29 18:15:50 +0000789 for (; __i < _Mp; ++__i)
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000790 {
Howard Hinnant99968442011-11-29 18:15:50 +0000791 _CharT __c = __str[__pos + _Mp - 1 - __i];
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000792 if (_Traits::eq(__c, __zero))
793 (*this)[__i] = false;
794 else
795 (*this)[__i] = true;
796 }
Howard Hinnant0949eed2011-06-30 21:18:19 +0000797 _VSTD::fill(base::__make_iter(__i), base::__make_iter(_Size), false);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000798}
799
800template <size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000801inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000802bitset<_Size>&
Howard Hinnant10f25d22011-05-27 20:52:28 +0000803bitset<_Size>::operator&=(const bitset& __rhs) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000804{
805 base::operator&=(__rhs);
806 return *this;
807}
808
809template <size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000810inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000811bitset<_Size>&
Howard Hinnant10f25d22011-05-27 20:52:28 +0000812bitset<_Size>::operator|=(const bitset& __rhs) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000813{
814 base::operator|=(__rhs);
815 return *this;
816}
817
818template <size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000819inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000820bitset<_Size>&
Howard Hinnant10f25d22011-05-27 20:52:28 +0000821bitset<_Size>::operator^=(const bitset& __rhs) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000822{
823 base::operator^=(__rhs);
824 return *this;
825}
826
827template <size_t _Size>
828bitset<_Size>&
Howard Hinnant10f25d22011-05-27 20:52:28 +0000829bitset<_Size>::operator<<=(size_t __pos) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000830{
Howard Hinnant0949eed2011-06-30 21:18:19 +0000831 __pos = _VSTD::min(__pos, _Size);
832 _VSTD::copy_backward(base::__make_iter(0), base::__make_iter(_Size - __pos), base::__make_iter(_Size));
833 _VSTD::fill_n(base::__make_iter(0), __pos, false);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000834 return *this;
835}
836
837template <size_t _Size>
838bitset<_Size>&
Howard Hinnant10f25d22011-05-27 20:52:28 +0000839bitset<_Size>::operator>>=(size_t __pos) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000840{
Howard Hinnant0949eed2011-06-30 21:18:19 +0000841 __pos = _VSTD::min(__pos, _Size);
842 _VSTD::copy(base::__make_iter(__pos), base::__make_iter(_Size), base::__make_iter(0));
843 _VSTD::fill_n(base::__make_iter(_Size - __pos), __pos, false);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000844 return *this;
845}
846
847template <size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000848inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000849bitset<_Size>&
Howard Hinnant10f25d22011-05-27 20:52:28 +0000850bitset<_Size>::set() _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000851{
Howard Hinnant0949eed2011-06-30 21:18:19 +0000852 _VSTD::fill_n(base::__make_iter(0), _Size, true);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000853 return *this;
854}
855
856template <size_t _Size>
857bitset<_Size>&
858bitset<_Size>::set(size_t __pos, bool __val)
859{
860 if (__pos >= _Size)
Marshall Clow14c09a22016-08-25 15:09:01 +0000861 __throw_out_of_range("bitset set argument out of range");
862
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000863 (*this)[__pos] = __val;
864 return *this;
865}
866
867template <size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000868inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000869bitset<_Size>&
Howard Hinnant10f25d22011-05-27 20:52:28 +0000870bitset<_Size>::reset() _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000871{
Howard Hinnant0949eed2011-06-30 21:18:19 +0000872 _VSTD::fill_n(base::__make_iter(0), _Size, false);
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000873 return *this;
874}
875
876template <size_t _Size>
877bitset<_Size>&
878bitset<_Size>::reset(size_t __pos)
879{
880 if (__pos >= _Size)
Marshall Clow14c09a22016-08-25 15:09:01 +0000881 __throw_out_of_range("bitset reset argument out of range");
882
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000883 (*this)[__pos] = false;
884 return *this;
885}
886
887template <size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000888inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000889bitset<_Size>
Howard Hinnant10f25d22011-05-27 20:52:28 +0000890bitset<_Size>::operator~() const _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000891{
892 bitset __x(*this);
893 __x.flip();
894 return __x;
895}
896
897template <size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000898inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000899bitset<_Size>&
Howard Hinnant10f25d22011-05-27 20:52:28 +0000900bitset<_Size>::flip() _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000901{
902 base::flip();
903 return *this;
904}
905
906template <size_t _Size>
907bitset<_Size>&
908bitset<_Size>::flip(size_t __pos)
909{
910 if (__pos >= _Size)
Marshall Clow14c09a22016-08-25 15:09:01 +0000911 __throw_out_of_range("bitset flip argument out of range");
912
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000913 reference r = base::__make_ref(__pos);
914 r = ~r;
915 return *this;
916}
917
918template <size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000919inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000920unsigned long
921bitset<_Size>::to_ulong() const
922{
923 return base::to_ulong();
924}
925
926template <size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000927inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000928unsigned long long
929bitset<_Size>::to_ullong() const
930{
931 return base::to_ullong();
932}
933
934template <size_t _Size>
Howard Hinnant324bb032010-08-22 00:02:43 +0000935template <class _CharT, class _Traits, class _Allocator>
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000936basic_string<_CharT, _Traits, _Allocator>
937bitset<_Size>::to_string(_CharT __zero, _CharT __one) const
938{
939 basic_string<_CharT, _Traits, _Allocator> __r(_Size, __zero);
940 for (size_t __i = 0; __i < _Size; ++__i)
941 {
942 if ((*this)[__i])
943 __r[_Size - 1 - __i] = __one;
944 }
945 return __r;
946}
947
948template <size_t _Size>
Howard Hinnant324bb032010-08-22 00:02:43 +0000949template <class _CharT, class _Traits>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000950inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000951basic_string<_CharT, _Traits, allocator<_CharT> >
952bitset<_Size>::to_string(_CharT __zero, _CharT __one) const
953{
954 return to_string<_CharT, _Traits, allocator<_CharT> >(__zero, __one);
955}
956
957template <size_t _Size>
Howard Hinnant324bb032010-08-22 00:02:43 +0000958template <class _CharT>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000959inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000960basic_string<_CharT, char_traits<_CharT>, allocator<_CharT> >
961bitset<_Size>::to_string(_CharT __zero, _CharT __one) const
962{
963 return to_string<_CharT, char_traits<_CharT>, allocator<_CharT> >(__zero, __one);
964}
965
966template <size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000967inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000968basic_string<char, char_traits<char>, allocator<char> >
969bitset<_Size>::to_string(char __zero, char __one) const
970{
971 return to_string<char, char_traits<char>, allocator<char> >(__zero, __one);
972}
973
974template <size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000975inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000976size_t
Howard Hinnant10f25d22011-05-27 20:52:28 +0000977bitset<_Size>::count() const _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000978{
Howard Hinnant0949eed2011-06-30 21:18:19 +0000979 return static_cast<size_t>(_VSTD::count(base::__make_iter(0), base::__make_iter(_Size), true));
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000980}
981
982template <size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000983inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000984bool
Howard Hinnant10f25d22011-05-27 20:52:28 +0000985bitset<_Size>::operator==(const bitset& __rhs) const _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000986{
Howard Hinnant0949eed2011-06-30 21:18:19 +0000987 return _VSTD::equal(base::__make_iter(0), base::__make_iter(_Size), __rhs.__make_iter(0));
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000988}
989
990template <size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +0000991inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000992bool
Howard Hinnant10f25d22011-05-27 20:52:28 +0000993bitset<_Size>::operator!=(const bitset& __rhs) const _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +0000994{
995 return !(*this == __rhs);
996}
997
998template <size_t _Size>
999bool
1000bitset<_Size>::test(size_t __pos) const
1001{
1002 if (__pos >= _Size)
Marshall Clow14c09a22016-08-25 15:09:01 +00001003 __throw_out_of_range("bitset test argument out of range");
1004
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001005 return (*this)[__pos];
1006}
1007
1008template <size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +00001009inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001010bool
Howard Hinnant10f25d22011-05-27 20:52:28 +00001011bitset<_Size>::all() const _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001012{
1013 return base::all();
1014}
1015
1016template <size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +00001017inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001018bool
Howard Hinnant10f25d22011-05-27 20:52:28 +00001019bitset<_Size>::any() const _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001020{
1021 return base::any();
1022}
1023
1024template <size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +00001025inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001026bitset<_Size>
Howard Hinnant10f25d22011-05-27 20:52:28 +00001027bitset<_Size>::operator<<(size_t __pos) const _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001028{
1029 bitset __r = *this;
1030 __r <<= __pos;
1031 return __r;
1032}
1033
1034template <size_t _Size>
Evgeniy Stepanova3b25f82015-11-07 01:22:13 +00001035inline
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001036bitset<_Size>
Howard Hinnant10f25d22011-05-27 20:52:28 +00001037bitset<_Size>::operator>>(size_t __pos) const _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001038{
1039 bitset __r = *this;
1040 __r >>= __pos;
1041 return __r;
1042}
1043
1044template <size_t _Size>
1045inline _LIBCPP_INLINE_VISIBILITY
1046bitset<_Size>
Howard Hinnant10f25d22011-05-27 20:52:28 +00001047operator&(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001048{
1049 bitset<_Size> __r = __x;
1050 __r &= __y;
1051 return __r;
1052}
1053
1054template <size_t _Size>
1055inline _LIBCPP_INLINE_VISIBILITY
1056bitset<_Size>
Howard Hinnant10f25d22011-05-27 20:52:28 +00001057operator|(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001058{
1059 bitset<_Size> __r = __x;
1060 __r |= __y;
1061 return __r;
1062}
1063
1064template <size_t _Size>
1065inline _LIBCPP_INLINE_VISIBILITY
1066bitset<_Size>
Howard Hinnant10f25d22011-05-27 20:52:28 +00001067operator^(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001068{
1069 bitset<_Size> __r = __x;
1070 __r ^= __y;
1071 return __r;
1072}
1073
1074template <size_t _Size>
Howard Hinnant0f678bd2013-08-12 18:38:34 +00001075struct _LIBCPP_TYPE_VIS_ONLY hash<bitset<_Size> >
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001076 : public unary_function<bitset<_Size>, size_t>
1077{
Howard Hinnant422a53f2010-09-21 21:28:23 +00001078 _LIBCPP_INLINE_VISIBILITY
Howard Hinnant10f25d22011-05-27 20:52:28 +00001079 size_t operator()(const bitset<_Size>& __bs) const _NOEXCEPT
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001080 {return __bs.__hash_code();}
1081};
1082
Howard Hinnant464aa5c2011-07-18 15:51:59 +00001083template <class _CharT, class _Traits, size_t _Size>
1084basic_istream<_CharT, _Traits>&
1085operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x);
1086
1087template <class _CharT, class _Traits, size_t _Size>
1088basic_ostream<_CharT, _Traits>&
1089operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x);
1090
Howard Hinnantbc8d3f92010-05-11 19:42:16 +00001091_LIBCPP_END_NAMESPACE_STD
1092
1093#endif // _LIBCPP_BITSET