ps_info.h

/*
 * Developer : Alexey Zakharov (alexey.zakharov@vectioneer.com)
 * All rights reserved. Copyright (c) 2018 VECTIONEER.
 */
 
#ifndef MOTORCORTEX_CORE_PS_INFO_H
#define MOTORCORTEX_CORE_PS_INFO_H
 
#include "ps_types.h"
#include <atomic>
#include <cstring>
#include <string>
 
namespace mcx {
 
namespace parameter_server {
 
struct DataTypeInfo {
  unsigned int data_type;
  unsigned int data_size;
};
 
class ParameterInfo {
public:
  ParameterInfo();
 
  ~ParameterInfo();
 
  inline void getInfo(motorcortex_ParameterInfo* info) const;
 
  inline const DataTypeInfo& getDataTypeInfo() const;
 
  void setName(const char* name);
 
  inline const char* getName() const;
 
  void setPath(const char* path);
 
  inline const char* getPath() const;
 
  inline size_t getPathLength() const;
 
  void setId(unsigned int id);
 
  inline unsigned int getId() const;
 
  void setUserGroup(motorcortex_UserGroup user_group);
 
  inline motorcortex_UserGroup getUserGroup() const;
 
  void setUnit(motorcortex_Unit unit);
 
  inline motorcortex_Unit getUnit() const;
 
  void setDataType(unsigned int data_type);
 
  inline unsigned int getDataType() const;
 
  void setDataSize(unsigned int data_size);
 
  inline unsigned int getDataSize() const;
 
  void setFlags(unsigned int flags);
 
  inline unsigned int getFlags() const;
 
  void setPermissions(unsigned int permissions);
 
  inline unsigned int getPermissions() const;
 
  void setType(motorcortex_ParameterType& type);
 
  inline motorcortex_ParameterType getType() const;
 
  void setNumberOfElements(unsigned int number_of_elements);
 
  inline unsigned int getNumberOfElements() const;
 
  void toggleOverwrite(bool overwrite);
 
  inline bool hasOverwrite() const;
 
  void toggleLink(bool link);
 
  inline bool hasLink() const;
 
  unsigned int getHash() const;
 
private:
  unsigned int id_{};
  DataTypeInfo data_type_info_{};
  unsigned int number_of_elements_{};
  std::atomic<unsigned int> flags_{};
  unsigned int permissions_{};
  motorcortex_ParameterType param_type_{};
  motorcortex_UserGroup group_id_{};
  motorcortex_Unit unit_{};
  std::string name_;
  std::string path_;
};
 
inline void ParameterInfo::getInfo(motorcortex_ParameterInfo* info) const {
  info->id = getId();
  info->data_type = getDataType();
  info->data_size = getDataSize();
  info->number_of_elements = getNumberOfElements();
  info->flags = getFlags();
  info->permissions = getPermissions();
  info->param_type = getType();
  info->group_id = getUserGroup();
  info->unit = getUnit();
  size_t path_len = getPathLength() < (sizeof(info->path) - 1) ? getPathLength() : sizeof(info->path) - 1;
  std::strncpy(info->path, getPath(), path_len);
  if (path_len > 0) {
    info->path[path_len] = 0;
  } else {
    info->path[0] = 0;
  }
}
 
inline const DataTypeInfo& ParameterInfo::getDataTypeInfo() const { return data_type_info_; }
 
inline const char* ParameterInfo::getName() const { return name_.c_str(); }
 
inline const char* ParameterInfo::getPath() const { return path_.c_str(); }
 
inline size_t ParameterInfo::getPathLength() const { return path_.length(); }
 
inline unsigned int ParameterInfo::getId() const { return id_; }
 
inline motorcortex_UserGroup ParameterInfo::getUserGroup() const { return group_id_; }
 
inline motorcortex_Unit ParameterInfo::getUnit() const { return unit_; }
 
inline unsigned int ParameterInfo::getDataType() const { return data_type_info_.data_type; }
 
inline unsigned int ParameterInfo::getDataSize() const { return data_type_info_.data_size; }
 
inline unsigned int ParameterInfo::getFlags() const { return flags_.load(std::memory_order_relaxed); }
 
inline unsigned int ParameterInfo::getPermissions() const { return permissions_; }
 
inline void ParameterInfo::setType(motorcortex_ParameterType& type) { param_type_ = type; }
 
inline motorcortex_ParameterType ParameterInfo::getType() const { return param_type_; }
 
inline unsigned int ParameterInfo::getNumberOfElements() const { return number_of_elements_; }
 
inline bool ParameterInfo::hasOverwrite() const {
  return static_cast<bool>(flags_.load(std::memory_order_relaxed) & OVERWRITE_IS_ACTIVE);
}
 
inline bool ParameterInfo::hasLink() const {
  return static_cast<bool>(flags_.load(std::memory_order_relaxed) & motorcortex_ParameterFlag_LINK_IS_ACTIVE);
}
 
} // namespace parameter_server
 
} // namespace mcx
 
#endif // MOTORCORTEX_CORE_PS_INFO_H