Edit: /usr/include/c++/11/bits/ranges_uninitialized.h (18130B)
// Raw memory manipulators -*- C++ -*-
// Copyright (C) 2020-2021 Free Software Foundation, Inc.
//
// 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
//
.
/** @file bits/ranges_uninitialized.h
* This is an internal header file, included by other library headers.
* Do not attempt to use it directly. @headername{memory}
*/
#ifndef _RANGES_UNINITIALIZED_H
#define _RANGES_UNINITIALIZED_H 1
#if __cplusplus > 201703L
#if __cpp_lib_concepts
#include
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
namespace ranges
{
namespace __detail
{
template
constexpr void*
__voidify(_Tp& __obj) noexcept
{
return const_cast
(static_cast(std::__addressof(__obj)));
}
template
concept __nothrow_input_iterator
= (input_iterator<_Iter>
&& is_lvalue_reference_v>
&& same_as>,
iter_value_t<_Iter>>);
template
concept __nothrow_sentinel = sentinel_for<_Sent, _Iter>;
template
concept __nothrow_input_range
= (range<_Range>
&& __nothrow_input_iterator>
&& __nothrow_sentinel, iterator_t<_Range>>);
template
concept __nothrow_forward_iterator
= (__nothrow_input_iterator<_Iter>
&& forward_iterator<_Iter>
&& __nothrow_sentinel<_Iter, _Iter>);
template
concept __nothrow_forward_range
= (__nothrow_input_range<_Range>
&& __nothrow_forward_iterator>);
} // namespace __detail
struct __destroy_fn
{
template<__detail::__nothrow_input_iterator _Iter,
__detail::__nothrow_sentinel<_Iter> _Sent>
requires destructible>
constexpr _Iter
operator()(_Iter __first, _Sent __last) const noexcept;
template<__detail::__nothrow_input_range _Range>
requires destructible>
constexpr borrowed_iterator_t<_Range>
operator()(_Range&& __r) const noexcept;
};
inline constexpr __destroy_fn destroy{};
namespace __detail
{
template
requires destructible>
struct _DestroyGuard
{
private:
_Iter _M_first;
const _Iter* _M_cur;
public:
explicit
_DestroyGuard(const _Iter& __iter)
: _M_first(__iter), _M_cur(std::__addressof(__iter))
{ }
void
release() noexcept
{ _M_cur = nullptr; }
~_DestroyGuard()
{
if (_M_cur != nullptr)
ranges::destroy(std::move(_M_first), *_M_cur);
}
};
template
requires destructible>
&& is_trivially_destructible_v>
struct _DestroyGuard<_Iter>
{
explicit
_DestroyGuard(const _Iter&)
{ }
void
release() noexcept
{ }
};
} // namespace __detail
struct __uninitialized_default_construct_fn
{
template<__detail::__nothrow_forward_iterator _Iter,
__detail::__nothrow_sentinel<_Iter> _Sent>
requires default_initializable>
_Iter
operator()(_Iter __first, _Sent __last) const
{
using _ValueType = remove_reference_t>;
if constexpr (is_trivially_default_constructible_v<_ValueType>)
return ranges::next(__first, __last);
else
{
auto __guard = __detail::_DestroyGuard(__first);
for (; __first != __last; ++__first)
::new (__detail::__voidify(*__first)) _ValueType;
__guard.release();
return __first;
}
}
template<__detail::__nothrow_forward_range _Range>
requires default_initializable>
borrowed_iterator_t<_Range>
operator()(_Range&& __r) const
{
return (*this)(ranges::begin(__r), ranges::end(__r));
}
};
inline constexpr __uninitialized_default_construct_fn
uninitialized_default_construct{};
struct __uninitialized_default_construct_n_fn
{
template<__detail::__nothrow_forward_iterator _Iter>
requires default_initializable>
_Iter
operator()(_Iter __first, iter_difference_t<_Iter> __n) const
{
using _ValueType = remove_reference_t>;
if constexpr (is_trivially_default_constructible_v<_ValueType>)
return ranges::next(__first, __n);
else
{
auto __guard = __detail::_DestroyGuard(__first);
for (; __n > 0; ++__first, (void) --__n)
::new (__detail::__voidify(*__first)) _ValueType;
__guard.release();
return __first;
}
}
};
inline constexpr __uninitialized_default_construct_n_fn
uninitialized_default_construct_n;
struct __uninitialized_value_construct_fn
{
template<__detail::__nothrow_forward_iterator _Iter,
__detail::__nothrow_sentinel<_Iter> _Sent>
requires default_initializable>
_Iter
operator()(_Iter __first, _Sent __last) const
{
using _ValueType = remove_reference_t>;
if constexpr (is_trivial_v<_ValueType>
&& is_copy_assignable_v<_ValueType>)
return ranges::fill(__first, __last, _ValueType());
else
{
auto __guard = __detail::_DestroyGuard(__first);
for (; __first != __last; ++__first)
::new (__detail::__voidify(*__first)) _ValueType();
__guard.release();
return __first;
}
}
template<__detail::__nothrow_forward_range _Range>
requires default_initializable>
borrowed_iterator_t<_Range>
operator()(_Range&& __r) const
{
return (*this)(ranges::begin(__r), ranges::end(__r));
}
};
inline constexpr __uninitialized_value_construct_fn
uninitialized_value_construct{};
struct __uninitialized_value_construct_n_fn
{
template<__detail::__nothrow_forward_iterator _Iter>
requires default_initializable>
_Iter
operator()(_Iter __first, iter_difference_t<_Iter> __n) const
{
using _ValueType = remove_reference_t>;
if constexpr (is_trivial_v<_ValueType>
&& is_copy_assignable_v<_ValueType>)
return ranges::fill_n(__first, __n, _ValueType());
else
{
auto __guard = __detail::_DestroyGuard(__first);
for (; __n > 0; ++__first, (void) --__n)
::new (__detail::__voidify(*__first)) _ValueType();
__guard.release();
return __first;
}
}
};
inline constexpr __uninitialized_value_construct_n_fn
uninitialized_value_construct_n;
template
using uninitialized_copy_result = in_out_result<_Iter, _Out>;
struct __uninitialized_copy_fn
{
template _ISent,
__detail::__nothrow_forward_iterator _Out,
__detail::__nothrow_sentinel<_Out> _OSent>
requires constructible_from, iter_reference_t<_Iter>>
uninitialized_copy_result<_Iter, _Out>
operator()(_Iter __ifirst, _ISent __ilast,
_Out __ofirst, _OSent __olast) const
{
using _OutType = remove_reference_t>;
if constexpr (sized_sentinel_for<_ISent, _Iter>
&& sized_sentinel_for<_OSent, _Out>
&& is_trivial_v<_OutType>
&& is_nothrow_assignable_v<_OutType&,
iter_reference_t<_Iter>>)
{
auto __d1 = __ilast - __ifirst;
auto __d2 = __olast - __ofirst;
return ranges::copy_n(std::move(__ifirst), std::min(__d1, __d2),
__ofirst);
}
else
{
auto __guard = __detail::_DestroyGuard(__ofirst);
for (; __ifirst != __ilast && __ofirst != __olast;
++__ofirst, (void)++__ifirst)
::new (__detail::__voidify(*__ofirst)) _OutType(*__ifirst);
__guard.release();
return {std::move(__ifirst), __ofirst};
}
}
template
requires constructible_from,
range_reference_t<_IRange>>
uninitialized_copy_result,
borrowed_iterator_t<_ORange>>
operator()(_IRange&& __inr, _ORange&& __outr) const
{
return (*this)(ranges::begin(__inr), ranges::end(__inr),
ranges::begin(__outr), ranges::end(__outr));
}
};
inline constexpr __uninitialized_copy_fn uninitialized_copy{};
template
using uninitialized_copy_n_result = in_out_result<_Iter, _Out>;
struct __uninitialized_copy_n_fn
{
template _Sent>
requires constructible_from, iter_reference_t<_Iter>>
uninitialized_copy_n_result<_Iter, _Out>
operator()(_Iter __ifirst, iter_difference_t<_Iter> __n,
_Out __ofirst, _Sent __olast) const
{
using _OutType = remove_reference_t>;
if constexpr (sized_sentinel_for<_Sent, _Out>
&& is_trivial_v<_OutType>
&& is_nothrow_assignable_v<_OutType&,
iter_reference_t<_Iter>>)
{
auto __d = __olast - __ofirst;
return ranges::copy_n(std::move(__ifirst), std::min(__n, __d),
__ofirst);
}
else
{
auto __guard = __detail::_DestroyGuard(__ofirst);
for (; __n > 0 && __ofirst != __olast;
++__ofirst, (void)++__ifirst, (void)--__n)
::new (__detail::__voidify(*__ofirst)) _OutType(*__ifirst);
__guard.release();
return {std::move(__ifirst), __ofirst};
}
}
};
inline constexpr __uninitialized_copy_n_fn uninitialized_copy_n{};
template
using uninitialized_move_result = in_out_result<_Iter, _Out>;
struct __uninitialized_move_fn
{
template _ISent,
__detail::__nothrow_forward_iterator _Out,
__detail::__nothrow_sentinel<_Out> _OSent>
requires constructible_from,
iter_rvalue_reference_t<_Iter>>
uninitialized_move_result<_Iter, _Out>
operator()(_Iter __ifirst, _ISent __ilast,
_Out __ofirst, _OSent __olast) const
{
using _OutType = remove_reference_t>;
if constexpr (sized_sentinel_for<_ISent, _Iter>
&& sized_sentinel_for<_OSent, _Out>
&& is_trivial_v<_OutType>
&& is_nothrow_assignable_v<_OutType&,
iter_rvalue_reference_t<_Iter>>)
{
auto __d1 = __ilast - __ifirst;
auto __d2 = __olast - __ofirst;
auto [__in, __out]
= ranges::copy_n(std::make_move_iterator(std::move(__ifirst)),
std::min(__d1, __d2), __ofirst);
return {std::move(__in).base(), __out};
}
else
{
auto __guard = __detail::_DestroyGuard(__ofirst);
for (; __ifirst != __ilast && __ofirst != __olast;
++__ofirst, (void)++__ifirst)
::new (__detail::__voidify(*__ofirst))
_OutType(ranges::iter_move(__ifirst));
__guard.release();
return {std::move(__ifirst), __ofirst};
}
}
template
requires constructible_from,
range_rvalue_reference_t<_IRange>>
uninitialized_move_result,
borrowed_iterator_t<_ORange>>
operator()(_IRange&& __inr, _ORange&& __outr) const
{
return (*this)(ranges::begin(__inr), ranges::end(__inr),
ranges::begin(__outr), ranges::end(__outr));
}
};
inline constexpr __uninitialized_move_fn uninitialized_move{};
template
using uninitialized_move_n_result = in_out_result<_Iter, _Out>;
struct __uninitialized_move_n_fn
{
template _Sent>
requires constructible_from,
iter_rvalue_reference_t<_Iter>>
uninitialized_move_n_result<_Iter, _Out>
operator()(_Iter __ifirst, iter_difference_t<_Iter> __n,
_Out __ofirst, _Sent __olast) const
{
using _OutType = remove_reference_t>;
if constexpr (sized_sentinel_for<_Sent, _Out>
&& is_trivial_v<_OutType>
&& is_nothrow_assignable_v<_OutType&,
iter_rvalue_reference_t<_Iter>>)
{
auto __d = __olast - __ofirst;
auto [__in, __out]
= ranges::copy_n(std::make_move_iterator(std::move(__ifirst)),
std::min(__n, __d), __ofirst);
return {std::move(__in).base(), __out};
}
else
{
auto __guard = __detail::_DestroyGuard(__ofirst);
for (; __n > 0 && __ofirst != __olast;
++__ofirst, (void)++__ifirst, (void)--__n)
::new (__detail::__voidify(*__ofirst))
_OutType(ranges::iter_move(__ifirst));
__guard.release();
return {std::move(__ifirst), __ofirst};
}
}
};
inline constexpr __uninitialized_move_n_fn uninitialized_move_n{};
struct __uninitialized_fill_fn
{
template<__detail::__nothrow_forward_iterator _Iter,
__detail::__nothrow_sentinel<_Iter> _Sent, typename _Tp>
requires constructible_from, const _Tp&>
_Iter
operator()(_Iter __first, _Sent __last, const _Tp& __x) const
{
using _ValueType = remove_reference_t>;
if constexpr (is_trivial_v<_ValueType>
&& is_nothrow_assignable_v<_ValueType&, const _Tp&>)
return ranges::fill(__first, __last, __x);
else
{
auto __guard = __detail::_DestroyGuard(__first);
for (; __first != __last; ++__first)
::new (__detail::__voidify(*__first)) _ValueType(__x);
__guard.release();
return __first;
}
}
template<__detail::__nothrow_forward_range _Range, typename _Tp>
requires constructible_from, const _Tp&>
borrowed_iterator_t<_Range>
operator()(_Range&& __r, const _Tp& __x) const
{
return (*this)(ranges::begin(__r), ranges::end(__r), __x);
}
};
inline constexpr __uninitialized_fill_fn uninitialized_fill{};
struct __uninitialized_fill_n_fn
{
template<__detail::__nothrow_forward_iterator _Iter, typename _Tp>
requires constructible_from, const _Tp&>
_Iter
operator()(_Iter __first, iter_difference_t<_Iter> __n,
const _Tp& __x) const
{
using _ValueType = remove_reference_t>;
if constexpr (is_trivial_v<_ValueType>
&& is_nothrow_assignable_v<_ValueType&, const _Tp&>)
return ranges::fill_n(__first, __n, __x);
else
{
auto __guard = __detail::_DestroyGuard(__first);
for (; __n > 0; ++__first, (void)--__n)
::new (__detail::__voidify(*__first)) _ValueType(__x);
__guard.release();
return __first;
}
}
};
inline constexpr __uninitialized_fill_n_fn uninitialized_fill_n{};
struct __construct_at_fn
{
template
requires requires {
::new (std::declval()) _Tp(std::declval<_Args>()...);
}
constexpr _Tp*
operator()(_Tp* __location, _Args&&... __args) const
noexcept(noexcept(std::construct_at(__location,
std::forward<_Args>(__args)...)))
{
return std::construct_at(__location,
std::forward<_Args>(__args)...);
}
};
inline constexpr __construct_at_fn construct_at{};
struct __destroy_at_fn
{
template
constexpr void
operator()(_Tp* __location) const noexcept
{
if constexpr (is_array_v<_Tp>)
ranges::destroy(ranges::begin(*__location), ranges::end(*__location));
else
__location->~_Tp();
}
};
inline constexpr __destroy_at_fn destroy_at{};
template<__detail::__nothrow_input_iterator _Iter,
__detail::__nothrow_sentinel<_Iter> _Sent>
requires destructible>
constexpr _Iter
__destroy_fn::operator()(_Iter __first, _Sent __last) const noexcept
{
if constexpr (is_trivially_destructible_v>)
return ranges::next(std::move(__first), __last);
else
{
for (; __first != __last; ++__first)
ranges::destroy_at(std::__addressof(*__first));
return __first;
}
}
template<__detail::__nothrow_input_range _Range>
requires destructible>
constexpr borrowed_iterator_t<_Range>
__destroy_fn::operator()(_Range&& __r) const noexcept
{
return (*this)(ranges::begin(__r), ranges::end(__r));
}
struct __destroy_n_fn
{
template<__detail::__nothrow_input_iterator _Iter>
requires destructible>
constexpr _Iter
operator()(_Iter __first, iter_difference_t<_Iter> __n) const noexcept
{
if constexpr (is_trivially_destructible_v>)
return ranges::next(std::move(__first), __n);
else
{
for (; __n > 0; ++__first, (void)--__n)
ranges::destroy_at(std::__addressof(*__first));
return __first;
}
}
};
inline constexpr __destroy_n_fn destroy_n{};
}
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // concepts
#endif // C++20
#endif // _RANGES_UNINITIALIZED_H