inplace_vector
Go to the documentation of this file.
// Sequence container with fixed capacity -*- C++ -*-
// Copyright The GNU Toolchain Authors.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.
// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
// <http://www.gnu.org/licenses/>.
/** @file include/inplace_vector
* This is a Standard C++ Library header.
* @ingroup sequences
*/
#ifndef _GLIBCXX_INPLACE_VECTOR
#define _GLIBCXX_INPLACE_VECTOR 1
#pragma GCC system_header
#define __glibcxx_want_inplace_vector
#include <bits/version.h>
#ifdef __glibcxx_inplace_vector // C++ >= 26
#include <compare>
#include <initializer_list>
#include <optional>
#include <bits/stdexcept_throw.h>
#include <bits/range_access.h>
#include <bits/ranges_base.h> // borrowed_iterator_t, __detail::__container_compatible_range
#include <bits/ranges_util.h> // subrange
#include <bits/ranges_uninitialized.h>
#include <bits/stl_construct.h>
#include <bits/stl_uninitialized.h>
#include <bits/stl_algo.h> // rotate
#include <bits/erase_if.h>
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
// [indirect], class template indirect
template<typename _Tp, size_t _Nm>
class inplace_vector
{
public:
// types:
using value_type = _Tp;
using pointer = _Tp*;
using const_pointer = const _Tp*;
using reference = value_type&;
using const_reference = const value_type&;
using size_type = size_t;
using difference_type = ptrdiff_t;
using iterator
= __gnu_cxx::__normal_iterator<_Tp*, inplace_vector>;
using const_iterator
= __gnu_cxx::__normal_iterator<const _Tp*, inplace_vector>;
using reverse_iterator = std::reverse_iterator<iterator>;
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
// [containers.sequences.inplace.vector.cons], construct/copy/destroy
constexpr
inplace_vector() noexcept
{ _M_init(); }
constexpr explicit
inplace_vector(size_type __n)
{
_M_init();
_S_reserve(__n);
std::uninitialized_value_construct_n(data(), __n);
_M_size = __n;
}
constexpr
inplace_vector(size_type __n, const _Tp& __value)
{
_M_init();
_S_reserve(__n);
std::uninitialized_fill_n(data(), __n, __value);
_M_size = __n;
}
template<__any_input_iterator _InputIterator>
constexpr
inplace_vector(_InputIterator __first, _InputIterator __last)
: inplace_vector()
{
if (const auto __n = _S_distance(__first, __last))
{
_S_reserve(__n);
std::uninitialized_copy(__first, __last, data());
_M_size = __n;
}
else
{
while (__first != __last)
emplace_back(*__first++);
}
}
template <__detail::__container_compatible_range<_Tp> _Rg>
constexpr
inplace_vector(from_range_t, _Rg&& __rg)
: inplace_vector()
{ append_range(__rg); }
constexpr
inplace_vector(initializer_list<_Tp> __il)
{
_M_init();
_S_reserve(__il.size());
std::uninitialized_copy(__il.begin(), __il.end(), data());
_M_size = __il.size();
}
inplace_vector(const inplace_vector&)
requires is_trivially_copy_constructible_v<_Tp>
= default;
constexpr
inplace_vector(const inplace_vector& __other)
noexcept(is_nothrow_copy_constructible_v<_Tp>)
{
_M_init();
std::uninitialized_copy(__other.begin(), __other.end(), data());
_M_size = __other.size();
}
inplace_vector(inplace_vector&&)
requires is_trivially_move_constructible_v<_Tp>
= default;
constexpr
inplace_vector(inplace_vector&& __other)
noexcept(is_nothrow_move_constructible_v<_Tp>)
{
_M_init();
std::uninitialized_move(__other.begin(), __other.end(), data());
_M_size = __other.size();
}
~inplace_vector()
requires is_trivially_destructible_v<_Tp>
= default;
constexpr
~inplace_vector()
{ clear(); }
inplace_vector&
operator=(const inplace_vector&)
requires is_trivially_copy_assignable_v<_Tp>
&& is_trivially_copy_constructible_v<_Tp>
&& is_trivially_destructible_v<_Tp>
= default;
constexpr inplace_vector&
operator=(const inplace_vector& __other)
noexcept(is_nothrow_copy_assignable_v<_Tp>
&& is_nothrow_copy_constructible_v<_Tp>)
{
if (std::addressof(__other) != this) [[likely]]
assign(__other.begin(), __other.end());
return *this;
}
inplace_vector&
operator=(inplace_vector&&)
requires is_trivially_move_assignable_v<_Tp>
&& is_trivially_move_constructible_v<_Tp>
&& is_trivially_destructible_v<_Tp>
= default;
constexpr inplace_vector&
operator=(inplace_vector&& __other)
noexcept(is_nothrow_move_assignable_v<_Tp>
&& is_nothrow_move_constructible_v<_Tp>)
{
if (std::addressof(__other) != this) [[likely]]
assign(std::make_move_iterator(__other.begin()),
std::make_move_iterator(__other.end()));
return *this;
}
constexpr inplace_vector&
operator=(initializer_list<_Tp> __il)
{
assign(__il.begin(), __il.end());
return *this;
}
template<__any_input_iterator _InputIterator>
constexpr void
assign(_InputIterator __first, _InputIterator __last)
{
if (const auto __n = _S_distance(__first, __last))
{
_S_reserve(__n);
if (_M_size <= __n)
{
for (size_t __i = 0; __i < _M_size; ++__i, (void)++__first)
_M_elems[__i] = *__first;
std::uninitialized_copy(__first, __last, end());
}
else
std::destroy(std::copy(__first, __last, begin()), end());
_M_size = __n;
}
else
{
size_t __i = 0;
for (;__first != __last && __i < _M_size; ++__first)
_M_elems[__i++] = *__first;
if (__first == __last)
{
std::_Destroy_n(data() + __i, _M_size - __i);
_M_size = __i;
}
else
{
while (__first != __last)
emplace_back(*__first++);
}
}
}
template<__detail::__container_compatible_range<_Tp> _Rg>
constexpr void
assign_range(_Rg&& __rg)
{
if constexpr (ranges::forward_range<_Rg> || ranges::sized_range<_Rg>)
{
const auto __sz = ranges::distance(__rg);
if (__sz > _Nm)
__throw_bad_alloc();
if (__sz <= size())
{
ranges::copy_n(ranges::begin(__rg), __sz, data());
std::destroy(data() + __sz, data() + _M_size);
}
else
{
auto [__in, __out] = ranges::copy_n(
ranges::begin(__rg), _M_size,
data());
ranges::uninitialized_copy(
std::move(__in), ranges::end(__rg),
__out, unreachable_sentinel);
}
_M_size = __sz;
}
else
{
auto __in = ranges::begin(__rg);
auto __end = ranges::end(__rg);
size_type __n = 0;
for (; __n < _M_size && __in != __end; ++__in)
_M_elems[__n++] = *__in;
if (__in == __end)
{
std::destroy(data() + __n, data() + _M_size);
_M_size = __n;
return;
}
else if (__n < _Nm)
{
auto __res = ranges::uninitialized_copy(
std::move(__in), __end,
data() + __n, data() + _Nm);
_M_size = __res.out - data();
if (__res.in == ranges::end(__rg))
return;
}
__throw_bad_alloc();
}
}
constexpr void
assign(size_type __n, const _Tp& __u)
{
_S_reserve(__n);
if (_M_size <= __n)
std::uninitialized_fill_n(std::fill_n(data(), _M_size, __u),
__n - _M_size, __u);
else
std::destroy_n(std::fill_n(data(), __n, __u), _M_size - __n);
_M_size = __n;
}
constexpr void
assign(initializer_list<_Tp> __il)
{ assign(__il.begin(), __il.end()); }
// iterators
[[nodiscard]]
constexpr iterator
begin() noexcept { return iterator(data()); }
[[nodiscard]]
constexpr const_iterator
begin() const noexcept { return const_iterator(data()); }
[[nodiscard]]
constexpr iterator
end() noexcept
{ return iterator(data() + _M_size); }
[[nodiscard]]
constexpr const_iterator
end() const noexcept
{ return const_iterator(data() + _M_size); }
[[nodiscard]]
constexpr reverse_iterator
rbegin() noexcept
{ return reverse_iterator(end()); }
[[nodiscard]]
constexpr const_reverse_iterator
rbegin() const noexcept
{ return const_reverse_iterator(end()); }
[[nodiscard]]
constexpr reverse_iterator
rend() noexcept { return reverse_iterator(begin()); }
[[nodiscard]]
constexpr const_reverse_iterator
rend() const noexcept { return const_reverse_iterator(begin()); }
[[nodiscard]]
constexpr const_iterator
cbegin() const noexcept { return begin(); }
[[nodiscard]]
constexpr const_iterator
cend() const noexcept { return end(); }
[[nodiscard]]
constexpr const_reverse_iterator
crbegin() const noexcept { return rbegin(); }
[[nodiscard]]
constexpr const_reverse_iterator
crend() const noexcept { return rend(); }
// [containers.sequences.inplace.vector.members] size/capacity
[[nodiscard]]
constexpr bool
empty() const noexcept { return _M_size == 0; }
[[nodiscard]]
constexpr size_type
size() const noexcept
{
if (_M_size > _Nm)
__builtin_unreachable();
return _M_size;
}
[[nodiscard]]
static constexpr size_type
max_size() noexcept { return _Nm; }
[[nodiscard]]
static constexpr size_type
capacity() noexcept { return _Nm; }
constexpr void
resize(size_type __n)
{
_S_reserve(__n);
if (__n > _M_size)
std::uninitialized_value_construct_n(data() + _M_size, __n - _M_size);
else if (__n < _M_size)
std::destroy_n(data() + __n, _M_size - __n);
_M_size = __n;
}
constexpr void
resize(size_type __n, const _Tp& __c)
{
_S_reserve(__n);
if (__n > _M_size)
std::uninitialized_fill_n(data() + _M_size, __n - _M_size, __c);
else if (__n < _M_size)
std::destroy_n(data() + __n, _M_size - __n);
_M_size = __n;
}
static constexpr void
reserve(size_type __n)
{ _S_reserve(__n); }
static constexpr void
shrink_to_fit() { }
// element access
[[nodiscard]]
constexpr reference
operator[](size_type __n)
{
__glibcxx_requires_subscript(__n);
return _M_elems[__n];
}
[[nodiscard]]
constexpr const_reference
operator[](size_type __n) const
{
__glibcxx_requires_subscript(__n);
return _M_elems[__n];
}
[[nodiscard]]
constexpr const_reference
at(size_type __n) const
{
if (__n >= _M_size)
std::__throw_out_of_range_fmt(__N("inplace_vector::at: __n "
"(which is %zu) "
">= size() (which is %zu)"),
__n, _M_size);
return _M_elems[__n];
}
[[nodiscard]]
constexpr reference
at(size_type __n)
{
if (__n >= _M_size)
std::__throw_out_of_range_fmt(__N("inplace_vector::at: __n "
"(which is %zu) "
">= size() (which is %zu)"),
__n, _M_size);
return _M_elems[__n];
}
[[nodiscard]]
constexpr reference
front()
{
__glibcxx_requires_nonempty();
return _M_elems[0];
}
[[nodiscard]]
constexpr const_reference
front() const
{
__glibcxx_requires_nonempty();
return _M_elems[0];
}
[[nodiscard]]
constexpr reference
back()
{
__glibcxx_requires_nonempty();
return _M_elems[_M_size - 1];
}
[[nodiscard]]
constexpr const_reference
back() const
{
__glibcxx_requires_nonempty();
return _M_elems[_M_size - 1];
}
// [containers.sequences.inplace.vector.data], data access
[[nodiscard]]
constexpr _Tp*
data() noexcept
{ return static_cast<pointer>(_M_elems); }
[[nodiscard]]
constexpr const _Tp*
data() const noexcept
{ return static_cast<const_pointer>(_M_elems); }
// [containers.sequences.inplace.vector.modifiers], modifiers
template<typename... _Args>
constexpr _Tp&
emplace_back(_Args&&... __args)
{
if (_M_size >= _Nm)
__throw_bad_alloc();
return unchecked_emplace_back(std::forward<_Args>(__args)...);
}
constexpr _Tp&
push_back(const _Tp& __x)
{ return emplace_back(__x); }
constexpr _Tp&
push_back(_Tp&& __x)
{ return emplace_back(std::move(__x)); }
template<__detail::__container_compatible_range<_Tp> _Rg>
constexpr void
append_range(_Rg&& __rg)
{
if constexpr (ranges::forward_range<_Rg> || ranges::sized_range<_Rg>)
{
const auto __sz = ranges::distance(__rg);
if (__sz > (_Nm - size()))
__throw_bad_alloc();
// Bounded on output range due PR121143
ranges::uninitialized_copy(
ranges::begin(__rg), unreachable_sentinel,
data() + _M_size, data() + _M_size + __sz);
_M_size += size_type(__sz);
}
else
{
ranges::subrange<pointer> __tail(data() + _M_size, data() + _Nm);
auto [__in, __out] = ranges::uninitialized_copy(__rg, __tail);
_M_size = __out - data();
if (__in != ranges::end(__rg))
__throw_bad_alloc();
}
}
constexpr void
pop_back()
{
__glibcxx_requires_nonempty();
--_M_size;
_M_elems[_M_size].~_Tp();
}
template<typename... _Args>
constexpr optional<_Tp&>
try_emplace_back(_Args&&... __args)
{
if (_M_size >= _Nm) [[unlikely]]
return nullopt;
return optional<_Tp&>(in_place,
unchecked_emplace_back(std::forward<_Args>(__args)...));
}
constexpr optional<_Tp&>
try_push_back(const _Tp& __x)
{
if (_M_size >= _Nm) [[unlikely]]
return nullopt;
return optional<_Tp&>(in_place, unchecked_emplace_back(__x));
}
constexpr optional<_Tp&>
try_push_back(_Tp&& __x)
{
if (_M_size >= _Nm) [[unlikely]]
return nullopt;
return optional<_Tp&>(in_place, unchecked_emplace_back(std::move(__x)));
}
template<typename... _Args>
constexpr _Tp&
unchecked_emplace_back(_Args&&... __args)
{
__glibcxx_assert(_M_size < _Nm);
auto __p = std::construct_at(data() + _M_size,
std::forward<_Args>(__args)...);
++_M_size;
return *__p;
}
constexpr _Tp&
unchecked_push_back(const _Tp& __x)
{ return unchecked_emplace_back(__x); }
constexpr _Tp&
unchecked_push_back(_Tp&& __x)
{ return unchecked_emplace_back(std::move(__x)); }
template<typename... _Args>
constexpr iterator
emplace(const_iterator __position, _Args&&... __args)
{
size_t __b = __position - cbegin(); // elements before position
__glibcxx_assert(__b <= _M_size);
if (_M_size >= _Nm)
__throw_bad_alloc();
iterator __pos = begin() + __b;
std::construct_at(data() + _M_size, std::forward<_Args>(__args)...);
if (_M_size++)
std::rotate(__pos, end() - 1, end());
return __pos;
}
constexpr iterator
insert(const_iterator __position, const _Tp& __x)
{ return emplace(__position, __x); }
constexpr iterator
insert(const_iterator __position, _Tp&& __x)
{ return emplace(__position, std::move(__x)); }
constexpr iterator
insert(const_iterator __position, size_type __n, const _Tp& __x)
{
size_t __b = __position - cbegin(); // elements before position
__glibcxx_assert(__b <= _M_size);
if ((_Nm - _M_size) < __n)
__throw_bad_alloc();
iterator __pos = begin() + __b;
std::uninitialized_fill_n(data() + _M_size, __n, __x);
if (std::__exchange(_M_size, _M_size + __n))
std::rotate(__pos, end() - __n, end());
return __pos;
}
template<__any_input_iterator _InputIterator>
constexpr iterator
insert(const_iterator __position, _InputIterator __first,
_InputIterator __last)
{
size_t __b = __position - cbegin(); // elements before position
__glibcxx_assert(__b <= _M_size);
iterator __pos = begin() + __b;
const size_t __s = _M_size;
if (const auto __n = _S_distance(__first, __last))
{
if ((_Nm - _M_size) < __n)
__throw_bad_alloc();
std::uninitialized_copy(__first, __last, data() + _M_size);
_M_size += __n;
}
else
{
while (__first != __last)
emplace_back(*__first++);
}
if (__s)
std::rotate(__pos, begin() + __s, end());
return __pos;
}
template<__detail::__container_compatible_range<_Tp> _Rg>
constexpr iterator
insert_range(const_iterator __position, _Rg&& __rg)
{
iterator __pos = begin() + (__position - cbegin());
const auto __end = end();
if constexpr (ranges::forward_range<_Rg> || ranges::sized_range<_Rg>)
{
const auto __len = ranges::distance(__rg);
if (__len > (_Nm - size()))
__throw_bad_alloc();
if (!__len) [[unlikely]]
return __pos;
const size_type __n = size_type(__len);
const size_type __num_after = __end - __pos;
if (__num_after >= __n)
{
ranges::uninitialized_move(__end - __n, __end,
__end, unreachable_sentinel);
_M_size += __n;
ranges::move_backward(__pos, __end - __n, __end);
ranges::copy(__rg, __pos);
}
else if constexpr (ranges::forward_range<_Rg>)
{
auto __mid = ranges::next(ranges::begin(__rg), __num_after);
ranges::uninitialized_copy(__mid, ranges::end(__rg),
__end, unreachable_sentinel);
_M_size += __n - __num_after;
ranges::uninitialized_move(__pos, __end,
__pos + __n, unreachable_sentinel);
_M_size += __num_after;
ranges::copy(ranges::begin(__rg), __mid, __pos);
}
else
{
ranges::uninitialized_copy(
ranges::begin(__rg), ranges::end(__rg),
__end, unreachable_sentinel);
_M_size += __n;
std::rotate(__pos, __end, end());
}
}
else
{
append_range(__rg);
std::rotate(__pos, __end, end());
}
return __pos;
}
constexpr iterator
insert(const_iterator __position, initializer_list<_Tp> __il)
{ return insert(__position, __il.begin(), __il.end()); }
constexpr iterator
erase(const_iterator __position)
{
size_t __n = __position - cbegin();
__glibcxx_assert(__n < _M_size);
iterator __pos = begin() + __n;
std::move(__pos + 1, end(), __pos);
pop_back();
return __pos;
}
constexpr iterator
erase(const_iterator __first, const_iterator __last)
{
size_t __n = __first - cbegin();
size_t __x = __last - __first;
__glibcxx_assert(__n <= _M_size);
__glibcxx_assert(__x <= _M_size);
iterator __pos = begin() + __n;
iterator __end = std::move(__pos + __x, end(), __pos);
std::destroy_n(__end, __x);
_M_size -= __x;
return __pos;
}
constexpr void
swap(inplace_vector& __x)
noexcept(is_nothrow_swappable_v<_Tp> && is_nothrow_move_constructible_v<_Tp>)
{
inplace_vector* __vs[2]{ this, std::addressof(__x) };
const auto __smaller = __vs[__x.size() < size()];
const auto __bigger = __vs[__x.size() >= size()];
size_type __n = __smaller->size();
size_type __n2 = __bigger->size();
if constexpr (is_nothrow_move_constructible_v<_Tp>)
{
for (size_type __i = __n; __i < __n2; ++__i)
{
std::construct_at(__smaller->data() + __i,
std::move(*(__bigger->data() + __i)));
std::destroy_at(__bigger->data() + __i);
}
}
else
{
std::uninitialized_copy(__bigger->data() + __n,
__bigger->data() + __n2,
__smaller->data() + __n);
std::destroy(__bigger->data() + __n, __bigger->data() + __n2);
}
__smaller->_M_size = __n2;
__bigger->_M_size = __n;
using std::swap;
for (size_type __i = 0; __i < __n; __i++)
swap(_M_elems[__i], __x._M_elems[__i]);
}
constexpr void
clear() noexcept
{
std::destroy_n(data(), size_t(_M_size));
_M_size = 0;
}
constexpr friend bool
operator==(const inplace_vector& __x, const inplace_vector& __y)
{ return std::equal(__x.begin(), __x.end(), __y.begin(), __y.end()); }
constexpr friend auto
operator<=>(const inplace_vector& __x, const inplace_vector& __y)
requires requires (const _Tp __t) {
{ __t < __t } -> __detail::__boolean_testable;
}
{
return std::lexicographical_compare_three_way(__x.begin(), __x.end(),
__y.begin(), __y.end(),
__detail::__synth3way);
}
// [inplace.vector.special], specialized algorithms
constexpr friend void
swap(inplace_vector& __x, inplace_vector& __y)
noexcept(is_nothrow_swappable_v<_Tp> && is_nothrow_move_constructible_v<_Tp>)
{ __x.swap(__y); }
private:
union {
_Tp _M_elems[_Nm];
};
// Check whether integer type _UInt is wide enough to store _Nm,
// so that we use a smaller type for _M_size when that saves space.
template<typename _UInt, bool = (alignof(_Tp) <= sizeof(_UInt))>
static constexpr bool __fits
= _Nm <= __gnu_cxx::__int_traits<_UInt>::__max;
// Don't bother using a smaller type if alignment of the array elements
// means that it doesn't actually save space.
template<typename _UInt>
static constexpr bool __fits<_UInt, false> = false;
static consteval auto __select_size_type()
{
if constexpr (__fits<unsigned char>)
return (unsigned char)0;
#if __SHRT_WIDTH__ < __SIZE_WIDTH__
else if constexpr (__fits<unsigned short>)
return (unsigned short)0;
#endif
#if __INT_WIDTH__ < __SIZE_WIDTH__ && __INT_WIDTH__ > __SHRT_WIDTH__
else if constexpr (__fits<unsigned int>)
return 0u;
#endif
#if __LONG_WIDTH__ < __SIZE_WIDTH__ && __LONG_WIDTH__ > __INT_WIDTH__
else if constexpr (__fits<unsigned long>)
return 0ul;
#endif
else // Just use size_t.
return 0uz;
}
decltype(__select_size_type()) _M_size = 0;
constexpr void
_M_init()
{
if !consteval
{
#if __glibcxx_start_lifetime_as
std::start_lifetime_as_array<_Tp>(data(), _Nm);
#endif
}
else
{
// TODO: use new(_M_elems) _Tp[_Nm]() once PR121068 is fixed
if constexpr (is_trivial_v<_Tp>)
for (size_t __i = 0; __i < _Nm; ++__i)
_M_elems[__i] = _Tp();
else
__builtin_unreachable(); // only trivial types are supported at compile time
}
}
static constexpr void
_S_reserve(size_t __n)
{
if (__n > _Nm)
__throw_bad_alloc();
}
template<typename _InputIterator>
constexpr static auto
_S_distance(_InputIterator __first, _InputIterator __last)
{
if constexpr (sized_sentinel_for<_InputIterator, _InputIterator>
|| forward_iterator<_InputIterator>)
return (size_type)ranges::distance(__first, __last);
else if constexpr (derived_from<__iter_category_t<_InputIterator>,
forward_iterator_tag>)
return (size_type)std::distance(__first, __last);
else
return false_type{};
}
};
// specialization for zero capacity, that is required to be trivally copyable
// and empty regardless of _Tp.
template<typename _Tp>
class inplace_vector<_Tp, 0>
{
public:
// types:
using value_type = _Tp;
using pointer = _Tp*;
using const_pointer = const _Tp*;
using reference = value_type&;
using const_reference = const value_type&;
using size_type = size_t;
using difference_type = ptrdiff_t;
using iterator
= __gnu_cxx::__normal_iterator<_Tp*, inplace_vector>;
using const_iterator
= __gnu_cxx::__normal_iterator<const _Tp*, inplace_vector>;
using reverse_iterator = std::reverse_iterator<iterator>;
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
// [containers.sequences.inplace.vector.cons], construct/copy/destroy
inplace_vector() = default;
constexpr explicit
inplace_vector(size_type __n)
{
if (__n != 0)
__throw_bad_alloc();
}
constexpr
inplace_vector(size_type __n, const _Tp& __value)
{
if (__n != 0)
__throw_bad_alloc();
}
template<__any_input_iterator _InputIterator>
constexpr
inplace_vector(_InputIterator __first, _InputIterator __last)
{
if (__first != __last)
__throw_bad_alloc();
}
template <__detail::__container_compatible_range<_Tp> _Rg>
constexpr
inplace_vector(from_range_t, _Rg&& __rg)
{
if (ranges::begin(__rg) != ranges::end(__rg))
__throw_bad_alloc();
}
constexpr
inplace_vector(initializer_list<_Tp> __il)
{
if (__il.size() != 0)
__throw_bad_alloc();
}
inplace_vector(const inplace_vector&) = default;
inplace_vector(inplace_vector&&) = default;
constexpr
~inplace_vector() = default;
inplace_vector&
operator=(const inplace_vector&) = default;
inplace_vector&
operator=(inplace_vector&&) = default;
constexpr inplace_vector&
operator=(initializer_list<_Tp> __il)
{
if (__il.size() != 0)
__throw_bad_alloc();
return *this;
}
template<__any_input_iterator _InputIterator>
constexpr void
assign(_InputIterator __first, _InputIterator __last)
{
if (__first != __last)
__throw_bad_alloc();
}
template<__detail::__container_compatible_range<_Tp> _Rg>
constexpr void
assign_range(_Rg&& __rg)
{
if (ranges::begin(__rg) != ranges::end(__rg))
__throw_bad_alloc();
}
constexpr void
assign(size_type __n, const _Tp& __u)
{
if (__n != 0)
__throw_bad_alloc();
}
constexpr void
assign(initializer_list<_Tp> __il)
{
if (__il.size() != 0)
__throw_bad_alloc();
}
// iterators
[[nodiscard]]
constexpr iterator
begin() noexcept { return iterator(nullptr); }
[[nodiscard]]
constexpr const_iterator
begin() const noexcept { return const_iterator(nullptr); }
[[nodiscard]]
constexpr iterator
end() noexcept { return iterator(nullptr); }
[[nodiscard]]
constexpr const_iterator
end() const noexcept { return const_iterator(nullptr); }
[[nodiscard]]
constexpr reverse_iterator
rbegin() noexcept
{ return reverse_iterator(end()); }
[[nodiscard]]
constexpr const_reverse_iterator
rbegin() const noexcept
{ return const_reverse_iterator(end()); }
[[nodiscard]]
constexpr reverse_iterator
rend() noexcept { return reverse_iterator(begin()); }
[[nodiscard]]
constexpr const_reverse_iterator
rend() const noexcept { return const_reverse_iterator(begin()); }
[[nodiscard]]
constexpr const_iterator
cbegin() const noexcept { return begin(); }
[[nodiscard]]
constexpr const_iterator
cend() const noexcept { return end(); }
[[nodiscard]]
constexpr const_reverse_iterator
crbegin() const noexcept { return rbegin(); }
[[nodiscard]]
constexpr const_reverse_iterator
crend() const noexcept { return rend(); }
// [containers.sequences.inplace.vector.members] size/capacity
[[nodiscard]]
constexpr bool
empty() const noexcept { return true; }
[[nodiscard]]
constexpr size_type
size() const noexcept { return 0; }
[[nodiscard]]
static constexpr size_type
max_size() noexcept { return 0; }
[[nodiscard]]
static constexpr size_type
capacity() noexcept { return 0; }
constexpr void
resize(size_type __n)
{
if (__n != 0)
__throw_bad_alloc();
}
constexpr void
resize(size_type __n, const _Tp&)
{
if (__n != 0)
__throw_bad_alloc();
}
static constexpr void
reserve(size_type __n)
{
if (__n != 0)
__throw_bad_alloc();
}
static constexpr void
shrink_to_fit() { }
// element access
[[nodiscard,noreturn]]
constexpr reference
operator[](size_type)
{ __builtin_trap(); }
[[nodiscard,noreturn]]
constexpr const_reference
operator[](size_type) const
{ __builtin_trap(); }
[[nodiscard,noreturn]]
constexpr const_reference
at(size_type __n) const
{
std::__throw_out_of_range_fmt(__N("inplace_vector::at: __n "
"(which is %zu) "
">= size() (which is 0)"),
__n);
}
[[nodiscard,noreturn]]
constexpr reference
at(size_type __n)
{
std::__throw_out_of_range_fmt(__N("inplace_vector::at: __n "
"(which is %zu) "
">= size() (which is 0)"),
__n);
}
[[nodiscard,noreturn]]
constexpr reference
front()
{ __builtin_trap(); }
[[nodiscard,noreturn]]
constexpr const_reference
front() const
{ __builtin_trap(); }
[[nodiscard,noreturn]]
constexpr reference
back()
{ __builtin_trap(); }
[[nodiscard,noreturn]]
constexpr const_reference
back() const
{ __builtin_trap(); }
// [containers.sequences.inplace.vector.data], data access
[[nodiscard]]
constexpr _Tp*
data() noexcept
{ return nullptr; }
[[nodiscard]]
constexpr const _Tp*
data() const noexcept
{ return nullptr; }
// [containers.sequences.inplace.vector.modifiers], modifiers
template<typename... _Args>
[[noreturn]]
constexpr _Tp&
emplace_back(_Args&&...)
{ __throw_bad_alloc(); }
[[noreturn]]
constexpr _Tp&
push_back(const _Tp&)
{ __throw_bad_alloc(); }
[[noreturn]]
constexpr _Tp&
push_back(_Tp&&)
{ __throw_bad_alloc(); }
template<__detail::__container_compatible_range<_Tp> _Rg>
constexpr void
append_range(_Rg&& __rg)
{
if (ranges::begin(__rg) != ranges::end(__rg))
__throw_bad_alloc();
}
[[noreturn]]
constexpr void
pop_back()
{ __builtin_trap(); }
template<typename... _Args>
constexpr optional<_Tp&>
try_emplace_back(_Args&&...)
{ return nullopt; }
constexpr optional<_Tp&>
try_push_back(const _Tp&)
{ return nullopt; }
constexpr optional<_Tp&>
try_push_back(_Tp&&)
{ return nullopt; }
template<typename... _Args>
[[noreturn]]
constexpr _Tp&
unchecked_emplace_back(_Args&&...)
{ __builtin_trap(); }
[[noreturn]]
constexpr _Tp&
unchecked_push_back(const _Tp&)
{ __builtin_trap(); }
[[noreturn]]
constexpr _Tp&
unchecked_push_back(_Tp&&)
{ __builtin_trap(); }
template<typename... _Args>
[[noreturn]]
constexpr iterator
emplace(const_iterator, _Args&&...)
{ __throw_bad_alloc(); }
[[noreturn]]
constexpr iterator
insert(const_iterator, const _Tp&)
{ __throw_bad_alloc(); }
[[noreturn]]
constexpr iterator
insert(const_iterator, _Tp&&)
{ __throw_bad_alloc(); }
constexpr iterator
insert(const_iterator, size_type __n, const _Tp&)
{
if (__n != 0)
__throw_bad_alloc();
return begin();
}
template<typename _InputIterator>
constexpr iterator
insert(const_iterator, _InputIterator __first, _InputIterator __last)
{
if (__first != __last)
__throw_bad_alloc();
return begin();
}
template<__detail::__container_compatible_range<_Tp> _Rg>
constexpr iterator
insert_range(const_iterator, _Rg&& __rg)
{
if (ranges::begin(__rg) != ranges::end(__rg))
__throw_bad_alloc();
return begin();
}
constexpr iterator
insert(const_iterator, initializer_list<_Tp> __il)
{
if (__il.size() != 0)
__throw_bad_alloc();
return begin();
}
[[noreturn]]
constexpr iterator
erase(const_iterator)
{ __builtin_trap(); }
constexpr iterator
erase(const_iterator __first, const_iterator __last)
{
__glibcxx_assert(__first == __last);
return begin();
}
constexpr void
swap(inplace_vector& __x)
noexcept
{ }
constexpr void
clear() noexcept
{ }
constexpr friend bool
operator==(const inplace_vector&, const inplace_vector&)
{ return true; }
constexpr friend auto
operator<=>(const inplace_vector&, const inplace_vector&)
requires requires (const _Tp __t) {
{ __t < __t } -> __detail::__boolean_testable;
}
{ return std::strong_ordering::equal; }
// n.b. there is not explicit wording requiring that swap for inplace_vector,
// with zero size, works even if element type is not swappable. However given
// that move operations are required to be present and trivial, it makes sense
// to support them.
constexpr friend void
swap(inplace_vector&, inplace_vector&) noexcept
{ }
};
_GLIBCXX_END_NAMESPACE_CONTAINER
template<typename _Tp, size_t _Nm, typename _Predicate>
constexpr size_t
erase_if(_GLIBCXX_STD_C::inplace_vector<_Tp, _Nm>& __cont,
_Predicate __pred)
{
if constexpr (_Nm != 0)
return __detail::__erase_if(__cont, __cont, std::move(__pred));
return 0;
}
template<typename _Tp, size_t _Nm, typename _Up = _Tp>
constexpr size_t
erase(_GLIBCXX_STD_C::inplace_vector<_Tp, _Nm>& __cont, const _Up& __value)
{ return std::erase_if(__cont, __gnu_cxx::__ops::__equal_to(__value)); }
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
#ifdef _GLIBCXX_DEBUG
# include <debug/inplace_vector>
#endif
#endif // __glibcxx_inplace_vector
#endif // _GLIBCXX_INPLACE_VECTOR
compare
initializer_list
optional
stl_construct.h
ranges_util.h
range_access.h
stdexcept_throw.h
version.h
stl_uninitialized.h
stl_algo.h
ranges_base.h
erase_if.h
ranges_uninitialized.h
std::uninitialized_value_construct_n
constexpr _ForwardIterator uninitialized_value_construct_n(_ForwardIterator __first, _Size __count)
Value-initializes objects in the range [first,first+count).
Definition stl_uninitialized.h:1280
std::uninitialized_move
constexpr _ForwardIterator uninitialized_move(_InputIterator __first, _InputIterator __last, _ForwardIterator __result)
Move-construct from the range [first,last) into result.
Definition stl_uninitialized.h:1296
std::uninitialized_fill_n
constexpr _ForwardIterator uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp &__x)
Copies the value x into the range [first,first+n).
Definition stl_uninitialized.h:550
std::uninitialized_copy
constexpr _ForwardIterator uninitialized_copy(_InputIterator __first, _InputIterator __last, _ForwardIterator __result)
Copies the range [first,last) into result.
Definition stl_uninitialized.h:252
std::false_type
__bool_constant< false > false_type
The type used as a compile-time boolean with false value.
Definition type_traits:122
std::addressof
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...
Definition move.h:176
std::move
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
Definition move.h:138
std::forward
constexpr _Tp && forward(typename std::remove_reference< _Tp >::type &__t) noexcept
Forward an lvalue.
Definition move.h:72
std::lexicographical_compare_three_way
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.
Definition stl_algobase.h:1867
std::experimental::fundamentals_v1::nullopt
constexpr nullopt_t nullopt
Tag to disengage optional objects.
Definition experimental/optional:98
std
ISO C++ entities toplevel namespace is std.
std::distance
constexpr iterator_traits< _InputIterator >::difference_type distance(_InputIterator __first, _InputIterator __last)
A generalization of pointer arithmetic.
Definition stl_iterator_base_funcs.h:172
std::_Destroy_n
constexpr _ForwardIterator _Destroy_n(_ForwardIterator __first, _Size __count)
Definition stl_construct.h:245