construct.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_MEMORY_CONSTRUCT_HPP__
#define NEFORCE_CORE_MEMORY_CONSTRUCT_HPP__

 
#include "NeForce/core/typeinfo/concepts.hpp"
NEFORCE_BEGIN_NAMESPACE__


template <typename T, typename... Args>
NEFORCE_CONSTEXPR20 T* construct(T* ptr, Args&&... args) noexcept(is_nothrow_constructible_v<T, Args...>) {
    static_assert(is_constructible_v<T, Args...>, "T must be constructible with arguments");
    return static_cast<T*>(new (static_cast<void*>(ptr)) T(_NEFORCE forward<Args>(args)...));
}

template <typename T>
NEFORCE_CONSTEXPR20 void destroy(T* pointer) noexcept(is_nothrow_destructible_v<T>) {
    pointer->~T();
}

template <typename Iterator>
NEFORCE_CONSTEXPR20 enable_if_t<is_iter_v<Iterator> && !is_trivially_destructible_v<iter_value_t<Iterator>>>
destroy(Iterator first, Iterator last) noexcept(is_nothrow_destructible_v<iter_value_t<Iterator>>) {
    for (; first < last; ++first) {
        _NEFORCE destroy(&*first);
    }
    return;
}

template <typename Iterator>
NEFORCE_CONSTEXPR20 enable_if_t<is_iter_v<Iterator> && is_trivially_destructible_v<iter_value_t<Iterator>>>
destroy(Iterator first, Iterator last) noexcept {
    return;
}
 
 
template <typename T>
struct temporary_guard {
    static_assert(is_nothrow_move_constructible_v<T>, "T must be nothrow move constructible");
 
private:
    T* guarded_ptr;
    T temp;
 
public:
    constexpr explicit temporary_guard(T& value) :
    guarded_ptr(_NEFORCE addressof(value)),
    temp(_NEFORCE move(value)) {
        _NEFORCE destroy(guarded_ptr);
    }
 
    NEFORCE_CONSTEXPR20 ~temporary_guard() {
        if (guarded_ptr) {
            _NEFORCE construct(guarded_ptr, _NEFORCE move(temp));
        }
    }
 
    temporary_guard(const temporary_guard&) = delete;
    temporary_guard& operator=(const temporary_guard&) = delete;
 
    constexpr T&& release() noexcept {
        guarded_ptr = nullptr;
        return _NEFORCE move(temp);
    }
};
 
template <typename NT, typename OT, typename Arg>
constexpr enable_if_t<is_nothrow_constructible_v<NT, Arg>>
reinitialize(NT* new_val, OT* old_val, Arg&& arg) noexcept(is_nothrow_constructible_v<NT, Arg>) {
    _NEFORCE destroy(old_val);
    _NEFORCE construct(new_val, _NEFORCE forward<Arg>(arg));
    return;
}
 
template <typename NT, typename OT, typename Arg>
constexpr enable_if_t<!is_nothrow_constructible_v<NT, Arg> && is_nothrow_move_constructible_v<NT>>
reinitialize(NT* new_val, OT* old_val, Arg&& arg) noexcept(is_nothrow_constructible_v<NT, Arg>) {
    NT temp(_NEFORCE forward<Arg>(arg));
    _NEFORCE destroy(old_val);
    _NEFORCE construct(new_val, _NEFORCE move(temp));
    return;
}
 
template <typename NT, typename OT, typename Arg>
constexpr enable_if_t<!is_nothrow_constructible_v<NT, Arg> && !is_nothrow_move_constructible_v<NT>>
reinitialize(NT* new_val, OT* old_val, Arg&& arg) noexcept(is_nothrow_constructible_v<NT, Arg>) {
    temporary_guard<OT> guard(*old_val);
    _NEFORCE construct(new_val, _NEFORCE forward<Arg>(arg));
    guard.release();
    return;
}
 // InplaceMemoryFunction
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_MEMORY_CONSTRUCT_HPP__