function.h

#pragma once
#include <functional>
#include <memory>
 
namespace coro {
 
 
 
template<typename Prototype, unsigned int reserved_space = 4*sizeof(void *)>
class function;
template<typename Prototype, bool nx, unsigned int reserved_space = 4*sizeof(void *)>
class function_impl;
 
 
template<typename T, typename RetVal, bool nx, typename ... Args>
concept IsFunctionConstructible = (nx?std::is_nothrow_invocable_r_v<RetVal,T, Args...>:std::is_invocable_r_v<RetVal, T, Args...>);
 
 
template<typename T, typename ToObj>
concept hasnt_cast_operator = !requires(T t) {
    {t.operator ToObj()};
};
 
 
 
 
template<typename RetVal, bool nx, typename ... Args, unsigned int reserved_space>
class function_impl<RetVal(Args...), nx, reserved_space> {
 
    /*
    +------------------+
    |    vtable +------|------->  dtor()
    +------------------+       |- call()
    |                  |       |- move()
    |    payload       |       |- valid()
    |                  |
    +------------------+
    */
 
 
    class Abstract {
    public:
        virtual ~Abstract() = default;
        virtual RetVal call(Args && ... args) = 0;
 
        virtual void move(void *address) = 0;
 
        virtual bool valid() const = 0;
    };
 
    template<typename Fn>
    class WrapFnSmall: public Abstract {
    public:
        template<std::convertible_to<Fn> Fun>
        WrapFnSmall(Fun &&fn):_fn(std::forward<Fun>(fn)) {}
 
        virtual RetVal call(Args && ... args) override {
            return _fn(std::forward<Args>(args)...);
        }
        virtual void move(void *address) override {
            //allocate at address and move
            new(address) WrapFnSmall(std::move(*this));
        }
        virtual bool valid() const override {return true;}
 
    protected:
        //function is allocated directly in the object
        Fn _fn;
    };
 
    template<typename Fn>
    class WrapFnLarge: public Abstract {
    public:
        template<std::convertible_to<Fn> Fun>
        WrapFnLarge(Fun &&fn):_fn(std::make_unique<Fn>(std::forward<Fun>(fn))) {}
 
        virtual RetVal call(Args && ... args) override {
            return (*_fn)(std::forward<Args>(args)...);
        }
        virtual void move(void *address) override {
            //allocate at address and move
            new(address) WrapFnLarge(std::move(*this));
        }
        virtual bool valid() const override {return true;}
 
    protected:
        //pointer is held to a function allocated on the heap
        std::unique_ptr<Fn> _fn;
    };
 
    template<typename Fn>
    class WrapFnPlacement: public Abstract {
    public:
        struct Deleter {
            void operator()(Fn *fn){std::destroy_at(fn);};
        };
 
        template<std::convertible_to<Fn> Fun>
        WrapFnPlacement(Fun &&fn, void *ptr):_fn(new(ptr) Fn(std::forward<Fun>(fn))) {}
 
        virtual RetVal call(Args && ... args) override {
            return (*_fn)(std::forward<Args>(args)...);
        }
        virtual void move(void *address) override {
            //allocate at address and move
            new(address) WrapFnPlacement(std::move(*this));
        }
        virtual bool valid() const override {return true;}
 
    protected:
        //pointer is held to a function allocated on the heap
        std::unique_ptr<Fn, Deleter> _fn;
    };
 
 
    class InvalidFn: public Abstract {
    public:
        virtual RetVal call(Args &&... ) override {
            throw std::bad_function_call();
        }
        virtual void move(void *address) override {
            new(address) InvalidFn(std::move(*this));
        }
        virtual bool valid() const override {return false;}
    };
 
    struct TestCallable {
        RetVal operator()(Args ...) noexcept(nx);
    };
 
public:
    static_assert(IsFunctionConstructible<TestCallable, RetVal, nx, Args ...>);
    static_assert(sizeof(WrapFnLarge<TestCallable>) <= reserved_space, "Reserved space is too small");
 
    function_impl() {
        //allocate object in reserved space
        new(_reserved) InvalidFn();
    }
 
    template<IsFunctionConstructible<RetVal, nx, Args...> Fn>
    function_impl(Fn &&fn) {
        using Small = WrapFnSmall<std::decay_t<Fn> >;
        using Large = WrapFnLarge<std::decay_t<Fn> >;
        if constexpr(sizeof(Small) <= reserved_space) {
            //allocate object in reserved space
            new(_reserved) Small(std::forward<Fn>(fn));
        } else {
            //allocate object in reserved space
            new(_reserved) Large(std::forward<Fn>(fn));
        }
    }
 
 
    template<IsFunctionConstructible<RetVal, nx, Args...> Fn>
    function_impl(void *ptr, Fn &&fn) {
        new(_reserved) WrapFnPlacement<std::decay_t<Fn> >(std::forward<Fn>(fn), ptr);
    }
 
 
    function_impl(function_impl &&other) {
        //move to current reserved space
        other.ref().move(_reserved);
    }
    ~function_impl() {
        destroy();
    }
 
    function_impl &operator=(function_impl &&other) {
        if (this != &other) {
            destroy();
            //move to current reserved space
            other.ref().move(_reserved);
        }
        return *this;
    }
 
 
    function_impl &operator=(std::nullptr_t) {
        if (*this) {
            destroy();
            new(_reserved) InvalidFn();
        }
        return *this;
    }
 
    RetVal operator()(Args  ... args) noexcept(nx) {
        return ref().call(std::forward<Args>(args)...);
    }
 
 
    explicit operator bool() const {
        return ref().valid();
    }
 
    static constexpr bool is_noexcept = nx;
    using value_type = RetVal;
 
 
protected:
 
    char _reserved[reserved_space];
 
    Abstract &ref() {return *reinterpret_cast<Abstract *>(_reserved);}
    const Abstract &ref() const {return *reinterpret_cast<const Abstract *>(_reserved);}
 
    void destroy() {
        //direct call of the destructor
        ref().~Abstract();
    }
 
};
 
 
template<typename RetVal, typename ... Args, unsigned int reserved_space>
class function<RetVal(Args...) noexcept(false), reserved_space>: public function_impl<RetVal(Args...), false, reserved_space> {
public:
    using function_impl<RetVal(Args...), false, reserved_space>::function_impl;
};
 
template<typename RetVal, typename ... Args, unsigned int reserved_space>
class function<RetVal(Args...) noexcept(true), reserved_space>: public function_impl<RetVal(Args...), true, reserved_space> {
public:
    using function_impl<RetVal(Args...), true, reserved_space>::function_impl;
};
 
 
 
 
template<unsigned int reserved_space = 4*sizeof(void *)>
class any {
public:
 
    struct content {
        const std::type_info &type;
        void *ptr;
        std::size_t size;
    };
 
 
    template<hasnt_cast_operator<any> Arg>
    any(Arg &&arg):_storage([v = Arg(std::forward<Arg>(arg))]()mutable -> content{
        return {
            typeid(v),
            &v,
            sizeof(v)
        };
    }) {}
 
 
    any():_storage([]()mutable->content{
        return {typeid(nullptr),nullptr,0};
    }) {}
 
 
    const content get_info() const {
        return _storage();
    }
 
    content get_info() {
        return _storage();
    }
 
 
    template<typename T>
    const T *get_ptr() const noexcept {
        auto ctx = get_info();
        if (ctx.type != typeid(T)) return nullptr;
        return reinterpret_cast<const T *>(ctx.ptr);
    }
 
    template<typename T>
    T *get_ptr() noexcept  {
        auto ctx = get_info();
        if (ctx.type != typeid(T)) return nullptr;
        return reinterpret_cast<T *>(ctx.ptr);
    }
 
 
    template<typename T>
    const T &get() const {
        auto ptr = get_ptr<T>();
        if (ptr == nullptr) throw std::bad_cast();
        return *ptr;
    }
 
    template<typename T>
    T &get()  {
        auto ptr = get_ptr<T>();
        if (ptr == nullptr) throw std::bad_cast();
        return *ptr;
    }
 
 
    bool empty() const noexcept {
        return get_info().ptr == nullptr;
    }
 
 
    operator bool() const noexcept {
        return get_info().ptr != nullptr;
    }
 
 
    template<typename T>
    bool contains() const noexcept {
        return  get_info().type ==  typeid(T);
    }
 
protected:
    mutable function<content()> _storage;
};
 
 
}