2010-05-12 03:42:16 +08:00
|
|
|
// -*- C++ -*-
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
//
|
2010-05-12 05:36:01 +08:00
|
|
|
// The LLVM Compiler Infrastructure
|
2010-05-12 03:42:16 +08:00
|
|
|
//
|
2010-11-17 06:09:02 +08:00
|
|
|
// This file is dual licensed under the MIT and the University of Illinois Open
|
|
|
|
|
// Source Licenses. See LICENSE.TXT for details.
|
2010-05-12 03:42:16 +08:00
|
|
|
//
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
|
|
#ifndef _LIBCPP___BIT_REFERENCE
|
|
|
|
|
#define _LIBCPP___BIT_REFERENCE
|
|
|
|
|
|
|
|
|
|
#include <__config>
|
|
|
|
|
#include <algorithm>
|
|
|
|
|
|
|
|
|
|
#pragma GCC system_header
|
|
|
|
|
|
|
|
|
|
_LIBCPP_BEGIN_NAMESPACE_STD
|
|
|
|
|
|
|
|
|
|
template <class _C, bool _IsConst> class __bit_iterator;
|
|
|
|
|
template <class _C> class __bit_const_reference;
|
|
|
|
|
|
2011-07-03 04:33:23 +08:00
|
|
|
template <class _Tp>
|
|
|
|
|
struct __has_storage_type
|
|
|
|
|
{
|
|
|
|
|
static const bool value = false;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
template <class _C, bool = __has_storage_type<_C>::value>
|
2010-05-12 03:42:16 +08:00
|
|
|
class __bit_reference
|
|
|
|
|
{
|
|
|
|
|
typedef typename _C::__storage_type __storage_type;
|
|
|
|
|
typedef typename _C::__storage_pointer __storage_pointer;
|
|
|
|
|
|
|
|
|
|
__storage_pointer __seg_;
|
|
|
|
|
__storage_type __mask_;
|
|
|
|
|
|
|
|
|
|
#if defined(__clang__)
|
|
|
|
|
friend typename _C::__self;
|
|
|
|
|
#else
|
|
|
|
|
friend class _C::__self;
|
|
|
|
|
#endif
|
|
|
|
|
friend class __bit_const_reference<_C>;
|
|
|
|
|
friend class __bit_iterator<_C, false>;
|
|
|
|
|
public:
|
2011-05-28 04:52:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY operator bool() const _NOEXCEPT
|
|
|
|
|
{return static_cast<bool>(*__seg_ & __mask_);}
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY bool operator ~() const _NOEXCEPT
|
|
|
|
|
{return !static_cast<bool>(*this);}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-05-28 04:52:28 +08:00
|
|
|
__bit_reference& operator=(bool __x) _NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
|
if (__x)
|
|
|
|
|
*__seg_ |= __mask_;
|
|
|
|
|
else
|
|
|
|
|
*__seg_ &= ~__mask_;
|
|
|
|
|
return *this;
|
|
|
|
|
}
|
2010-08-22 08:02:43 +08:00
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-05-28 04:52:28 +08:00
|
|
|
__bit_reference& operator=(const __bit_reference& __x) _NOEXCEPT
|
|
|
|
|
{return operator=(static_cast<bool>(__x));}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2011-05-28 04:52:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY void flip() _NOEXCEPT {*__seg_ ^= __mask_;}
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY __bit_iterator<_C, false> operator&() const _NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
{return __bit_iterator<_C, false>(__seg_, static_cast<unsigned>(__ctz(__mask_)));}
|
|
|
|
|
private:
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-05-28 04:52:28 +08:00
|
|
|
__bit_reference(__storage_pointer __s, __storage_type __m) _NOEXCEPT
|
|
|
|
|
: __seg_(__s), __mask_(__m) {}
|
2010-05-12 03:42:16 +08:00
|
|
|
};
|
|
|
|
|
|
2011-07-03 04:33:23 +08:00
|
|
|
template <class _C>
|
|
|
|
|
class __bit_reference<_C, false>
|
|
|
|
|
{
|
|
|
|
|
};
|
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _C, class _D>
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY inline
|
|
|
|
|
void
|
2011-05-28 04:52:28 +08:00
|
|
|
swap(__bit_reference<_C> __x, __bit_reference<_D> __y) _NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
|
bool __t = __x;
|
|
|
|
|
__x = __y;
|
|
|
|
|
__y = __t;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _C>
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY inline
|
|
|
|
|
void
|
2011-05-28 04:52:28 +08:00
|
|
|
swap(__bit_reference<_C> __x, bool& __y) _NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
|
bool __t = __x;
|
|
|
|
|
__x = __y;
|
|
|
|
|
__y = __t;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _C>
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY inline
|
|
|
|
|
void
|
2011-05-28 04:52:28 +08:00
|
|
|
swap(bool& __x, __bit_reference<_C> __y) _NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
|
bool __t = __x;
|
|
|
|
|
__x = __y;
|
|
|
|
|
__y = __t;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _C>
|
|
|
|
|
class __bit_const_reference
|
|
|
|
|
{
|
|
|
|
|
typedef typename _C::__storage_type __storage_type;
|
|
|
|
|
typedef typename _C::__const_storage_pointer __storage_pointer;
|
|
|
|
|
|
|
|
|
|
__storage_pointer __seg_;
|
|
|
|
|
__storage_type __mask_;
|
|
|
|
|
|
|
|
|
|
#if defined(__clang__)
|
|
|
|
|
friend typename _C::__self;
|
|
|
|
|
#else
|
|
|
|
|
friend class _C::__self;
|
|
|
|
|
#endif
|
|
|
|
|
friend class __bit_iterator<_C, true>;
|
|
|
|
|
public:
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-05-28 04:52:28 +08:00
|
|
|
__bit_const_reference(const __bit_reference<_C>& __x) _NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
: __seg_(__x.__seg_), __mask_(__x.__mask_) {}
|
|
|
|
|
|
2011-05-28 04:52:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY operator bool() const _NOEXCEPT
|
|
|
|
|
{return static_cast<bool>(*__seg_ & __mask_);}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2011-05-28 04:52:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY __bit_iterator<_C, true> operator&() const _NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
{return __bit_iterator<_C, true>(__seg_, static_cast<unsigned>(__ctz(__mask_)));}
|
|
|
|
|
private:
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-05-28 04:52:28 +08:00
|
|
|
__bit_const_reference(__storage_pointer __s, __storage_type __m) _NOEXCEPT
|
|
|
|
|
: __seg_(__s), __mask_(__m) {}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
|
__bit_const_reference& operator=(const __bit_const_reference& __x);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// find
|
|
|
|
|
|
|
|
|
|
template <class _C>
|
|
|
|
|
__bit_iterator<_C, false>
|
|
|
|
|
__find_bool_true(__bit_iterator<_C, false> __first, typename _C::size_type __n)
|
|
|
|
|
{
|
|
|
|
|
typedef __bit_iterator<_C, false> _It;
|
|
|
|
|
typedef typename _It::__storage_type __storage_type;
|
|
|
|
|
static const unsigned __bits_per_word = _It::__bits_per_word;
|
|
|
|
|
// do first partial word
|
|
|
|
|
if (__first.__ctz_ != 0)
|
|
|
|
|
{
|
|
|
|
|
__storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
|
2011-07-01 05:18:19 +08:00
|
|
|
__storage_type __dn = _VSTD::min(__clz_f, __n);
|
2010-05-12 03:42:16 +08:00
|
|
|
__storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
|
|
|
|
|
__storage_type __b = *__first.__seg_ & __m;
|
|
|
|
|
if (__b)
|
2011-07-01 05:18:19 +08:00
|
|
|
return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__ctz(__b)));
|
2010-05-12 03:42:16 +08:00
|
|
|
__n -= __dn;
|
|
|
|
|
++__first.__seg_;
|
|
|
|
|
}
|
|
|
|
|
// do middle whole words
|
|
|
|
|
for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word)
|
|
|
|
|
if (*__first.__seg_)
|
2011-07-01 05:18:19 +08:00
|
|
|
return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__ctz(*__first.__seg_)));
|
2010-05-12 03:42:16 +08:00
|
|
|
// do last partial word
|
|
|
|
|
if (__n > 0)
|
|
|
|
|
{
|
|
|
|
|
__storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
|
|
|
|
|
__storage_type __b = *__first.__seg_ & __m;
|
|
|
|
|
if (__b)
|
2011-07-01 05:18:19 +08:00
|
|
|
return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__ctz(__b)));
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
return _It(__first.__seg_, static_cast<unsigned>(__n));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _C>
|
|
|
|
|
__bit_iterator<_C, false>
|
|
|
|
|
__find_bool_false(__bit_iterator<_C, false> __first, typename _C::size_type __n)
|
|
|
|
|
{
|
|
|
|
|
typedef __bit_iterator<_C, false> _It;
|
|
|
|
|
typedef typename _It::__storage_type __storage_type;
|
|
|
|
|
static const unsigned __bits_per_word = _It::__bits_per_word;
|
|
|
|
|
// do first partial word
|
|
|
|
|
if (__first.__ctz_ != 0)
|
|
|
|
|
{
|
|
|
|
|
__storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
|
2011-07-01 05:18:19 +08:00
|
|
|
__storage_type __dn = _VSTD::min(__clz_f, __n);
|
2010-05-12 03:42:16 +08:00
|
|
|
__storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
|
|
|
|
|
__storage_type __b = ~(*__first.__seg_ & __m);
|
|
|
|
|
if (__b)
|
2011-07-01 05:18:19 +08:00
|
|
|
return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__ctz(__b)));
|
2010-05-12 03:42:16 +08:00
|
|
|
__n -= __dn;
|
|
|
|
|
++__first.__seg_;
|
|
|
|
|
}
|
|
|
|
|
// do middle whole words
|
|
|
|
|
for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word)
|
|
|
|
|
{
|
|
|
|
|
__storage_type __b = ~*__first.__seg_;
|
|
|
|
|
if (__b)
|
2011-07-01 05:18:19 +08:00
|
|
|
return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__ctz(__b)));
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
// do last partial word
|
|
|
|
|
if (__n > 0)
|
|
|
|
|
{
|
|
|
|
|
__storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
|
|
|
|
|
__storage_type __b = ~(*__first.__seg_ & __m);
|
|
|
|
|
if (__b)
|
2011-07-01 05:18:19 +08:00
|
|
|
return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__ctz(__b)));
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
return _It(__first.__seg_, static_cast<unsigned>(__n));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _C, class _Tp>
|
|
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
|
|
|
__bit_iterator<_C, false>
|
|
|
|
|
find(__bit_iterator<_C, false> __first, __bit_iterator<_C, false> __last, const _Tp& __value)
|
|
|
|
|
{
|
|
|
|
|
if (static_cast<bool>(__value))
|
|
|
|
|
return __find_bool_true(__first, static_cast<typename _C::size_type>(__last - __first));
|
|
|
|
|
return __find_bool_false(__first, static_cast<typename _C::size_type>(__last - __first));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// count
|
|
|
|
|
|
|
|
|
|
template <class _C>
|
|
|
|
|
typename __bit_iterator<_C, false>::difference_type
|
|
|
|
|
__count_bool_true(__bit_iterator<_C, false> __first, typename _C::size_type __n)
|
|
|
|
|
{
|
|
|
|
|
typedef __bit_iterator<_C, false> _It;
|
|
|
|
|
typedef typename _It::__storage_type __storage_type;
|
|
|
|
|
typedef typename _It::difference_type difference_type;
|
|
|
|
|
static const unsigned __bits_per_word = _It::__bits_per_word;
|
|
|
|
|
difference_type __r = 0;
|
|
|
|
|
// do first partial word
|
|
|
|
|
if (__first.__ctz_ != 0)
|
|
|
|
|
{
|
|
|
|
|
__storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
|
2011-07-01 05:18:19 +08:00
|
|
|
__storage_type __dn = _VSTD::min(__clz_f, __n);
|
2010-05-12 03:42:16 +08:00
|
|
|
__storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
|
2011-07-01 05:18:19 +08:00
|
|
|
__r = _VSTD::__pop_count(*__first.__seg_ & __m);
|
2010-05-12 03:42:16 +08:00
|
|
|
__n -= __dn;
|
|
|
|
|
++__first.__seg_;
|
|
|
|
|
}
|
|
|
|
|
// do middle whole words
|
|
|
|
|
for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word)
|
2011-07-01 05:18:19 +08:00
|
|
|
__r += _VSTD::__pop_count(*__first.__seg_);
|
2010-05-12 03:42:16 +08:00
|
|
|
// do last partial word
|
|
|
|
|
if (__n > 0)
|
|
|
|
|
{
|
|
|
|
|
__storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
|
2011-07-01 05:18:19 +08:00
|
|
|
__r += _VSTD::__pop_count(*__first.__seg_ & __m);
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
return __r;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _C>
|
|
|
|
|
typename __bit_iterator<_C, false>::difference_type
|
|
|
|
|
__count_bool_false(__bit_iterator<_C, false> __first, typename _C::size_type __n)
|
|
|
|
|
{
|
|
|
|
|
typedef __bit_iterator<_C, false> _It;
|
|
|
|
|
typedef typename _It::__storage_type __storage_type;
|
|
|
|
|
typedef typename _It::difference_type difference_type;
|
|
|
|
|
static const unsigned __bits_per_word = _It::__bits_per_word;
|
|
|
|
|
difference_type __r = 0;
|
|
|
|
|
// do first partial word
|
|
|
|
|
if (__first.__ctz_ != 0)
|
|
|
|
|
{
|
|
|
|
|
__storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
|
2011-07-01 05:18:19 +08:00
|
|
|
__storage_type __dn = _VSTD::min(__clz_f, __n);
|
2010-05-12 03:42:16 +08:00
|
|
|
__storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
|
2011-07-01 05:18:19 +08:00
|
|
|
__r = _VSTD::__pop_count(~(*__first.__seg_ & __m));
|
2010-05-12 03:42:16 +08:00
|
|
|
__n -= __dn;
|
|
|
|
|
++__first.__seg_;
|
|
|
|
|
}
|
|
|
|
|
// do middle whole words
|
|
|
|
|
for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word)
|
2011-07-01 05:18:19 +08:00
|
|
|
__r += _VSTD::__pop_count(~*__first.__seg_);
|
2010-05-12 03:42:16 +08:00
|
|
|
// do last partial word
|
|
|
|
|
if (__n > 0)
|
|
|
|
|
{
|
|
|
|
|
__storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
|
2011-07-01 05:18:19 +08:00
|
|
|
__r += _VSTD::__pop_count(~(*__first.__seg_ & __m));
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
return __r;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _C, class _Tp>
|
|
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
|
|
|
typename __bit_iterator<_C, false>::difference_type
|
|
|
|
|
count(__bit_iterator<_C, false> __first, __bit_iterator<_C, false> __last, const _Tp& __value)
|
|
|
|
|
{
|
|
|
|
|
if (static_cast<bool>(__value))
|
|
|
|
|
return __count_bool_true(__first, static_cast<typename _C::size_type>(__last - __first));
|
|
|
|
|
return __count_bool_false(__first, static_cast<typename _C::size_type>(__last - __first));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// fill_n
|
|
|
|
|
|
|
|
|
|
template <class _C>
|
|
|
|
|
void
|
|
|
|
|
__fill_n_false(__bit_iterator<_C, false> __first, typename _C::size_type __n)
|
|
|
|
|
{
|
|
|
|
|
typedef __bit_iterator<_C, false> _It;
|
|
|
|
|
typedef typename _It::__storage_type __storage_type;
|
|
|
|
|
static const unsigned __bits_per_word = _It::__bits_per_word;
|
|
|
|
|
// do first partial word
|
|
|
|
|
if (__first.__ctz_ != 0)
|
|
|
|
|
{
|
|
|
|
|
__storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
|
2011-07-01 05:18:19 +08:00
|
|
|
__storage_type __dn = _VSTD::min(__clz_f, __n);
|
2010-05-12 03:42:16 +08:00
|
|
|
__storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
|
|
|
|
|
*__first.__seg_ &= ~__m;
|
|
|
|
|
__n -= __dn;
|
|
|
|
|
++__first.__seg_;
|
|
|
|
|
}
|
|
|
|
|
// do middle whole words
|
|
|
|
|
__storage_type __nw = __n / __bits_per_word;
|
2011-07-01 05:18:19 +08:00
|
|
|
_VSTD::memset(__first.__seg_, 0, __nw * sizeof(__storage_type));
|
2010-05-12 03:42:16 +08:00
|
|
|
__n -= __nw * __bits_per_word;
|
|
|
|
|
// do last partial word
|
|
|
|
|
if (__n > 0)
|
|
|
|
|
{
|
|
|
|
|
__first.__seg_ += __nw;
|
|
|
|
|
__storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
|
|
|
|
|
*__first.__seg_ &= ~__m;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _C>
|
|
|
|
|
void
|
|
|
|
|
__fill_n_true(__bit_iterator<_C, false> __first, typename _C::size_type __n)
|
|
|
|
|
{
|
|
|
|
|
typedef __bit_iterator<_C, false> _It;
|
|
|
|
|
typedef typename _It::__storage_type __storage_type;
|
|
|
|
|
static const unsigned __bits_per_word = _It::__bits_per_word;
|
|
|
|
|
// do first partial word
|
|
|
|
|
if (__first.__ctz_ != 0)
|
|
|
|
|
{
|
|
|
|
|
__storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
|
2011-07-01 05:18:19 +08:00
|
|
|
__storage_type __dn = _VSTD::min(__clz_f, __n);
|
2010-05-12 03:42:16 +08:00
|
|
|
__storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
|
|
|
|
|
*__first.__seg_ |= __m;
|
|
|
|
|
__n -= __dn;
|
|
|
|
|
++__first.__seg_;
|
|
|
|
|
}
|
|
|
|
|
// do middle whole words
|
|
|
|
|
__storage_type __nw = __n / __bits_per_word;
|
2011-07-01 05:18:19 +08:00
|
|
|
_VSTD::memset(__first.__seg_, -1, __nw * sizeof(__storage_type));
|
2010-05-12 03:42:16 +08:00
|
|
|
__n -= __nw * __bits_per_word;
|
|
|
|
|
// do last partial word
|
|
|
|
|
if (__n > 0)
|
|
|
|
|
{
|
|
|
|
|
__first.__seg_ += __nw;
|
|
|
|
|
__storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
|
|
|
|
|
*__first.__seg_ |= __m;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _C>
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY inline
|
|
|
|
|
void
|
|
|
|
|
fill_n(__bit_iterator<_C, false> __first, typename _C::size_type __n, bool __value)
|
|
|
|
|
{
|
|
|
|
|
if (__n > 0)
|
|
|
|
|
{
|
|
|
|
|
if (__value)
|
|
|
|
|
__fill_n_true(__first, __n);
|
|
|
|
|
else
|
|
|
|
|
__fill_n_false(__first, __n);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// fill
|
|
|
|
|
|
|
|
|
|
template <class _C>
|
|
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
|
|
|
void
|
|
|
|
|
fill(__bit_iterator<_C, false> __first, __bit_iterator<_C, false> __last, bool __value)
|
|
|
|
|
{
|
2011-07-01 05:18:19 +08:00
|
|
|
_VSTD::fill_n(__first, static_cast<typename _C::size_type>(__last - __first), __value);
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// copy
|
|
|
|
|
|
|
|
|
|
template <class _C, bool _IsConst>
|
|
|
|
|
__bit_iterator<_C, false>
|
|
|
|
|
__copy_aligned(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C, _IsConst> __last,
|
|
|
|
|
__bit_iterator<_C, false> __result)
|
|
|
|
|
{
|
|
|
|
|
typedef __bit_iterator<_C, _IsConst> _In;
|
|
|
|
|
typedef typename _In::difference_type difference_type;
|
|
|
|
|
typedef typename _In::__storage_type __storage_type;
|
|
|
|
|
static const unsigned __bits_per_word = _In::__bits_per_word;
|
|
|
|
|
difference_type __n = __last - __first;
|
|
|
|
|
if (__n > 0)
|
|
|
|
|
{
|
|
|
|
|
// do first word
|
|
|
|
|
if (__first.__ctz_ != 0)
|
|
|
|
|
{
|
|
|
|
|
unsigned __clz = __bits_per_word - __first.__ctz_;
|
2011-07-01 05:18:19 +08:00
|
|
|
difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz), __n);
|
2010-05-12 03:42:16 +08:00
|
|
|
__n -= __dn;
|
|
|
|
|
__storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz - __dn));
|
|
|
|
|
__storage_type __b = *__first.__seg_ & __m;
|
|
|
|
|
*__result.__seg_ &= ~__m;
|
|
|
|
|
*__result.__seg_ |= __b;
|
|
|
|
|
__result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
|
|
|
|
|
__result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_) % __bits_per_word);
|
|
|
|
|
++__first.__seg_;
|
|
|
|
|
// __first.__ctz_ = 0;
|
|
|
|
|
}
|
|
|
|
|
// __first.__ctz_ == 0;
|
|
|
|
|
// do middle words
|
|
|
|
|
__storage_type __nw = __n / __bits_per_word;
|
2011-07-01 05:18:19 +08:00
|
|
|
_VSTD::memmove(__result.__seg_, __first.__seg_, __nw * sizeof(__storage_type));
|
2010-05-12 03:42:16 +08:00
|
|
|
__n -= __nw * __bits_per_word;
|
|
|
|
|
__result.__seg_ += __nw;
|
|
|
|
|
// do last word
|
|
|
|
|
if (__n > 0)
|
|
|
|
|
{
|
|
|
|
|
__first.__seg_ += __nw;
|
|
|
|
|
__storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
|
|
|
|
|
__storage_type __b = *__first.__seg_ & __m;
|
|
|
|
|
*__result.__seg_ &= ~__m;
|
|
|
|
|
*__result.__seg_ |= __b;
|
|
|
|
|
__result.__ctz_ = static_cast<unsigned>(__n);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return __result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _C, bool _IsConst>
|
|
|
|
|
__bit_iterator<_C, false>
|
|
|
|
|
__copy_unaligned(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C, _IsConst> __last,
|
|
|
|
|
__bit_iterator<_C, false> __result)
|
|
|
|
|
{
|
|
|
|
|
typedef __bit_iterator<_C, _IsConst> _In;
|
|
|
|
|
typedef typename _In::difference_type difference_type;
|
|
|
|
|
typedef typename _In::__storage_type __storage_type;
|
|
|
|
|
static const unsigned __bits_per_word = _In::__bits_per_word;
|
|
|
|
|
difference_type __n = __last - __first;
|
|
|
|
|
if (__n > 0)
|
|
|
|
|
{
|
|
|
|
|
// do first word
|
|
|
|
|
if (__first.__ctz_ != 0)
|
|
|
|
|
{
|
|
|
|
|
unsigned __clz_f = __bits_per_word - __first.__ctz_;
|
2011-07-01 05:18:19 +08:00
|
|
|
difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz_f), __n);
|
2010-05-12 03:42:16 +08:00
|
|
|
__n -= __dn;
|
|
|
|
|
__storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
|
|
|
|
|
__storage_type __b = *__first.__seg_ & __m;
|
|
|
|
|
unsigned __clz_r = __bits_per_word - __result.__ctz_;
|
2011-07-01 05:18:19 +08:00
|
|
|
__storage_type __ddn = _VSTD::min<__storage_type>(__dn, __clz_r);
|
2010-05-12 03:42:16 +08:00
|
|
|
__m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn));
|
|
|
|
|
*__result.__seg_ &= ~__m;
|
|
|
|
|
if (__result.__ctz_ > __first.__ctz_)
|
|
|
|
|
*__result.__seg_ |= __b << (__result.__ctz_ - __first.__ctz_);
|
|
|
|
|
else
|
|
|
|
|
*__result.__seg_ |= __b >> (__first.__ctz_ - __result.__ctz_);
|
|
|
|
|
__result.__seg_ += (__ddn + __result.__ctz_) / __bits_per_word;
|
|
|
|
|
__result.__ctz_ = static_cast<unsigned>((__ddn + __result.__ctz_) % __bits_per_word);
|
|
|
|
|
__dn -= __ddn;
|
|
|
|
|
if (__dn > 0)
|
|
|
|
|
{
|
|
|
|
|
__m = ~__storage_type(0) >> (__bits_per_word - __dn);
|
|
|
|
|
*__result.__seg_ &= ~__m;
|
|
|
|
|
*__result.__seg_ |= __b >> (__first.__ctz_ + __ddn);
|
|
|
|
|
__result.__ctz_ = static_cast<unsigned>(__dn);
|
|
|
|
|
}
|
|
|
|
|
++__first.__seg_;
|
|
|
|
|
// __first.__ctz_ = 0;
|
|
|
|
|
}
|
|
|
|
|
// __first.__ctz_ == 0;
|
|
|
|
|
// do middle words
|
|
|
|
|
unsigned __clz_r = __bits_per_word - __result.__ctz_;
|
|
|
|
|
__storage_type __m = ~__storage_type(0) << __result.__ctz_;
|
|
|
|
|
for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first.__seg_)
|
|
|
|
|
{
|
|
|
|
|
__storage_type __b = *__first.__seg_;
|
|
|
|
|
*__result.__seg_ &= ~__m;
|
|
|
|
|
*__result.__seg_ |= __b << __result.__ctz_;
|
|
|
|
|
++__result.__seg_;
|
|
|
|
|
*__result.__seg_ &= __m;
|
|
|
|
|
*__result.__seg_ |= __b >> __clz_r;
|
|
|
|
|
}
|
|
|
|
|
// do last word
|
|
|
|
|
if (__n > 0)
|
|
|
|
|
{
|
|
|
|
|
__m = ~__storage_type(0) >> (__bits_per_word - __n);
|
|
|
|
|
__storage_type __b = *__first.__seg_ & __m;
|
2011-07-01 05:18:19 +08:00
|
|
|
__storage_type __dn = _VSTD::min(__n, static_cast<difference_type>(__clz_r));
|
2010-05-12 03:42:16 +08:00
|
|
|
__m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn));
|
|
|
|
|
*__result.__seg_ &= ~__m;
|
|
|
|
|
*__result.__seg_ |= __b << __result.__ctz_;
|
|
|
|
|
__result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
|
|
|
|
|
__result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_) % __bits_per_word);
|
|
|
|
|
__n -= __dn;
|
|
|
|
|
if (__n > 0)
|
|
|
|
|
{
|
|
|
|
|
__m = ~__storage_type(0) >> (__bits_per_word - __n);
|
|
|
|
|
*__result.__seg_ &= ~__m;
|
|
|
|
|
*__result.__seg_ |= __b >> __dn;
|
|
|
|
|
__result.__ctz_ = static_cast<unsigned>(__n);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return __result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _C, bool _IsConst>
|
|
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
|
|
|
__bit_iterator<_C, false>
|
|
|
|
|
copy(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C, _IsConst> __last, __bit_iterator<_C, false> __result)
|
|
|
|
|
{
|
|
|
|
|
if (__first.__ctz_ == __result.__ctz_)
|
|
|
|
|
return __copy_aligned(__first, __last, __result);
|
|
|
|
|
return __copy_unaligned(__first, __last, __result);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// copy_backward
|
|
|
|
|
|
|
|
|
|
template <class _C, bool _IsConst>
|
|
|
|
|
__bit_iterator<_C, false>
|
|
|
|
|
__copy_backward_aligned(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C, _IsConst> __last,
|
|
|
|
|
__bit_iterator<_C, false> __result)
|
|
|
|
|
{
|
|
|
|
|
typedef __bit_iterator<_C, _IsConst> _In;
|
|
|
|
|
typedef typename _In::difference_type difference_type;
|
|
|
|
|
typedef typename _In::__storage_type __storage_type;
|
|
|
|
|
static const unsigned __bits_per_word = _In::__bits_per_word;
|
|
|
|
|
difference_type __n = __last - __first;
|
|
|
|
|
if (__n > 0)
|
|
|
|
|
{
|
|
|
|
|
// do first word
|
|
|
|
|
if (__last.__ctz_ != 0)
|
|
|
|
|
{
|
2011-07-01 05:18:19 +08:00
|
|
|
difference_type __dn = _VSTD::min(static_cast<difference_type>(__last.__ctz_), __n);
|
2010-05-12 03:42:16 +08:00
|
|
|
__n -= __dn;
|
|
|
|
|
unsigned __clz = __bits_per_word - __last.__ctz_;
|
|
|
|
|
__storage_type __m = (~__storage_type(0) << (__last.__ctz_ - __dn)) & (~__storage_type(0) >> __clz);
|
|
|
|
|
__storage_type __b = *__last.__seg_ & __m;
|
|
|
|
|
*__result.__seg_ &= ~__m;
|
|
|
|
|
*__result.__seg_ |= __b;
|
|
|
|
|
__result.__ctz_ = static_cast<unsigned>(((-__dn & (__bits_per_word - 1)) +
|
|
|
|
|
__result.__ctz_) % __bits_per_word);
|
|
|
|
|
// __last.__ctz_ = 0
|
|
|
|
|
}
|
|
|
|
|
// __last.__ctz_ == 0 || __n == 0
|
|
|
|
|
// __result.__ctz_ == 0 || __n == 0
|
|
|
|
|
// do middle words
|
|
|
|
|
__storage_type __nw = __n / __bits_per_word;
|
|
|
|
|
__result.__seg_ -= __nw;
|
|
|
|
|
__last.__seg_ -= __nw;
|
2011-07-01 05:18:19 +08:00
|
|
|
_VSTD::memmove(__result.__seg_, __last.__seg_, __nw * sizeof(__storage_type));
|
2010-05-12 03:42:16 +08:00
|
|
|
__n -= __nw * __bits_per_word;
|
|
|
|
|
// do last word
|
|
|
|
|
if (__n > 0)
|
|
|
|
|
{
|
|
|
|
|
__storage_type __m = ~__storage_type(0) << (__bits_per_word - __n);
|
|
|
|
|
__storage_type __b = *--__last.__seg_ & __m;
|
|
|
|
|
*--__result.__seg_ &= ~__m;
|
|
|
|
|
*__result.__seg_ |= __b;
|
|
|
|
|
__result.__ctz_ = static_cast<unsigned>(-__n & (__bits_per_word - 1));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return __result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _C, bool _IsConst>
|
|
|
|
|
__bit_iterator<_C, false>
|
|
|
|
|
__copy_backward_unaligned(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C, _IsConst> __last,
|
|
|
|
|
__bit_iterator<_C, false> __result)
|
|
|
|
|
{
|
|
|
|
|
typedef __bit_iterator<_C, _IsConst> _In;
|
|
|
|
|
typedef typename _In::difference_type difference_type;
|
|
|
|
|
typedef typename _In::__storage_type __storage_type;
|
|
|
|
|
static const unsigned __bits_per_word = _In::__bits_per_word;
|
|
|
|
|
difference_type __n = __last - __first;
|
|
|
|
|
if (__n > 0)
|
|
|
|
|
{
|
|
|
|
|
// do first word
|
|
|
|
|
if (__last.__ctz_ != 0)
|
|
|
|
|
{
|
2011-07-01 05:18:19 +08:00
|
|
|
difference_type __dn = _VSTD::min(static_cast<difference_type>(__last.__ctz_), __n);
|
2010-05-12 03:42:16 +08:00
|
|
|
__n -= __dn;
|
|
|
|
|
unsigned __clz_l = __bits_per_word - __last.__ctz_;
|
|
|
|
|
__storage_type __m = (~__storage_type(0) << (__last.__ctz_ - __dn)) & (~__storage_type(0) >> __clz_l);
|
|
|
|
|
__storage_type __b = *__last.__seg_ & __m;
|
|
|
|
|
unsigned __clz_r = __bits_per_word - __result.__ctz_;
|
2011-07-01 05:18:19 +08:00
|
|
|
__storage_type __ddn = _VSTD::min(__dn, static_cast<difference_type>(__result.__ctz_));
|
2010-05-12 03:42:16 +08:00
|
|
|
if (__ddn > 0)
|
|
|
|
|
{
|
|
|
|
|
__m = (~__storage_type(0) << (__result.__ctz_ - __ddn)) & (~__storage_type(0) >> __clz_r);
|
|
|
|
|
*__result.__seg_ &= ~__m;
|
|
|
|
|
if (__result.__ctz_ > __last.__ctz_)
|
|
|
|
|
*__result.__seg_ |= __b << (__result.__ctz_ - __last.__ctz_);
|
|
|
|
|
else
|
|
|
|
|
*__result.__seg_ |= __b >> (__last.__ctz_ - __result.__ctz_);
|
|
|
|
|
__result.__ctz_ = static_cast<unsigned>(((-__ddn & (__bits_per_word - 1)) +
|
|
|
|
|
__result.__ctz_) % __bits_per_word);
|
|
|
|
|
__dn -= __ddn;
|
|
|
|
|
}
|
|
|
|
|
if (__dn > 0)
|
|
|
|
|
{
|
|
|
|
|
// __result.__ctz_ == 0
|
|
|
|
|
--__result.__seg_;
|
|
|
|
|
__result.__ctz_ = static_cast<unsigned>(-__dn & (__bits_per_word - 1));
|
|
|
|
|
__m = ~__storage_type(0) << __result.__ctz_;
|
|
|
|
|
*__result.__seg_ &= ~__m;
|
|
|
|
|
__last.__ctz_ -= __dn + __ddn;
|
|
|
|
|
*__result.__seg_ |= __b << (__result.__ctz_ - __last.__ctz_);
|
|
|
|
|
}
|
|
|
|
|
// __last.__ctz_ = 0
|
|
|
|
|
}
|
|
|
|
|
// __last.__ctz_ == 0 || __n == 0
|
|
|
|
|
// __result.__ctz_ != 0 || __n == 0
|
|
|
|
|
// do middle words
|
|
|
|
|
unsigned __clz_r = __bits_per_word - __result.__ctz_;
|
|
|
|
|
__storage_type __m = ~__storage_type(0) >> __clz_r;
|
|
|
|
|
for (; __n >= __bits_per_word; __n -= __bits_per_word)
|
|
|
|
|
{
|
|
|
|
|
__storage_type __b = *--__last.__seg_;
|
|
|
|
|
*__result.__seg_ &= ~__m;
|
|
|
|
|
*__result.__seg_ |= __b >> __clz_r;
|
|
|
|
|
*--__result.__seg_ &= __m;
|
|
|
|
|
*__result.__seg_ |= __b << __result.__ctz_;
|
|
|
|
|
}
|
|
|
|
|
// do last word
|
|
|
|
|
if (__n > 0)
|
|
|
|
|
{
|
|
|
|
|
__m = ~__storage_type(0) << (__bits_per_word - __n);
|
|
|
|
|
__storage_type __b = *--__last.__seg_ & __m;
|
|
|
|
|
unsigned __clz_r = __bits_per_word - __result.__ctz_;
|
2011-07-01 05:18:19 +08:00
|
|
|
__storage_type __dn = _VSTD::min(__n, static_cast<difference_type>(__result.__ctz_));
|
2010-05-12 03:42:16 +08:00
|
|
|
__m = (~__storage_type(0) << (__result.__ctz_ - __dn)) & (~__storage_type(0) >> __clz_r);
|
|
|
|
|
*__result.__seg_ &= ~__m;
|
|
|
|
|
*__result.__seg_ |= __b >> (__bits_per_word - __result.__ctz_);
|
|
|
|
|
__result.__ctz_ = static_cast<unsigned>(((-__dn & (__bits_per_word - 1)) +
|
|
|
|
|
__result.__ctz_) % __bits_per_word);
|
|
|
|
|
__n -= __dn;
|
|
|
|
|
if (__n > 0)
|
|
|
|
|
{
|
|
|
|
|
// __result.__ctz_ == 0
|
|
|
|
|
--__result.__seg_;
|
|
|
|
|
__result.__ctz_ = static_cast<unsigned>(-__n & (__bits_per_word - 1));
|
|
|
|
|
__m = ~__storage_type(0) << __result.__ctz_;
|
|
|
|
|
*__result.__seg_ &= ~__m;
|
|
|
|
|
*__result.__seg_ |= __b << (__result.__ctz_ - (__bits_per_word - __n - __dn));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return __result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _C, bool _IsConst>
|
|
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
|
|
|
__bit_iterator<_C, false>
|
|
|
|
|
copy_backward(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C, _IsConst> __last, __bit_iterator<_C, false> __result)
|
|
|
|
|
{
|
|
|
|
|
if (__last.__ctz_ == __result.__ctz_)
|
|
|
|
|
return __copy_backward_aligned(__first, __last, __result);
|
|
|
|
|
return __copy_backward_unaligned(__first, __last, __result);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// move
|
|
|
|
|
|
|
|
|
|
template <class _C, bool _IsConst>
|
|
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
|
|
|
__bit_iterator<_C, false>
|
|
|
|
|
move(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C, _IsConst> __last, __bit_iterator<_C, false> __result)
|
|
|
|
|
{
|
2011-07-01 05:18:19 +08:00
|
|
|
return _VSTD::copy(__first, __last, __result);
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// move_backward
|
|
|
|
|
|
|
|
|
|
template <class _C, bool _IsConst>
|
|
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
|
|
|
__bit_iterator<_C, false>
|
|
|
|
|
move_backward(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C, _IsConst> __last, __bit_iterator<_C, false> __result)
|
|
|
|
|
{
|
2011-07-01 05:18:19 +08:00
|
|
|
return _VSTD::copy(__first, __last, __result);
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// swap_ranges
|
|
|
|
|
|
2011-09-24 00:11:27 +08:00
|
|
|
template <class __C1, class __C2>
|
|
|
|
|
__bit_iterator<__C2, false>
|
|
|
|
|
__swap_ranges_aligned(__bit_iterator<__C1, false> __first, __bit_iterator<__C1, false> __last,
|
|
|
|
|
__bit_iterator<__C2, false> __result)
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2011-09-24 00:11:27 +08:00
|
|
|
typedef __bit_iterator<__C1, false> _I1;
|
2010-05-12 03:42:16 +08:00
|
|
|
typedef typename _I1::difference_type difference_type;
|
|
|
|
|
typedef typename _I1::__storage_type __storage_type;
|
|
|
|
|
static const unsigned __bits_per_word = _I1::__bits_per_word;
|
|
|
|
|
difference_type __n = __last - __first;
|
|
|
|
|
if (__n > 0)
|
|
|
|
|
{
|
|
|
|
|
// do first word
|
|
|
|
|
if (__first.__ctz_ != 0)
|
|
|
|
|
{
|
|
|
|
|
unsigned __clz = __bits_per_word - __first.__ctz_;
|
2011-07-01 05:18:19 +08:00
|
|
|
difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz), __n);
|
2010-05-12 03:42:16 +08:00
|
|
|
__n -= __dn;
|
|
|
|
|
__storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz - __dn));
|
|
|
|
|
__storage_type __b1 = *__first.__seg_ & __m;
|
|
|
|
|
*__first.__seg_ &= ~__m;
|
|
|
|
|
__storage_type __b2 = *__result.__seg_ & __m;
|
|
|
|
|
*__result.__seg_ &= ~__m;
|
|
|
|
|
*__result.__seg_ |= __b1;
|
|
|
|
|
*__first.__seg_ |= __b2;
|
|
|
|
|
__result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
|
|
|
|
|
__result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_) % __bits_per_word);
|
|
|
|
|
++__first.__seg_;
|
|
|
|
|
// __first.__ctz_ = 0;
|
|
|
|
|
}
|
|
|
|
|
// __first.__ctz_ == 0;
|
|
|
|
|
// do middle words
|
|
|
|
|
for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first.__seg_, ++__result.__seg_)
|
|
|
|
|
swap(*__first.__seg_, *__result.__seg_);
|
|
|
|
|
// do last word
|
|
|
|
|
if (__n > 0)
|
|
|
|
|
{
|
|
|
|
|
__storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
|
|
|
|
|
__storage_type __b1 = *__first.__seg_ & __m;
|
|
|
|
|
*__first.__seg_ &= ~__m;
|
|
|
|
|
__storage_type __b2 = *__result.__seg_ & __m;
|
|
|
|
|
*__result.__seg_ &= ~__m;
|
|
|
|
|
*__result.__seg_ |= __b1;
|
|
|
|
|
*__first.__seg_ |= __b2;
|
|
|
|
|
__result.__ctz_ = static_cast<unsigned>(__n);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return __result;
|
|
|
|
|
}
|
|
|
|
|
|
2011-09-24 00:11:27 +08:00
|
|
|
template <class __C1, class __C2>
|
|
|
|
|
__bit_iterator<__C2, false>
|
|
|
|
|
__swap_ranges_unaligned(__bit_iterator<__C1, false> __first, __bit_iterator<__C1, false> __last,
|
|
|
|
|
__bit_iterator<__C2, false> __result)
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2011-09-24 00:11:27 +08:00
|
|
|
typedef __bit_iterator<__C1, false> _I1;
|
2010-05-12 03:42:16 +08:00
|
|
|
typedef typename _I1::difference_type difference_type;
|
|
|
|
|
typedef typename _I1::__storage_type __storage_type;
|
|
|
|
|
static const unsigned __bits_per_word = _I1::__bits_per_word;
|
|
|
|
|
difference_type __n = __last - __first;
|
|
|
|
|
if (__n > 0)
|
|
|
|
|
{
|
|
|
|
|
// do first word
|
|
|
|
|
if (__first.__ctz_ != 0)
|
|
|
|
|
{
|
|
|
|
|
unsigned __clz_f = __bits_per_word - __first.__ctz_;
|
2011-07-01 05:18:19 +08:00
|
|
|
difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz_f), __n);
|
2010-05-12 03:42:16 +08:00
|
|
|
__n -= __dn;
|
|
|
|
|
__storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
|
|
|
|
|
__storage_type __b1 = *__first.__seg_ & __m;
|
|
|
|
|
*__first.__seg_ &= ~__m;
|
|
|
|
|
unsigned __clz_r = __bits_per_word - __result.__ctz_;
|
2011-07-01 05:18:19 +08:00
|
|
|
__storage_type __ddn = _VSTD::min<__storage_type>(__dn, __clz_r);
|
2010-05-12 03:42:16 +08:00
|
|
|
__m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn));
|
|
|
|
|
__storage_type __b2 = *__result.__seg_ & __m;
|
|
|
|
|
*__result.__seg_ &= ~__m;
|
|
|
|
|
if (__result.__ctz_ > __first.__ctz_)
|
|
|
|
|
{
|
|
|
|
|
unsigned __s = __result.__ctz_ - __first.__ctz_;
|
|
|
|
|
*__result.__seg_ |= __b1 << __s;
|
|
|
|
|
*__first.__seg_ |= __b2 >> __s;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
unsigned __s = __first.__ctz_ - __result.__ctz_;
|
|
|
|
|
*__result.__seg_ |= __b1 >> __s;
|
|
|
|
|
*__first.__seg_ |= __b2 << __s;
|
|
|
|
|
}
|
|
|
|
|
__result.__seg_ += (__ddn + __result.__ctz_) / __bits_per_word;
|
|
|
|
|
__result.__ctz_ = static_cast<unsigned>((__ddn + __result.__ctz_) % __bits_per_word);
|
|
|
|
|
__dn -= __ddn;
|
|
|
|
|
if (__dn > 0)
|
|
|
|
|
{
|
|
|
|
|
__m = ~__storage_type(0) >> (__bits_per_word - __dn);
|
|
|
|
|
__b2 = *__result.__seg_ & __m;
|
|
|
|
|
*__result.__seg_ &= ~__m;
|
|
|
|
|
unsigned __s = __first.__ctz_ + __ddn;
|
|
|
|
|
*__result.__seg_ |= __b1 >> __s;
|
|
|
|
|
*__first.__seg_ |= __b2 << __s;
|
|
|
|
|
__result.__ctz_ = static_cast<unsigned>(__dn);
|
|
|
|
|
}
|
|
|
|
|
++__first.__seg_;
|
|
|
|
|
// __first.__ctz_ = 0;
|
|
|
|
|
}
|
|
|
|
|
// __first.__ctz_ == 0;
|
|
|
|
|
// do middle words
|
|
|
|
|
__storage_type __m = ~__storage_type(0) << __result.__ctz_;
|
|
|
|
|
unsigned __clz_r = __bits_per_word - __result.__ctz_;
|
|
|
|
|
for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first.__seg_)
|
|
|
|
|
{
|
|
|
|
|
__storage_type __b1 = *__first.__seg_;
|
|
|
|
|
__storage_type __b2 = *__result.__seg_ & __m;
|
|
|
|
|
*__result.__seg_ &= ~__m;
|
|
|
|
|
*__result.__seg_ |= __b1 << __result.__ctz_;
|
|
|
|
|
*__first.__seg_ = __b2 >> __result.__ctz_;
|
|
|
|
|
++__result.__seg_;
|
|
|
|
|
__b2 = *__result.__seg_ & ~__m;
|
|
|
|
|
*__result.__seg_ &= __m;
|
|
|
|
|
*__result.__seg_ |= __b1 >> __clz_r;
|
|
|
|
|
*__first.__seg_ |= __b2 << __clz_r;
|
|
|
|
|
}
|
|
|
|
|
// do last word
|
|
|
|
|
if (__n > 0)
|
|
|
|
|
{
|
|
|
|
|
__m = ~__storage_type(0) >> (__bits_per_word - __n);
|
|
|
|
|
__storage_type __b1 = *__first.__seg_ & __m;
|
|
|
|
|
*__first.__seg_ &= ~__m;
|
2011-07-01 05:18:19 +08:00
|
|
|
__storage_type __dn = _VSTD::min<__storage_type>(__n, __clz_r);
|
2010-05-12 03:42:16 +08:00
|
|
|
__m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn));
|
|
|
|
|
__storage_type __b2 = *__result.__seg_ & __m;
|
|
|
|
|
*__result.__seg_ &= ~__m;
|
|
|
|
|
*__result.__seg_ |= __b1 << __result.__ctz_;
|
|
|
|
|
*__first.__seg_ |= __b2 >> __result.__ctz_;
|
|
|
|
|
__result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
|
|
|
|
|
__result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_) % __bits_per_word);
|
|
|
|
|
__n -= __dn;
|
|
|
|
|
if (__n > 0)
|
|
|
|
|
{
|
|
|
|
|
__m = ~__storage_type(0) >> (__bits_per_word - __n);
|
|
|
|
|
__b2 = *__result.__seg_ & __m;
|
|
|
|
|
*__result.__seg_ &= ~__m;
|
|
|
|
|
*__result.__seg_ |= __b1 >> __dn;
|
|
|
|
|
*__first.__seg_ |= __b2 << __dn;
|
|
|
|
|
__result.__ctz_ = static_cast<unsigned>(__n);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return __result;
|
|
|
|
|
}
|
|
|
|
|
|
2011-09-24 00:11:27 +08:00
|
|
|
template <class __C1, class __C2>
|
2010-05-12 03:42:16 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2011-09-24 00:11:27 +08:00
|
|
|
__bit_iterator<__C2, false>
|
|
|
|
|
swap_ranges(__bit_iterator<__C1, false> __first1, __bit_iterator<__C1, false> __last1,
|
|
|
|
|
__bit_iterator<__C2, false> __first2)
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
|
if (__first1.__ctz_ == __first2.__ctz_)
|
|
|
|
|
return __swap_ranges_aligned(__first1, __last1, __first2);
|
|
|
|
|
return __swap_ranges_unaligned(__first1, __last1, __first2);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// rotate
|
|
|
|
|
|
|
|
|
|
template <class _C>
|
|
|
|
|
struct __bit_array
|
|
|
|
|
{
|
|
|
|
|
typedef typename _C::difference_type difference_type;
|
|
|
|
|
typedef typename _C::__storage_type __storage_type;
|
|
|
|
|
typedef typename _C::iterator iterator;
|
|
|
|
|
static const unsigned __bits_per_word = _C::__bits_per_word;
|
|
|
|
|
static const unsigned _N = 4;
|
|
|
|
|
|
|
|
|
|
difference_type __size_;
|
|
|
|
|
__storage_type __word_[_N];
|
|
|
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY static difference_type capacity()
|
|
|
|
|
{return static_cast<difference_type>(_N * __bits_per_word);}
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY explicit __bit_array(difference_type __s) : __size_(__s) {}
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY iterator begin() {return iterator(__word_, 0);}
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY iterator end() {return iterator(__word_ + __size_ / __bits_per_word,
|
|
|
|
|
static_cast<unsigned>(__size_ % __bits_per_word));}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
template <class _C>
|
|
|
|
|
__bit_iterator<_C, false>
|
|
|
|
|
rotate(__bit_iterator<_C, false> __first, __bit_iterator<_C, false> __middle, __bit_iterator<_C, false> __last)
|
|
|
|
|
{
|
|
|
|
|
typedef __bit_iterator<_C, false> _I1;
|
|
|
|
|
typedef typename _I1::difference_type difference_type;
|
|
|
|
|
typedef typename _I1::__storage_type __storage_type;
|
|
|
|
|
static const unsigned __bits_per_word = _I1::__bits_per_word;
|
|
|
|
|
difference_type __d1 = __middle - __first;
|
|
|
|
|
difference_type __d2 = __last - __middle;
|
|
|
|
|
_I1 __r = __first + __d2;
|
|
|
|
|
while (__d1 != 0 && __d2 != 0)
|
|
|
|
|
{
|
|
|
|
|
if (__d1 <= __d2)
|
|
|
|
|
{
|
|
|
|
|
if (__d1 <= __bit_array<_C>::capacity())
|
|
|
|
|
{
|
|
|
|
|
__bit_array<_C> __b(__d1);
|
2011-07-01 05:18:19 +08:00
|
|
|
_VSTD::copy(__first, __middle, __b.begin());
|
|
|
|
|
_VSTD::copy(__b.begin(), __b.end(), _VSTD::copy(__middle, __last, __first));
|
2010-05-12 03:42:16 +08:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2011-07-01 05:18:19 +08:00
|
|
|
__bit_iterator<_C, false> __mp = _VSTD::swap_ranges(__first, __middle, __middle);
|
2010-05-12 03:42:16 +08:00
|
|
|
__first = __middle;
|
|
|
|
|
__middle = __mp;
|
|
|
|
|
__d2 -= __d1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (__d2 <= __bit_array<_C>::capacity())
|
|
|
|
|
{
|
|
|
|
|
__bit_array<_C> __b(__d2);
|
2011-07-01 05:18:19 +08:00
|
|
|
_VSTD::copy(__middle, __last, __b.begin());
|
|
|
|
|
_VSTD::copy_backward(__b.begin(), __b.end(), _VSTD::copy_backward(__first, __middle, __last));
|
2010-05-12 03:42:16 +08:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
__bit_iterator<_C, false> __mp = __first + __d2;
|
2011-07-01 05:18:19 +08:00
|
|
|
_VSTD::swap_ranges(__first, __mp, __middle);
|
2010-05-12 03:42:16 +08:00
|
|
|
__first = __mp;
|
|
|
|
|
__d1 -= __d2;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return __r;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// equal
|
|
|
|
|
|
|
|
|
|
template <class _C>
|
|
|
|
|
bool
|
|
|
|
|
__equal_unaligned(__bit_iterator<_C, true> __first1, __bit_iterator<_C, true> __last1,
|
|
|
|
|
__bit_iterator<_C, true> __first2)
|
|
|
|
|
{
|
|
|
|
|
typedef __bit_iterator<_C, true> _It;
|
|
|
|
|
typedef typename _It::difference_type difference_type;
|
|
|
|
|
typedef typename _It::__storage_type __storage_type;
|
|
|
|
|
static const unsigned __bits_per_word = _It::__bits_per_word;
|
|
|
|
|
difference_type __n = __last1 - __first1;
|
|
|
|
|
if (__n > 0)
|
|
|
|
|
{
|
|
|
|
|
// do first word
|
|
|
|
|
if (__first1.__ctz_ != 0)
|
|
|
|
|
{
|
|
|
|
|
unsigned __clz_f = __bits_per_word - __first1.__ctz_;
|
2011-07-01 05:18:19 +08:00
|
|
|
difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz_f), __n);
|
2010-05-12 03:42:16 +08:00
|
|
|
__n -= __dn;
|
|
|
|
|
__storage_type __m = (~__storage_type(0) << __first1.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
|
|
|
|
|
__storage_type __b = *__first1.__seg_ & __m;
|
|
|
|
|
unsigned __clz_r = __bits_per_word - __first2.__ctz_;
|
2011-07-01 05:18:19 +08:00
|
|
|
__storage_type __ddn = _VSTD::min<__storage_type>(__dn, __clz_r);
|
2010-05-12 03:42:16 +08:00
|
|
|
__m = (~__storage_type(0) << __first2.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn));
|
|
|
|
|
if (__first2.__ctz_ > __first1.__ctz_)
|
|
|
|
|
if ((*__first2.__seg_ & __m) != (__b << (__first2.__ctz_ - __first1.__ctz_)))
|
|
|
|
|
return false;
|
|
|
|
|
else
|
|
|
|
|
if ((*__first2.__seg_ & __m) != (__b >> (__first1.__ctz_ - __first2.__ctz_)))
|
|
|
|
|
return false;
|
|
|
|
|
__first2.__seg_ += (__ddn + __first2.__ctz_) / __bits_per_word;
|
|
|
|
|
__first2.__ctz_ = static_cast<unsigned>((__ddn + __first2.__ctz_) % __bits_per_word);
|
|
|
|
|
__dn -= __ddn;
|
|
|
|
|
if (__dn > 0)
|
|
|
|
|
{
|
|
|
|
|
__m = ~__storage_type(0) >> (__bits_per_word - __dn);
|
|
|
|
|
if ((*__first2.__seg_ & __m) != (__b >> (__first1.__ctz_ + __ddn)))
|
|
|
|
|
return false;
|
|
|
|
|
__first2.__ctz_ = static_cast<unsigned>(__dn);
|
|
|
|
|
}
|
|
|
|
|
++__first1.__seg_;
|
|
|
|
|
// __first1.__ctz_ = 0;
|
|
|
|
|
}
|
|
|
|
|
// __first1.__ctz_ == 0;
|
|
|
|
|
// do middle words
|
|
|
|
|
unsigned __clz_r = __bits_per_word - __first2.__ctz_;
|
|
|
|
|
__storage_type __m = ~__storage_type(0) << __first2.__ctz_;
|
|
|
|
|
for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first1.__seg_)
|
|
|
|
|
{
|
|
|
|
|
__storage_type __b = *__first1.__seg_;
|
|
|
|
|
if ((*__first2.__seg_ & __m) != (__b << __first2.__ctz_))
|
|
|
|
|
return false;
|
|
|
|
|
++__first2.__seg_;
|
|
|
|
|
if ((*__first2.__seg_ & ~__m) != (__b >> __clz_r))
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
// do last word
|
|
|
|
|
if (__n > 0)
|
|
|
|
|
{
|
|
|
|
|
__m = ~__storage_type(0) >> (__bits_per_word - __n);
|
|
|
|
|
__storage_type __b = *__first1.__seg_ & __m;
|
2011-07-01 05:18:19 +08:00
|
|
|
__storage_type __dn = _VSTD::min(__n, static_cast<difference_type>(__clz_r));
|
2010-05-12 03:42:16 +08:00
|
|
|
__m = (~__storage_type(0) << __first2.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn));
|
|
|
|
|
if ((*__first2.__seg_ & __m) != (__b << __first2.__ctz_))
|
|
|
|
|
return false;
|
|
|
|
|
__first2.__seg_ += (__dn + __first2.__ctz_) / __bits_per_word;
|
|
|
|
|
__first2.__ctz_ = static_cast<unsigned>((__dn + __first2.__ctz_) % __bits_per_word);
|
|
|
|
|
__n -= __dn;
|
|
|
|
|
if (__n > 0)
|
|
|
|
|
{
|
|
|
|
|
__m = ~__storage_type(0) >> (__bits_per_word - __n);
|
|
|
|
|
if ((*__first2.__seg_ & __m) != (__b >> __dn))
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _C>
|
|
|
|
|
bool
|
|
|
|
|
__equal_aligned(__bit_iterator<_C, true> __first1, __bit_iterator<_C, true> __last1,
|
|
|
|
|
__bit_iterator<_C, true> __first2)
|
|
|
|
|
{
|
|
|
|
|
typedef __bit_iterator<_C, true> _It;
|
|
|
|
|
typedef typename _It::difference_type difference_type;
|
|
|
|
|
typedef typename _It::__storage_type __storage_type;
|
|
|
|
|
static const unsigned __bits_per_word = _It::__bits_per_word;
|
|
|
|
|
difference_type __n = __last1 - __first1;
|
|
|
|
|
if (__n > 0)
|
|
|
|
|
{
|
|
|
|
|
// do first word
|
|
|
|
|
if (__first1.__ctz_ != 0)
|
|
|
|
|
{
|
|
|
|
|
unsigned __clz = __bits_per_word - __first1.__ctz_;
|
2011-07-01 05:18:19 +08:00
|
|
|
difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz), __n);
|
2010-05-12 03:42:16 +08:00
|
|
|
__n -= __dn;
|
|
|
|
|
__storage_type __m = (~__storage_type(0) << __first1.__ctz_) & (~__storage_type(0) >> (__clz - __dn));
|
|
|
|
|
if ((*__first2.__seg_ & __m) != (*__first1.__seg_ & __m))
|
|
|
|
|
return false;
|
|
|
|
|
++__first2.__seg_;
|
|
|
|
|
++__first1.__seg_;
|
|
|
|
|
// __first1.__ctz_ = 0;
|
|
|
|
|
// __first2.__ctz_ = 0;
|
|
|
|
|
}
|
|
|
|
|
// __first1.__ctz_ == 0;
|
|
|
|
|
// __first2.__ctz_ == 0;
|
|
|
|
|
// do middle words
|
|
|
|
|
for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first1.__seg_, ++__first2.__seg_)
|
|
|
|
|
if (*__first2.__seg_ != *__first1.__seg_)
|
|
|
|
|
return false;
|
|
|
|
|
// do last word
|
|
|
|
|
if (__n > 0)
|
|
|
|
|
{
|
|
|
|
|
__storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
|
|
|
|
|
if ((*__first2.__seg_ & __m) != (*__first1.__seg_ & __m))
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _C, bool _IC1, bool _IC2>
|
2010-09-22 01:32:39 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
bool
|
|
|
|
|
equal(__bit_iterator<_C, _IC1> __first1, __bit_iterator<_C, _IC1> __last1, __bit_iterator<_C, _IC2> __first2)
|
|
|
|
|
{
|
|
|
|
|
if (__first1.__ctz_ == __first2.__ctz_)
|
|
|
|
|
return __equal_aligned(__first1, __last1, __first2);
|
|
|
|
|
return __equal_unaligned(__first1, __last1, __first2);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
template <class _C, bool _IsConst>
|
|
|
|
|
class __bit_iterator
|
|
|
|
|
{
|
|
|
|
|
public:
|
|
|
|
|
typedef typename _C::difference_type difference_type;
|
|
|
|
|
typedef bool value_type;
|
|
|
|
|
typedef __bit_iterator pointer;
|
|
|
|
|
typedef typename conditional<_IsConst, __bit_const_reference<_C>, __bit_reference<_C> >::type reference;
|
|
|
|
|
typedef random_access_iterator_tag iterator_category;
|
|
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
typedef typename _C::__storage_type __storage_type;
|
|
|
|
|
typedef typename conditional<_IsConst, typename _C::__const_storage_pointer,
|
|
|
|
|
typename _C::__storage_pointer>::type __storage_pointer;
|
|
|
|
|
static const unsigned __bits_per_word = _C::__bits_per_word;
|
|
|
|
|
|
|
|
|
|
__storage_pointer __seg_;
|
|
|
|
|
unsigned __ctz_;
|
|
|
|
|
|
|
|
|
|
public:
|
2011-05-28 04:52:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY __bit_iterator() _NOEXCEPT {}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2011-05-28 04:52:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
|
__bit_iterator(const __bit_iterator<_C, false>& __it) _NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
: __seg_(__it.__seg_), __ctz_(__it.__ctz_) {}
|
|
|
|
|
|
2011-05-28 04:52:28 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY reference operator*() const _NOEXCEPT
|
|
|
|
|
{return reference(__seg_, __storage_type(1) << __ctz_);}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY __bit_iterator& operator++()
|
|
|
|
|
{
|
|
|
|
|
if (__ctz_ != __bits_per_word-1)
|
|
|
|
|
++__ctz_;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
__ctz_ = 0;
|
|
|
|
|
++__seg_;
|
|
|
|
|
}
|
|
|
|
|
return *this;
|
|
|
|
|
}
|
2010-08-22 08:02:43 +08:00
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY __bit_iterator operator++(int)
|
|
|
|
|
{
|
|
|
|
|
__bit_iterator __tmp = *this;
|
|
|
|
|
++(*this);
|
|
|
|
|
return __tmp;
|
|
|
|
|
}
|
2010-08-22 08:02:43 +08:00
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY __bit_iterator& operator--()
|
|
|
|
|
{
|
|
|
|
|
if (__ctz_ != 0)
|
|
|
|
|
--__ctz_;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
__ctz_ = __bits_per_word - 1;
|
|
|
|
|
--__seg_;
|
|
|
|
|
}
|
|
|
|
|
return *this;
|
|
|
|
|
}
|
2010-08-22 08:02:43 +08:00
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY __bit_iterator operator--(int)
|
|
|
|
|
{
|
|
|
|
|
__bit_iterator __tmp = *this;
|
|
|
|
|
--(*this);
|
|
|
|
|
return __tmp;
|
|
|
|
|
}
|
2010-08-22 08:02:43 +08:00
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY __bit_iterator& operator+=(difference_type __n)
|
|
|
|
|
{
|
|
|
|
|
if (__n >= 0)
|
|
|
|
|
__seg_ += (__n + __ctz_) / __bits_per_word;
|
|
|
|
|
else
|
|
|
|
|
__seg_ += static_cast<difference_type>(__n - __bits_per_word + __ctz_ + 1)
|
|
|
|
|
/ static_cast<difference_type>(__bits_per_word);
|
|
|
|
|
__n &= (__bits_per_word - 1);
|
|
|
|
|
__ctz_ = static_cast<unsigned>((__n + __ctz_) % __bits_per_word);
|
|
|
|
|
return *this;
|
|
|
|
|
}
|
2010-08-22 08:02:43 +08:00
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY __bit_iterator& operator-=(difference_type __n)
|
|
|
|
|
{
|
|
|
|
|
return *this += -__n;
|
|
|
|
|
}
|
2010-08-22 08:02:43 +08:00
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY __bit_iterator operator+(difference_type __n) const
|
|
|
|
|
{
|
|
|
|
|
__bit_iterator __t(*this);
|
|
|
|
|
__t += __n;
|
|
|
|
|
return __t;
|
|
|
|
|
}
|
2010-08-22 08:02:43 +08:00
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY __bit_iterator operator-(difference_type __n) const
|
|
|
|
|
{
|
|
|
|
|
__bit_iterator __t(*this);
|
|
|
|
|
__t -= __n;
|
|
|
|
|
return __t;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
|
friend __bit_iterator operator+(difference_type __n, const __bit_iterator& __it) {return __it + __n;}
|
|
|
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
|
friend difference_type operator-(const __bit_iterator& __x, const __bit_iterator& __y)
|
|
|
|
|
{return (__x.__seg_ - __y.__seg_) * __bits_per_word + __x.__ctz_ - __y.__ctz_;}
|
|
|
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY reference operator[](difference_type __n) const {return *(*this + __n);}
|
|
|
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY friend bool operator==(const __bit_iterator& __x, const __bit_iterator& __y)
|
|
|
|
|
{return __x.__seg_ == __y.__seg_ && __x.__ctz_ == __y.__ctz_;}
|
|
|
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY friend bool operator!=(const __bit_iterator& __x, const __bit_iterator& __y)
|
|
|
|
|
{return !(__x == __y);}
|
|
|
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY friend bool operator<(const __bit_iterator& __x, const __bit_iterator& __y)
|
|
|
|
|
{return __x.__seg_ < __y.__seg_ || (__x.__seg_ == __y.__seg_ && __x.__ctz_ < __y.__ctz_);}
|
|
|
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY friend bool operator>(const __bit_iterator& __x, const __bit_iterator& __y)
|
|
|
|
|
{return __y < __x;}
|
|
|
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY friend bool operator<=(const __bit_iterator& __x, const __bit_iterator& __y)
|
|
|
|
|
{return !(__y < __x);}
|
|
|
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY friend bool operator>=(const __bit_iterator& __x, const __bit_iterator& __y)
|
|
|
|
|
{return !(__x < __y);}
|
|
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-05-28 04:52:28 +08:00
|
|
|
__bit_iterator(__storage_pointer __s, unsigned __ctz) _NOEXCEPT
|
|
|
|
|
: __seg_(__s), __ctz_(__ctz) {}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
|
#if defined(__clang__)
|
|
|
|
|
friend typename _C::__self;
|
|
|
|
|
#else
|
|
|
|
|
friend class _C::__self;
|
|
|
|
|
#endif
|
|
|
|
|
friend class __bit_reference<_C>;
|
|
|
|
|
friend class __bit_const_reference<_C>;
|
|
|
|
|
friend class __bit_iterator<_C, true>;
|
|
|
|
|
template <class _D> friend struct __bit_array;
|
|
|
|
|
template <class _D> friend void __fill_n_false(__bit_iterator<_D, false> __first, typename _D::size_type __n);
|
|
|
|
|
template <class _D> friend void __fill_n_true(__bit_iterator<_D, false> __first, typename _D::size_type __n);
|
|
|
|
|
template <class _D, bool _IC> friend __bit_iterator<_D, false> __copy_aligned(__bit_iterator<_D, _IC> __first,
|
|
|
|
|
__bit_iterator<_D, _IC> __last,
|
|
|
|
|
__bit_iterator<_D, false> __result);
|
|
|
|
|
template <class _D, bool _IC> friend __bit_iterator<_D, false> __copy_unaligned(__bit_iterator<_D, _IC> __first,
|
|
|
|
|
__bit_iterator<_D, _IC> __last,
|
|
|
|
|
__bit_iterator<_D, false> __result);
|
|
|
|
|
template <class _D, bool _IC> friend __bit_iterator<_D, false> copy(__bit_iterator<_D, _IC> __first,
|
|
|
|
|
__bit_iterator<_D, _IC> __last,
|
|
|
|
|
__bit_iterator<_D, false> __result);
|
|
|
|
|
template <class _D, bool _IC> friend __bit_iterator<_D, false> __copy_backward_aligned(__bit_iterator<_D, _IC> __first,
|
|
|
|
|
__bit_iterator<_D, _IC> __last,
|
|
|
|
|
__bit_iterator<_D, false> __result);
|
|
|
|
|
template <class _D, bool _IC> friend __bit_iterator<_D, false> __copy_backward_unaligned(__bit_iterator<_D, _IC> __first,
|
|
|
|
|
__bit_iterator<_D, _IC> __last,
|
|
|
|
|
__bit_iterator<_D, false> __result);
|
|
|
|
|
template <class _D, bool _IC> friend __bit_iterator<_D, false> copy_backward(__bit_iterator<_D, _IC> __first,
|
|
|
|
|
__bit_iterator<_D, _IC> __last,
|
|
|
|
|
__bit_iterator<_D, false> __result);
|
2011-09-24 00:11:27 +08:00
|
|
|
template <class __C1, class __C2>friend __bit_iterator<__C2, false> __swap_ranges_aligned(__bit_iterator<__C1, false>,
|
|
|
|
|
__bit_iterator<__C1, false>,
|
|
|
|
|
__bit_iterator<__C2, false>);
|
|
|
|
|
template <class __C1, class __C2>friend __bit_iterator<__C2, false> __swap_ranges_unaligned(__bit_iterator<__C1, false>,
|
|
|
|
|
__bit_iterator<__C1, false>,
|
|
|
|
|
__bit_iterator<__C2, false>);
|
|
|
|
|
template <class __C1, class __C2>friend __bit_iterator<__C2, false> swap_ranges(__bit_iterator<__C1, false>,
|
|
|
|
|
__bit_iterator<__C1, false>,
|
|
|
|
|
__bit_iterator<__C2, false>);
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _D> friend __bit_iterator<_D, false> rotate(__bit_iterator<_D, false>,
|
|
|
|
|
__bit_iterator<_D, false>,
|
|
|
|
|
__bit_iterator<_D, false>);
|
|
|
|
|
template <class _D> friend bool __equal_aligned(__bit_iterator<_D, true>,
|
|
|
|
|
__bit_iterator<_D, true>,
|
|
|
|
|
__bit_iterator<_D, true>);
|
|
|
|
|
template <class _D> friend bool __equal_unaligned(__bit_iterator<_D, true>,
|
|
|
|
|
__bit_iterator<_D, true>,
|
|
|
|
|
__bit_iterator<_D, true>);
|
|
|
|
|
template <class _D, bool _IC1, bool _IC2> friend bool equal(__bit_iterator<_D, _IC1>,
|
|
|
|
|
__bit_iterator<_D, _IC1>,
|
|
|
|
|
__bit_iterator<_D, _IC2>);
|
|
|
|
|
template <class _D> friend __bit_iterator<_D, false> __find_bool_true(__bit_iterator<_D, false>,
|
|
|
|
|
typename _D::size_type);
|
|
|
|
|
template <class _D> friend __bit_iterator<_D, false> __find_bool_false(__bit_iterator<_D, false>,
|
|
|
|
|
typename _D::size_type);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
_LIBCPP_END_NAMESPACE_STD
|
|
|
|
|
|
|
|
|
|
#endif // _LIBCPP___BIT_REFERENCE
|
