56 #ifndef _STL_BVECTOR_H
57 #define _STL_BVECTOR_H 1
59 #if __cplusplus >= 201103L
63 namespace std _GLIBCXX_VISIBILITY(default)
65 _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
67 typedef unsigned long _Bit_type;
68 enum { _S_word_bit = int(__CHAR_BIT__ *
sizeof(_Bit_type)) };
75 _Bit_reference(_Bit_type * __x, _Bit_type __y)
76 : _M_p(__x), _M_mask(__y) { }
78 _Bit_reference() _GLIBCXX_NOEXCEPT : _M_p(0), _M_mask(0) { }
80 operator bool() const _GLIBCXX_NOEXCEPT
81 {
return !!(*_M_p & _M_mask); }
84 operator=(
bool __x) _GLIBCXX_NOEXCEPT
94 operator=(
const _Bit_reference& __x) _GLIBCXX_NOEXCEPT
95 {
return *
this = bool(__x); }
98 operator==(
const _Bit_reference& __x)
const
99 {
return bool(*
this) == bool(__x); }
102 operator<(
const _Bit_reference& __x)
const
103 {
return !bool(*
this) && bool(__x); }
106 flip() _GLIBCXX_NOEXCEPT
107 { *_M_p ^= _M_mask; }
110 #if __cplusplus >= 201103L
112 swap(_Bit_reference __x, _Bit_reference __y) noexcept
120 swap(_Bit_reference __x,
bool& __y) noexcept
128 swap(
bool& __x, _Bit_reference __y) noexcept
136 struct _Bit_iterator_base
137 :
public std::iterator<std::random_access_iterator_tag, bool>
140 unsigned int _M_offset;
142 _Bit_iterator_base(_Bit_type * __x,
unsigned int __y)
143 : _M_p(__x), _M_offset(__y) { }
148 if (_M_offset++ ==
int(_S_word_bit) - 1)
158 if (_M_offset-- == 0)
160 _M_offset = int(_S_word_bit) - 1;
166 _M_incr(ptrdiff_t __i)
169 _M_p += __n / int(_S_word_bit);
170 __n = __n % int(_S_word_bit);
173 __n += int(_S_word_bit);
176 _M_offset =
static_cast<unsigned int>(__n);
180 operator==(
const _Bit_iterator_base& __i)
const
181 {
return _M_p == __i._M_p && _M_offset == __i._M_offset; }
184 operator<(
const _Bit_iterator_base& __i)
const
186 return _M_p < __i._M_p
187 || (_M_p == __i._M_p && _M_offset < __i._M_offset);
191 operator!=(
const _Bit_iterator_base& __i)
const
192 {
return !(*
this == __i); }
195 operator>(
const _Bit_iterator_base& __i)
const
196 {
return __i < *
this; }
199 operator<=(
const _Bit_iterator_base& __i)
const
200 {
return !(__i < *
this); }
203 operator>=(
const _Bit_iterator_base& __i)
const
204 {
return !(*
this < __i); }
208 operator-(
const _Bit_iterator_base& __x,
const _Bit_iterator_base& __y)
210 return (
int(_S_word_bit) * (__x._M_p - __y._M_p)
211 + __x._M_offset - __y._M_offset);
214 struct _Bit_iterator :
public _Bit_iterator_base
216 typedef _Bit_reference reference;
217 typedef _Bit_reference* pointer;
218 typedef _Bit_iterator iterator;
220 _Bit_iterator() : _Bit_iterator_base(0, 0) { }
222 _Bit_iterator(_Bit_type * __x,
unsigned int __y)
223 : _Bit_iterator_base(__x, __y) { }
226 _M_const_cast()
const
231 {
return reference(_M_p, 1UL << _M_offset); }
243 iterator __tmp = *
this;
258 iterator __tmp = *
this;
264 operator+=(difference_type __i)
271 operator-=(difference_type __i)
280 iterator __tmp = *
this;
287 iterator __tmp = *
this;
293 {
return *(*
this + __i); }
297 operator+(ptrdiff_t __n,
const _Bit_iterator& __x)
298 {
return __x + __n; }
300 struct _Bit_const_iterator :
public _Bit_iterator_base
302 typedef bool reference;
303 typedef bool const_reference;
304 typedef const bool* pointer;
305 typedef _Bit_const_iterator const_iterator;
307 _Bit_const_iterator() : _Bit_iterator_base(0, 0) { }
309 _Bit_const_iterator(_Bit_type * __x,
unsigned int __y)
310 : _Bit_iterator_base(__x, __y) { }
312 _Bit_const_iterator(
const _Bit_iterator& __x)
313 : _Bit_iterator_base(__x._M_p, __x._M_offset) { }
316 _M_const_cast()
const
317 {
return _Bit_iterator(_M_p, _M_offset); }
321 {
return _Bit_reference(_M_p, 1UL << _M_offset); }
333 const_iterator __tmp = *
this;
348 const_iterator __tmp = *
this;
354 operator+=(difference_type __i)
361 operator-=(difference_type __i)
370 const_iterator __tmp = *
this;
377 const_iterator __tmp = *
this;
383 {
return *(*
this + __i); }
386 inline _Bit_const_iterator
387 operator+(ptrdiff_t __n,
const _Bit_const_iterator& __x)
388 {
return __x + __n; }
391 __fill_bvector(_Bit_iterator __first, _Bit_iterator __last,
bool __x)
393 for (; __first != __last; ++__first)
398 fill(_Bit_iterator __first, _Bit_iterator __last,
const bool& __x)
400 if (__first._M_p != __last._M_p)
402 std::fill(__first._M_p + 1, __last._M_p, __x ? ~0 : 0);
403 __fill_bvector(__first, _Bit_iterator(__first._M_p + 1, 0), __x);
404 __fill_bvector(_Bit_iterator(__last._M_p, 0), __last, __x);
407 __fill_bvector(__first, __last, __x);
410 template<
typename _Alloc>
413 typedef typename _Alloc::template rebind<_Bit_type>::other
417 :
public _Bit_alloc_type
419 _Bit_iterator _M_start;
420 _Bit_iterator _M_finish;
421 _Bit_type* _M_end_of_storage;
424 : _Bit_alloc_type(), _M_start(), _M_finish(), _M_end_of_storage(0)
427 _Bvector_impl(
const _Bit_alloc_type& __a)
428 : _Bit_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage(0)
431 #if __cplusplus >= 201103L
432 _Bvector_impl(_Bit_alloc_type&& __a)
433 : _Bit_alloc_type(std::move(__a)), _M_start(), _M_finish(),
440 typedef _Alloc allocator_type;
443 _M_get_Bit_allocator() _GLIBCXX_NOEXCEPT
444 {
return *
static_cast<_Bit_alloc_type*
>(&this->_M_impl); }
446 const _Bit_alloc_type&
447 _M_get_Bit_allocator() const _GLIBCXX_NOEXCEPT
448 {
return *
static_cast<const _Bit_alloc_type*
>(&this->_M_impl); }
451 get_allocator() const _GLIBCXX_NOEXCEPT
452 {
return allocator_type(_M_get_Bit_allocator()); }
457 _Bvector_base(
const allocator_type& __a)
460 #if __cplusplus >= 201103L
461 _Bvector_base(_Bvector_base&& __x) noexcept
462 : _M_impl(std::move(__x._M_get_Bit_allocator()))
464 this->_M_impl._M_start = __x._M_impl._M_start;
465 this->_M_impl._M_finish = __x._M_impl._M_finish;
466 this->_M_impl._M_end_of_storage = __x._M_impl._M_end_of_storage;
467 __x._M_impl._M_start = _Bit_iterator();
468 __x._M_impl._M_finish = _Bit_iterator();
469 __x._M_impl._M_end_of_storage = 0;
474 { this->_M_deallocate(); }
477 _Bvector_impl _M_impl;
480 _M_allocate(
size_t __n)
481 {
return _M_impl.allocate(_S_nword(__n)); }
486 if (_M_impl._M_start._M_p)
487 _M_impl.deallocate(_M_impl._M_start._M_p,
488 _M_impl._M_end_of_storage - _M_impl._M_start._M_p);
493 {
return (__n +
int(_S_word_bit) - 1) / int(_S_word_bit); }
496 _GLIBCXX_END_NAMESPACE_CONTAINER
502 namespace std _GLIBCXX_VISIBILITY(default)
504 _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
525 template<
typename _Alloc>
526 class vector<bool, _Alloc> :
protected _Bvector_base<_Alloc>
528 typedef _Bvector_base<_Alloc> _Base;
530 #if __cplusplus >= 201103L
531 template<
typename>
friend struct hash;
535 typedef bool value_type;
536 typedef size_t size_type;
537 typedef ptrdiff_t difference_type;
538 typedef _Bit_reference reference;
539 typedef bool const_reference;
540 typedef _Bit_reference* pointer;
541 typedef const bool* const_pointer;
542 typedef _Bit_iterator iterator;
543 typedef _Bit_const_iterator const_iterator;
546 typedef _Alloc allocator_type;
548 allocator_type get_allocator()
const
549 {
return _Base::get_allocator(); }
552 using _Base::_M_allocate;
553 using _Base::_M_deallocate;
554 using _Base::_S_nword;
555 using _Base::_M_get_Bit_allocator;
562 vector(
const allocator_type& __a)
565 #if __cplusplus >= 201103L
567 vector(size_type __n,
const allocator_type& __a = allocator_type())
571 vector(size_type __n,
const bool& __value,
572 const allocator_type& __a = allocator_type())
576 std::fill(this->_M_impl._M_start._M_p, this->_M_impl._M_end_of_storage,
581 vector(size_type __n,
const bool& __value =
bool(),
582 const allocator_type& __a = allocator_type())
586 std::fill(this->_M_impl._M_start._M_p, this->_M_impl._M_end_of_storage,
592 : _Base(__x._M_get_Bit_allocator())
594 _M_initialize(__x.
size());
595 _M_copy_aligned(__x.
begin(), __x.
end(), this->_M_impl._M_start);
598 #if __cplusplus >= 201103L
600 : _Base(std::move(__x)) { }
603 const allocator_type& __a = allocator_type())
606 _M_initialize_range(__l.begin(), __l.end(),
611 #if __cplusplus >= 201103L
612 template<
typename _InputIterator,
613 typename = std::_RequireInputIter<_InputIterator>>
614 vector(_InputIterator __first, _InputIterator __last,
615 const allocator_type& __a = allocator_type())
617 { _M_initialize_dispatch(__first, __last, __false_type()); }
619 template<
typename _InputIterator>
620 vector(_InputIterator __first, _InputIterator __last,
621 const allocator_type& __a = allocator_type())
624 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
625 _M_initialize_dispatch(__first, __last, _Integral());
629 ~vector() _GLIBCXX_NOEXCEPT { }
638 this->_M_deallocate();
639 _M_initialize(__x.
size());
641 this->_M_impl._M_finish = _M_copy_aligned(__x.
begin(), __x.
end(),
646 #if __cplusplus >= 201103L
660 this->
assign (__l.begin(), __l.end());
670 assign(size_type __n,
const bool& __x)
671 { _M_fill_assign(__n, __x); }
673 #if __cplusplus >= 201103L
674 template<
typename _InputIterator,
675 typename = std::_RequireInputIter<_InputIterator>>
677 assign(_InputIterator __first, _InputIterator __last)
678 { _M_assign_dispatch(__first, __last, __false_type()); }
680 template<
typename _InputIterator>
682 assign(_InputIterator __first, _InputIterator __last)
684 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
685 _M_assign_dispatch(__first, __last, _Integral());
689 #if __cplusplus >= 201103L
692 { this->
assign(__l.begin(), __l.end()); }
696 begin() _GLIBCXX_NOEXCEPT
697 {
return this->_M_impl._M_start; }
700 begin()
const _GLIBCXX_NOEXCEPT
701 {
return this->_M_impl._M_start; }
704 end() _GLIBCXX_NOEXCEPT
705 {
return this->_M_impl._M_finish; }
708 end()
const _GLIBCXX_NOEXCEPT
709 {
return this->_M_impl._M_finish; }
712 rbegin() _GLIBCXX_NOEXCEPT
716 rbegin()
const _GLIBCXX_NOEXCEPT
720 rend() _GLIBCXX_NOEXCEPT
724 rend()
const _GLIBCXX_NOEXCEPT
727 #if __cplusplus >= 201103L
730 {
return this->_M_impl._M_start; }
733 cend()
const noexcept
734 {
return this->_M_impl._M_finish; }
741 crend()
const noexcept
746 size()
const _GLIBCXX_NOEXCEPT
747 {
return size_type(
end() -
begin()); }
752 const size_type __isize =
753 __gnu_cxx::__numeric_traits<difference_type>::__max
754 - int(_S_word_bit) + 1;
755 const size_type __asize = _M_get_Bit_allocator().max_size();
756 return (__asize <= __isize /
int(_S_word_bit)
757 ? __asize *
int(_S_word_bit) : __isize);
762 {
return size_type(const_iterator(this->_M_impl._M_end_of_storage, 0)
766 empty()
const _GLIBCXX_NOEXCEPT
772 return *iterator(this->_M_impl._M_start._M_p
773 + __n /
int(_S_word_bit), __n %
int(_S_word_bit));
779 return *const_iterator(this->_M_impl._M_start._M_p
780 + __n /
int(_S_word_bit), __n %
int(_S_word_bit));
787 if (__n >= this->
size())
788 __throw_out_of_range(__N(
"vector<bool>::_M_range_check"));
797 at(size_type __n)
const
804 __throw_length_error(__N(
"vector::reserve"));
819 {
return *(
end() - 1); }
823 {
return *(
end() - 1); }
831 data() _GLIBCXX_NOEXCEPT { }
836 if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
837 *this->_M_impl._M_finish++ = __x;
839 _M_insert_aux(
end(), __x);
845 std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
846 std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
847 std::swap(this->_M_impl._M_end_of_storage,
848 __x._M_impl._M_end_of_storage);
852 std::__alloc_swap<typename _Base::_Bit_alloc_type>::
853 _S_do_it(_M_get_Bit_allocator(), __x._M_get_Bit_allocator());
858 swap(reference __x, reference __y) _GLIBCXX_NOEXCEPT
866 #if __cplusplus >= 201103L
867 insert(const_iterator __position,
const bool& __x =
bool())
869 insert(iterator __position,
const bool& __x =
bool())
872 const difference_type __n = __position -
begin();
873 if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage
874 && __position ==
end())
875 *this->_M_impl._M_finish++ = __x;
877 _M_insert_aux(__position._M_const_cast(), __x);
878 return begin() + __n;
881 #if __cplusplus >= 201103L
882 template<
typename _InputIterator,
883 typename = std::_RequireInputIter<_InputIterator>>
885 insert(const_iterator __position,
886 _InputIterator __first, _InputIterator __last)
888 difference_type __offset = __position -
cbegin();
889 _M_insert_dispatch(__position._M_const_cast(),
890 __first, __last, __false_type());
891 return begin() + __offset;
894 template<
typename _InputIterator>
896 insert(iterator __position,
897 _InputIterator __first, _InputIterator __last)
899 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
900 _M_insert_dispatch(__position, __first, __last, _Integral());
904 #if __cplusplus >= 201103L
906 insert(const_iterator __position, size_type __n,
const bool& __x)
908 difference_type __offset = __position -
cbegin();
909 _M_fill_insert(__position._M_const_cast(), __n, __x);
910 return begin() + __offset;
914 insert(iterator __position, size_type __n,
const bool& __x)
915 { _M_fill_insert(__position, __n, __x); }
918 #if __cplusplus >= 201103L
921 {
return this->
insert(__p, __l.begin(), __l.end()); }
926 { --this->_M_impl._M_finish; }
929 #if __cplusplus >= 201103L
930 erase(const_iterator __position)
932 erase(iterator __position)
934 {
return _M_erase(__position._M_const_cast()); }
937 #if __cplusplus >= 201103L
938 erase(const_iterator __first, const_iterator __last)
940 erase(iterator __first, iterator __last)
942 {
return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }
945 resize(size_type __new_size,
bool __x =
bool())
947 if (__new_size <
size())
948 _M_erase_at_end(
begin() + difference_type(__new_size));
953 #if __cplusplus >= 201103L
956 { _M_shrink_to_fit(); }
960 flip() _GLIBCXX_NOEXCEPT
962 for (_Bit_type * __p = this->_M_impl._M_start._M_p;
963 __p != this->_M_impl._M_end_of_storage; ++__p)
968 clear() _GLIBCXX_NOEXCEPT
969 { _M_erase_at_end(
begin()); }
975 _M_copy_aligned(const_iterator __first, const_iterator __last,
978 _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p);
979 return std::copy(const_iterator(__last._M_p, 0), __last,
984 _M_initialize(size_type __n)
986 _Bit_type* __q = this->_M_allocate(__n);
987 this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
988 this->_M_impl._M_start = iterator(__q, 0);
989 this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
993 _M_reallocate(size_type __n);
995 #if __cplusplus >= 201103L
1004 template<
typename _Integer>
1006 _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
1008 _M_initialize(static_cast<size_type>(__n));
1009 std::fill(this->_M_impl._M_start._M_p,
1010 this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
1013 template<
typename _InputIterator>
1015 _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
1017 { _M_initialize_range(__first, __last,
1020 template<
typename _InputIterator>
1022 _M_initialize_range(_InputIterator __first, _InputIterator __last,
1025 for (; __first != __last; ++__first)
1029 template<
typename _ForwardIterator>
1031 _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
1036 std::copy(__first, __last, this->_M_impl._M_start);
1041 template<
typename _Integer>
1043 _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
1044 { _M_fill_assign(__n, __val); }
1046 template<
class _InputIterator>
1048 _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
1053 _M_fill_assign(
size_t __n,
bool __x)
1057 std::fill(this->_M_impl._M_start._M_p,
1058 this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
1063 _M_erase_at_end(
begin() + __n);
1064 std::fill(this->_M_impl._M_start._M_p,
1065 this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
1069 template<
typename _InputIterator>
1071 _M_assign_aux(_InputIterator __first, _InputIterator __last,
1074 iterator __cur =
begin();
1075 for (; __first != __last && __cur !=
end(); ++__cur, ++__first)
1077 if (__first == __last)
1078 _M_erase_at_end(__cur);
1083 template<
typename _ForwardIterator>
1085 _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
1090 _M_erase_at_end(std::copy(__first, __last,
begin()));
1093 _ForwardIterator __mid = __first;
1095 std::copy(__first, __mid,
begin());
1104 template<
typename _Integer>
1106 _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
1108 { _M_fill_insert(__pos, __n, __x); }
1110 template<
typename _InputIterator>
1112 _M_insert_dispatch(iterator __pos,
1113 _InputIterator __first, _InputIterator __last,
1115 { _M_insert_range(__pos, __first, __last,
1119 _M_fill_insert(iterator __position, size_type __n,
bool __x);
1121 template<
typename _InputIterator>
1123 _M_insert_range(iterator __pos, _InputIterator __first,
1126 for (; __first != __last; ++__first)
1128 __pos =
insert(__pos, *__first);
1133 template<
typename _ForwardIterator>
1135 _M_insert_range(iterator __position, _ForwardIterator __first,
1139 _M_insert_aux(iterator __position,
bool __x);
1142 _M_check_len(size_type __n,
const char* __s)
const
1145 __throw_length_error(__N(__s));
1152 _M_erase_at_end(iterator __pos)
1153 { this->_M_impl._M_finish = __pos; }
1156 _M_erase(iterator __pos);
1159 _M_erase(iterator __first, iterator __last);
1162 _GLIBCXX_END_NAMESPACE_CONTAINER
1165 #if __cplusplus >= 201103L
1169 namespace std _GLIBCXX_VISIBILITY(default)
1171 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1175 template<
typename _Alloc>
1177 :
public __hash_base<size_t, _GLIBCXX_STD_C::vector<bool, _Alloc>>
1180 operator()(
const _GLIBCXX_STD_C::vector<bool, _Alloc>&)
const noexcept;
1183 _GLIBCXX_END_NAMESPACE_VERSION