task.hpp

Go to the documentation of this file.

#pragma once
 
#include <functional>
#include <future>
#include <vector>
 
class ITask {
public:
    virtual ~ITask() = default;
 
    virtual void execute() = 0;
 
private:
    std::vector<ITask*> _dependents{};
    int _dependencies{ 0 };
 
    friend class Exkit;
};
 
template <typename ResultType>
class Task : public ITask {
public:
    explicit Task(std::function<ResultType()> function);
 
    void execute() override;
 
    ResultType get();
 
private:
    std::function<ResultType()> _function;
    std::promise<ResultType> _promise;
    std::shared_future<ResultType> _future;
 
    friend class Exkit;
};
 
template <typename ResultType>
class TaskHandle {
public:
    explicit TaskHandle(Task<ResultType>* task);
 
    ResultType get() const;
 
private:
    Task<ResultType>* _task;
 
    friend class Exkit;
};
 
// ------------------------- Implementation of template methods -------------------------
 
template <typename ResultType>
auto dependency_value(TaskHandle<ResultType> const& handle) {
    if constexpr (std::is_void_v<ResultType>) {
        handle.get();
        return std::tuple<>{};
    } else {
        return std::tuple{ handle.get() };
    }
}
 
template <typename... ResultTypes>
auto dependency_values(TaskHandle<ResultTypes> const&... deps) {
    return std::tuple_cat(dependency_value(deps)...);
}
 
template <typename ResultType>
Task<ResultType>::Task(std::function<ResultType()> function) : _function(std::move(function)), _future(_promise.get_future().share()) {}
 
template <typename ResultType>
void Task<ResultType>::execute() {
    try {
        if constexpr (std::is_void_v<ResultType>) {
            _function();
            _promise.set_value();
        } else {
            ResultType result = _function();
            _promise.set_value(result);
        }
    } catch (...) {
        _promise.set_exception(std::current_exception());
    }
}
 
template <typename ResultType>
ResultType Task<ResultType>::get() {
    if constexpr (std::is_void_v<ResultType>) {
        _future.get();
    } else {
        return _future.get();
    }
}
 
template <typename ResultType>
TaskHandle<ResultType>::TaskHandle(Task<ResultType>* task) : _task(task) {}
 
template <typename ResultType>
ResultType TaskHandle<ResultType>::get() const {
    return _task->get();
}