function.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CORE_FUNCTION_HPP
#define JOIN_CORE_FUNCTION_HPP
 
// C++.
#include <type_traits>
#include <functional>
#include <utility>
#include <new>
 
// C.
#include <cstddef>
#include <cstring>
 
namespace join
{
    template <typename Signature, std::size_t Capacity = 32, std::size_t Alignment = alignof (std::max_align_t)>
    class Function;
 
    template <typename Return, typename... Args, std::size_t Capacity, std::size_t Alignment>
    class Function<Return (Args...), Capacity, Alignment>
    {
    public:
        Function () noexcept = default;
 
        Function (const Function& other) = delete;
 
        Function& operator= (const Function& other) = delete;
 
        Function (Function&& other) noexcept
        {
            moveFrom (std::move (other));
        }
 
        Function& operator= (Function&& other) noexcept
        {
            clear ();
            moveFrom (std::move (other));
            return *this;
        }
 
        Function (std::nullptr_t) noexcept
        : Function ()
        {
        }
 
        Function& operator= (std::nullptr_t) noexcept
        {
            clear ();
            return *this;
        }
 
        template <typename Func, typename DecayedFunc = std::decay_t<Func>>
        Function (Func&& callable)
            requires (!std::is_same_v<DecayedFunc, Function>) && std::is_invocable_r_v<Return, DecayedFunc&, Args...>
        {
            static_assert (sizeof (DecayedFunc) <= Capacity, "Callable size exceeds Function capacity.");
            static_assert (alignof (DecayedFunc) <= Alignment, "Callable alignment exceeds Function alignment.");
            static_assert (std::is_nothrow_move_constructible_v<DecayedFunc>,
                           "Callable must be nothrow move constructible.");
 
            new (&_storage) DecayedFunc (std::forward<Func> (callable));
 
            _invoker = [] (void* storage, Args&&... args) -> Return {
                return static_cast<Return> ((*static_cast<DecayedFunc*> (storage)) (std::forward<Args> (args)...));
            };
 
            _manager = nullptr;
            _destructor = nullptr;
 
            if constexpr (!std::is_trivially_copyable_v<DecayedFunc>)
            {
                _manager = [] (void* dst, void* src) noexcept {
                    DecayedFunc* source = static_cast<DecayedFunc*> (src);
                    new (dst) DecayedFunc (std::move (*source));
                    source->~DecayedFunc ();
                };
            }
 
            if constexpr (!std::is_trivially_destructible_v<DecayedFunc>)
            {
                _destructor = [] (void* storage) noexcept {
                    static_cast<DecayedFunc*> (storage)->~DecayedFunc ();
                };
            }
 
            // an empty target holds no state, so relocating it copies nothing at all and never
            // reads the storage, which is left uninitialized by the placement new above.
            _size = std::is_empty_v<DecayedFunc> ? 0 : sizeof (DecayedFunc);
        }
 
        ~Function ()
        {
            clear ();
        }
 
        Return operator() (Args... args) const
        {
            if (!_invoker)
            {
                throw std::bad_function_call ();
            }
            return _invoker (&_storage, std::forward<Args> (args)...);
        }
 
        explicit operator bool () const noexcept
        {
            return _invoker != nullptr;
        }
 
        void reset () noexcept
        {
            clear ();
        }
 
        void swap (Function& other) noexcept
        {
            Function tmp (std::move (other));
            other = std::move (*this);
            *this = std::move (tmp);
        }
 
    private:
        using InvokerFunc = Return (*) (void*, Args&&...);
 
        using ManagerFunc = void (*) (void*, void*);
 
        using DestructorFunc = void (*) (void*);
 
        void clear () noexcept
        {
            if (_invoker == nullptr)
            {
                return;
            }
 
            if (_destructor)
            {
                _destructor (&_storage);
            }
 
            _invoker = nullptr;
            _manager = nullptr;
            _destructor = nullptr;
            _size = 0;
        }
 
        void moveFrom (Function&& other) noexcept
        {
            _invoker = other._invoker;
            _manager = other._manager;
            _destructor = other._destructor;
            _size = other._size;
 
            if (_invoker == nullptr)
            {
                return;
            }
 
            if (_manager)
            {
                _manager (&_storage, &other._storage);
            }
            else
            {
                std::memcpy (&_storage, &other._storage, _size);
            }
 
            other._invoker = nullptr;
            other._manager = nullptr;
            other._destructor = nullptr;
            other._size = 0;
        }
 
        alignas (Alignment) mutable unsigned char _storage[Capacity];
 
        InvokerFunc _invoker = nullptr;
 
        ManagerFunc _manager = nullptr;
 
        DestructorFunc _destructor = nullptr;
 
        std::size_t _size = 0;
    };
}
 
#endif