command.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
 
#ifndef MODDEF_COMMAND_HPP
#define MODDEF_COMMAND_HPP
 
#include <cstdint>
#include <span>
#include <string_view>
 
#include "moddef/device.hpp"
#include "moddef/error.hpp"
#include "moddef/str.hpp"
#include "moddef/value.hpp"
 
extern "C" {
#include "moddef/command.h"
}
 
namespace moddef {
 
enum class CommandStatus : std::uint8_t {
    Running = MD_CMD_RUNNING,
    WaitingPoll = MD_CMD_WAITING_POLL,
    Done = MD_CMD_DONE,
    Error = MD_CMD_ERROR,
};
 
template <std::size_t N>
class CommandParams {
   public:
    bool value(std::string_view field, Value v) {
        auto* p = slot(field);
        if (!p) return false;
        p->kind = MD_CMD_PARAM_VALUE;
        p->value = v.raw();
        return true;
    }
    bool value(std::string_view field, std::int64_t v) { return value(field, Value{md_value_i64(v)}); }
    bool value(std::string_view field, double v) { return value(field, Value{md_value_f64(v)}); }
 
    bool str(std::string_view field, std::string_view s) {
        auto* p = slot(field);
        if (!p) return false;
        p->kind = MD_CMD_PARAM_STR;
        p->str = to_c(s);
        return true;
    }
 
    bool bytes(std::string_view field, std::span<const std::uint8_t> b) {
        auto* p = slot(field);
        if (!p) return false;
        p->kind = MD_CMD_PARAM_BYTES;
        p->bytes = md_bytes_t{b.data(), static_cast<std::uint32_t>(b.size())};
        return true;
    }
 
    const md_cmd_params_t* c_params() const noexcept { return &view_; }
 
    // The C executor keeps a pointer to items_; pin the object in place.
    CommandParams() = default;
    CommandParams(const CommandParams&) = delete;
    CommandParams& operator=(const CommandParams&) = delete;
 
   private:
    md_cmd_param_t* slot(std::string_view field) {
        if (n_ >= N) return nullptr;
        auto* p = &items_[n_++];
        *p = md_cmd_param_t{};
        p->field = to_c(field);
        view_ = {items_, static_cast<std::uint8_t>(n_)};
        return p;
    }
 
    md_cmd_param_t items_[N]{};
    std::size_t n_ = 0;
    md_cmd_params_t view_{items_, 0};
};
 
class CommandExecutor {
   public:
    static Result<CommandExecutor> begin(Device& dev, std::string_view command_id,
                                         const md_cmd_params_t* params,
                                         std::span<std::uint8_t> sink = {}) {
        CommandExecutor ex;
        if (auto e = md_cmd_begin(&ex.ex_, dev.c_dev(), to_c(command_id), params,
                                  sink.data(), sink.size());
            e != MD_OK)
            return std::unexpected(from_c(e));
        return ex;
    }
 
    CommandStatus tick(std::uint32_t now_ms) noexcept {
        return static_cast<CommandStatus>(md_cmd_tick(&ex_, now_ms));
    }
 
    Error error() const noexcept { return from_c(md_cmd_error(&ex_)); }
 
    Result<Value> result(std::string_view field) const {
        md_value_t v{};
        if (auto e = md_cmd_result(&ex_, to_c(field), &v); e != MD_OK)
            return std::unexpected(from_c(e));
        return Value{v};
    }
 
    Result<std::span<const std::uint8_t>> result_data(std::string_view field) const {
        const std::uint8_t* p = nullptr;
        std::size_t len = 0;
        if (auto e = md_cmd_result_data(&ex_, to_c(field), &p, &len); e != MD_OK)
            return std::unexpected(from_c(e));
        return std::span<const std::uint8_t>{p, len};
    }
 
    CommandExecutor(CommandExecutor&&) noexcept = default;
    CommandExecutor& operator=(CommandExecutor&&) noexcept = default;
    CommandExecutor(const CommandExecutor&) = delete;
    CommandExecutor& operator=(const CommandExecutor&) = delete;
 
   private:
    CommandExecutor() = default;
 
    md_cmd_exec_t ex_{};
};
 
}  // namespace moddef
 
#endif  // MODDEF_COMMAND_HPP