ps_parameter.h

/*
 * Developer : Alexey Zakharov (alexey.zakharov@vectioneer.com)
 * All rights reserved. Copyright (c) 2015 VECTIONEER.
 */
 
#ifndef PS_PARAMETER_H
#define PS_PARAMETER_H
 
#include "ps_actbuffer.h"
#include "ps_datacontainer.h"
#include "ps_handlers.h"
#include "ps_inbuffer.h"
#include "ps_info.h"
#include "ps_outbuffer.h"
#include "ps_parambase.h"
#include "ps_paramtype.h"
#include <atomic>
#include <map>
#include <pthread.h>
#include <set>
#include <string>
#include <string_view>
#include <vector>
 
namespace mcx::parameter_server {
 
// Length of input buffer must be power of 2
static constexpr size_t MAX_ACTION_BUFFER_LENGTH{1024};
static constexpr size_t DEFAULT_INPUT_BUFFER_LENGTH{4};
static constexpr size_t MAX_PATH_LENGTH{sizeof(motorcortex_ParameterInfo::path) - 1};
static constexpr size_t MAX_NAME_LENGTH{128};
 
struct LinkData {
  Parameter* param{};
  uint32_t update_counter{};
  uint32_t sub_counter{};
  ConversionData conversion;
};
 
using param_map_t = std::map<std::string, Parameter*, std::less<>>;
using param_vector_t = std::vector<Parameter*>;
using link_vector_t = std::vector<LinkData>;
using OverwriteBuffer = OutputBuffer;
 
class Parameter : public ParameterBase {
  friend class RingBufferManager;
 
  void init();
 
public:
  Parameter();
 
  explicit Parameter(unsigned int size);
 
  virtual ~Parameter();
 
  Parameter& operator=(const Parameter&) = delete;
 
  Parameter* create(const char* name, Parameter* parent, UserGroup user_group = default_group,
                    uint32_t permissions = default_permissions); // Creates and initialize current Node,
  // attaches itself to given parent;
  Parameter* create(const char* name, size_t length, Parameter* parent, UserGroup user_group = default_group,
                    uint32_t permissions = default_permissions); // Parent could be set to NULL;
 
  void destroy(); // Deallocate element and releases all related resources;
 
  void print(); // Print debug info;
 
  bool hasChildren();
 
  Parameter* createPath(const char* name, UserGroup user_group = default_group,
                        uint32_t permissions = default_permissions);
 
  Parameter* createPath(const char* name, size_t length, UserGroup user_group = default_group,
                        uint32_t permissions = default_permissions);
 
  ParamHandle
  addParameter(const char* name,         // Name of the parameter;
               ParameterType param_type, // Type of the parameter, for example: an input/output signal, model parameter
                                         // or block parameter;
               uint32_t data_type_id,    // Data type id;
               int data_type_size,       // Data type size in bytes;
               Unit unit,                // Unit of the parameter,;
               void* origin_ptr,         // Pointer to the origin of the parameter in the model;
               uint32_t origin_length =
                   1, // If origin_ptr point to an array, number of elements in this array, otherwise is set to 1);
               uint32_t input_buffer_length = DEFAULT_INPUT_BUFFER_LENGTH);
 
  ParamHandle
  addParameter(Parameter* update_node,   // pointer to the node which is responsible for updating parameter
               const char* name,         // Name of the parameter;
               ParameterType param_type, // Type of the parameter, for example: an input/output signal, model parameter
                                         // or block parameter;
               uint32_t data_type_id,    // Data type id;
               int data_type_size,       // Data type size in bytes;
               Unit unit,                // Unit of the parameter,;
               void* origin_ptr,         // Pointer to the origin of the parameter in the model;
               uint32_t origin_length =
                   1, // If origin_ptr point to an array, number of elements in this array, otherwise is set to 1);
               uint32_t input_buffer_length = DEFAULT_INPUT_BUFFER_LENGTH);
 
  SubHandle subscribe(const char* path, bool is_relative);
 
  ReqHandle request(const char* path, bool is_relative);
 
  PubHandle publish(const char* path, bool is_relative);
 
  LinkHandle link(ParameterPath source, ParameterPath destination);
 
  LinkHandle link(ParameterPath source, ParameterPath destination, double gain);
 
  LinkHandle link(ParameterPath source, ParameterPath destination, double gain, double offset);
 
  LinkHandle link(ParameterPath source, ParameterPath destination, double gain, double offset, bool inv_bool);
 
  LinkHandle link(ParameterPath source, ParameterPath destination, double gain, double offset, bool inv_bool,
                  bool clamp);
 
  OverwriteHandle overwrite(const char* path, bool is_relative);
 
  void setForceFlag(bool overwrite_active) override;
 
  void setUserGroup(UserGroup user_group, bool recursive) override;
 
  void setPermissions(Permission permission, bool recursive) override;
 
  bool addLink(Parameter* source_param, uint32_t src_el_offset, uint32_t src_el_count, uint32_t dst_el_offset,
               double gain, double offset, bool inv_bool, bool clamp, bool activate_now);
 
  void activateLink(bool flag) override;
 
  bool checkPermissions(UserGroup user_group, uint32_t permissions);
 
  Parameter* getParameter(const char* path, bool is_relative);
 
  Parameter* getParameter(const char* path, int length, bool is_relative);
 
  void force(const void* in_data, uint32_t size) override;
 
  /* Copies data from given address to input buffer (Buffer is thread-safe);
   * On success return true; */
  void write(const void* in_data, uint32_t size) override;
 
  void force(const void* in_data, uint32_t offset, uint32_t size);
 
  void write(const void* in_data, uint32_t offset, uint32_t size);
 
  /* Copies current value to given address and return its length (Buffer is thread-safe);
   * Returns timestamp of the value */
  uint32_t read(void* out_data, uint32_t size, struct timespec* update_time) override;
 
  uint32_t read(DataContainer* data);
 
  template <typename T, int number_of_param = 1>
  bool setParameterValue(const char* relative_path, const T& in_data);
 
  template <typename T>
  bool setParameterValue(const char* relative_path, std::initializer_list<T> in_data);
 
  inline const ParameterInfo& getInfo() const override; // Returns parameter description;
 
  size_t getSize() const override;
 
  size_t getMaxSize() const override;
 
  uint32_t getTotalNumberOfNodes();
 
  uint32_t getTotalNumberOfParams();
 
  param_map_t* getChildren();
 
  Parameter* getParent();
 
  void updateLink();
 
  void updateInput();     // Function triggers update of output buffer from origin_ptr;
  void overwriteInput();  // Function applies overwrite for input values;
  void overwriteOutput(); // Function applies overwrite for output values;
  void updateOutput(const struct timespec& app_time);
 
  void processActions();
 
  uint32_t addRequest() override;
 
  uint32_t getReplyId() override;
 
  void startPublisher();
 
  void stopPublisher();
 
  bool hasActions();
 
  bool isInputUpdated();
 
  bool isLinkUpdated();
 
  bool isOverwriteOutputUpdated();
 
  bool isOverwriteInputUpdated();
 
  bool isOutputUpdated();
 
  bool compareAndSwapUpdateCounter(uint32_t& last_update_counter) override;
 
  uint32_t getOutputCounter();
 
  void setUpdateOutputFlag(bool newval) override;
 
  void setUpdateOutputOnceFlag(uint32_t length) override;
 
  void setUpdateOutputOnInputFlag(bool newval) override;
 
private:
  enum class ConversionType { NO_CONVERSION_NEEDED, ERROR_CONVERSION_NOT_FOUND, CONVERSION_FOUND };
 
  static bool isFloat(uint32_t data_type);
 
  ConversionType selectConversion(const DataTypeInfo& src_info, const DataTypeInfo& dst_info, const OffsetData& offset,
                                  ConversionData::CoversionClb* clb);
 
  DataContainer* origin_ptr_{};
  DataContainer origin_copy_; /* Need to store origin value, before activate
                               * an overwrite */
  DataContainer origin_;      // Pointer to the variable to store;
  inline DataContainer& getOrigin() { return *origin_ptr_; }
 
  Parameter* parent_node_{}; /* parent node, used for tree navigation */
  Parameter* update_node_{}; /* note which is responsible for updating io buffers, by default =  parent_node_ */
  link_vector_t links_;
  param_map_t children_; // Array with children nodes;
  link_vector_t outputs_pub_;
  param_vector_t outputs_pub_once_;
  param_vector_t inputs_sub_;
  param_vector_t inputs_sub_once_;
  param_vector_t overwrite_inputs_;
  param_vector_t overwrite_outputs_;
  ParameterInfo param_info_; // Description info about parameter;
  std::string name_;         // Name of the current parameter;
 
  bool owned_{};
 
  static std::atomic<uint32_t> total_number_of_nodes_;
  static std::atomic<uint32_t> total_number_of_params_;
 
  InputBuffer in_buffer_;
  OverwriteBuffer overwrite_buffer_;
  OutputBuffer out_buffer_;
 
  ActionBuffer act_buffer_;
  uint32_t input_update_counter_{};
  uint32_t output_update_counter_{};
  bool update_output_flag_{};
  bool update_output_once_flag_{};
  bool update_output_on_input_flag_{};
};
 
inline const ParameterInfo& Parameter::getInfo() const { return param_info_; }
 
template <typename T, int number_of_param>
bool Parameter::setParameterValue(const char* relative_path, const T& in_data) {
  PubHandle pub = publish(relative_path, true);
  if (pub.isFound()) {
    pub.write<T, number_of_param>(in_data);
    return true;
  }
 
  return false;
}
 
template <typename T>
bool Parameter::setParameterValue(const char* relative_path, std::initializer_list<T> in_data) {
  PubHandle pub = publish(relative_path, true);
  if (pub.isFound()) {
    pub.write<T>(in_data);
    return true;
  }
 
  return false;
}
 
} // namespace mcx::parameter_server
 
#endif /* PS_PARAMETER_H */