30#ifndef _GLIBCXX_INPLACE_VECTOR
31#define _GLIBCXX_INPLACE_VECTOR 1
33#pragma GCC system_header
35#define __glibcxx_want_inplace_vector
38#ifdef __glibcxx_inplace_vector
52namespace std _GLIBCXX_VISIBILITY(default)
54_GLIBCXX_BEGIN_NAMESPACE_VERSION
55_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
58 template<
typename _Tp,
size_t _Nm>
64 using value_type = _Tp;
66 using const_pointer =
const _Tp*;
67 using reference = value_type&;
68 using const_reference =
const value_type&;
69 using size_type = size_t;
70 using difference_type = ptrdiff_t;
72 = __gnu_cxx::__normal_iterator<_Tp*, inplace_vector>;
74 = __gnu_cxx::__normal_iterator<const _Tp*, inplace_vector>;
75 using reverse_iterator = std::reverse_iterator<iterator>;
76 using const_reverse_iterator = std::reverse_iterator<const_iterator>;
80 inplace_vector() noexcept
84 inplace_vector(size_type __n)
93 inplace_vector(size_type __n,
const _Tp& __value)
101 template<__any_input_iterator _InputIterator>
103 inplace_vector(_InputIterator __first, _InputIterator __last)
106 if constexpr (__any_sizeable_iterator<_InputIterator>)
108 const size_type __n = _S_distance_if_fits(0, __first, __last);
114 while (__first != __last)
115 emplace_back(*__first++);
119 template <__detail::__container_compatible_range<_Tp> _Rg>
121 inplace_vector(from_range_t, _Rg&& __rg)
123 { append_range(__rg); }
126 inplace_vector(initializer_list<_Tp> __il)
129 _S_check_size(__il.size());
131 _M_size = __il.size();
134 inplace_vector(
const inplace_vector&)
135 requires is_trivially_copy_constructible_v<_Tp>
139 inplace_vector(
const inplace_vector& __other)
140 noexcept(is_nothrow_copy_constructible_v<_Tp>)
144 _M_size = __other.size();
147 inplace_vector(inplace_vector&&)
148 requires is_trivially_move_constructible_v<_Tp>
152 inplace_vector(inplace_vector&& __other)
153 noexcept(is_nothrow_move_constructible_v<_Tp>)
157 _M_size = __other.size();
161 requires is_trivially_destructible_v<_Tp>
169 operator=(
const inplace_vector&)
170 requires is_trivially_copy_assignable_v<_Tp>
171 && is_trivially_copy_constructible_v<_Tp>
172 && is_trivially_destructible_v<_Tp>
175 constexpr inplace_vector&
176 operator=(
const inplace_vector& __other)
177 noexcept(is_nothrow_copy_assignable_v<_Tp>
178 && is_nothrow_copy_constructible_v<_Tp>)
181 assign(__other.begin(), __other.end());
186 operator=(inplace_vector&&)
187 requires is_trivially_move_assignable_v<_Tp>
188 && is_trivially_move_constructible_v<_Tp>
189 && is_trivially_destructible_v<_Tp>
192 constexpr inplace_vector&
193 operator=(inplace_vector&& __other)
194 noexcept(is_nothrow_move_assignable_v<_Tp>
195 && is_nothrow_move_constructible_v<_Tp>)
198 assign(std::make_move_iterator(__other.begin()),
199 std::make_move_iterator(__other.end()));
203 constexpr inplace_vector&
204 operator=(initializer_list<_Tp> __il)
206 assign(__il.begin(), __il.end());
210 template<__any_input_iterator _InputIterator>
212 assign(_InputIterator __first, _InputIterator __last)
214 if constexpr (__any_sizeable_iterator<_InputIterator>)
216 const size_type __n = _S_distance_if_fits(0, __first, __last);
219 for (
size_t __i = 0; __i < _M_size; ++__i, (void)++__first)
220 _M_elems[__i] = *__first;
224 std::destroy(std::copy(__first, __last, begin()), end());
230 for (;__first != __last && __i < _M_size; ++__first)
231 _M_elems[__i++] = *__first;
232 if (__first == __last)
239 while (__first != __last)
240 emplace_back(*__first++);
245 template<__detail::__container_compatible_range<_Tp> _Rg>
247 assign_range(_Rg&& __rg)
249 if constexpr (ranges::forward_range<_Rg> || ranges::sized_range<_Rg>)
251 const size_type __sz = _S_distance_if_fits(0, __rg);
254 ranges::copy_n(ranges::begin(__rg), __sz, data());
255 std::destroy(data() + __sz, data() + _M_size);
259 auto [__in, __out] = ranges::copy_n(
260 ranges::begin(__rg), _M_size,
262 ranges::uninitialized_copy(
264 __out, unreachable_sentinel);
270 auto __in = ranges::begin(__rg);
271 auto __end = ranges::end(__rg);
273 for (; __n < _M_size && __in != __end; ++__in)
274 _M_elems[__n++] = *__in;
278 std::destroy(data() + __n, data() + _M_size);
284 auto __res = ranges::uninitialized_copy(
286 data() + __n, data() + _Nm);
287 _M_size = __res.out - data();
288 if (__res.in == ranges::end(__rg))
296 assign(size_type __n,
const _Tp& __u)
303 std::destroy_n(std::fill_n(data(), __n, __u), _M_size - __n);
308 assign(initializer_list<_Tp> __il)
309 { assign(__il.begin(), __il.end()); }
314 begin() noexcept {
return iterator(data()); }
317 constexpr const_iterator
318 begin() const noexcept {
return const_iterator(data()); }
323 {
return iterator(data() + _M_size); }
326 constexpr const_iterator
328 {
return const_iterator(data() + _M_size); }
331 constexpr reverse_iterator
333 {
return reverse_iterator(end()); }
336 constexpr const_reverse_iterator
337 rbegin() const noexcept
338 {
return const_reverse_iterator(end()); }
341 constexpr reverse_iterator
342 rend() noexcept {
return reverse_iterator(begin()); }
345 constexpr const_reverse_iterator
346 rend() const noexcept {
return const_reverse_iterator(begin()); }
349 constexpr const_iterator
350 cbegin() const noexcept {
return begin(); }
353 constexpr const_iterator
354 cend() const noexcept {
return end(); }
357 constexpr const_reverse_iterator
358 crbegin() const noexcept {
return rbegin(); }
361 constexpr const_reverse_iterator
362 crend() const noexcept {
return rend(); }
367 empty() const noexcept {
return _M_size == 0; }
371 size() const noexcept
374 __builtin_unreachable();
379 static constexpr size_type
380 max_size() noexcept {
return _Nm; }
383 static constexpr size_type
384 capacity() noexcept {
return _Nm; }
387 resize(size_type __n)
392 else if (__n < _M_size)
393 std::destroy_n(data() + __n, _M_size - __n);
398 resize(size_type __n,
const _Tp& __c)
403 else if (__n < _M_size)
404 std::destroy_n(data() + __n, _M_size - __n);
408 static constexpr void
409 reserve(size_type __n)
410 { _S_check_size(__n); }
412 static constexpr void
418 operator[](size_type __n)
420 __glibcxx_requires_subscript(__n);
421 return _M_elems[__n];
425 constexpr const_reference
426 operator[](size_type __n)
const
428 __glibcxx_requires_subscript(__n);
429 return _M_elems[__n];
433 constexpr const_reference
434 at(size_type __n)
const
437 std::__throw_out_of_range_fmt(__N(
"inplace_vector::at: __n "
439 ">= size() (which is %zu)"),
441 return _M_elems[__n];
449 std::__throw_out_of_range_fmt(__N(
"inplace_vector::at: __n "
451 ">= size() (which is %zu)"),
453 return _M_elems[__n];
460 __glibcxx_requires_nonempty();
465 constexpr const_reference
468 __glibcxx_requires_nonempty();
476 __glibcxx_requires_nonempty();
477 return _M_elems[_M_size - 1];
481 constexpr const_reference
484 __glibcxx_requires_nonempty();
485 return _M_elems[_M_size - 1];
493 {
return static_cast<pointer
>(_M_elems); }
497 data() const noexcept
498 {
return static_cast<const_pointer
>(_M_elems); }
501 template<
typename... _Args>
503 emplace_back(_Args&&... __args)
511 push_back(
const _Tp& __x)
512 {
return emplace_back(__x); }
518 template<__detail::__container_compatible_range<_Tp> _Rg>
520 append_range(_Rg&& __rg)
522 if constexpr (ranges::forward_range<_Rg> || ranges::sized_range<_Rg>)
524 const size_t __sz = _S_distance_if_fits(_M_size, __rg);
526 ranges::uninitialized_copy(
527 ranges::begin(__rg), unreachable_sentinel,
528 data() + _M_size, data() + _M_size + __sz);
533 ranges::subrange<pointer> __tail(data() + _M_size, data() + _Nm);
534 auto [__in, __out] = ranges::uninitialized_copy(__rg, __tail);
535 _M_size = __out - data();
536 if (__in != ranges::end(__rg))
544 __glibcxx_requires_nonempty();
546 _M_elems[_M_size].~_Tp();
549 template<
typename... _Args>
550 constexpr optional<_Tp&>
551 try_emplace_back(_Args&&... __args)
553 if (_M_size >= _Nm) [[unlikely]]
555 return optional<_Tp&>(in_place,
559 constexpr optional<_Tp&>
560 try_push_back(
const _Tp& __x)
562 if (_M_size >= _Nm) [[unlikely]]
564 return optional<_Tp&>(in_place, unchecked_emplace_back(__x));
567 constexpr optional<_Tp&>
568 try_push_back(_Tp&& __x)
570 if (_M_size >= _Nm) [[unlikely]]
572 return optional<_Tp&>(in_place, unchecked_emplace_back(
std::move(__x)));
575 template<
typename... _Args>
577 unchecked_emplace_back(_Args&&... __args)
579 __glibcxx_assert(_M_size < _Nm);
580 auto __p = std::construct_at(data() + _M_size,
587 unchecked_push_back(
const _Tp& __x)
588 {
return unchecked_emplace_back(__x); }
591 unchecked_push_back(_Tp&& __x)
592 {
return unchecked_emplace_back(
std::move(__x)); }
594 template<
typename... _Args>
596 emplace(const_iterator __position, _Args&&... __args)
598 size_t __b = __position - cbegin();
599 __glibcxx_assert(__b <= _M_size);
602 iterator __pos = begin() + __b;
605 std::rotate(__pos, end() - 1, end());
610 insert(const_iterator __position,
const _Tp& __x)
611 {
return emplace(__position, __x); }
614 insert(const_iterator __position, _Tp&& __x)
615 {
return emplace(__position,
std::move(__x)); }
618 insert(const_iterator __position, size_type __n,
const _Tp& __x)
620 size_t __b = __position - cbegin();
621 __glibcxx_assert(__b <= _M_size);
622 if ((_Nm - _M_size) < __n)
624 iterator __pos = begin() + __b;
626 if (std::__exchange(_M_size, _M_size + __n))
627 std::rotate(__pos, end() - __n, end());
631 template<__any_input_iterator _InputIterator>
633 insert(const_iterator __position, _InputIterator __first,
634 _InputIterator __last)
636 size_t __b = __position - cbegin();
637 __glibcxx_assert(__b <= _M_size);
638 iterator __pos = begin() + __b;
639 const size_t __s = _M_size;
640 if constexpr (__any_sizeable_iterator<_InputIterator>)
642 const size_type __n = _S_distance_if_fits(_M_size, __first, __last);
648 while (__first != __last)
649 emplace_back(*__first++);
652 std::rotate(__pos, begin() + __s, end());
656 template<__detail::__container_compatible_range<_Tp> _Rg>
658 insert_range(const_iterator __position, _Rg&& __rg)
660 iterator __pos = begin() + (__position - cbegin());
661 const auto __end = end();
662 if constexpr (ranges::forward_range<_Rg> || ranges::sized_range<_Rg>)
664 const size_type __sz = _S_distance_if_fits(_M_size, __rg);
665 if (!__sz) [[unlikely]]
668 const size_type __num_after = __end - __pos;
669 if (__num_after >= __sz)
671 ranges::uninitialized_move(__end - __sz, __end,
672 __end, unreachable_sentinel);
674 ranges::move_backward(__pos, __end - __sz, __end);
675 ranges::copy(__rg, __pos);
677 else if constexpr (ranges::forward_range<_Rg>)
679 auto __mid = ranges::next(ranges::begin(__rg), __num_after);
680 ranges::uninitialized_copy(__mid, ranges::end(__rg),
681 __end, unreachable_sentinel);
682 _M_size += __sz - __num_after;
683 ranges::uninitialized_move(__pos, __end,
684 __pos + __sz, unreachable_sentinel);
685 _M_size += __num_after;
686 ranges::copy(ranges::begin(__rg), __mid, __pos);
690 ranges::uninitialized_copy(
691 ranges::begin(__rg), ranges::end(__rg),
692 __end, unreachable_sentinel);
694 std::rotate(__pos, __end, end());
700 std::rotate(__pos, __end, end());
706 insert(const_iterator __position, initializer_list<_Tp> __il)
707 {
return insert(__position, __il.begin(), __il.end()); }
710 erase(const_iterator __position)
712 size_t __n = __position - cbegin();
713 __glibcxx_assert(__n < _M_size);
714 iterator __pos = begin() + __n;
721 erase(const_iterator __first, const_iterator __last)
723 size_t __n = __first - cbegin();
724 size_t __x = __last - __first;
725 __glibcxx_assert(__n <= _M_size);
726 __glibcxx_assert(__x <= _M_size);
727 iterator __pos = begin() + __n;
728 iterator __end =
std::move(__pos + __x, end(), __pos);
729 std::destroy_n(__end, __x);
735 swap(inplace_vector& __x)
736 noexcept(is_nothrow_swappable_v<_Tp> && is_nothrow_move_constructible_v<_Tp>)
739 const auto __smaller = __vs[__x.size() < size()];
740 const auto __bigger = __vs[__x.size() >= size()];
741 size_type __n = __smaller->size();
742 size_type __n2 = __bigger->size();
744 if constexpr (is_nothrow_move_constructible_v<_Tp>)
746 for (size_type __i = __n; __i < __n2; ++__i)
748 std::construct_at(__smaller->data() + __i,
750 std::destroy_at(__bigger->data() + __i);
756 __bigger->data() + __n2,
757 __smaller->data() + __n);
758 std::destroy(__bigger->data() + __n, __bigger->data() + __n2);
760 __smaller->_M_size = __n2;
761 __bigger->_M_size = __n;
764 for (size_type __i = 0; __i < __n; __i++)
765 swap(_M_elems[__i], __x._M_elems[__i]);
771 std::destroy_n(data(),
size_t(_M_size));
775 constexpr friend bool
776 operator==(
const inplace_vector& __x,
const inplace_vector& __y)
777 {
return std::equal(__x.begin(), __x.end(), __y.begin(), __y.end()); }
779 constexpr friend auto
780 operator<=>(
const inplace_vector& __x,
const inplace_vector& __y)
781 requires requires (
const _Tp __t) {
782 { __t < __t } -> __detail::__boolean_testable;
786 __y.begin(), __y.end(),
787 __detail::__synth3way);
791 constexpr friend void
792 swap(inplace_vector& __x, inplace_vector& __y)
793 noexcept(is_nothrow_swappable_v<_Tp> && is_nothrow_move_constructible_v<_Tp>)
803 template<
typename _UInt,
bool = (alignof(_Tp) <= sizeof(_UInt))>
804 static constexpr
bool __fits
805 = _Nm <= __gnu_cxx::__
int_traits<_UInt>::__max;
809 template<
typename _UInt>
810 static constexpr bool __fits<_UInt, false> =
false;
812 static consteval auto __select_size_type()
814 if constexpr (__fits<unsigned char>)
815 return (
unsigned char)0;
816#if __SHRT_WIDTH__ < __SIZE_WIDTH__
817 else if constexpr (__fits<unsigned short>)
818 return (
unsigned short)0;
820#if __INT_WIDTH__ < __SIZE_WIDTH__ && __INT_WIDTH__ > __SHRT_WIDTH__
821 else if constexpr (__fits<unsigned int>)
824#if __LONG_WIDTH__ < __SIZE_WIDTH__ && __LONG_WIDTH__ > __INT_WIDTH__
825 else if constexpr (__fits<unsigned long>)
831 decltype(__select_size_type()) _M_size = 0;
838 if constexpr (is_trivially_default_constructible_v<_Tp>
839 && is_trivially_copyable_v<_Tp>)
840 for (
size_t __i = 0; __i < _Nm; ++__i)
841 _M_elems[__i] = _Tp();
843#if __has_builtin(__builtin_constexpr_diag)
844 __builtin_constexpr_diag(2,
"",
845 "std::inplace_vector supports only trivally copyable and "
846 "trivially default constructible types at compile time");
848 __builtin_unreachable();
853 template<
typename _Integer>
854 static constexpr size_type
855 _S_check_size(_Integer __n, size_type __size = 0)
857 if constexpr (__detail::__is_signed_integer_like<_Integer>)
860 if (__n > (_Nm - __size))
862 return static_cast<size_type
>(__n);
865 template<
typename _Iterator,
typename _Sentinel>
866 static constexpr size_type
867 _S_check_distance(_Iterator __first, _Sentinel __last, size_type __size)
869 for (size_type __i = __size; __i < _Nm; ++__i)
870 if (__first == __last)
875 if (__first == __last)
883 template<
typename _InputIterator>
884 constexpr static size_t
885 _S_distance_if_fits(
size_t __size, _InputIterator __first, _InputIterator __last)
887 if constexpr (sized_sentinel_for<_InputIterator, _InputIterator>)
888 return _S_check_size(__last - __first, __size);
890 return _S_check_distance(__first, __last, __size);
894 template<
typename _Rg>
895 constexpr static size_t
896 _S_distance_if_fits(
size_t __size, _Rg& __rg)
898 if constexpr (ranges::sized_range<_Rg>)
899 return _S_check_size(ranges::size(__rg), __size);
901 return _S_check_distance(ranges::begin(__rg), ranges::end(__rg),
908 template<
typename _Tp>
909 class inplace_vector<_Tp, 0>
914 using pointer = _Tp*;
915 using const_pointer =
const _Tp*;
921 = __gnu_cxx::__normal_iterator<_Tp*, inplace_vector>;
923 = __gnu_cxx::__normal_iterator<const _Tp*, inplace_vector>;
925 using const_reverse_iterator = std::reverse_iterator<const_iterator>;
928 inplace_vector() =
default;
938 inplace_vector(
size_type __n,
const _Tp& __value)
944 template<__any_input_iterator _InputIterator>
946 inplace_vector(_InputIterator __first, _InputIterator __last)
948 if (__first != __last)
952 template <__detail::__container_compatible_range<_Tp> _Rg>
954 inplace_vector(from_range_t, _Rg&& __rg)
956 if (ranges::begin(__rg) != ranges::end(__rg))
963 if (__il.size() != 0)
967 inplace_vector(
const inplace_vector&) =
default;
968 inplace_vector(inplace_vector&&) =
default;
971 ~inplace_vector() =
default;
974 operator=(
const inplace_vector&) =
default;
977 operator=(inplace_vector&&) =
default;
979 constexpr inplace_vector&
982 if (__il.size() != 0)
987 template<__any_input_iterator _InputIterator>
989 assign(_InputIterator __first, _InputIterator __last)
991 if (__first != __last)
995 template<__detail::__container_compatible_range<_Tp> _Rg>
997 assign_range(_Rg&& __rg)
999 if (ranges::begin(__rg) != ranges::end(__rg))
1000 __throw_bad_alloc();
1007 __throw_bad_alloc();
1013 if (__il.size() != 0)
1014 __throw_bad_alloc();
1023 constexpr const_iterator
1024 begin() const noexcept {
return const_iterator(
nullptr); }
1031 constexpr const_iterator
1032 end() const noexcept {
return const_iterator(
nullptr); }
1040 constexpr const_reverse_iterator
1042 {
return const_reverse_iterator(
end()); }
1049 constexpr const_reverse_iterator
1050 rend() const noexcept {
return const_reverse_iterator(
begin()); }
1053 constexpr const_iterator
1057 constexpr const_iterator
1058 cend() const noexcept {
return end(); }
1061 constexpr const_reverse_iterator
1065 constexpr const_reverse_iterator
1066 crend() const noexcept {
return rend(); }
1071 empty() const noexcept {
return true; }
1075 size() const noexcept {
return 0; }
1079 max_size() noexcept {
return 0; }
1083 capacity() noexcept {
return 0; }
1089 __throw_bad_alloc();
1096 __throw_bad_alloc();
1099 static constexpr void
1103 __throw_bad_alloc();
1106 static constexpr void
1110 [[nodiscard,noreturn]]
1113 { __builtin_trap(); }
1115 [[nodiscard,noreturn]]
1116 constexpr const_reference
1118 { __builtin_trap(); }
1120 [[nodiscard,noreturn]]
1121 constexpr const_reference
1124 std::__throw_out_of_range_fmt(__N(
"inplace_vector::at: __n "
1126 ">= size() (which is 0)"),
1130 [[nodiscard,noreturn]]
1134 std::__throw_out_of_range_fmt(__N(
"inplace_vector::at: __n "
1136 ">= size() (which is 0)"),
1140 [[nodiscard,noreturn]]
1143 { __builtin_trap(); }
1145 [[nodiscard,noreturn]]
1146 constexpr const_reference
1148 { __builtin_trap(); }
1150 [[nodiscard,noreturn]]
1153 { __builtin_trap(); }
1155 [[nodiscard,noreturn]]
1156 constexpr const_reference
1158 { __builtin_trap(); }
1168 constexpr const _Tp*
1169 data() const noexcept
1173 template<
typename... _Args>
1176 emplace_back(_Args&&...)
1177 { __throw_bad_alloc(); }
1181 push_back(
const _Tp&)
1182 { __throw_bad_alloc(); }
1187 { __throw_bad_alloc(); }
1189 template<__detail::__container_compatible_range<_Tp> _Rg>
1191 append_range(_Rg&& __rg)
1193 if (ranges::begin(__rg) != ranges::end(__rg))
1194 __throw_bad_alloc();
1200 { __builtin_trap(); }
1202 template<
typename... _Args>
1203 constexpr optional<_Tp&>
1204 try_emplace_back(_Args&&...)
1207 constexpr optional<_Tp&>
1208 try_push_back(
const _Tp&)
1211 constexpr optional<_Tp&>
1212 try_push_back(_Tp&&)
1215 template<
typename... _Args>
1218 unchecked_emplace_back(_Args&&...)
1219 { __builtin_trap(); }
1223 unchecked_push_back(
const _Tp&)
1224 { __builtin_trap(); }
1228 unchecked_push_back(_Tp&&)
1229 { __builtin_trap(); }
1231 template<
typename... _Args>
1234 emplace(const_iterator, _Args&&...)
1235 { __throw_bad_alloc(); }
1239 insert(const_iterator,
const _Tp&)
1240 { __throw_bad_alloc(); }
1244 insert(const_iterator, _Tp&&)
1245 { __throw_bad_alloc(); }
1248 insert(const_iterator,
size_type __n,
const _Tp&)
1251 __throw_bad_alloc();
1255 template<
typename _InputIterator>
1257 insert(const_iterator, _InputIterator __first, _InputIterator __last)
1259 if (__first != __last)
1260 __throw_bad_alloc();
1264 template<__detail::__container_compatible_range<_Tp> _Rg>
1266 insert_range(const_iterator, _Rg&& __rg)
1268 if (ranges::begin(__rg) != ranges::end(__rg))
1269 __throw_bad_alloc();
1276 if (__il.size() != 0)
1277 __throw_bad_alloc();
1283 erase(const_iterator)
1284 { __builtin_trap(); }
1287 erase(const_iterator __first, const_iterator __last)
1289 __glibcxx_assert(__first == __last);
1294 swap(inplace_vector& __x)
1302 constexpr friend bool
1303 operator==(
const inplace_vector&,
const inplace_vector&)
1306 constexpr friend auto
1307 operator<=>(
const inplace_vector&,
const inplace_vector&)
1308 requires requires (
const _Tp __t) {
1309 { __t < __t } -> __detail::__boolean_testable;
1311 {
return std::strong_ordering::equal; }
1317 constexpr friend void
1318 swap(inplace_vector&, inplace_vector&)
noexcept
1322_GLIBCXX_END_NAMESPACE_CONTAINER
1324 template<
typename _Tp,
size_t _Nm,
typename _Predicate>
1326 erase_if(_GLIBCXX_STD_C::inplace_vector<_Tp, _Nm>& __cont,
1329 if constexpr (_Nm != 0)
1330 return __detail::__erase_if(__cont, __cont,
std::move(__pred));
1335 template<
typename _Tp,
size_t _Nm,
typename _Up = _Tp>
1337 erase(_GLIBCXX_STD_C::inplace_vector<_Tp, _Nm>& __cont,
const _Up& __value)
1338 {
return std::erase_if(__cont, __gnu_cxx::__ops::__equal_to(__value)); }
1340_GLIBCXX_END_NAMESPACE_VERSION
1343#ifdef _GLIBCXX_DEBUG
1344# include <debug/inplace_vector>
constexpr _ForwardIterator uninitialized_value_construct_n(_ForwardIterator __first, _Size __count)
Value-initializes objects in the range [first,first+count).
constexpr _ForwardIterator uninitialized_move(_InputIterator __first, _InputIterator __last, _ForwardIterator __result)
Move-construct from the range [first,last) into result.
constexpr _ForwardIterator uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp &__x)
Copies the value x into the range [first,first+n).
constexpr _ForwardIterator uninitialized_copy(_InputIterator __first, _InputIterator __last, _ForwardIterator __result)
Copies the range [first,last) into result.
constexpr _Tp * addressof(_Tp &__r) noexcept
Returns the actual address of the object or function referenced by r, even in the presence of an over...
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
constexpr _Tp && forward(typename std::remove_reference< _Tp >::type &__t) noexcept
Forward an lvalue.
_Tp * end(valarray< _Tp > &__va) noexcept
Return an iterator pointing to one past the last element of the valarray.
_Tp * begin(valarray< _Tp > &__va) noexcept
Return an iterator pointing to the first element of the valarray.
constexpr auto lexicographical_compare_three_way(_InputIter1 __first1, _InputIter1 __last1, _InputIter2 __first2, _InputIter2 __last2, _Comp __comp) -> decltype(__comp(*__first1, *__first2))
Performs dictionary comparison on ranges.
constexpr nullopt_t nullopt
Tag to disengage optional objects.
ISO C++ entities toplevel namespace is std.
constexpr auto rbegin(_Container &__cont) noexcept(noexcept(__cont.rbegin())) -> decltype(__cont.rbegin())
Return a reverse iterator pointing to the last element of the container.
constexpr _ForwardIterator _Destroy_n(_ForwardIterator __first, _Size __count)
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.
constexpr auto empty(const _Container &__cont) noexcept(noexcept(__cont.empty())) -> decltype(__cont.empty())
Return whether a container is empty.
constexpr auto crbegin(const _Container &__cont) noexcept(noexcept(std::rbegin(__cont))) -> decltype(std::rbegin(__cont))
Return a reverse iterator pointing to the last element of the const container.
constexpr auto size(const _Container &__cont) noexcept(noexcept(__cont.size())) -> decltype(__cont.size())
Return the size of a container.
constexpr auto data(_Container &__cont) noexcept(noexcept(__cont.data())) -> decltype(__cont.data())
Return the data pointer of a container.
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.
constexpr auto rend(_Container &__cont) noexcept(noexcept(__cont.rend())) -> decltype(__cont.rend())
Return a reverse iterator pointing one past the first element of the container.
constexpr auto crend(const _Container &__cont) noexcept(noexcept(std::rend(__cont))) -> decltype(std::rend(__cont))
Return a reverse iterator pointing one past the first element of the const container.