task.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <threadman/display.hpp>
#include <threadman/stats.hpp>
 
#include <commons/display_info.hpp>
 
#include <atomic>
#include <chrono>
#include <cstdint>
#include <exception>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <utility>
 
namespace threadman {
 
class TaskHandle {
public:
    struct State {
        std::uint64_t id = 0;
        std::optional<std::string> name;
        std::uint64_t pool_id = 0;
        std::atomic<TaskState> state{TaskState::Queued};
        std::chrono::steady_clock::time_point created_at{std::chrono::steady_clock::now()};
        std::optional<std::chrono::steady_clock::time_point> started_at;
        std::optional<std::chrono::steady_clock::time_point> finished_at;
        std::exception_ptr exception;
        mutable std::mutex mtx;  // guards optionals + exception
    };
 
    explicit TaskHandle(const std::uint64_t id,
                        const std::uint64_t pool_id,
                        std::optional<std::string> name = std::nullopt)
        : state_(std::make_shared<State>()) {
        state_->id = id;
        state_->pool_id = pool_id;
        state_->name = std::move(name);
    }
 
    TaskHandle() = default;
    TaskHandle(const TaskHandle&) = default;
    TaskHandle(TaskHandle&&) noexcept = default;
    TaskHandle& operator=(const TaskHandle&) = default;
    TaskHandle& operator=(TaskHandle&&) noexcept = default;
    ~TaskHandle() = default;
 
    [[nodiscard]] bool valid() const noexcept {
        return static_cast<bool>(state_);
    }
 
    [[nodiscard]] std::uint64_t id() const noexcept {
        return state_ ? state_->id : 0;
    }
    [[nodiscard]] std::uint64_t pool_id() const noexcept {
        return state_ ? state_->pool_id : 0;
    }
    [[nodiscard]] TaskState state() const noexcept {
        return state_ ? state_->state.load(std::memory_order_acquire) : TaskState::Cancelled;
    }
    [[nodiscard]] std::optional<std::string> name() const {
        if (!state_) {
            return std::nullopt;
        }
        std::scoped_lock guard(state_->mtx);
        return state_->name;
    }
 
    [[nodiscard]] std::shared_ptr<State> raw() const noexcept {
        return state_;
    }
 
    void mark_running() const {
        if (!state_) {
            return;
        }
        {
            const auto now = std::chrono::steady_clock::now();
            std::scoped_lock guard(state_->mtx);
            state_->started_at = now;
        }
        state_->state.store(TaskState::Running, std::memory_order_release);
    }
 
    void mark_completed() const {
        if (!state_) {
            return;
        }
        {
            const auto now = std::chrono::steady_clock::now();
            std::scoped_lock guard(state_->mtx);
            state_->finished_at = now;
        }
        state_->state.store(TaskState::Completed, std::memory_order_release);
    }
 
    void mark_failed(const std::exception_ptr& ex) const {
        if (!state_) {
            return;
        }
        {
            const auto now = std::chrono::steady_clock::now();
            std::scoped_lock guard(state_->mtx);
            state_->finished_at = now;
            state_->exception = ex;
        }
        state_->state.store(TaskState::Failed, std::memory_order_release);
    }
 
    void mark_cancelled(const std::exception_ptr& ex = nullptr) const {
        if (!state_) {
            return;
        }
        {
            const auto now = std::chrono::steady_clock::now();
            std::scoped_lock guard(state_->mtx);
            state_->finished_at = now;
            if (ex) {
                state_->exception = ex;
            }
        }
        state_->state.store(TaskState::Cancelled, std::memory_order_release);
    }
 
    [[nodiscard]] TaskSnapshot snapshot() const {
        TaskSnapshot snap;
        if (!state_) {
            return snap;
        }
        snap.id = state_->id;
        snap.pool_id = state_->pool_id;
        snap.state = state_->state.load(std::memory_order_acquire);
        snap.failed = (snap.state == TaskState::Failed);
        std::scoped_lock guard(state_->mtx);
        snap.name = state_->name;
        snap.created_at = state_->created_at;
        snap.started_at = state_->started_at;
        snap.finished_at = state_->finished_at;
        return snap;
    }
 
    [[nodiscard]] static const comms::DisplayInfo& display_info() {
        static const comms::DisplayInfo info{
            .name = "TaskHandle",
            .description = "Handle to a single task submitted to a ThreadPool.",
            .icon = comms::Icon::from("mdi:format-list-checks"),
        };
        return info;
    }
 
private:
    std::shared_ptr<State> state_;
};
 
}  // namespace threadman