placement.hpp

Go to the documentation of this file.

#ifndef VEG_PLACEMENT_HPP_LP0HMLTPS
#define VEG_PLACEMENT_HPP_LP0HMLTPS

#include "proxsuite/linalg/veg/type_traits/constructible.hpp"
#include "proxsuite/linalg/veg/internal/std.hpp"
#include "proxsuite/linalg/veg/type_traits/invocable.hpp"
#include "proxsuite/linalg/veg/memory/address.hpp"
#include "proxsuite/linalg/veg/internal/prologue.hpp"
#include <new>

#if defined(VEG_WITH_CXX20_SUPPORT) && !VEG_HAS_BUILTIN(__builtin_bit_cast)
#include <bit>
#define VEG_HAS_BITCAST 1
#define VEG_BITCAST(T, x) ::std::bit_cast<T>(x)
#define VEG_BITCAST_CONSTEXPR constexpr
#elif VEG_HAS_BUILTIN(__builtin_bit_cast)
#define VEG_HAS_BITCAST 1
#define VEG_BITCAST(T, x) __builtin_bit_cast(T, x)
#define VEG_BITCAST_CONSTEXPR constexpr
#else
#include <cstring>
#define VEG_HAS_BITCAST 0
#define VEG_BITCAST_CONSTEXPR
#endif

// construct_at
#if defined(VEG_WITH_CXX20_SUPPORT)

// std::construct_at
#if __VEG_HAS_INCLUDE(<bits / stl_construct.h>) && \
 __VEG_HAS_INCLUDE(<bits / stl_iterator_base_types.h>) && \
 __VEG_HAS_INCLUDE(<bits / stl_iterator_base_funcs.h>)
#include <bits/stl_iterator_base_types.h>
#include <bits/stl_iterator_base_funcs.h>
#include <bits/stl_construct.h>
#else
#include <memory>
#endif

#endif

#if VEG_HAS_BUILTIN(__builtin_launder) || __GNUC__ >= 7
#define VEG_LAUNDER(p) (__builtin_launder(p))
#elif defined(VEG_WITH_CXX17_SUPPORT) && __GNUC__ >= 6
#include <new>
#define VEG_LAUNDER(p) (::std::launder(p))
#else
#define VEG_LAUNDER(p) (+p)
#endif

namespace proxsuite {
namespace linalg {
namespace veg {
namespace mem {
namespace nb {
struct launder
{
 VEG_TEMPLATE(typename T,
 requires(VEG_CONCEPT(complete<T>)),
 VEG_INLINE constexpr auto
 operator(),
 (mem, T*))
 const VEG_NOEXCEPT->T* { return VEG_LAUNDER(mem); }
};
#undef VEG_LAUNDER

struct construct_at
{
 VEG_TEMPLATE((typename T, typename... Args),
 requires(!VEG_CONCEPT(const_type<T>) &&
 VEG_CONCEPT(inplace_constructible<T, Args...>)),
 VEG_INLINE VEG_CPP20(constexpr) auto
 operator(),
 (mem, T*),
 (... args, Args&&))
 const VEG_NOEXCEPT_IF(VEG_CONCEPT(nothrow_inplace_constructible<T, Args...>))
 ->T*
 {
#if defined(VEG_WITH_CXX20_SUPPORT)
 return ::std::construct_at(mem, VEG_FWD(args)...);
#else
 return ::new (mem) T(VEG_FWD(args)...);
#endif
 }
};

struct construct_with
{
 VEG_TEMPLATE((typename T, typename Fn),
 requires(!VEG_CONCEPT(const_type<T>) &&
 VEG_CONCEPT(fn_once<Fn, T>)),
 VEG_INLINE VEG_CPP20(constexpr) auto
 operator(),
 (mem, T*),
 (fn, Fn&&))
 const VEG_NOEXCEPT_IF(VEG_CONCEPT(nothrow_fn_once<Fn, T>))->T*
 {
#if defined(VEG_WITH_CXX20_SUPPORT)
 struct Convertor
 {
 Fn&& fn;
 VEG_INLINE constexpr operator T() const&& VEG_NOEXCEPT_IF(
 VEG_CONCEPT(nothrow_fn_once<Fn, T>))
 {
 return VEG_FWD(fn)();
 }
 };

 return ::std::construct_at(mem, Convertor{ VEG_FWD(fn) });
#else
 return ::new (mem) T(VEG_FWD(fn)());
#endif
 }
};

struct destroy_at
{
 VEG_TEMPLATE((typename T),
 requires(VEG_CONCEPT(complete<T>)),
 VEG_INLINE VEG_CPP14(constexpr) void
 operator(),
 (mem, T*))
 const VEG_NOEXCEPT_IF(VEG_CONCEPT(nothrow_destructible<T>)) { mem->~T(); }
};
struct align_next
{
 auto operator()(usize alignment, void* ptr) const VEG_NOEXCEPT->void*
 {
 using byte_ptr = unsigned char*;
 std::uintptr_t lo_mask = alignment - 1U;
 std::uintptr_t hi_mask = ~lo_mask;
 auto const intptr = reinterpret_cast<std::uintptr_t>(ptr);
 auto* const byteptr = static_cast<byte_ptr>(ptr);
 auto offset = ((intptr + alignment - 1U) & hi_mask) - intptr;

 return byteptr + offset;
 }
 auto operator()(usize alignment,
 void const* ptr) const VEG_NOEXCEPT->void const*
 {
 return this->operator()(alignment, const_cast<void*>(ptr));
 }
};
struct align_prev
{
 auto operator()(usize alignment, void* ptr) const VEG_NOEXCEPT->void*
 {
 using byte_ptr = unsigned char*;
 std::uintptr_t lo_mask = alignment - 1U;
 std::uintptr_t hi_mask = ~lo_mask;
 auto const intptr = reinterpret_cast<std::uintptr_t>(ptr);
 auto* const byteptr = static_cast<byte_ptr>(ptr);
 auto offset = ((intptr)&hi_mask) - intptr;

 return byteptr + offset;
 }
 auto operator()(usize alignment,
 void const* ptr) const VEG_NOEXCEPT->void const*
 {
 return this->operator()(alignment, const_cast<void*>(ptr));
 }
};
} // namespace nb
VEG_NIEBLOID(align_next);
VEG_NIEBLOID(align_prev);
VEG_NIEBLOID(launder);
VEG_NIEBLOID(construct_at);
VEG_NIEBLOID(construct_with);
VEG_NIEBLOID(destroy_at);

namespace nb {
template<typename To>
struct bit_cast
{
 VEG_TEMPLATE(typename From,
 requires((VEG_CONCEPT(trivially_copyable<From>) && //
 VEG_CONCEPT(trivially_copyable<To>) && //
 (sizeof(From) == sizeof(To)))),
 VEG_INLINE VEG_BITCAST_CONSTEXPR auto
 operator(),
 (from, From const&))
 const VEG_NOEXCEPT->To
 {
#if VEG_HAS_BITCAST
 return VEG_BITCAST(To, from);
#else
 alignas(To) unsigned char buf[sizeof(To)];
 To* ptr = reinterpret_cast<To*>(static_cast<unsigned char*>(buf));
 ::std::memcpy(ptr, nb::addressof{}(from), sizeof(To));
 return To(static_cast<To&&>(*nb::launder{}(ptr)));
#endif
 }
};
} // namespace nb
VEG_NIEBLOID_TEMPLATE(typename To, bit_cast, To);
} // namespace mem
} // namespace veg
} // namespace linalg
} // namespace proxsuite

#include "proxsuite/linalg/veg/internal/epilogue.hpp"
#endif /* end of include guard VEG_PLACEMENT_HPP_LP0HMLTPS */