ct_module.h

/*
 * Developer : Alexey Zakharov (alexey.zakharov@vectioneer.com)
 * All rights reserved. Copyright (c) 2015 - 2021 VECTIONEER.
 */
 
#ifndef CONTAINER_CT_MODULE_H
#define CONTAINER_CT_MODULE_H
 
#include "ct_helpers.h"
#include "ct_time.h"
#include "ps_parameter.h"
#include "utl_span.h"
#include "visit_helper.h"
#include "visit_struct.h"
#include <cstdint>
#include <functional>
#include <mutex>
#include <string>
#include <vector>
 
namespace mcx::container {
 
 
class Module {
public:
  enum class ModuleStates {
    NOT_INITIALIZED = 0,
    PHASE_0 = 1,
    PHASE0 = 2,
    PHASE0_1 = 3,
    PHASE1 = 4,
    PHASE1_2 = 5,
    PHASE2 = 6,
    PHASE2_OP = 7,
    OP = 8,
    OP_PHASE2 = 9,
    PHASE2_NOT_INIT = 10,
  };
 
  enum class ModuleErrors { NO_ERROR = 0, NO_CALLBACK_DEFINED = 1, CALLBACK_FAILED = 2, WRONG_STATE = 3 };
 
  enum class ModuleEvents { EMPTY = -1, STOP = 0, START = 1, PAUSE = 2, ACK = 0xFF };
 
  Module();
 
  virtual ~Module() = default;
 
  Module(const Module& orig) = delete;
 
  Module& operator=(const Module&) = delete;
 
  void create(const char* name, parameter_server::Parameter* parameter_server, uint64_t dt_micro_s = 0);
 
  void create(const char* name, parameter_server::Parameter* parameter_server, uint64_t dt_micro_s,
              parameter_server::UserGroup owner_group, uint32_t permissions = parameter_server::default_permissions);
 
  bool initPhase1();
 
  bool initPhase2();
 
  bool startOp();
 
  bool stopOp();
 
  bool iterate(const TaskTime& task_time, UserTime* user_time);
 
  void setName(const char* name);
 
  const char* getName() const;
 
  void setDtMicroSec(uint64_t micro_sec);
 
  uint64_t getDtMicroSec() const;
 
  void setDtSec(double sec);
 
  double getDtSec() const;
 
  ModuleStates getState() const;
 
  void setEvent(ModuleEvents event);
 
  ModuleErrors getError() const;
 
protected:
  virtual void create_(const char* name, parameter_server::Parameter* parameter_server, uint64_t dt_micro_s) = 0;
 
  virtual bool initPhase1_() = 0;
 
  virtual bool initPhase2_() = 0;
 
  virtual bool startOp_() = 0;
 
  virtual bool stopOp_() = 0;
 
  virtual bool iteratePreOp_(const TaskTime& system_time, UserTime* user_time) { return true; }
 
  virtual bool iterateOp_(const TaskTime& system_time, UserTime* user_time) = 0;
 
  void createSubmodule(Module* module, const char* name);
 
  template <typename T>
  void createSubmodules(utils::span<T> module_array, const char* basename) {
    size_t idx = 0;
    for (auto& module : module_array) {
      createSubmodule(&module, fmt::format("{}{:02d}", basename, ++idx).c_str());
    }
  }
 
  void setType(const char* name);
 
  template <size_t buffer_size = parameter_server::DEFAULT_INPUT_BUFFER_LENGTH>
  parameter_server::ParamHandle addParameter(const char* id, parameter_server::ParameterType param_type, char* str_ptr,
                                             size_t length);
 
  template <typename T, size_t buffer_size = parameter_server::DEFAULT_INPUT_BUFFER_LENGTH,
            add_visitable::EnableIfNotVisitable<T> = true>
  parameter_server::ParamHandle addParameter(const char* id, parameter_server::ParameterType param_type, T* value_ptr,
                                             size_t length = 1,
                                             parameter_server::Unit param_unit = parameter_server::Unit::undefined);
 
  template <typename T, size_t buffer_size = parameter_server::DEFAULT_INPUT_BUFFER_LENGTH,
            add_visitable::EnableIfVisitable<T> = true>
  parameter_server::GroupHandle addParameter(const char* id, parameter_server::ParameterType param_type, T* value_ptr,
                                             size_t length = 1,
                                             parameter_server::Unit param_unit = parameter_server::Unit::undefined);
 
  template <typename T, size_t buffer_size = parameter_server::DEFAULT_INPUT_BUFFER_LENGTH>
  parameter_server::ParamHandle addParameter(const char* id, parameter_server::ParameterType param_type,
                                             parameter_server::DataType data_type, T* value_ptr, size_t length = 1,
                                             parameter_server::Unit param_unit = parameter_server::Unit::undefined);
 
  parameter_server::SubHandle subscribe(const char* path);
 
  parameter_server::ReqHandle request(const char* path);
 
  parameter_server::PubHandle publish(const char* path);
 
  parameter_server::Parameter* getParameterRoot();
 
  parameter_server::Parameter* getLocalBranch();
 
private:
  friend class Task;
 
  inline void updateLinks() {
    if (local_branch_.isLinkUpdated()) {
      local_branch_.updateLink();
    }
  }
 
  inline void updateInputs() {
    if (local_branch_.isInputUpdated()) {
      local_branch_.updateInput();
    }
 
    if (local_branch_.isOverwriteInputUpdated()) {
      local_branch_.overwriteInput();
    }
  }
 
  parameter_server::ParamHandle addParameter(const char* name, parameter_server::ParameterType param_type,
                                             uint32_t data_type, int32_t data_type_size, parameter_server::Unit unit,
                                             void* value_ptr, uint32_t origin_length, uint32_t buffer_length);
 
  bool createWrapper();
 
  const char* stateToStr(ModuleStates state) const;
 
  bool readyToStart();
 
  bool switchState(ModuleStates* actual_state_ptr, ModuleErrors* error_ptr, ModuleStates expected_state,
                   ModuleStates new_state, const std::function<bool(Module*)>&, std::mutex* switch_guard);
 
  uint64_t dt_micro_s_{};
  uint64_t utilization_{};
  std::string module_name_{"Undefined"};
  std::string module_type_;
  parameter_server::Parameter* root_ptr_{};
  parameter_server::Parameter local_branch_;
  std::vector<Module*> submodules_;
 
  ModuleStates state_{ModuleStates::NOT_INITIALIZED};
  ModuleErrors error_{ModuleErrors::NO_ERROR};
  ModuleEvents event_{ModuleEvents::EMPTY};
  ModuleEvents old_event_{ModuleEvents::EMPTY};
  mutable std::mutex switch_guard_;
};
 
inline parameter_server::Parameter* Module::getParameterRoot() { return root_ptr_; }
 
inline parameter_server::Parameter* Module::getLocalBranch() { return &local_branch_; }
 
inline void Module::setDtMicroSec(uint64_t micro_sec) {
  dt_micro_s_ = micro_sec;
  for (auto& m : submodules_) {
    m->setDtMicroSec(micro_sec);
  }
}
 
inline uint64_t Module::getDtMicroSec() const { return dt_micro_s_; }
 
inline void Module::setDtSec(double sec) { setDtMicroSec(static_cast<uint64_t>(sec * 1000000)); }
 
inline double Module::getDtSec() const { return dt_micro_s_ / 1000000.0; }
 
template <size_t buffer_size>
parameter_server::ParamHandle Module::addParameter(const char* id, parameter_server::ParameterType param_type,
                                                   char* str_ptr, size_t length) {
 
  parameter_server::DataType data_type = parameter_server::DataType::STRING;
  parameter_server::Unit param_unit = parameter_server::Unit::undefined;
 
  return addParameter<char, buffer_size>(id, param_type, data_type, str_ptr, length, param_unit);
}
 
template <typename T, size_t buffer_size, add_visitable::EnableIfNotVisitable<T>>
parameter_server::ParamHandle
Module::addParameter(const char* id, parameter_server::ParameterType param_type, T* value_ptr, size_t length /*= 1*/,
                     parameter_server::Unit param_unit /*= parameter_server::Unit::undefined*/) {
  auto type = mcx::getType(*value_ptr);
  return addParameter<T, buffer_size>(id, param_type, std::get<0>(type), value_ptr, length, param_unit);
}
 
template <typename T, size_t buffer_size, add_visitable::EnableIfVisitable<T>>
parameter_server::GroupHandle Module::addParameter(const char* id, parameter_server::ParameterType param_type,
                                                   T* value_ptr, size_t length, parameter_server::Unit) {
  log_assert(length == 1, "addParameter for the visitable structures does not support length > 1");
  add_visitable::ParamHandleMap params_handle_map;
  auto root = add_visitable::addParameterVisitableArrayImpl<buffer_size>(
      &local_branch_, &local_branch_, params_handle_map, nullptr, id, param_type, *value_ptr);
  return mcx::parameter_server::GroupHandle(root, std::move(params_handle_map));
}
 
template <typename T, size_t buffer_size>
parameter_server::ParamHandle Module::addParameter(const char* id, parameter_server::ParameterType param_type,
                                                   parameter_server::DataType data_type, T* value_ptr, size_t length,
                                                   parameter_server::Unit param_unit) {
  size_t type_size = sizeof(T);
  return addParameter(id, param_type, static_cast<unsigned int>(data_type), static_cast<int32_t>(type_size), param_unit,
                      value_ptr, static_cast<uint32_t>(length), static_cast<uint32_t>(buffer_size));
}
 
} // namespace mcx::container
 
#endif // CONTAINER_CT_MODULE_H