CommandQueue.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/BorrowedRef.h"
#include "common/Module.h"
#include "common/Result.h"
#include "common/Scheduling.h"
#include "common/SquirrelOwnership.h"
#include "common/Value.h"
 
#include <cstddef>
#include <cstdint>
#include <deque>
#include <map>
#include <memory>
#include <string>
#include <vector>
 
namespace eve::orders {
 
struct CommandQueueHandleTag {};
using CommandQueueHandleRef = eve::script::RuntimeHandleRef<CommandQueueHandleTag>;
 
enum class OrderState { Queued, Active, Completed, Failed, Cancelled };
 
class EVENGINE_API_FOUNDATION OrderPayload {
public:
    void setString(const std::string& key, const std::string& value);
    void setNumber(const std::string& key, double value);
    void setBool(const std::string& key, bool value);
    void setNull(const std::string& key);
    [[nodiscard]] eve::Result<void> setJson(const std::string& key, std::string_view json);
    [[nodiscard]] eve::Result<void> set(const std::string& key, eve::Value value);
    bool has(const std::string& key) const;
    [[nodiscard]] eve::Result<bool> erase(const std::string& key);
    void clear();
    std::string getJson(const std::string& key) const;
    std::string toJson() const;
 
private:
    friend class CommandQueue;
    eve::Value::Object values_;
};
 
struct Order : eve::scheduling::ItemMetadata {
    std::string  kind;
    OrderState   state          = OrderState::Queued;
    double       timeoutSeconds = 0.0;
    double       elapsedSeconds = 0.0;
    OrderPayload payload;
};
 
struct OrderEvent : eve::scheduling::EventMetadata {
    std::string orderId;
    std::string kind;
    OrderState  from = OrderState::Queued;
    OrderState  to   = OrderState::Queued;
};
 
class EVENGINE_API_FOUNDATION CommandQueue {
public:
    [[nodiscard]] eve::Result<std::string> append(const std::string& kind, int priority = 0,
                                                  double timeoutSeconds = 0.0);
    [[nodiscard]] eve::Result<std::string> replace(const std::string& kind, int priority = 0,
                                                   double timeoutSeconds = 0.0);
    [[nodiscard]] eve::Result<std::string> interrupt(const std::string& kind, int priority = 0,
                                                     double timeoutSeconds = 0.0);
    [[nodiscard]] eve::Result<void> complete(const std::string& id);
    [[nodiscard]] eve::Result<void> fail(const std::string& id, const std::string& reason);
    [[nodiscard]] eve::Result<void> cancel(const std::string& id, const std::string& reason = "cancelled");
    [[nodiscard]] eve::Result<void> update(double dtSeconds);
    void clear();
 
    [[nodiscard]] eve::OptionalRef<Order> current();
    [[nodiscard]] eve::OptionalRef<const Order> current() const;
    [[nodiscard]] eve::OptionalRef<Order> find(const std::string& id);
    [[nodiscard]] eve::OptionalRef<const Order> find(const std::string& id) const;
    int queuedCount() const;
    int orderCount() const;
    [[nodiscard]] eve::OptionalRef<Order> orderAt(int index);
    [[nodiscard]] eve::OptionalRef<const Order> orderAt(int index) const;
 
    int eventCount() const;
    [[nodiscard]] eve::OptionalRef<OrderEvent> eventAt(int index);
    [[nodiscard]] eve::OptionalRef<const OrderEvent> eventAt(int index) const;
    void clearEvents();
 
    [[nodiscard]] eve::Result<std::string> snapshot() const;
 
    [[nodiscard]] eve::Result<void> restore(std::string_view json);
 
private:
    std::string appendUnchecked(const std::string& kind, int priority, double timeoutSeconds);
    std::string replaceUnchecked(const std::string& kind, int priority, double timeoutSeconds);
    std::string interruptUnchecked(const std::string& kind, int priority, double timeoutSeconds);
    bool        completeUnchecked(const std::string& id);
    bool        failUnchecked(const std::string& id, const std::string& reason);
    bool        cancelUnchecked(const std::string& id, const std::string& reason);
    void        updateUnchecked(double dtSeconds);
    std::string create(const std::string& kind, int priority, double timeoutSeconds, bool activateNow);
    void        activateNext();
    bool        transition(Order& order, OrderState state, const std::string& reason);
    void        cancelUnfinished(const std::string& reason);
 
    uint64_t               nextId_       = 1;
    uint64_t               nextSequence_ = 1;
    std::deque<Order>      orders_;
    std::vector<size_t>    queued_;
    size_t                 active_ = static_cast<size_t>(-1);
    std::deque<OrderEvent> events_;
};
 
EVENGINE_API_FOUNDATION std::string stateName(OrderState state);
 
class Orders : public Module {
public:
    Module_REG(Orders);
    Orders()           = default;
    ~Orders() override = default;
 
    [[nodiscard]] static eve::Result<CommandQueueHandleRef> newQueueHandle();
 
    [[nodiscard]] static eve::script::Borrowed<CommandQueue> resolve(CommandQueueHandleRef reference) noexcept;
 
    [[nodiscard]] static eve::Result<void> release(CommandQueueHandleRef reference);
 
    [[nodiscard]] static bool isStale(CommandQueueHandleRef reference) noexcept;
 
private:
    eve::script::RuntimeObjectRegistry<CommandQueue, CommandQueueHandleTag> queues_;
};
 
}  // namespace eve::orders