EditingTaskService.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "editing/EditingProtocol.h"
 
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <deque>
#include <functional>
#include <memory>
#include <mutex>
#include <string>
#include <thread>
#include <unordered_map>
 
namespace eve::editing {
 
enum class TaskState { Queued, Running, Succeeded, Failed, Cancelled };
 
struct TaskSnapshot {
    TaskId                        id;
    std::string                   name;
    TaskState                     state    = TaskState::Queued;
    float                         progress = 0.0F;
    Value                         output;
    std::vector<Diagnostic>       diagnostics;
};
 
class EVENGINE_API_PLATFORM TaskContext {
public:
    bool isCancellationRequested() const;
    void reportProgress(float progress) const;
 
private:
    friend class TaskService;
    TaskContext(std::shared_ptr<std::atomic_bool> cancelled, std::function<void(float)> progress);
    std::shared_ptr<std::atomic_bool> cancelled_;
    std::function<void(float)>        progress_;
};
 
struct TaskOutcome {
    Status                  status = Status::Applied;
    Value                   output;
    std::vector<Diagnostic> diagnostics;
};
 
class EVENGINE_API_PLATFORM TaskService {
public:
    using Work = std::function<TaskOutcome(const TaskContext&)>;
 
    TaskService();
    ~TaskService();
    TaskService(const TaskService&)            = delete;
    TaskService& operator=(const TaskService&) = delete;
 
    [[nodiscard]] Result<TaskId> submit(std::string name, Work work);
    [[nodiscard]] Result<void> cancel(const TaskId& task);
    [[nodiscard]] Result<TaskSnapshot> snapshot(const TaskId& task) const;
    [[nodiscard]] Result<void> waitIdle(std::chrono::milliseconds timeout);
 
private:
    struct TaskRecord;
    void workerLoop();
 
    mutable std::mutex                                                                  mutex_;
    std::condition_variable                                                             workReady_;
    std::condition_variable                                                             idle_;
    std::unordered_map<TaskId, std::shared_ptr<TaskRecord>, StrongIdHash<TaskId>> tasks_;
    std::deque<std::shared_ptr<TaskRecord>>                                             queue_;
    std::thread                                                                         worker_;
    bool                                                                                stopping_ = false;
    std::uint64_t                                                                       sequence_ = 0;
};
 
}  // namespace eve::editing