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_VERSION
66 _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
68 typedef unsigned long _Bit_type;
69 enum { _S_word_bit = int(__CHAR_BIT__ *
sizeof(_Bit_type)) };
76 _Bit_reference(_Bit_type * __x, _Bit_type __y)
77 : _M_p(__x), _M_mask(__y) { }
79 _Bit_reference() _GLIBCXX_NOEXCEPT : _M_p(0), _M_mask(0) { }
81 operator bool() const _GLIBCXX_NOEXCEPT
82 {
return !!(*_M_p & _M_mask); }
85 operator=(
bool __x) _GLIBCXX_NOEXCEPT
95 operator=(
const _Bit_reference& __x) _GLIBCXX_NOEXCEPT
96 {
return *
this = bool(__x); }
99 operator==(
const _Bit_reference& __x)
const 100 {
return bool(*
this) == bool(__x); }
103 operator<(
const _Bit_reference& __x)
const 104 {
return !bool(*
this) && bool(__x); }
107 flip() _GLIBCXX_NOEXCEPT
108 { *_M_p ^= _M_mask; }
111 #if __cplusplus >= 201103L 113 swap(_Bit_reference __x, _Bit_reference __y) noexcept
121 swap(_Bit_reference __x,
bool& __y) noexcept
129 swap(
bool& __x, _Bit_reference __y) noexcept
137 struct _Bit_iterator_base
138 :
public std::iterator<std::random_access_iterator_tag, bool>
141 unsigned int _M_offset;
143 _Bit_iterator_base(_Bit_type * __x,
unsigned int __y)
144 : _M_p(__x), _M_offset(__y) { }
149 if (_M_offset++ ==
int(_S_word_bit) - 1)
159 if (_M_offset-- == 0)
161 _M_offset = int(_S_word_bit) - 1;
167 _M_incr(ptrdiff_t __i)
169 difference_type __n = __i + _M_offset;
170 _M_p += __n / int(_S_word_bit);
171 __n = __n % int(_S_word_bit);
174 __n += int(_S_word_bit);
177 _M_offset =
static_cast<unsigned int>(__n);
181 operator==(
const _Bit_iterator_base& __i)
const 182 {
return _M_p == __i._M_p && _M_offset == __i._M_offset; }
185 operator<(
const _Bit_iterator_base& __i)
const 187 return _M_p < __i._M_p
188 || (_M_p == __i._M_p && _M_offset < __i._M_offset);
192 operator!=(
const _Bit_iterator_base& __i)
const 193 {
return !(*
this == __i); }
196 operator>(
const _Bit_iterator_base& __i)
const 197 {
return __i < *
this; }
200 operator<=(
const _Bit_iterator_base& __i)
const 201 {
return !(__i < *
this); }
204 operator>=(
const _Bit_iterator_base& __i)
const 205 {
return !(*
this < __i); }
209 operator-(
const _Bit_iterator_base& __x,
const _Bit_iterator_base& __y)
211 return (
int(_S_word_bit) * (__x._M_p - __y._M_p)
212 + __x._M_offset - __y._M_offset);
215 struct _Bit_iterator :
public _Bit_iterator_base
217 typedef _Bit_reference reference;
218 typedef _Bit_reference* pointer;
219 typedef _Bit_iterator iterator;
221 _Bit_iterator() : _Bit_iterator_base(0, 0) { }
223 _Bit_iterator(_Bit_type * __x,
unsigned int __y)
224 : _Bit_iterator_base(__x, __y) { }
227 _M_const_cast()
const 232 {
return reference(_M_p, 1UL << _M_offset); }
244 iterator __tmp = *
this;
259 iterator __tmp = *
this;
265 operator+=(difference_type __i)
272 operator-=(difference_type __i)
281 iterator __tmp = *
this;
288 iterator __tmp = *
this;
293 operator[](difference_type __i)
const 294 {
return *(*
this + __i); }
298 operator+(ptrdiff_t __n,
const _Bit_iterator& __x)
299 {
return __x + __n; }
301 struct _Bit_const_iterator :
public _Bit_iterator_base
303 typedef bool reference;
304 typedef bool const_reference;
305 typedef const bool* pointer;
306 typedef _Bit_const_iterator const_iterator;
308 _Bit_const_iterator() : _Bit_iterator_base(0, 0) { }
310 _Bit_const_iterator(_Bit_type * __x,
unsigned int __y)
311 : _Bit_iterator_base(__x, __y) { }
313 _Bit_const_iterator(
const _Bit_iterator& __x)
314 : _Bit_iterator_base(__x._M_p, __x._M_offset) { }
317 _M_const_cast()
const 318 {
return _Bit_iterator(_M_p, _M_offset); }
322 {
return _Bit_reference(_M_p, 1UL << _M_offset); }
334 const_iterator __tmp = *
this;
349 const_iterator __tmp = *
this;
355 operator+=(difference_type __i)
362 operator-=(difference_type __i)
371 const_iterator __tmp = *
this;
378 const_iterator __tmp = *
this;
383 operator[](difference_type __i)
const 384 {
return *(*
this + __i); }
387 inline _Bit_const_iterator
388 operator+(ptrdiff_t __n,
const _Bit_const_iterator& __x)
389 {
return __x + __n; }
392 __fill_bvector(_Bit_type * __v,
393 unsigned int __first,
unsigned int __last,
bool __x)
395 const _Bit_type __fmask = ~0ul << __first;
396 const _Bit_type __lmask = ~0ul >> (_S_word_bit - __last);
397 const _Bit_type __mask = __fmask & __lmask;
406 fill(_Bit_iterator __first, _Bit_iterator __last,
const bool& __x)
408 if (__first._M_p != __last._M_p)
410 _Bit_type* __first_p = __first._M_p;
411 if (__first._M_offset != 0)
412 __fill_bvector(__first_p++, __first._M_offset, _S_word_bit, __x);
414 __builtin_memset(__first_p, __x ? ~0 : 0,
415 (__last._M_p - __first_p) *
sizeof(_Bit_type));
417 if (__last._M_offset != 0)
418 __fill_bvector(__last._M_p, 0, __last._M_offset, __x);
420 else if (__first._M_offset != __last._M_offset)
421 __fill_bvector(__first._M_p, __first._M_offset, __last._M_offset, __x);
424 template<
typename _Alloc>
428 rebind<_Bit_type>::other _Bit_alloc_type;
431 typedef typename _Bit_alloc_traits::pointer _Bit_pointer;
433 struct _Bvector_impl_data
435 _Bit_iterator _M_start;
436 _Bit_iterator _M_finish;
437 _Bit_pointer _M_end_of_storage;
439 _Bvector_impl_data() _GLIBCXX_NOEXCEPT
440 : _M_start(), _M_finish(), _M_end_of_storage()
443 #if __cplusplus >= 201103L 444 _Bvector_impl_data(_Bvector_impl_data&& __x) noexcept
445 : _M_start(__x._M_start), _M_finish(__x._M_finish)
446 , _M_end_of_storage(__x._M_end_of_storage)
450 _M_move_data(_Bvector_impl_data&& __x) noexcept
452 this->_M_start = __x._M_start;
453 this->_M_finish = __x._M_finish;
454 this->_M_end_of_storage = __x._M_end_of_storage;
460 _M_reset() _GLIBCXX_NOEXCEPT
462 _M_start = _M_finish = _Bit_iterator();
463 _M_end_of_storage = _Bit_pointer();
468 :
public _Bit_alloc_type,
public _Bvector_impl_data
472 _GLIBCXX_NOEXCEPT_IF( noexcept(_Bit_alloc_type()) )
476 _Bvector_impl(
const _Bit_alloc_type& __a) _GLIBCXX_NOEXCEPT
477 : _Bit_alloc_type(__a)
480 #if __cplusplus >= 201103L 481 _Bvector_impl(_Bvector_impl&&) =
default;
485 _M_end_addr() const _GLIBCXX_NOEXCEPT
487 if (this->_M_end_of_storage)
494 typedef _Alloc allocator_type;
497 _M_get_Bit_allocator() _GLIBCXX_NOEXCEPT
498 {
return this->_M_impl; }
500 const _Bit_alloc_type&
501 _M_get_Bit_allocator() const _GLIBCXX_NOEXCEPT
502 {
return this->_M_impl; }
505 get_allocator() const _GLIBCXX_NOEXCEPT
506 {
return allocator_type(_M_get_Bit_allocator()); }
508 #if __cplusplus >= 201103L 509 _Bvector_base() =
default;
514 _Bvector_base(
const allocator_type& __a)
517 #if __cplusplus >= 201103L 518 _Bvector_base(_Bvector_base&&) =
default;
522 { this->_M_deallocate(); }
525 _Bvector_impl _M_impl;
528 _M_allocate(
size_t __n)
529 {
return _Bit_alloc_traits::allocate(_M_impl, _S_nword(__n)); }
534 if (_M_impl._M_start._M_p)
536 const size_t __n = _M_impl._M_end_addr() - _M_impl._M_start._M_p;
537 _Bit_alloc_traits::deallocate(_M_impl,
538 _M_impl._M_end_of_storage - __n,
544 #if __cplusplus >= 201103L 546 _M_move_data(_Bvector_base&& __x) noexcept
547 { _M_impl._M_move_data(std::move(__x._M_impl)); }
552 {
return (__n +
int(_S_word_bit) - 1) / int(_S_word_bit); }
555 _GLIBCXX_END_NAMESPACE_CONTAINER
556 _GLIBCXX_END_NAMESPACE_VERSION
562 namespace std _GLIBCXX_VISIBILITY(default)
564 _GLIBCXX_BEGIN_NAMESPACE_VERSION
565 _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
586 template<
typename _Alloc>
587 class vector<bool, _Alloc> :
protected _Bvector_base<_Alloc>
589 typedef _Bvector_base<_Alloc> _Base;
590 typedef typename _Base::_Bit_pointer _Bit_pointer;
593 #if __cplusplus >= 201103L 594 template<
typename>
friend struct hash;
598 typedef bool value_type;
599 typedef size_t size_type;
600 typedef ptrdiff_t difference_type;
601 typedef _Bit_reference reference;
602 typedef bool const_reference;
603 typedef _Bit_reference* pointer;
604 typedef const bool* const_pointer;
605 typedef _Bit_iterator iterator;
606 typedef _Bit_const_iterator const_iterator;
609 typedef _Alloc allocator_type;
612 get_allocator()
const 613 {
return _Base::get_allocator(); }
616 using _Base::_M_allocate;
617 using _Base::_M_deallocate;
618 using _Base::_S_nword;
619 using _Base::_M_get_Bit_allocator;
622 #if __cplusplus >= 201103L 629 vector(
const allocator_type& __a)
632 #if __cplusplus >= 201103L 634 vector(size_type __n,
const allocator_type& __a = allocator_type())
638 vector(size_type __n,
const bool& __value,
639 const allocator_type& __a = allocator_type())
642 vector(size_type __n,
const bool& __value =
bool(),
643 const allocator_type& __a = allocator_type())
648 _M_initialize_value(__value);
652 : _Base(_Bit_alloc_traits::_S_select_on_copy(__x._M_get_Bit_allocator()))
654 _M_initialize(__x.
size());
655 _M_copy_aligned(__x.
begin(), __x.
end(), this->_M_impl._M_start);
658 #if __cplusplus >= 201103L 662 noexcept(_Bit_alloc_traits::_S_always_equal())
665 if (__x.get_allocator() == __a)
666 this->_M_move_data(std::move(__x));
669 _M_initialize(__x.
size());
678 _M_initialize(__x.
size());
679 _M_copy_aligned(__x.
begin(), __x.
end(), this->_M_impl._M_start);
683 const allocator_type& __a = allocator_type())
686 _M_initialize_range(__l.begin(), __l.end(),
691 #if __cplusplus >= 201103L 692 template<
typename _InputIterator,
693 typename = std::_RequireInputIter<_InputIterator>>
694 vector(_InputIterator __first, _InputIterator __last,
695 const allocator_type& __a = allocator_type())
697 { _M_initialize_dispatch(__first, __last, __false_type()); }
699 template<
typename _InputIterator>
700 vector(_InputIterator __first, _InputIterator __last,
701 const allocator_type& __a = allocator_type())
704 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
705 _M_initialize_dispatch(__first, __last, _Integral());
709 ~vector() _GLIBCXX_NOEXCEPT { }
712 operator=(
const vector& __x)
716 #if __cplusplus >= 201103L 717 if (_Bit_alloc_traits::_S_propagate_on_copy_assign())
719 if (this->_M_get_Bit_allocator() != __x._M_get_Bit_allocator())
721 this->_M_deallocate();
722 std::__alloc_on_copy(_M_get_Bit_allocator(),
723 __x._M_get_Bit_allocator());
724 _M_initialize(__x.
size());
727 std::__alloc_on_copy(_M_get_Bit_allocator(),
728 __x._M_get_Bit_allocator());
731 if (__x.
size() > capacity())
733 this->_M_deallocate();
734 _M_initialize(__x.
size());
736 this->_M_impl._M_finish = _M_copy_aligned(__x.
begin(), __x.
end(),
741 #if __cplusplus >= 201103L 743 operator=(vector&& __x) noexcept(_Bit_alloc_traits::_S_nothrow_move())
745 if (_Bit_alloc_traits::_S_propagate_on_move_assign()
746 || this->_M_get_Bit_allocator() == __x._M_get_Bit_allocator())
748 this->_M_deallocate();
749 this->_M_move_data(std::move(__x));
750 std::__alloc_on_move(_M_get_Bit_allocator(),
751 __x._M_get_Bit_allocator());
755 if (__x.
size() > capacity())
757 this->_M_deallocate();
758 _M_initialize(__x.
size());
760 this->_M_impl._M_finish = _M_copy_aligned(__x.
begin(), __x.
end(),
770 this->assign (__l.begin(), __l.end());
780 assign(size_type __n,
const bool& __x)
781 { _M_fill_assign(__n, __x); }
783 #if __cplusplus >= 201103L 784 template<
typename _InputIterator,
785 typename = std::_RequireInputIter<_InputIterator>>
787 assign(_InputIterator __first, _InputIterator __last)
790 template<
typename _InputIterator>
792 assign(_InputIterator __first, _InputIterator __last)
794 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
795 _M_assign_dispatch(__first, __last, _Integral());
799 #if __cplusplus >= 201103L 806 begin() _GLIBCXX_NOEXCEPT
807 {
return this->_M_impl._M_start; }
810 begin()
const _GLIBCXX_NOEXCEPT
811 {
return this->_M_impl._M_start; }
814 end() _GLIBCXX_NOEXCEPT
815 {
return this->_M_impl._M_finish; }
818 end()
const _GLIBCXX_NOEXCEPT
819 {
return this->_M_impl._M_finish; }
822 rbegin() _GLIBCXX_NOEXCEPT
823 {
return reverse_iterator(
end()); }
825 const_reverse_iterator
826 rbegin()
const _GLIBCXX_NOEXCEPT
827 {
return const_reverse_iterator(
end()); }
830 rend() _GLIBCXX_NOEXCEPT
831 {
return reverse_iterator(
begin()); }
833 const_reverse_iterator
834 rend()
const _GLIBCXX_NOEXCEPT
835 {
return const_reverse_iterator(
begin()); }
837 #if __cplusplus >= 201103L 840 {
return this->_M_impl._M_start; }
843 cend()
const noexcept
844 {
return this->_M_impl._M_finish; }
846 const_reverse_iterator
848 {
return const_reverse_iterator(
end()); }
850 const_reverse_iterator
851 crend()
const noexcept
852 {
return const_reverse_iterator(
begin()); }
856 size()
const _GLIBCXX_NOEXCEPT
857 {
return size_type(
end() -
begin()); }
860 max_size()
const _GLIBCXX_NOEXCEPT
862 const size_type __isize =
863 __gnu_cxx::__numeric_traits<difference_type>::__max
864 - int(_S_word_bit) + 1;
865 const size_type __asize
866 = _Bit_alloc_traits::max_size(_M_get_Bit_allocator());
867 return (__asize <= __isize /
int(_S_word_bit)
868 ? __asize *
int(_S_word_bit) : __isize);
872 capacity()
const _GLIBCXX_NOEXCEPT
873 {
return size_type(const_iterator(this->_M_impl._M_end_addr(), 0)
877 empty()
const _GLIBCXX_NOEXCEPT
881 operator[](size_type __n)
883 return *iterator(this->_M_impl._M_start._M_p
884 + __n /
int(_S_word_bit), __n %
int(_S_word_bit));
888 operator[](size_type __n)
const 890 return *const_iterator(this->_M_impl._M_start._M_p
891 + __n /
int(_S_word_bit), __n %
int(_S_word_bit));
896 _M_range_check(size_type __n)
const 898 if (__n >= this->size())
899 __throw_out_of_range_fmt(__N(
"vector<bool>::_M_range_check: __n " 900 "(which is %zu) >= this->size() " 908 { _M_range_check(__n);
return (*
this)[__n]; }
911 at(size_type __n)
const 912 { _M_range_check(__n);
return (*
this)[__n]; }
915 reserve(size_type __n)
917 if (__n > max_size())
918 __throw_length_error(__N(
"vector::reserve"));
919 if (capacity() < __n)
933 {
return *(
end() - 1); }
937 {
return *(
end() - 1); }
945 data() _GLIBCXX_NOEXCEPT { }
950 if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr())
951 *this->_M_impl._M_finish++ = __x;
953 _M_insert_aux(
end(), __x);
957 swap(vector& __x) _GLIBCXX_NOEXCEPT
959 std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
960 std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
961 std::swap(this->_M_impl._M_end_of_storage,
962 __x._M_impl._M_end_of_storage);
963 _Bit_alloc_traits::_S_on_swap(_M_get_Bit_allocator(),
964 __x._M_get_Bit_allocator());
969 swap(reference __x, reference __y) _GLIBCXX_NOEXCEPT
977 #if __cplusplus >= 201103L 978 insert(const_iterator __position,
const bool& __x =
bool())
980 insert(iterator __position,
const bool& __x =
bool())
983 const difference_type __n = __position -
begin();
984 if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr()
985 && __position ==
end())
986 *this->_M_impl._M_finish++ = __x;
988 _M_insert_aux(__position._M_const_cast(), __x);
989 return begin() + __n;
992 #if __cplusplus >= 201103L 993 template<
typename _InputIterator,
994 typename = std::_RequireInputIter<_InputIterator>>
996 insert(const_iterator __position,
997 _InputIterator __first, _InputIterator __last)
999 difference_type __offset = __position -
cbegin();
1000 _M_insert_dispatch(__position._M_const_cast(),
1001 __first, __last, __false_type());
1002 return begin() + __offset;
1005 template<
typename _InputIterator>
1007 insert(iterator __position,
1008 _InputIterator __first, _InputIterator __last)
1010 typedef typename std::__is_integer<_InputIterator>::__type _Integral;
1011 _M_insert_dispatch(__position, __first, __last, _Integral());
1015 #if __cplusplus >= 201103L 1017 insert(const_iterator __position, size_type __n,
const bool& __x)
1019 difference_type __offset = __position -
cbegin();
1020 _M_fill_insert(__position._M_const_cast(), __n, __x);
1021 return begin() + __offset;
1025 insert(iterator __position, size_type __n,
const bool& __x)
1026 { _M_fill_insert(__position, __n, __x); }
1029 #if __cplusplus >= 201103L 1032 {
return this->insert(__p, __l.begin(), __l.end()); }
1037 { --this->_M_impl._M_finish; }
1040 #if __cplusplus >= 201103L 1041 erase(const_iterator __position)
1043 erase(iterator __position)
1045 {
return _M_erase(__position._M_const_cast()); }
1048 #if __cplusplus >= 201103L 1049 erase(const_iterator __first, const_iterator __last)
1051 erase(iterator __first, iterator __last)
1053 {
return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }
1056 resize(size_type __new_size,
bool __x =
bool())
1058 if (__new_size < size())
1059 _M_erase_at_end(
begin() + difference_type(__new_size));
1061 insert(
end(), __new_size - size(), __x);
1064 #if __cplusplus >= 201103L 1067 { _M_shrink_to_fit(); }
1071 flip() _GLIBCXX_NOEXCEPT
1073 _Bit_type *
const __end = this->_M_impl._M_end_addr();
1074 for (_Bit_type * __p = this->_M_impl._M_start._M_p; __p != __end; ++__p)
1079 clear() _GLIBCXX_NOEXCEPT
1080 { _M_erase_at_end(
begin()); }
1082 #if __cplusplus >= 201103L 1083 template<
typename... _Args>
1084 #if __cplusplus > 201402L 1089 emplace_back(_Args&&... __args)
1091 push_back(
bool(__args...));
1092 #if __cplusplus > 201402L 1097 template<
typename... _Args>
1099 emplace(const_iterator __pos, _Args&&... __args)
1100 {
return insert(__pos,
bool(__args...)); }
1106 _M_copy_aligned(const_iterator __first, const_iterator __last,
1109 _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p);
1110 return std::copy(const_iterator(__last._M_p, 0), __last,
1115 _M_initialize(size_type __n)
1119 _Bit_pointer __q = this->_M_allocate(__n);
1120 this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
1125 this->_M_impl._M_end_of_storage = _Bit_pointer();
1126 this->_M_impl._M_start = iterator(0, 0);
1128 this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
1133 _M_initialize_value(
bool __x)
1135 if (_Bit_type* __p = this->_M_impl._M_start._M_p)
1136 __builtin_memset(__p, __x ? ~0 : 0,
1137 (this->_M_impl._M_end_addr() - __p)
1138 *
sizeof(_Bit_type));
1142 _M_reallocate(size_type __n);
1144 #if __cplusplus >= 201103L 1153 template<
typename _Integer>
1155 _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
1157 _M_initialize(static_cast<size_type>(__n));
1158 _M_initialize_value(__x);
1161 template<
typename _InputIterator>
1163 _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
1165 { _M_initialize_range(__first, __last,
1168 template<
typename _InputIterator>
1170 _M_initialize_range(_InputIterator __first, _InputIterator __last,
1173 for (; __first != __last; ++__first)
1174 push_back(*__first);
1177 template<
typename _ForwardIterator>
1179 _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
1184 std::copy(__first, __last, this->_M_impl._M_start);
1187 #if __cplusplus < 201103L 1190 template<
typename _Integer>
1192 _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
1193 { _M_fill_assign(__n, __val); }
1195 template<
class _InputIterator>
1197 _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
1203 _M_fill_assign(
size_t __n,
bool __x)
1207 _M_initialize_value(__x);
1208 insert(
end(), __n - size(), __x);
1212 _M_erase_at_end(
begin() + __n);
1213 _M_initialize_value(__x);
1217 template<
typename _InputIterator>
1219 _M_assign_aux(_InputIterator __first, _InputIterator __last,
1222 iterator __cur =
begin();
1223 for (; __first != __last && __cur !=
end(); ++__cur, ++__first)
1225 if (__first == __last)
1226 _M_erase_at_end(__cur);
1228 insert(
end(), __first, __last);
1231 template<
typename _ForwardIterator>
1233 _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
1238 _M_erase_at_end(std::copy(__first, __last,
begin()));
1241 _ForwardIterator __mid = __first;
1243 std::copy(__first, __mid,
begin());
1244 insert(
end(), __mid, __last);
1252 template<
typename _Integer>
1254 _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
1256 { _M_fill_insert(__pos, __n, __x); }
1258 template<
typename _InputIterator>
1260 _M_insert_dispatch(iterator __pos,
1261 _InputIterator __first, _InputIterator __last,
1263 { _M_insert_range(__pos, __first, __last,
1267 _M_fill_insert(iterator __position, size_type __n,
bool __x);
1269 template<
typename _InputIterator>
1271 _M_insert_range(iterator __pos, _InputIterator __first,
1274 for (; __first != __last; ++__first)
1276 __pos = insert(__pos, *__first);
1281 template<
typename _ForwardIterator>
1283 _M_insert_range(iterator __position, _ForwardIterator __first,
1287 _M_insert_aux(iterator __position,
bool __x);
1290 _M_check_len(size_type __n,
const char* __s)
const 1292 if (max_size() - size() < __n)
1293 __throw_length_error(__N(__s));
1295 const size_type __len = size() +
std::max(size(), __n);
1296 return (__len < size() || __len > max_size()) ? max_size() : __len;
1300 _M_erase_at_end(iterator __pos)
1301 { this->_M_impl._M_finish = __pos; }
1304 _M_erase(iterator __pos);
1307 _M_erase(iterator __first, iterator __last);
1310 _GLIBCXX_END_NAMESPACE_CONTAINER
1311 _GLIBCXX_END_NAMESPACE_VERSION
1314 #if __cplusplus >= 201103L 1318 namespace std _GLIBCXX_VISIBILITY(default)
1320 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1324 template<
typename _Alloc>
1326 :
public __hash_base<size_t, _GLIBCXX_STD_C::vector<bool, _Alloc>>
1329 operator()(
const _GLIBCXX_STD_C::vector<bool, _Alloc>&)
const noexcept;
1332 _GLIBCXX_END_NAMESPACE_VERSION
_GLIBCXX17_CONSTEXPR auto crbegin(const _Container &__cont) -> decltype(std::rbegin(__cont))
Return a reverse iterator pointing to the last element of the const container.
constexpr const _Tp * end(initializer_list< _Tp > __ils) noexcept
Return an iterator pointing to one past the last element of the initializer_list. ...
iterator begin() noexcept
Primary class template hash.
constexpr auto cbegin(const _Container &__cont) noexcept(noexcept(std::begin(__cont))) -> decltype(std::begin(__cont))
Return an iterator pointing to the first element of the const container.
complex< _Tp > operator-(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x minus y.
constexpr const _Tp * begin(initializer_list< _Tp > __ils) noexcept
Return an iterator pointing to the first element of the initializer_list.
size_type size() const noexcept
_GLIBCXX17_CONSTEXPR auto rend(_Container &__cont) -> decltype(__cont.rend())
Return a reverse iterator pointing one past the first element of the container.
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
complex< _Tp > operator+(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x plus y.
constexpr auto cend(const _Container &__cont) noexcept(noexcept(std::end(__cont))) -> decltype(std::end(__cont))
Return an iterator pointing to one past the last element of the const container.
Forward iterators support a superset of input iterator operations.
ISO C++ entities toplevel namespace is std.
_GLIBCXX17_CONSTEXPR iterator_traits< _InputIterator >::difference_type distance(_InputIterator __first, _InputIterator __last)
A generalization of pointer arithmetic.
A standard container which offers fixed time access to individual elements in any order...
Random-access iterators support a superset of bidirectional iterator operations.
Uniform interface to C++98 and C++11 allocators.
_GLIBCXX17_CONSTEXPR void advance(_InputIterator &__i, _Distance __n)
A generalization of pointer arithmetic.
constexpr iterator_traits< _Iter >::iterator_category __iterator_category(const _Iter &)
_GLIBCXX14_CONSTEXPR const _Tp & max(const _Tp &, const _Tp &)
This does what you think it does.
_GLIBCXX17_CONSTEXPR auto crend(const _Container &__cont) -> decltype(std::rend(__cont))
Return a reverse iterator pointing one past the first element of the const container.
complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
_GLIBCXX17_CONSTEXPR auto rbegin(_Container &__cont) -> decltype(__cont.rbegin())
Return a reverse iterator pointing to the last element of the container.