functional/function.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_FUNCTIONAL_FUNCTION_HPP__
#define NEFORCE_CORE_FUNCTIONAL_FUNCTION_HPP__

 
#include <typeinfo>
#include "NeForce/core/exception/exception.hpp"
#include "NeForce/core/functional/invoke.hpp"
NEFORCE_BEGIN_NAMESPACE__


template <typename Sign>
class function;

NEFORCE_BEGIN_INNER__

enum class FUNCTION_OPERATE {
    GET_TYPE_INFO, 
    GET_PTR,       
    COPY_PTR,      
    DESTROY_PTR    
};
 

class __undefined_util;

union __nocopy_type {
    void* object_;
    const void* const_object_;
    void (*function_pointer_)();
    void (__undefined_util::*member_pointer_)();
};

union storage_data {
    storage_data() noexcept = default;
 
    NEFORCE_NODISCARD void* access() noexcept { return &data_[0]; }
    NEFORCE_NODISCARD const void* access() const noexcept { return &data_[0]; }
 
    template <typename T>
    NEFORCE_NODISCARD T& access() noexcept {
        return *static_cast<T*>(access());
    }
 
    template <typename T>
    NEFORCE_NODISCARD const T& access() const noexcept {
        return *static_cast<const T*>(access());
    }
 
    __nocopy_type unused_;               
    byte_t data_[sizeof(__nocopy_type)]; 
};

class __function_base {
public:
    static constexpr size_t max_size_ = sizeof(__nocopy_type);   
    static constexpr size_t max_align_ = alignof(__nocopy_type); 

    template <typename F>
    class __manager_base {
    protected:
        static constexpr bool stored_ = is_location_invariant_v<F> && sizeof(F) <= max_size_ &&
                                        alignof(F) <= max_align_ && max_align_ % alignof(F) == 0;
 
    private:
        template <typename U, bool = stored_>
        struct __get_pointer_impl;
 
        template <typename U>
        struct __get_pointer_impl<U, true> {
            static U* get(const storage_data& src) noexcept {
                const U& f = src.access<U>();
                return const_cast<U*>(_NEFORCE addressof(f));
            }
        };
 
        template <typename U>
        struct __get_pointer_impl<U, false> {
            static U* get(const storage_data& src) noexcept { return src.access<U*>(); }
        };
 
    protected:
        using storage_ = bool_constant<stored_>;
 
        static F* get_pointer(const storage_data& src) noexcept { return __get_pointer_impl<F>::get(src); }
 
    private:
        template <typename Fn>
        static void create(storage_data& data, Fn&& f, true_type /*unused*/) {
            ::new (data.access()) F(_NEFORCE forward<Fn>(f));
        }
        template <typename Fn>
        static void create(storage_data& data, Fn&& f, false_type /*unused*/) {
            data.access<F*>() = new F(_NEFORCE forward<Fn>(f));
        }
 
        static void destroy(storage_data& data, true_type /*unused*/) { data.access<F>().~F(); }
        static void destroy(storage_data& data, false_type /*unused*/) { delete data.access<F*>(); }
 
    public:
        static bool manage(storage_data& dest, const storage_data& src, const FUNCTION_OPERATE oper) {
            switch (oper) {
                case FUNCTION_OPERATE::GET_TYPE_INFO:
                    dest.access<const std::type_info*>() = &typeid(F);
                    break;
                case FUNCTION_OPERATE::GET_PTR:
                    dest.access<F*>() = __manager_base::get_pointer(src);
                    break;
                case FUNCTION_OPERATE::COPY_PTR:
                    __manager_base::init_func(dest, *const_cast<const F*>(__manager_base::get_pointer(src)));
                    break;
                case FUNCTION_OPERATE::DESTROY_PTR:
                    __manager_base::destroy(dest, storage_());
                    break;
            }
            return false;
        }
 
        template <typename Fn>
        static void init_func(storage_data& func,
                              Fn&& f) noexcept(conjunction_v<storage_, is_nothrow_constructible<F, Fn>>) {
            __manager_base::create(func, _NEFORCE forward<Fn>(f), storage_());
        }
 
        template <typename Sign>
        static bool not_empty_function(const _NEFORCE function<Sign>& f) noexcept {
            return static_cast<bool>(f);
        }
        template <typename T>
        static bool not_empty_function(T* fptr) noexcept {
            return fptr != nullptr;
        }
        template <typename Class, typename T>
        static bool not_empty_function(T Class::* mptr) noexcept {
            return mptr != nullptr;
        }
        template <typename T>
        static bool not_empty_function(const T& /*unused*/) noexcept {
            return true;
        }
    };
 
    using manage_type = bool (*)(storage_data&, const storage_data&, FUNCTION_OPERATE);
 
    storage_data func_{};
    manage_type manager_ = nullptr;
 
 
    __function_base() noexcept = default;
    ~__function_base() {
        if (manager_ != nullptr) {
            manager_(func_, func_, FUNCTION_OPERATE::DESTROY_PTR);
        }
    }
 
    NEFORCE_NODISCARD bool empty() const { return manager_ == nullptr; }
};

template <typename Sign, typename F>
class __function_manage_handler;
 
template <typename Res, typename F, typename... Args>
class __function_manage_handler<Res(Args...), F> : public __function_base::__manager_base<F> {
private:
    using base_type = __function_base::__manager_base<F>;
 
public:
    static bool manage(storage_data& dest, const storage_data& src, FUNCTION_OPERATE oper) {
        switch (oper) {
            case FUNCTION_OPERATE::GET_TYPE_INFO:
                dest.access<const std::type_info*>() = &typeid(F);
                break;
            case FUNCTION_OPERATE::GET_PTR:
                dest.access<F*>() = base_type::get_pointer(src);
                break;
            default:
                base_type::manage(dest, src, oper);
        }
        return false;
    }
 
    static Res invoke(const storage_data& f, Args... args) {
        return _NEFORCE invoke_r<Res>(*base_type::get_pointer(f), _NEFORCE forward<Args>(args)...);
    }
 
    template <typename Fn>
    static constexpr bool nothrow_init() noexcept {
        return conjunction_v<typename base_type::storage_, is_nothrow_constructible<F, Fn>>;
    }
};
 
template <>
class __function_manage_handler<void, void> {
public:
    static bool manage(storage_data& /*unused*/, const storage_data& /*unused*/, FUNCTION_OPERATE /*unused*/) {
        return false;
    }
};
 
template <typename Sign, typename F, bool Valid = is_object_v<F>>
struct __function_handler_dispatch : __function_manage_handler<Sign, remove_cv_t<F>> {};
 
template <typename Sign, typename F>
struct __function_handler_dispatch<Sign, F, false> : __function_manage_handler<void, void> {};
 
NEFORCE_END_INNER__

template <typename Res, typename... Args>
class function<Res(Args...)> : inner::__function_base {
private:
    using invoker_type = Res (*)(const inner::storage_data&, Args...); 
 
private:
    invoker_type invoker_ = nullptr; 
 
private:
    template <typename F, bool IsSelf = is_same_v<remove_cvref_t<F>, function>>
    using enable_decay_t = typename enable_if_t<!IsSelf, decay<F>>::type;
 
    template <typename F, typename = void>
    struct callable_t : false_type {};
 
    template <typename F>
    struct callable_t<
            F, enable_if_t<!is_same_v<remove_cvref_t<F>, function> && is_invocable_r_v<Res, decay_t<F>&, Args...>>>
    : true_type {};
 
    template <typename F>
    using handler_t = inner::__function_manage_handler<Res(Args...), decay_t<F>>;
 
    template <typename F, enable_if_t<is_object_v<F>, int> = 0>
    NEFORCE_ALWAYS_INLINE const F* __target_impl() const noexcept {
        if (manager_ == &inner::__function_handler_dispatch<Res(Args...), F>::manage) {
            inner::storage_data ptr{};
            manager_(ptr, func_, inner::FUNCTION_OPERATE::GET_PTR);
            return ptr.access<const F*>();
        }
        return nullptr;
    }
 
    template <typename F, enable_if_t<!is_object_v<F>, int> = 0>
    NEFORCE_ALWAYS_INLINE const F* __target_impl() const noexcept {
        return nullptr;
    }
 
public:
    using result_type = Res; 

    function(nullptr_t np = nullptr) noexcept :
    __function_base() {}

    function(const function& other) :
    __function_base() {
        if (static_cast<bool>(other)) {
            other.manager_(func_, other.func_, inner::FUNCTION_OPERATE::COPY_PTR);
            invoker_ = other.invoker_;
            manager_ = other.manager_;
        }
    }

    function(function&& other) noexcept :
    __function_base() {
        func_ = other.func_;
        manager_ = other.manager_;
        invoker_ = other.invoker_;
        other.manager_ = nullptr;
        other.invoker_ = nullptr;
    }

    template <typename F, enable_if_t<callable_t<F>::value, int> = 0>
    function(F&& callable) noexcept(handler_t<F>::template nothrow_init<F>()) :
    __function_base() {
        static_assert(is_copy_constructible_v<decay_t<F>> && is_constructible_v<decay_t<F>, F>,
                      "target of function must be constructible");
 
        using handler = handler_t<F>;
        if (handler::not_empty_function(callable)) {
            handler::init_func(func_, _NEFORCE forward<F>(callable));
            invoker_ = &handler::invoke;
            manager_ = &handler::manage;
        }
    }

    function& operator=(const function& other) {
        function(other).swap(*this);
        return *this;
    }

    function& operator=(function&& other) noexcept {
        function(_NEFORCE move(other)).swap(*this);
        return *this;
    }

    function& operator=(nullptr_t np) noexcept {
        if (manager_) {
            manager_(func_, func_, inner::FUNCTION_OPERATE::DESTROY_PTR);
            manager_ = nullptr;
            invoker_ = nullptr;
        }
        return *this;
    }

    template <typename F, enable_if_t<callable_t<F>::value, int> = 0>
    function& operator=(F&& callable) noexcept(handler_t<F>::template nothrow_init<F>()) {
        function(_NEFORCE forward<F>(callable)).swap(*this);
        return *this;
    }

    template <typename F>
    function& operator=(reference_wrapper<F> wrapper) noexcept {
        function(wrapper).swap(*this);
        return *this;
    }

    void swap(function& other) noexcept {
        _NEFORCE swap(func_, other.func_);
        _NEFORCE swap(manager_, other.manager_);
        _NEFORCE swap(invoker_, other.invoker_);
    }

    explicit operator bool() const noexcept { return !empty(); }

    Res operator()(Args... args) const {
        if (empty()) {
            NEFORCE_THROW_EXCEPTION(memory_exception("functional pointing to null."));
        }
        return invoker_(func_, _NEFORCE forward<Args>(args)...);
    }

    NEFORCE_NODISCARD const std::type_info& target_type() const noexcept {
        if (manager_) {
            inner::storage_data result{};
            manager_(result, func_, inner::FUNCTION_OPERATE::GET_TYPE_INFO);
            if (const auto* const info = result.access<const std::type_info*>()) {
                return *info;
            }
        }
        return typeid(void);
    }

    template <typename F>
    const F* target() const noexcept {
        return __target_impl<F>();
    }

    template <typename F>
    F* target() noexcept {
        const F* f = const_cast<const function*>(this)->target<F>();
        return const_cast<F*>(f);
    }
};
 
#ifdef NEFORCE_STANDARD_17
NEFORCE_BEGIN_INNER__
 
template <typename>
struct __function_guide_helper;
 
template <typename Result, typename Class, typename... Args>
struct __function_guide_helper<Result (Class::*)(Args...)> {
    using type = Result(Args...);
};
 
NEFORCE_END_INNER__
 
template <typename Res, typename... Args>
function(Res (*)(Args...)) -> function<Res(Args...)>;
 
template <typename Func, typename Sign = typename inner::__function_guide_helper<
                                 remove_function_qualifiers_t<decltype(&Func::operator())>>::type>
function(Func) -> function<Sign>;
 
#endif
 

template <typename Res, typename... Args>
bool operator==(const function<Res(Args...)>& f, nullptr_t np) noexcept {
    return !static_cast<bool>(f);
}

template <typename Res, typename... Args>
bool operator==(nullptr_t np, const function<Res(Args...)>& f) noexcept {
    return !static_cast<bool>(f);
}

template <typename Res, typename... Args>
bool operator!=(const function<Res(Args...)>& f, nullptr_t np) noexcept {
    return static_cast<bool>(f);
}

template <typename Res, typename... Args>
bool operator!=(nullptr_t np, const function<Res(Args...)>& f) noexcept {
    return static_cast<bool>(f);
}
 // FunctionWrapper
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_FUNCTIONAL_FUNCTION_HPP__