+ const static TaskVtable vtable {
+ // Call:
+ [](TaskUnion& buffer, Args... args) {
+ auto* src = reinterpret_cast<F*>(&buffer);
+ F code = std::move(*src);
+ src->~F();
+ // NOTE: std::forward<Args>(args)... is correct.
+ return code(std::forward<Args>(args)...);
+ },
+ // Destroy:
+ std::is_trivially_destructible_v<F> ?
+ static_cast<destroy_function>(nullptr) :
+ [](TaskUnion& buffer) {
+ auto* code = reinterpret_cast<F*>(&buffer);
+ code->~F();
+ },
+ // Move:
+ [](TaskUnion& dst, TaskUnion& src) {
+ auto* src_code = reinterpret_cast<F*>(&src);
+ auto* dst_code = reinterpret_cast<F*>(&dst);
+ new(dst_code) F(std::move(*src_code));
+ src_code->~F();
+ }
+ };
+ new (&buffer_) F(std::move(task_code));
+ vtable_ = &vtable;
+ }
+
+ template <class F> typename std::enable_if_t<not canSBO<F>()> init(F task_code)
+ {
+ const static TaskVtable vtable {
+ // Call:
+ [](TaskUnion& buffer, Args... args) {
+ // Delete F when we go out of scope:
+ std::unique_ptr<F> code(*reinterpret_cast<F**>(&buffer));
+ // NOTE: std::forward<Args>(args)... is correct.
+ return (*code)(std::forward<Args>(args)...);
+ },
+ // Destroy:
+ [](TaskUnion& buffer) {
+ F* code = *reinterpret_cast<F**>(&buffer);
+ delete code;
+ },
+ // Move:
+ nullptr
+ };
+ *reinterpret_cast<F**>(&buffer_) = new F(std::move(task_code));
+ vtable_ = &vtable;
+ }
+
+public:
+ template <class F> explicit Task(F code) { this->init(std::move(code)); }
+
+ operator bool() const { return vtable_ != nullptr; }
+ bool operator!() const { return vtable_ == nullptr; }
+
+ R operator()(Args... args)
+ {
+ if (vtable_ == nullptr)
+ throw std::bad_function_call();
+ const TaskVtable* vtable = vtable_;
+ vtable_ = nullptr;
+ // NOTE: std::forward<Args>(args)... is correct.
+ // see C++ [func.wrap.func.inv] for an example
+ return vtable->call(buffer_, std::forward<Args>(args)...);