ps_handlers.h

/*
 * Developer : Alexey Zakharov (alexey.zakharov@vectioneer.com)
 * All rights reserved. Copyright (c) 2015 VECTIONEER.
 */
#ifndef PS_HANDLERS_H
#define PS_HANDLERS_H
 
#include "ps_info.h"
#include "ps_parambase.h"
#include "utl_log.h"
#include <initializer_list>
#include <map>
 
namespace mcx {
 
namespace parameter_server {
 
// Base class for all types parameter handlers
 
class Handle {
public:
  explicit Handle(ParameterBase* param) : param_(param){};
 
  inline bool isFound() const { return param_ != nullptr; }
 
  inline const char* getPath() const { return param_->getInfo().getPath(); }
 
  inline motorcortex_ParameterInfo getInfo() const {
    motorcortex_ParameterInfo info{};
    if (param_) {
      param_->getInfo().getInfo(&info);
    }
    return info;
  }
 
protected:
  ParameterBase* param_;
};
 
// ParamHandle is created by addParam method
// Instance of ParamHandle shows if parameter was updated from the input buffer
 
class ParamHandle : public Handle {
public:
  ParamHandle();
 
  ParamHandle(ParameterBase* param, void* origin_ptr);
 
  virtual ~ParamHandle();
 
  ParamHandle(const ParamHandle& orig);
 
  ParamHandle& operator=(const ParamHandle& orig);
 
  void setUserGroup(UserGroup user_group);
 
  // check if new value has been written to the parameter input
  bool isUpdated();
 
  size_t size() const;
 
  // enable/disable update of the output buffer
  void updateOutput(bool newval);
 
  void updateOutputOnce();
 
  void updateOutputOnce(size_t length);
 
  void updateOutputOnInput(bool newval);
 
  template <typename T>
  void write(const T& in_data) {
    *(T*)origin_ptr_ = in_data;
    updateOutputOnce();
  }
 
  template <typename T>
  void write(const T in_data, int length) {
    for (int i = 0; i < length; i++) {
      ((T)origin_ptr_)[i] = in_data[i];
    }
    updateOutputOnce();
  }
 
private:
  uint32_t update_counter_{};
  void* origin_ptr_;
};
 
class GroupHandle : public Handle {
public:
  GroupHandle();
 
  GroupHandle(ParameterBase* group, std::map<std::string, ParamHandle> params);
 
  virtual ~GroupHandle();
 
  GroupHandle(const GroupHandle& orig);
 
  GroupHandle& operator=(const GroupHandle& orig);
 
  ParamHandle& getHandle(const std::string& name);
 
  void setUserGroup(UserGroup user_group);
 
  // check if new value has been written to the parameter input
  bool isUpdated();
 
  // enable/disable update of the output buffer
  void updateOutput(bool newval);
 
  void updateOutputOnce();
 
  void updateOutputOnInput(bool newval);
 
  template <typename T>
  void write(const std::string& name, const T& in_data) {
    params_handle_[name].write(in_data);
  }
 
  template <typename T>
  void write(const std::string& name, const T in_data, int length) {
    params_handle_[name].write(in_data, length);
  }
 
private:
  std::map<std::string, ParamHandle> params_handle_;
};
 
// ReqHandle is created by request method
// Instance of ReqHandle is used to perform asynchronous read of the output buffer of the parameter
// ReqHandle does not start continuous
 
class ReqHandle : public Handle {
public:
  ReqHandle();
 
  ReqHandle(ParameterBase* param, long id);
 
  virtual ~ReqHandle();
 
  ReqHandle(const ReqHandle& orig);
 
  ReqHandle& operator=(const ReqHandle& orig);
 
  template <typename T>
  bool read(T* out_data, int number_of_param);
 
  template <typename T>
  bool read(T& out_data);
 
  const struct timespec& getTime() const;
 
private:
  long update_counter_{};
  struct timespec update_time_ {};
};
 
template <typename T>
bool ReqHandle::read(T* out_data, int number_of_param) {
  if (param_) {
    if (update_counter_ >= 0 && update_counter_ != param_->getReplyId()) {
      param_->read(out_data, sizeof(T) * number_of_param, &update_time_);
      update_counter_ = -1;
      return true;
    } else {
      update_counter_ = param_->addRequest();
    }
  }
 
  return false;
}
 
template <typename T>
bool ReqHandle::read(T& out_data) {
  return read(&out_data, 1);
}
 
// SubHandle is created by subscribe method
// Instance of SubHandle is used to read value from an output buffer of the parameter
 
class SubHandle : public Handle {
public:
  SubHandle();
 
  explicit SubHandle(ParameterBase* param);
 
  virtual ~SubHandle();
 
  SubHandle(const SubHandle& orig);
 
  SubHandle& operator=(const SubHandle& orig);
 
  template <typename T>
  struct timespec read(T& out_data);
};
 
template <typename T>
struct timespec SubHandle::read(T& out_data) {
  log_assert(param_, "SubHandle can not have NULL pointer to the parameter") struct timespec timestamp {};
  param_->read(&out_data, sizeof(out_data), &timestamp);
  return timestamp;
}
 
// PubHandle is created by publish method
// Instance of PubHandle is used to write values to an input buffer of the parameter
 
class PubHandle : public Handle {
public:
  PubHandle();
 
  explicit PubHandle(ParameterBase* param);
 
  virtual ~PubHandle();
 
  PubHandle(const PubHandle& orig);
 
  PubHandle& operator=(const PubHandle& orig);
 
  template <typename T>
  void write(std::initializer_list<T> in_data);
 
  template <typename T, int number_of_param = 1>
  void write(const T& in_data);
};
 
template <typename T>
void PubHandle::write(std::initializer_list<T> in_data) {
  log_assert(param_, "PubHandle can not have NULL pointer to the parameter")
      param_->write(in_data.begin(), static_cast<uint32_t>(in_data.size() * sizeof(T)));
}
 
template <typename T, int number_of_param>
void PubHandle::write(const T& in_data) {
  log_assert(param_, "PubHandle can not have NULL pointer to the parameter")
      param_->write(&in_data, number_of_param * sizeof(in_data));
}
 
// LinkHandle is created by link method
// Instance of LinkHandle is used to remove link if necessary
 
class LinkHandle : public Handle {
public:
  LinkHandle();
 
  LinkHandle(ParameterBase* param, uint32_t element_offset);
 
  virtual ~LinkHandle();
 
  LinkHandle(const LinkHandle& orig);
 
  LinkHandle& operator=(const LinkHandle& orig);
 
  void activate(bool flag);
 
private:
  uint32_t element_offset_{};
};
 
class OverwriteHandle : public Handle {
public:
  OverwriteHandle();
 
  explicit OverwriteHandle(ParameterBase* param);
 
  virtual ~OverwriteHandle();
 
  OverwriteHandle(const OverwriteHandle& orig);
 
  OverwriteHandle& operator=(const OverwriteHandle& orig);
 
  void activate(bool flag);
 
  template <typename T>
  void write(std::initializer_list<T> in_data);
 
  template <typename T, int number_of_param = 1>
  void write(const T& in_data);
};
 
template <typename T>
void OverwriteHandle::write(std::initializer_list<T> in_data) {
  log_assert(param_, "OverwriteHandle can not have NULL pointer to the parameter")
      param_->force(in_data.begin(), static_cast<uint32_t>(in_data.size() * sizeof(T)));
}
 
template <typename T, int number_of_param>
void OverwriteHandle::write(const T& in_data) {
  log_assert(param_, "OverwriteHandle can not have NULL pointer to the parameter")
      param_->force(&in_data, number_of_param * sizeof(in_data));
}
 
} // namespace parameter_server
 
} // namespace mcx
 
#endif /* PS_HANDLERS_H */