ModelBusClient.hpp

Go to the documentation of this file.

#pragma once
 
#include <Bus.hpp>
#include <cstdint>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <utility>
 
#include "bus/Envelopes.hpp"
 
namespace lacte::bus {
// ---------------------------------------------------------------------------
// ModelBusHandler: серверный доменный контракт. Реализуйте эти методы, и
// ModelBusClient::ServeModel() будет отвечать на них через шину.
// ---------------------------------------------------------------------------

class ModelBusHandler {
 public:
  virtual ~ModelBusHandler() = default;

  virtual auto health() -> bool = 0;

  virtual auto get_param(const std::string& name) -> std::optional<int> = 0;

  virtual auto set_param(const std::string& name, int value) -> bool = 0;

  virtual auto get_snapshot() -> BoardSnapshot = 0;

  virtual auto get_rfid_data() -> RfidData = 0;
};

class CallbackModelBusHandler : public ModelBusHandler {
 public:
  std::function<bool()> health_fn;
  std::function<std::optional<int>(std::string)> get_param_fn;
  std::function<bool(std::string, int)> set_param_fn;
  std::function<BoardSnapshot()> get_snapshot_fn;
  std::function<RfidData()> get_rfid_data_fn;
 
  auto health() -> bool override { return health_fn ? health_fn() : true; }
 
  auto get_param(const std::string& name) -> std::optional<int> override {
    return get_param_fn ? get_param_fn(name) : std::nullopt;
  }
 
  auto set_param(const std::string& name, const int value) -> bool override {
    return set_param_fn ? set_param_fn(name, value) : false;
  }
 
  auto get_snapshot() -> BoardSnapshot override {
    return get_snapshot_fn ? get_snapshot_fn() : BoardSnapshot{};
  }
 
  auto get_rfid_data() -> RfidData override {
    return get_rfid_data_fn ? get_rfid_data_fn() : RfidData{};
  }
};

inline constexpr uint32_t K_MODEL_BUS_ADDRESS = 1;
 
// ---------------------------------------------------------------------------
// ModelBusClient: см. doc-комментарий файла выше.
// ---------------------------------------------------------------------------
 
class ModelBusClient : public insitech::bus::LocalClient {
 public:
  static auto create(insitech::bus::IHub& bus, const uint32_t address,
                     const std::string& name,
                     const std::string& binary = "lacteApp")
      -> std::shared_ptr<ModelBusClient> {
    auto self = std::shared_ptr<ModelBusClient>(new ModelBusClient(
        address, proto::bus::make_identity(name, binary, 1, "lacte"),
        bus.make_client_bindings(address)));
    bus.register_local_client(address, self);
    return self;
  }
 
  ModelBusClient(const ModelBusClient&) = delete;
  auto operator=(const ModelBusClient&) -> ModelBusClient& = delete;

  void serve_model(ModelBusHandler& handler) {
    serve<HealthRequest, StatusReply>(
        [&handler](const HealthRequest&) -> StatusReply {
          return StatusReply{handler.health()};
        },
        "Model health check");
 
    serve<ParamGetRequest, ParamGetReply>(
        [&handler](const ParamGetRequest& request) -> ParamGetReply {
          const auto value = handler.get_param(request.param);
          if (!value) {
            return ParamGetReply{false, "not-found", request.param, 0};
          }
          return ParamGetReply{true, "", request.param, *value};
        },
        "Reads one board parameter's current value",
        {proto::bus::TopicParam{"param", "param name", true}});
 
    serve<ParamSetRequest, StatusReply>(
        [&handler](const ParamSetRequest& request) -> StatusReply {
          return StatusReply{handler.set_param(request.param, request.value),
                             ""};
        },
        "Sets one board parameter's value",
        {proto::bus::TopicParam{"param", "param name", true},
         proto::bus::TopicParam{"value", "value", true}});
 
    serve<SnapshotRequest, SnapshotReply>(
        [&handler](const SnapshotRequest&) -> SnapshotReply {
          return SnapshotReply{true, "", handler.get_snapshot()};
        },
        "Returns the Model's current full board snapshot");
 
    serve<RfidDataRequest, RfidDataReply>(
        [&handler](const RfidDataRequest&) -> RfidDataReply {
          return RfidDataReply{true, "", handler.get_rfid_data()};
        },
        "Returns the currently-attached RFID card's raw data");
 
    // TestBoardOnlineRequest::K_TOPIC здесь НЕ обслуживается - см.
    // собственный doc-комментарий ModelBusHandler. Вне режима --virtual
    // этот топик вообще никем не обслуживается, так что
    // ConsoleUi::SetTestBoardOnline() просто получает тайм-аут - тот же
    // результат "недоступно", что и раньше, только через тайм-аут, а не
    // мгновенный ответ.
  }
 
 private:
  // Приватный: только Create() может сконструировать экземпляр, так что
  // нигде не может оказаться ModelBusClient, который никогда не был
  // зарегистрирован на своей шине (см. doc-комментарий Create()) - обычный
  // публичный конструктор не смог бы это гарантировать.
  ModelBusClient(const uint32_t address,
                 const proto::bus::NodeIdentity& identity, Bindings bindings)
      : LocalClient(address, identity, std::move(bindings)) {}
};
}  // namespace lacte::bus