function.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <functional>
#include <type_traits>
#include <utility>
#include <promeki/namespace.h>
 
PROMEKI_NAMESPACE_BEGIN
 
template <typename Sig> class Function;
 
template <typename R, typename... Args> class Function<R(Args...)> {
        public:
                using DataType = std::function<R(Args...)>;
 
                using ResultType = R;
 
                Function() = default;
 
                Function(std::nullptr_t) noexcept {}
 
                template <typename F,
                          typename = std::enable_if_t<!std::is_same_v<std::decay_t<F>, Function> &&
                                                      std::is_invocable_r_v<R, F &, Args...>>>
                Function(F &&f) : d(std::forward<F>(f)) {}
 
                Function(const DataType &f) : d(f) {}
 
                Function(DataType &&f) noexcept : d(std::move(f)) {}
 
                Function(const Function &other) = default;
 
                Function(Function &&other) noexcept = default;
 
                ~Function() = default;
 
                Function &operator=(const Function &other) = default;
 
                Function &operator=(Function &&other) noexcept = default;
 
                Function &operator=(std::nullptr_t) noexcept {
                        d = nullptr;
                        return *this;
                }
 
                template <typename F,
                          typename = std::enable_if_t<!std::is_same_v<std::decay_t<F>, Function> &&
                                                      std::is_invocable_r_v<R, F &, Args...>>>
                Function &operator=(F &&f) {
                        d = std::forward<F>(f);
                        return *this;
                }
 
                R operator()(Args... args) const { return d(std::forward<Args>(args)...); }
 
                explicit operator bool() const noexcept { return static_cast<bool>(d); }
 
                bool isNull() const noexcept { return !d; }
 
                void clear() noexcept { d = nullptr; }
 
                void swap(Function &other) noexcept { d.swap(other.d); }
 
                const DataType &toStdFunction() const noexcept { return d; }
 
                DataType &toStdFunction() noexcept { return d; }
 
                friend bool operator==(const Function &f, std::nullptr_t) noexcept { return !f.d; }
 
                friend bool operator==(std::nullptr_t, const Function &f) noexcept { return !f.d; }
 
                friend bool operator!=(const Function &f, std::nullptr_t) noexcept { return static_cast<bool>(f.d); }
 
                friend bool operator!=(std::nullptr_t, const Function &f) noexcept { return static_cast<bool>(f.d); }
 
        private:
                DataType d;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE