__bit_reference revision 249998
1// -*- C++ -*- 2//===----------------------------------------------------------------------===// 3// 4// The LLVM Compiler Infrastructure 5// 6// This file is dual licensed under the MIT and the University of Illinois Open 7// Source Licenses. See LICENSE.TXT for details. 8// 9//===----------------------------------------------------------------------===// 10 11#ifndef _LIBCPP___BIT_REFERENCE 12#define _LIBCPP___BIT_REFERENCE 13 14#include <__config> 15#include <algorithm> 16 17#include <__undef_min_max> 18 19#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 20#pragma GCC system_header 21#endif 22 23_LIBCPP_BEGIN_NAMESPACE_STD 24 25template <class _Cp, bool _IsConst, typename _Cp::__storage_type = 0> class __bit_iterator; 26template <class _Cp> class __bit_const_reference; 27 28template <class _Tp> 29struct __has_storage_type 30{ 31 static const bool value = false; 32}; 33 34template <class _Cp, bool = __has_storage_type<_Cp>::value> 35class __bit_reference 36{ 37 typedef typename _Cp::__storage_type __storage_type; 38 typedef typename _Cp::__storage_pointer __storage_pointer; 39 40 __storage_pointer __seg_; 41 __storage_type __mask_; 42 43#if defined(__clang__) 44 friend typename _Cp::__self; 45#else 46 friend class _Cp::__self; 47#endif 48 friend class __bit_const_reference<_Cp>; 49 friend class __bit_iterator<_Cp, false>; 50public: 51 _LIBCPP_INLINE_VISIBILITY operator bool() const _NOEXCEPT 52 {return static_cast<bool>(*__seg_ & __mask_);} 53 _LIBCPP_INLINE_VISIBILITY bool operator ~() const _NOEXCEPT 54 {return !static_cast<bool>(*this);} 55 56 _LIBCPP_INLINE_VISIBILITY 57 __bit_reference& operator=(bool __x) _NOEXCEPT 58 { 59 if (__x) 60 *__seg_ |= __mask_; 61 else 62 *__seg_ &= ~__mask_; 63 return *this; 64 } 65 66 _LIBCPP_INLINE_VISIBILITY 67 __bit_reference& operator=(const __bit_reference& __x) _NOEXCEPT 68 {return operator=(static_cast<bool>(__x));} 69 70 _LIBCPP_INLINE_VISIBILITY void flip() _NOEXCEPT {*__seg_ ^= __mask_;} 71 _LIBCPP_INLINE_VISIBILITY __bit_iterator<_Cp, false> operator&() const _NOEXCEPT 72 {return __bit_iterator<_Cp, false>(__seg_, static_cast<unsigned>(__ctz(__mask_)));} 73private: 74 _LIBCPP_INLINE_VISIBILITY 75 __bit_reference(__storage_pointer __s, __storage_type __m) _NOEXCEPT 76 : __seg_(__s), __mask_(__m) {} 77}; 78 79template <class _Cp> 80class __bit_reference<_Cp, false> 81{ 82}; 83 84template <class _Cp> 85_LIBCPP_INLINE_VISIBILITY inline 86void 87swap(__bit_reference<_Cp> __x, __bit_reference<_Cp> __y) _NOEXCEPT 88{ 89 bool __t = __x; 90 __x = __y; 91 __y = __t; 92} 93 94template <class _Cp, class _Dp> 95_LIBCPP_INLINE_VISIBILITY inline 96void 97swap(__bit_reference<_Cp> __x, __bit_reference<_Dp> __y) _NOEXCEPT 98{ 99 bool __t = __x; 100 __x = __y; 101 __y = __t; 102} 103 104template <class _Cp> 105_LIBCPP_INLINE_VISIBILITY inline 106void 107swap(__bit_reference<_Cp> __x, bool& __y) _NOEXCEPT 108{ 109 bool __t = __x; 110 __x = __y; 111 __y = __t; 112} 113 114template <class _Cp> 115_LIBCPP_INLINE_VISIBILITY inline 116void 117swap(bool& __x, __bit_reference<_Cp> __y) _NOEXCEPT 118{ 119 bool __t = __x; 120 __x = __y; 121 __y = __t; 122} 123 124template <class _Cp> 125class __bit_const_reference 126{ 127 typedef typename _Cp::__storage_type __storage_type; 128 typedef typename _Cp::__const_storage_pointer __storage_pointer; 129 130 __storage_pointer __seg_; 131 __storage_type __mask_; 132 133#if defined(__clang__) 134 friend typename _Cp::__self; 135#else 136 friend class _Cp::__self; 137#endif 138 friend class __bit_iterator<_Cp, true>; 139public: 140 _LIBCPP_INLINE_VISIBILITY 141 __bit_const_reference(const __bit_reference<_Cp>& __x) _NOEXCEPT 142 : __seg_(__x.__seg_), __mask_(__x.__mask_) {} 143 144 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR operator bool() const _NOEXCEPT 145 {return static_cast<bool>(*__seg_ & __mask_);} 146 147 _LIBCPP_INLINE_VISIBILITY __bit_iterator<_Cp, true> operator&() const _NOEXCEPT 148 {return __bit_iterator<_Cp, true>(__seg_, static_cast<unsigned>(__ctz(__mask_)));} 149private: 150 _LIBCPP_INLINE_VISIBILITY 151 _LIBCPP_CONSTEXPR 152 __bit_const_reference(__storage_pointer __s, __storage_type __m) _NOEXCEPT 153 : __seg_(__s), __mask_(__m) {} 154 155 __bit_const_reference& operator=(const __bit_const_reference& __x); 156}; 157 158// find 159 160template <class _Cp, bool _IsConst> 161__bit_iterator<_Cp, _IsConst> 162__find_bool_true(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n) 163{ 164 typedef __bit_iterator<_Cp, _IsConst> _It; 165 typedef typename _It::__storage_type __storage_type; 166 static const unsigned __bits_per_word = _It::__bits_per_word; 167 // do first partial word 168 if (__first.__ctz_ != 0) 169 { 170 __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_); 171 __storage_type __dn = _VSTD::min(__clz_f, __n); 172 __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn)); 173 __storage_type __b = *__first.__seg_ & __m; 174 if (__b) 175 return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__ctz(__b))); 176 __n -= __dn; 177 ++__first.__seg_; 178 } 179 // do middle whole words 180 for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word) 181 if (*__first.__seg_) 182 return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__ctz(*__first.__seg_))); 183 // do last partial word 184 if (__n > 0) 185 { 186 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n); 187 __storage_type __b = *__first.__seg_ & __m; 188 if (__b) 189 return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__ctz(__b))); 190 } 191 return _It(__first.__seg_, static_cast<unsigned>(__n)); 192} 193 194template <class _Cp, bool _IsConst> 195__bit_iterator<_Cp, _IsConst> 196__find_bool_false(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n) 197{ 198 typedef __bit_iterator<_Cp, _IsConst> _It; 199 typedef typename _It::__storage_type __storage_type; 200 static const unsigned __bits_per_word = _It::__bits_per_word; 201 // do first partial word 202 if (__first.__ctz_ != 0) 203 { 204 __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_); 205 __storage_type __dn = _VSTD::min(__clz_f, __n); 206 __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn)); 207 __storage_type __b = ~*__first.__seg_ & __m; 208 if (__b) 209 return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__ctz(__b))); 210 __n -= __dn; 211 ++__first.__seg_; 212 } 213 // do middle whole words 214 for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word) 215 { 216 __storage_type __b = ~*__first.__seg_; 217 if (__b) 218 return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__ctz(__b))); 219 } 220 // do last partial word 221 if (__n > 0) 222 { 223 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n); 224 __storage_type __b = ~*__first.__seg_ & __m; 225 if (__b) 226 return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__ctz(__b))); 227 } 228 return _It(__first.__seg_, static_cast<unsigned>(__n)); 229} 230 231template <class _Cp, bool _IsConst, class _Tp> 232inline _LIBCPP_INLINE_VISIBILITY 233__bit_iterator<_Cp, _IsConst> 234find(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value_) 235{ 236 if (static_cast<bool>(__value_)) 237 return __find_bool_true(__first, static_cast<typename _Cp::size_type>(__last - __first)); 238 return __find_bool_false(__first, static_cast<typename _Cp::size_type>(__last - __first)); 239} 240 241// count 242 243template <class _Cp, bool _IsConst> 244typename __bit_iterator<_Cp, _IsConst>::difference_type 245__count_bool_true(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n) 246{ 247 typedef __bit_iterator<_Cp, _IsConst> _It; 248 typedef typename _It::__storage_type __storage_type; 249 typedef typename _It::difference_type difference_type; 250 static const unsigned __bits_per_word = _It::__bits_per_word; 251 difference_type __r = 0; 252 // do first partial word 253 if (__first.__ctz_ != 0) 254 { 255 __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_); 256 __storage_type __dn = _VSTD::min(__clz_f, __n); 257 __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn)); 258 __r = _VSTD::__pop_count(*__first.__seg_ & __m); 259 __n -= __dn; 260 ++__first.__seg_; 261 } 262 // do middle whole words 263 for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word) 264 __r += _VSTD::__pop_count(*__first.__seg_); 265 // do last partial word 266 if (__n > 0) 267 { 268 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n); 269 __r += _VSTD::__pop_count(*__first.__seg_ & __m); 270 } 271 return __r; 272} 273 274template <class _Cp, bool _IsConst> 275typename __bit_iterator<_Cp, _IsConst>::difference_type 276__count_bool_false(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type __n) 277{ 278 typedef __bit_iterator<_Cp, _IsConst> _It; 279 typedef typename _It::__storage_type __storage_type; 280 typedef typename _It::difference_type difference_type; 281 static const unsigned __bits_per_word = _It::__bits_per_word; 282 difference_type __r = 0; 283 // do first partial word 284 if (__first.__ctz_ != 0) 285 { 286 __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_); 287 __storage_type __dn = _VSTD::min(__clz_f, __n); 288 __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn)); 289 __r = _VSTD::__pop_count(~*__first.__seg_ & __m); 290 __n -= __dn; 291 ++__first.__seg_; 292 } 293 // do middle whole words 294 for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word) 295 __r += _VSTD::__pop_count(~*__first.__seg_); 296 // do last partial word 297 if (__n > 0) 298 { 299 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n); 300 __r += _VSTD::__pop_count(~*__first.__seg_ & __m); 301 } 302 return __r; 303} 304 305template <class _Cp, bool _IsConst, class _Tp> 306inline _LIBCPP_INLINE_VISIBILITY 307typename __bit_iterator<_Cp, _IsConst>::difference_type 308count(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value_) 309{ 310 if (static_cast<bool>(__value_)) 311 return __count_bool_true(__first, static_cast<typename _Cp::size_type>(__last - __first)); 312 return __count_bool_false(__first, static_cast<typename _Cp::size_type>(__last - __first)); 313} 314 315// fill_n 316 317template <class _Cp> 318void 319__fill_n_false(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n) 320{ 321 typedef __bit_iterator<_Cp, false> _It; 322 typedef typename _It::__storage_type __storage_type; 323 static const unsigned __bits_per_word = _It::__bits_per_word; 324 // do first partial word 325 if (__first.__ctz_ != 0) 326 { 327 __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_); 328 __storage_type __dn = _VSTD::min(__clz_f, __n); 329 __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn)); 330 *__first.__seg_ &= ~__m; 331 __n -= __dn; 332 ++__first.__seg_; 333 } 334 // do middle whole words 335 __storage_type __nw = __n / __bits_per_word; 336 _VSTD::memset(__first.__seg_, 0, __nw * sizeof(__storage_type)); 337 __n -= __nw * __bits_per_word; 338 // do last partial word 339 if (__n > 0) 340 { 341 __first.__seg_ += __nw; 342 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n); 343 *__first.__seg_ &= ~__m; 344 } 345} 346 347template <class _Cp> 348void 349__fill_n_true(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n) 350{ 351 typedef __bit_iterator<_Cp, false> _It; 352 typedef typename _It::__storage_type __storage_type; 353 static const unsigned __bits_per_word = _It::__bits_per_word; 354 // do first partial word 355 if (__first.__ctz_ != 0) 356 { 357 __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_); 358 __storage_type __dn = _VSTD::min(__clz_f, __n); 359 __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn)); 360 *__first.__seg_ |= __m; 361 __n -= __dn; 362 ++__first.__seg_; 363 } 364 // do middle whole words 365 __storage_type __nw = __n / __bits_per_word; 366 _VSTD::memset(__first.__seg_, -1, __nw * sizeof(__storage_type)); 367 __n -= __nw * __bits_per_word; 368 // do last partial word 369 if (__n > 0) 370 { 371 __first.__seg_ += __nw; 372 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n); 373 *__first.__seg_ |= __m; 374 } 375} 376 377template <class _Cp> 378_LIBCPP_INLINE_VISIBILITY inline 379void 380fill_n(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n, bool __value_) 381{ 382 if (__n > 0) 383 { 384 if (__value_) 385 __fill_n_true(__first, __n); 386 else 387 __fill_n_false(__first, __n); 388 } 389} 390 391// fill 392 393template <class _Cp> 394inline _LIBCPP_INLINE_VISIBILITY 395void 396fill(__bit_iterator<_Cp, false> __first, __bit_iterator<_Cp, false> __last, bool __value_) 397{ 398 _VSTD::fill_n(__first, static_cast<typename _Cp::size_type>(__last - __first), __value_); 399} 400 401// copy 402 403template <class _Cp, bool _IsConst> 404__bit_iterator<_Cp, false> 405__copy_aligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, 406 __bit_iterator<_Cp, false> __result) 407{ 408 typedef __bit_iterator<_Cp, _IsConst> _In; 409 typedef typename _In::difference_type difference_type; 410 typedef typename _In::__storage_type __storage_type; 411 static const unsigned __bits_per_word = _In::__bits_per_word; 412 difference_type __n = __last - __first; 413 if (__n > 0) 414 { 415 // do first word 416 if (__first.__ctz_ != 0) 417 { 418 unsigned __clz = __bits_per_word - __first.__ctz_; 419 difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz), __n); 420 __n -= __dn; 421 __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz - __dn)); 422 __storage_type __b = *__first.__seg_ & __m; 423 *__result.__seg_ &= ~__m; 424 *__result.__seg_ |= __b; 425 __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word; 426 __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_) % __bits_per_word); 427 ++__first.__seg_; 428 // __first.__ctz_ = 0; 429 } 430 // __first.__ctz_ == 0; 431 // do middle words 432 __storage_type __nw = __n / __bits_per_word; 433 _VSTD::memmove(__result.__seg_, __first.__seg_, __nw * sizeof(__storage_type)); 434 __n -= __nw * __bits_per_word; 435 __result.__seg_ += __nw; 436 // do last word 437 if (__n > 0) 438 { 439 __first.__seg_ += __nw; 440 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n); 441 __storage_type __b = *__first.__seg_ & __m; 442 *__result.__seg_ &= ~__m; 443 *__result.__seg_ |= __b; 444 __result.__ctz_ = static_cast<unsigned>(__n); 445 } 446 } 447 return __result; 448} 449 450template <class _Cp, bool _IsConst> 451__bit_iterator<_Cp, false> 452__copy_unaligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, 453 __bit_iterator<_Cp, false> __result) 454{ 455 typedef __bit_iterator<_Cp, _IsConst> _In; 456 typedef typename _In::difference_type difference_type; 457 typedef typename _In::__storage_type __storage_type; 458 static const unsigned __bits_per_word = _In::__bits_per_word; 459 difference_type __n = __last - __first; 460 if (__n > 0) 461 { 462 // do first word 463 if (__first.__ctz_ != 0) 464 { 465 unsigned __clz_f = __bits_per_word - __first.__ctz_; 466 difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz_f), __n); 467 __n -= __dn; 468 __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn)); 469 __storage_type __b = *__first.__seg_ & __m; 470 unsigned __clz_r = __bits_per_word - __result.__ctz_; 471 __storage_type __ddn = _VSTD::min<__storage_type>(__dn, __clz_r); 472 __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn)); 473 *__result.__seg_ &= ~__m; 474 if (__result.__ctz_ > __first.__ctz_) 475 *__result.__seg_ |= __b << (__result.__ctz_ - __first.__ctz_); 476 else 477 *__result.__seg_ |= __b >> (__first.__ctz_ - __result.__ctz_); 478 __result.__seg_ += (__ddn + __result.__ctz_) / __bits_per_word; 479 __result.__ctz_ = static_cast<unsigned>((__ddn + __result.__ctz_) % __bits_per_word); 480 __dn -= __ddn; 481 if (__dn > 0) 482 { 483 __m = ~__storage_type(0) >> (__bits_per_word - __dn); 484 *__result.__seg_ &= ~__m; 485 *__result.__seg_ |= __b >> (__first.__ctz_ + __ddn); 486 __result.__ctz_ = static_cast<unsigned>(__dn); 487 } 488 ++__first.__seg_; 489 // __first.__ctz_ = 0; 490 } 491 // __first.__ctz_ == 0; 492 // do middle words 493 unsigned __clz_r = __bits_per_word - __result.__ctz_; 494 __storage_type __m = ~__storage_type(0) << __result.__ctz_; 495 for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first.__seg_) 496 { 497 __storage_type __b = *__first.__seg_; 498 *__result.__seg_ &= ~__m; 499 *__result.__seg_ |= __b << __result.__ctz_; 500 ++__result.__seg_; 501 *__result.__seg_ &= __m; 502 *__result.__seg_ |= __b >> __clz_r; 503 } 504 // do last word 505 if (__n > 0) 506 { 507 __m = ~__storage_type(0) >> (__bits_per_word - __n); 508 __storage_type __b = *__first.__seg_ & __m; 509 __storage_type __dn = _VSTD::min(__n, static_cast<difference_type>(__clz_r)); 510 __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn)); 511 *__result.__seg_ &= ~__m; 512 *__result.__seg_ |= __b << __result.__ctz_; 513 __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word; 514 __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_) % __bits_per_word); 515 __n -= __dn; 516 if (__n > 0) 517 { 518 __m = ~__storage_type(0) >> (__bits_per_word - __n); 519 *__result.__seg_ &= ~__m; 520 *__result.__seg_ |= __b >> __dn; 521 __result.__ctz_ = static_cast<unsigned>(__n); 522 } 523 } 524 } 525 return __result; 526} 527 528template <class _Cp, bool _IsConst> 529inline _LIBCPP_INLINE_VISIBILITY 530__bit_iterator<_Cp, false> 531copy(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result) 532{ 533 if (__first.__ctz_ == __result.__ctz_) 534 return __copy_aligned(__first, __last, __result); 535 return __copy_unaligned(__first, __last, __result); 536} 537 538// copy_backward 539 540template <class _Cp, bool _IsConst> 541__bit_iterator<_Cp, false> 542__copy_backward_aligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, 543 __bit_iterator<_Cp, false> __result) 544{ 545 typedef __bit_iterator<_Cp, _IsConst> _In; 546 typedef typename _In::difference_type difference_type; 547 typedef typename _In::__storage_type __storage_type; 548 static const unsigned __bits_per_word = _In::__bits_per_word; 549 difference_type __n = __last - __first; 550 if (__n > 0) 551 { 552 // do first word 553 if (__last.__ctz_ != 0) 554 { 555 difference_type __dn = _VSTD::min(static_cast<difference_type>(__last.__ctz_), __n); 556 __n -= __dn; 557 unsigned __clz = __bits_per_word - __last.__ctz_; 558 __storage_type __m = (~__storage_type(0) << (__last.__ctz_ - __dn)) & (~__storage_type(0) >> __clz); 559 __storage_type __b = *__last.__seg_ & __m; 560 *__result.__seg_ &= ~__m; 561 *__result.__seg_ |= __b; 562 __result.__ctz_ = static_cast<unsigned>(((-__dn & (__bits_per_word - 1)) + 563 __result.__ctz_) % __bits_per_word); 564 // __last.__ctz_ = 0 565 } 566 // __last.__ctz_ == 0 || __n == 0 567 // __result.__ctz_ == 0 || __n == 0 568 // do middle words 569 __storage_type __nw = __n / __bits_per_word; 570 __result.__seg_ -= __nw; 571 __last.__seg_ -= __nw; 572 _VSTD::memmove(__result.__seg_, __last.__seg_, __nw * sizeof(__storage_type)); 573 __n -= __nw * __bits_per_word; 574 // do last word 575 if (__n > 0) 576 { 577 __storage_type __m = ~__storage_type(0) << (__bits_per_word - __n); 578 __storage_type __b = *--__last.__seg_ & __m; 579 *--__result.__seg_ &= ~__m; 580 *__result.__seg_ |= __b; 581 __result.__ctz_ = static_cast<unsigned>(-__n & (__bits_per_word - 1)); 582 } 583 } 584 return __result; 585} 586 587template <class _Cp, bool _IsConst> 588__bit_iterator<_Cp, false> 589__copy_backward_unaligned(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, 590 __bit_iterator<_Cp, false> __result) 591{ 592 typedef __bit_iterator<_Cp, _IsConst> _In; 593 typedef typename _In::difference_type difference_type; 594 typedef typename _In::__storage_type __storage_type; 595 static const unsigned __bits_per_word = _In::__bits_per_word; 596 difference_type __n = __last - __first; 597 if (__n > 0) 598 { 599 // do first word 600 if (__last.__ctz_ != 0) 601 { 602 difference_type __dn = _VSTD::min(static_cast<difference_type>(__last.__ctz_), __n); 603 __n -= __dn; 604 unsigned __clz_l = __bits_per_word - __last.__ctz_; 605 __storage_type __m = (~__storage_type(0) << (__last.__ctz_ - __dn)) & (~__storage_type(0) >> __clz_l); 606 __storage_type __b = *__last.__seg_ & __m; 607 unsigned __clz_r = __bits_per_word - __result.__ctz_; 608 __storage_type __ddn = _VSTD::min(__dn, static_cast<difference_type>(__result.__ctz_)); 609 if (__ddn > 0) 610 { 611 __m = (~__storage_type(0) << (__result.__ctz_ - __ddn)) & (~__storage_type(0) >> __clz_r); 612 *__result.__seg_ &= ~__m; 613 if (__result.__ctz_ > __last.__ctz_) 614 *__result.__seg_ |= __b << (__result.__ctz_ - __last.__ctz_); 615 else 616 *__result.__seg_ |= __b >> (__last.__ctz_ - __result.__ctz_); 617 __result.__ctz_ = static_cast<unsigned>(((-__ddn & (__bits_per_word - 1)) + 618 __result.__ctz_) % __bits_per_word); 619 __dn -= __ddn; 620 } 621 if (__dn > 0) 622 { 623 // __result.__ctz_ == 0 624 --__result.__seg_; 625 __result.__ctz_ = static_cast<unsigned>(-__dn & (__bits_per_word - 1)); 626 __m = ~__storage_type(0) << __result.__ctz_; 627 *__result.__seg_ &= ~__m; 628 __last.__ctz_ -= __dn + __ddn; 629 *__result.__seg_ |= __b << (__result.__ctz_ - __last.__ctz_); 630 } 631 // __last.__ctz_ = 0 632 } 633 // __last.__ctz_ == 0 || __n == 0 634 // __result.__ctz_ != 0 || __n == 0 635 // do middle words 636 unsigned __clz_r = __bits_per_word - __result.__ctz_; 637 __storage_type __m = ~__storage_type(0) >> __clz_r; 638 for (; __n >= __bits_per_word; __n -= __bits_per_word) 639 { 640 __storage_type __b = *--__last.__seg_; 641 *__result.__seg_ &= ~__m; 642 *__result.__seg_ |= __b >> __clz_r; 643 *--__result.__seg_ &= __m; 644 *__result.__seg_ |= __b << __result.__ctz_; 645 } 646 // do last word 647 if (__n > 0) 648 { 649 __m = ~__storage_type(0) << (__bits_per_word - __n); 650 __storage_type __b = *--__last.__seg_ & __m; 651 __clz_r = __bits_per_word - __result.__ctz_; 652 __storage_type __dn = _VSTD::min(__n, static_cast<difference_type>(__result.__ctz_)); 653 __m = (~__storage_type(0) << (__result.__ctz_ - __dn)) & (~__storage_type(0) >> __clz_r); 654 *__result.__seg_ &= ~__m; 655 *__result.__seg_ |= __b >> (__bits_per_word - __result.__ctz_); 656 __result.__ctz_ = static_cast<unsigned>(((-__dn & (__bits_per_word - 1)) + 657 __result.__ctz_) % __bits_per_word); 658 __n -= __dn; 659 if (__n > 0) 660 { 661 // __result.__ctz_ == 0 662 --__result.__seg_; 663 __result.__ctz_ = static_cast<unsigned>(-__n & (__bits_per_word - 1)); 664 __m = ~__storage_type(0) << __result.__ctz_; 665 *__result.__seg_ &= ~__m; 666 *__result.__seg_ |= __b << (__result.__ctz_ - (__bits_per_word - __n - __dn)); 667 } 668 } 669 } 670 return __result; 671} 672 673template <class _Cp, bool _IsConst> 674inline _LIBCPP_INLINE_VISIBILITY 675__bit_iterator<_Cp, false> 676copy_backward(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result) 677{ 678 if (__last.__ctz_ == __result.__ctz_) 679 return __copy_backward_aligned(__first, __last, __result); 680 return __copy_backward_unaligned(__first, __last, __result); 681} 682 683// move 684 685template <class _Cp, bool _IsConst> 686inline _LIBCPP_INLINE_VISIBILITY 687__bit_iterator<_Cp, false> 688move(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result) 689{ 690 return _VSTD::copy(__first, __last, __result); 691} 692 693// move_backward 694 695template <class _Cp, bool _IsConst> 696inline _LIBCPP_INLINE_VISIBILITY 697__bit_iterator<_Cp, false> 698move_backward(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result) 699{ 700 return _VSTD::copy(__first, __last, __result); 701} 702 703// swap_ranges 704 705template <class __C1, class __C2> 706__bit_iterator<__C2, false> 707__swap_ranges_aligned(__bit_iterator<__C1, false> __first, __bit_iterator<__C1, false> __last, 708 __bit_iterator<__C2, false> __result) 709{ 710 typedef __bit_iterator<__C1, false> _I1; 711 typedef typename _I1::difference_type difference_type; 712 typedef typename _I1::__storage_type __storage_type; 713 static const unsigned __bits_per_word = _I1::__bits_per_word; 714 difference_type __n = __last - __first; 715 if (__n > 0) 716 { 717 // do first word 718 if (__first.__ctz_ != 0) 719 { 720 unsigned __clz = __bits_per_word - __first.__ctz_; 721 difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz), __n); 722 __n -= __dn; 723 __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz - __dn)); 724 __storage_type __b1 = *__first.__seg_ & __m; 725 *__first.__seg_ &= ~__m; 726 __storage_type __b2 = *__result.__seg_ & __m; 727 *__result.__seg_ &= ~__m; 728 *__result.__seg_ |= __b1; 729 *__first.__seg_ |= __b2; 730 __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word; 731 __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_) % __bits_per_word); 732 ++__first.__seg_; 733 // __first.__ctz_ = 0; 734 } 735 // __first.__ctz_ == 0; 736 // do middle words 737 for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first.__seg_, ++__result.__seg_) 738 swap(*__first.__seg_, *__result.__seg_); 739 // do last word 740 if (__n > 0) 741 { 742 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n); 743 __storage_type __b1 = *__first.__seg_ & __m; 744 *__first.__seg_ &= ~__m; 745 __storage_type __b2 = *__result.__seg_ & __m; 746 *__result.__seg_ &= ~__m; 747 *__result.__seg_ |= __b1; 748 *__first.__seg_ |= __b2; 749 __result.__ctz_ = static_cast<unsigned>(__n); 750 } 751 } 752 return __result; 753} 754 755template <class __C1, class __C2> 756__bit_iterator<__C2, false> 757__swap_ranges_unaligned(__bit_iterator<__C1, false> __first, __bit_iterator<__C1, false> __last, 758 __bit_iterator<__C2, false> __result) 759{ 760 typedef __bit_iterator<__C1, false> _I1; 761 typedef typename _I1::difference_type difference_type; 762 typedef typename _I1::__storage_type __storage_type; 763 static const unsigned __bits_per_word = _I1::__bits_per_word; 764 difference_type __n = __last - __first; 765 if (__n > 0) 766 { 767 // do first word 768 if (__first.__ctz_ != 0) 769 { 770 unsigned __clz_f = __bits_per_word - __first.__ctz_; 771 difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz_f), __n); 772 __n -= __dn; 773 __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn)); 774 __storage_type __b1 = *__first.__seg_ & __m; 775 *__first.__seg_ &= ~__m; 776 unsigned __clz_r = __bits_per_word - __result.__ctz_; 777 __storage_type __ddn = _VSTD::min<__storage_type>(__dn, __clz_r); 778 __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn)); 779 __storage_type __b2 = *__result.__seg_ & __m; 780 *__result.__seg_ &= ~__m; 781 if (__result.__ctz_ > __first.__ctz_) 782 { 783 unsigned __s = __result.__ctz_ - __first.__ctz_; 784 *__result.__seg_ |= __b1 << __s; 785 *__first.__seg_ |= __b2 >> __s; 786 } 787 else 788 { 789 unsigned __s = __first.__ctz_ - __result.__ctz_; 790 *__result.__seg_ |= __b1 >> __s; 791 *__first.__seg_ |= __b2 << __s; 792 } 793 __result.__seg_ += (__ddn + __result.__ctz_) / __bits_per_word; 794 __result.__ctz_ = static_cast<unsigned>((__ddn + __result.__ctz_) % __bits_per_word); 795 __dn -= __ddn; 796 if (__dn > 0) 797 { 798 __m = ~__storage_type(0) >> (__bits_per_word - __dn); 799 __b2 = *__result.__seg_ & __m; 800 *__result.__seg_ &= ~__m; 801 unsigned __s = __first.__ctz_ + __ddn; 802 *__result.__seg_ |= __b1 >> __s; 803 *__first.__seg_ |= __b2 << __s; 804 __result.__ctz_ = static_cast<unsigned>(__dn); 805 } 806 ++__first.__seg_; 807 // __first.__ctz_ = 0; 808 } 809 // __first.__ctz_ == 0; 810 // do middle words 811 __storage_type __m = ~__storage_type(0) << __result.__ctz_; 812 unsigned __clz_r = __bits_per_word - __result.__ctz_; 813 for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first.__seg_) 814 { 815 __storage_type __b1 = *__first.__seg_; 816 __storage_type __b2 = *__result.__seg_ & __m; 817 *__result.__seg_ &= ~__m; 818 *__result.__seg_ |= __b1 << __result.__ctz_; 819 *__first.__seg_ = __b2 >> __result.__ctz_; 820 ++__result.__seg_; 821 __b2 = *__result.__seg_ & ~__m; 822 *__result.__seg_ &= __m; 823 *__result.__seg_ |= __b1 >> __clz_r; 824 *__first.__seg_ |= __b2 << __clz_r; 825 } 826 // do last word 827 if (__n > 0) 828 { 829 __m = ~__storage_type(0) >> (__bits_per_word - __n); 830 __storage_type __b1 = *__first.__seg_ & __m; 831 *__first.__seg_ &= ~__m; 832 __storage_type __dn = _VSTD::min<__storage_type>(__n, __clz_r); 833 __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn)); 834 __storage_type __b2 = *__result.__seg_ & __m; 835 *__result.__seg_ &= ~__m; 836 *__result.__seg_ |= __b1 << __result.__ctz_; 837 *__first.__seg_ |= __b2 >> __result.__ctz_; 838 __result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word; 839 __result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_) % __bits_per_word); 840 __n -= __dn; 841 if (__n > 0) 842 { 843 __m = ~__storage_type(0) >> (__bits_per_word - __n); 844 __b2 = *__result.__seg_ & __m; 845 *__result.__seg_ &= ~__m; 846 *__result.__seg_ |= __b1 >> __dn; 847 *__first.__seg_ |= __b2 << __dn; 848 __result.__ctz_ = static_cast<unsigned>(__n); 849 } 850 } 851 } 852 return __result; 853} 854 855template <class __C1, class __C2> 856inline _LIBCPP_INLINE_VISIBILITY 857__bit_iterator<__C2, false> 858swap_ranges(__bit_iterator<__C1, false> __first1, __bit_iterator<__C1, false> __last1, 859 __bit_iterator<__C2, false> __first2) 860{ 861 if (__first1.__ctz_ == __first2.__ctz_) 862 return __swap_ranges_aligned(__first1, __last1, __first2); 863 return __swap_ranges_unaligned(__first1, __last1, __first2); 864} 865 866// rotate 867 868template <class _Cp> 869struct __bit_array 870{ 871 typedef typename _Cp::difference_type difference_type; 872 typedef typename _Cp::__storage_type __storage_type; 873 typedef typename _Cp::iterator iterator; 874 static const unsigned __bits_per_word = _Cp::__bits_per_word; 875 static const unsigned _Np = 4; 876 877 difference_type __size_; 878 __storage_type __word_[_Np]; 879 880 _LIBCPP_INLINE_VISIBILITY static difference_type capacity() 881 {return static_cast<difference_type>(_Np * __bits_per_word);} 882 _LIBCPP_INLINE_VISIBILITY explicit __bit_array(difference_type __s) : __size_(__s) {} 883 _LIBCPP_INLINE_VISIBILITY iterator begin() {return iterator(__word_, 0);} 884 _LIBCPP_INLINE_VISIBILITY iterator end() {return iterator(__word_ + __size_ / __bits_per_word, 885 static_cast<unsigned>(__size_ % __bits_per_word));} 886}; 887 888template <class _Cp> 889__bit_iterator<_Cp, false> 890rotate(__bit_iterator<_Cp, false> __first, __bit_iterator<_Cp, false> __middle, __bit_iterator<_Cp, false> __last) 891{ 892 typedef __bit_iterator<_Cp, false> _I1; 893 typedef typename _I1::difference_type difference_type; 894 typedef typename _I1::__storage_type __storage_type; 895 difference_type __d1 = __middle - __first; 896 difference_type __d2 = __last - __middle; 897 _I1 __r = __first + __d2; 898 while (__d1 != 0 && __d2 != 0) 899 { 900 if (__d1 <= __d2) 901 { 902 if (__d1 <= __bit_array<_Cp>::capacity()) 903 { 904 __bit_array<_Cp> __b(__d1); 905 _VSTD::copy(__first, __middle, __b.begin()); 906 _VSTD::copy(__b.begin(), __b.end(), _VSTD::copy(__middle, __last, __first)); 907 break; 908 } 909 else 910 { 911 __bit_iterator<_Cp, false> __mp = _VSTD::swap_ranges(__first, __middle, __middle); 912 __first = __middle; 913 __middle = __mp; 914 __d2 -= __d1; 915 } 916 } 917 else 918 { 919 if (__d2 <= __bit_array<_Cp>::capacity()) 920 { 921 __bit_array<_Cp> __b(__d2); 922 _VSTD::copy(__middle, __last, __b.begin()); 923 _VSTD::copy_backward(__b.begin(), __b.end(), _VSTD::copy_backward(__first, __middle, __last)); 924 break; 925 } 926 else 927 { 928 __bit_iterator<_Cp, false> __mp = __first + __d2; 929 _VSTD::swap_ranges(__first, __mp, __middle); 930 __first = __mp; 931 __d1 -= __d2; 932 } 933 } 934 } 935 return __r; 936} 937 938// equal 939 940template <class _Cp, bool _IC1, bool _IC2> 941bool 942__equal_unaligned(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1, 943 __bit_iterator<_Cp, _IC2> __first2) 944{ 945 typedef __bit_iterator<_Cp, _IC1> _It; 946 typedef typename _It::difference_type difference_type; 947 typedef typename _It::__storage_type __storage_type; 948 static const unsigned __bits_per_word = _It::__bits_per_word; 949 difference_type __n = __last1 - __first1; 950 if (__n > 0) 951 { 952 // do first word 953 if (__first1.__ctz_ != 0) 954 { 955 unsigned __clz_f = __bits_per_word - __first1.__ctz_; 956 difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz_f), __n); 957 __n -= __dn; 958 __storage_type __m = (~__storage_type(0) << __first1.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn)); 959 __storage_type __b = *__first1.__seg_ & __m; 960 unsigned __clz_r = __bits_per_word - __first2.__ctz_; 961 __storage_type __ddn = _VSTD::min<__storage_type>(__dn, __clz_r); 962 __m = (~__storage_type(0) << __first2.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn)); 963 if (__first2.__ctz_ > __first1.__ctz_) 964 { 965 if ((*__first2.__seg_ & __m) != (__b << (__first2.__ctz_ - __first1.__ctz_))) 966 return false; 967 } 968 else 969 { 970 if ((*__first2.__seg_ & __m) != (__b >> (__first1.__ctz_ - __first2.__ctz_))) 971 return false; 972 } 973 __first2.__seg_ += (__ddn + __first2.__ctz_) / __bits_per_word; 974 __first2.__ctz_ = static_cast<unsigned>((__ddn + __first2.__ctz_) % __bits_per_word); 975 __dn -= __ddn; 976 if (__dn > 0) 977 { 978 __m = ~__storage_type(0) >> (__bits_per_word - __dn); 979 if ((*__first2.__seg_ & __m) != (__b >> (__first1.__ctz_ + __ddn))) 980 return false; 981 __first2.__ctz_ = static_cast<unsigned>(__dn); 982 } 983 ++__first1.__seg_; 984 // __first1.__ctz_ = 0; 985 } 986 // __first1.__ctz_ == 0; 987 // do middle words 988 unsigned __clz_r = __bits_per_word - __first2.__ctz_; 989 __storage_type __m = ~__storage_type(0) << __first2.__ctz_; 990 for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first1.__seg_) 991 { 992 __storage_type __b = *__first1.__seg_; 993 if ((*__first2.__seg_ & __m) != (__b << __first2.__ctz_)) 994 return false; 995 ++__first2.__seg_; 996 if ((*__first2.__seg_ & ~__m) != (__b >> __clz_r)) 997 return false; 998 } 999 // do last word 1000 if (__n > 0) 1001 { 1002 __m = ~__storage_type(0) >> (__bits_per_word - __n); 1003 __storage_type __b = *__first1.__seg_ & __m; 1004 __storage_type __dn = _VSTD::min(__n, static_cast<difference_type>(__clz_r)); 1005 __m = (~__storage_type(0) << __first2.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn)); 1006 if ((*__first2.__seg_ & __m) != (__b << __first2.__ctz_)) 1007 return false; 1008 __first2.__seg_ += (__dn + __first2.__ctz_) / __bits_per_word; 1009 __first2.__ctz_ = static_cast<unsigned>((__dn + __first2.__ctz_) % __bits_per_word); 1010 __n -= __dn; 1011 if (__n > 0) 1012 { 1013 __m = ~__storage_type(0) >> (__bits_per_word - __n); 1014 if ((*__first2.__seg_ & __m) != (__b >> __dn)) 1015 return false; 1016 } 1017 } 1018 } 1019 return true; 1020} 1021 1022template <class _Cp, bool _IC1, bool _IC2> 1023bool 1024__equal_aligned(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1, 1025 __bit_iterator<_Cp, _IC2> __first2) 1026{ 1027 typedef __bit_iterator<_Cp, _IC1> _It; 1028 typedef typename _It::difference_type difference_type; 1029 typedef typename _It::__storage_type __storage_type; 1030 static const unsigned __bits_per_word = _It::__bits_per_word; 1031 difference_type __n = __last1 - __first1; 1032 if (__n > 0) 1033 { 1034 // do first word 1035 if (__first1.__ctz_ != 0) 1036 { 1037 unsigned __clz = __bits_per_word - __first1.__ctz_; 1038 difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz), __n); 1039 __n -= __dn; 1040 __storage_type __m = (~__storage_type(0) << __first1.__ctz_) & (~__storage_type(0) >> (__clz - __dn)); 1041 if ((*__first2.__seg_ & __m) != (*__first1.__seg_ & __m)) 1042 return false; 1043 ++__first2.__seg_; 1044 ++__first1.__seg_; 1045 // __first1.__ctz_ = 0; 1046 // __first2.__ctz_ = 0; 1047 } 1048 // __first1.__ctz_ == 0; 1049 // __first2.__ctz_ == 0; 1050 // do middle words 1051 for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first1.__seg_, ++__first2.__seg_) 1052 if (*__first2.__seg_ != *__first1.__seg_) 1053 return false; 1054 // do last word 1055 if (__n > 0) 1056 { 1057 __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n); 1058 if ((*__first2.__seg_ & __m) != (*__first1.__seg_ & __m)) 1059 return false; 1060 } 1061 } 1062 return true; 1063} 1064 1065template <class _Cp, bool _IC1, bool _IC2> 1066inline _LIBCPP_INLINE_VISIBILITY 1067bool 1068equal(__bit_iterator<_Cp, _IC1> __first1, __bit_iterator<_Cp, _IC1> __last1, __bit_iterator<_Cp, _IC2> __first2) 1069{ 1070 if (__first1.__ctz_ == __first2.__ctz_) 1071 return __equal_aligned(__first1, __last1, __first2); 1072 return __equal_unaligned(__first1, __last1, __first2); 1073} 1074 1075template <class _Cp, bool _IsConst, 1076 typename _Cp::__storage_type> 1077class __bit_iterator 1078{ 1079public: 1080 typedef typename _Cp::difference_type difference_type; 1081 typedef bool value_type; 1082 typedef __bit_iterator pointer; 1083 typedef typename conditional<_IsConst, __bit_const_reference<_Cp>, __bit_reference<_Cp> >::type reference; 1084 typedef random_access_iterator_tag iterator_category; 1085 1086private: 1087 typedef typename _Cp::__storage_type __storage_type; 1088 typedef typename conditional<_IsConst, typename _Cp::__const_storage_pointer, 1089 typename _Cp::__storage_pointer>::type __storage_pointer; 1090 static const unsigned __bits_per_word = _Cp::__bits_per_word; 1091 1092 __storage_pointer __seg_; 1093 unsigned __ctz_; 1094 1095public: 1096 _LIBCPP_INLINE_VISIBILITY __bit_iterator() _NOEXCEPT {} 1097 1098 _LIBCPP_INLINE_VISIBILITY 1099 __bit_iterator(const __bit_iterator<_Cp, false>& __it) _NOEXCEPT 1100 : __seg_(__it.__seg_), __ctz_(__it.__ctz_) {} 1101 1102 _LIBCPP_INLINE_VISIBILITY reference operator*() const _NOEXCEPT 1103 {return reference(__seg_, __storage_type(1) << __ctz_);} 1104 1105 _LIBCPP_INLINE_VISIBILITY __bit_iterator& operator++() 1106 { 1107 if (__ctz_ != __bits_per_word-1) 1108 ++__ctz_; 1109 else 1110 { 1111 __ctz_ = 0; 1112 ++__seg_; 1113 } 1114 return *this; 1115 } 1116 1117 _LIBCPP_INLINE_VISIBILITY __bit_iterator operator++(int) 1118 { 1119 __bit_iterator __tmp = *this; 1120 ++(*this); 1121 return __tmp; 1122 } 1123 1124 _LIBCPP_INLINE_VISIBILITY __bit_iterator& operator--() 1125 { 1126 if (__ctz_ != 0) 1127 --__ctz_; 1128 else 1129 { 1130 __ctz_ = __bits_per_word - 1; 1131 --__seg_; 1132 } 1133 return *this; 1134 } 1135 1136 _LIBCPP_INLINE_VISIBILITY __bit_iterator operator--(int) 1137 { 1138 __bit_iterator __tmp = *this; 1139 --(*this); 1140 return __tmp; 1141 } 1142 1143 _LIBCPP_INLINE_VISIBILITY __bit_iterator& operator+=(difference_type __n) 1144 { 1145 if (__n >= 0) 1146 __seg_ += (__n + __ctz_) / __bits_per_word; 1147 else 1148 __seg_ += static_cast<difference_type>(__n - __bits_per_word + __ctz_ + 1) 1149 / static_cast<difference_type>(__bits_per_word); 1150 __n &= (__bits_per_word - 1); 1151 __ctz_ = static_cast<unsigned>((__n + __ctz_) % __bits_per_word); 1152 return *this; 1153 } 1154 1155 _LIBCPP_INLINE_VISIBILITY __bit_iterator& operator-=(difference_type __n) 1156 { 1157 return *this += -__n; 1158 } 1159 1160 _LIBCPP_INLINE_VISIBILITY __bit_iterator operator+(difference_type __n) const 1161 { 1162 __bit_iterator __t(*this); 1163 __t += __n; 1164 return __t; 1165 } 1166 1167 _LIBCPP_INLINE_VISIBILITY __bit_iterator operator-(difference_type __n) const 1168 { 1169 __bit_iterator __t(*this); 1170 __t -= __n; 1171 return __t; 1172 } 1173 1174 _LIBCPP_INLINE_VISIBILITY 1175 friend __bit_iterator operator+(difference_type __n, const __bit_iterator& __it) {return __it + __n;} 1176 1177 _LIBCPP_INLINE_VISIBILITY 1178 friend difference_type operator-(const __bit_iterator& __x, const __bit_iterator& __y) 1179 {return (__x.__seg_ - __y.__seg_) * __bits_per_word + __x.__ctz_ - __y.__ctz_;} 1180 1181 _LIBCPP_INLINE_VISIBILITY reference operator[](difference_type __n) const {return *(*this + __n);} 1182 1183 _LIBCPP_INLINE_VISIBILITY friend bool operator==(const __bit_iterator& __x, const __bit_iterator& __y) 1184 {return __x.__seg_ == __y.__seg_ && __x.__ctz_ == __y.__ctz_;} 1185 1186 _LIBCPP_INLINE_VISIBILITY friend bool operator!=(const __bit_iterator& __x, const __bit_iterator& __y) 1187 {return !(__x == __y);} 1188 1189 _LIBCPP_INLINE_VISIBILITY friend bool operator<(const __bit_iterator& __x, const __bit_iterator& __y) 1190 {return __x.__seg_ < __y.__seg_ || (__x.__seg_ == __y.__seg_ && __x.__ctz_ < __y.__ctz_);} 1191 1192 _LIBCPP_INLINE_VISIBILITY friend bool operator>(const __bit_iterator& __x, const __bit_iterator& __y) 1193 {return __y < __x;} 1194 1195 _LIBCPP_INLINE_VISIBILITY friend bool operator<=(const __bit_iterator& __x, const __bit_iterator& __y) 1196 {return !(__y < __x);} 1197 1198 _LIBCPP_INLINE_VISIBILITY friend bool operator>=(const __bit_iterator& __x, const __bit_iterator& __y) 1199 {return !(__x < __y);} 1200 1201private: 1202 _LIBCPP_INLINE_VISIBILITY 1203 __bit_iterator(__storage_pointer __s, unsigned __ctz) _NOEXCEPT 1204 : __seg_(__s), __ctz_(__ctz) {} 1205 1206#if defined(__clang__) 1207 friend typename _Cp::__self; 1208#else 1209 friend class _Cp::__self; 1210#endif 1211 friend class __bit_reference<_Cp>; 1212 friend class __bit_const_reference<_Cp>; 1213 friend class __bit_iterator<_Cp, true>; 1214 template <class _Dp> friend struct __bit_array; 1215 template <class _Dp> friend void __fill_n_false(__bit_iterator<_Dp, false> __first, typename _Dp::size_type __n); 1216 template <class _Dp> friend void __fill_n_true(__bit_iterator<_Dp, false> __first, typename _Dp::size_type __n); 1217 template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> __copy_aligned(__bit_iterator<_Dp, _IC> __first, 1218 __bit_iterator<_Dp, _IC> __last, 1219 __bit_iterator<_Dp, false> __result); 1220 template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> __copy_unaligned(__bit_iterator<_Dp, _IC> __first, 1221 __bit_iterator<_Dp, _IC> __last, 1222 __bit_iterator<_Dp, false> __result); 1223 template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> copy(__bit_iterator<_Dp, _IC> __first, 1224 __bit_iterator<_Dp, _IC> __last, 1225 __bit_iterator<_Dp, false> __result); 1226 template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> __copy_backward_aligned(__bit_iterator<_Dp, _IC> __first, 1227 __bit_iterator<_Dp, _IC> __last, 1228 __bit_iterator<_Dp, false> __result); 1229 template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> __copy_backward_unaligned(__bit_iterator<_Dp, _IC> __first, 1230 __bit_iterator<_Dp, _IC> __last, 1231 __bit_iterator<_Dp, false> __result); 1232 template <class _Dp, bool _IC> friend __bit_iterator<_Dp, false> copy_backward(__bit_iterator<_Dp, _IC> __first, 1233 __bit_iterator<_Dp, _IC> __last, 1234 __bit_iterator<_Dp, false> __result); 1235 template <class __C1, class __C2>friend __bit_iterator<__C2, false> __swap_ranges_aligned(__bit_iterator<__C1, false>, 1236 __bit_iterator<__C1, false>, 1237 __bit_iterator<__C2, false>); 1238 template <class __C1, class __C2>friend __bit_iterator<__C2, false> __swap_ranges_unaligned(__bit_iterator<__C1, false>, 1239 __bit_iterator<__C1, false>, 1240 __bit_iterator<__C2, false>); 1241 template <class __C1, class __C2>friend __bit_iterator<__C2, false> swap_ranges(__bit_iterator<__C1, false>, 1242 __bit_iterator<__C1, false>, 1243 __bit_iterator<__C2, false>); 1244 template <class _Dp> friend __bit_iterator<_Dp, false> rotate(__bit_iterator<_Dp, false>, 1245 __bit_iterator<_Dp, false>, 1246 __bit_iterator<_Dp, false>); 1247 template <class _Dp, bool _IC1, bool _IC2> friend bool __equal_aligned(__bit_iterator<_Dp, _IC1>, 1248 __bit_iterator<_Dp, _IC1>, 1249 __bit_iterator<_Dp, _IC2>); 1250 template <class _Dp, bool _IC1, bool _IC2> friend bool __equal_unaligned(__bit_iterator<_Dp, _IC1>, 1251 __bit_iterator<_Dp, _IC1>, 1252 __bit_iterator<_Dp, _IC2>); 1253 template <class _Dp, bool _IC1, bool _IC2> friend bool equal(__bit_iterator<_Dp, _IC1>, 1254 __bit_iterator<_Dp, _IC1>, 1255 __bit_iterator<_Dp, _IC2>); 1256 template <class _Dp, bool _IC> friend __bit_iterator<_Dp, _IC> __find_bool_true(__bit_iterator<_Dp, _IC>, 1257 typename _Dp::size_type); 1258 template <class _Dp, bool _IC> friend __bit_iterator<_Dp, _IC> __find_bool_false(__bit_iterator<_Dp, _IC>, 1259 typename _Dp::size_type); 1260 template <class _Dp, bool _IC> friend typename __bit_iterator<_Dp, _IC>::difference_type 1261 __count_bool_true(__bit_iterator<_Dp, _IC>, typename _Dp::size_type); 1262 template <class _Dp, bool _IC> friend typename __bit_iterator<_Dp, _IC>::difference_type 1263 __count_bool_false(__bit_iterator<_Dp, _IC>, typename _Dp::size_type); 1264}; 1265 1266_LIBCPP_END_NAMESPACE_STD 1267 1268#endif // _LIBCPP___BIT_REFERENCE 1269