ps_datacontainer.h

/*
 * Developer : Alexey Zakharov (alexey.zakharov@vectioneer.com)
 * All rights reserved. Copyright (c) 2015 VECTIONEER.
 */
 
#ifndef PS_DATACONTAINER_H
#define PS_DATACONTAINER_H
 
#include "utl_log.h"
#include <cstdint>
#include <ctime>
#include <functional>
 
namespace mcx {
 
namespace parameter_server {
 
struct OffsetData {
  size_t src_byte_offset;
  size_t src_el_byte_size;
  size_t src_el_count;
 
  size_t dst_byte_offset;
  size_t dst_el_byte_size;
 
  double gain;
  double offset;
  bool inv_bool;
  bool clamp;
};
 
struct ConversionData {
  using CoversionClb =
      std::function<void(uint8_t*, const uint8_t*, size_t size, const ConversionData& conversion_data)>;
  bool conversion_on;
  OffsetData offset_data;
  CoversionClb copy_clb;
};
 
class DataContainer {
public:
  enum class Type {
    NONE,
    PARAMETER_FIXED,
    PARAMETER_VARIABLE,
    INPUT_BUFFER,
    OUTPUT_BUFFER,
    EXTERNAL,
  };
 
  DataContainer();
 
  DataContainer(Type type, const void* data_ptr, size_t offset_bytes, size_t length_bytes);
 
  virtual ~DataContainer();
 
  bool allocate(Type type, size_t length_bytes);
 
  void deallocate();
 
  DataContainer(const DataContainer& orig) = delete;
 
  inline DataContainer& operator=(const DataContainer& orig) {
    log_assert((orig.getSize() + orig.getOffset()) <= getMaxSize(), "Source offset: {}, length: {} > length: {}",
               orig.getOffset(), orig.getSize(), getMaxSize()) app_time_ = orig.app_time_;
    switch (type_) {
    case Type::NONE:
      break;
    case Type::EXTERNAL:
      /* copy data to an output buffer */
      offset_bytes_.offset = 0;
      offset_bytes_.size = orig.getOffset() + orig.getSize();
      memcpy(data_.ui_ptr, orig.getData(), offset_bytes_.size);
      return *this;
    case Type::OUTPUT_BUFFER:
      /* copy data to an output buffer */
      if (orig.getType() == Type::PARAMETER_VARIABLE) {
        offset_bytes_.offset = 0;
        offset_bytes_.size = orig.getOffset() + orig.getSize();
      } else {
        offset_bytes_.offset = 0;
        offset_bytes_.size = orig.getMaxSize();
      }
      memcpy(data_.ui_ptr, orig.getData(), offset_bytes_.size);
      return *this;
    case Type::INPUT_BUFFER:
      /* copy data to input buffer */
      offset_bytes_.offset = orig.getOffset();
      offset_bytes_.size = orig.getSize();
      memcpy(data_.ui_ptr, orig.getData(), offset_bytes_.size);
      return *this;
    case Type::PARAMETER_VARIABLE:
      offset_bytes_.offset = 0;
      offset_bytes_.size = orig.getOffset() + orig.getSize();
    case Type::PARAMETER_FIXED:
      /* do not copy size and offset */
      memcpy(data_.ui_ptr + orig.getOffset(), orig.getData(), orig.getSize());
      return *this;
    }
 
    return *this;
  }
 
  void setDataPtr(Type type, const void* data_ptr, size_t offset_bytes, size_t length_bytes);
 
  void readWithConversion(DataContainer* dst, const ConversionData& conversion);
 
  inline size_t getMaxSize() const { return offset_bytes_.max_size; }
 
  inline size_t getSize() const { return offset_bytes_.size; }
 
  inline size_t getOffset() const { return offset_bytes_.offset; }
 
  inline const uint8_t* getData() const { return data_.ui_ptr; }
 
  inline Type getType() const { return type_; }
 
  void setSize(size_t size) {
    if (size < offset_bytes_.max_size) {
      offset_bytes_.size = size;
    } else {
      offset_bytes_.size = offset_bytes_.max_size;
    }
  }
 
  inline void setTime(const struct timespec& app_time) { app_time_ = app_time; }
 
  const struct timespec& getTime() const { return app_time_; }
 
private:
  Type type_{Type::NONE};
 
  bool allocated_{};
 
  struct {
    size_t offset;
    size_t size;
    size_t max_size;
  } offset_bytes_{};
 
  union {
    const void* v_ptr;
    uint8_t* ui_ptr;
  } data_{};
 
  struct timespec app_time_ {};
};
 
} // namespace parameter_server
 
} // namespace mcx
 
#endif /* PS_DATACONTAINER_H */