DataFrameView.h

#pragma once
 
#include <string>
 
#include <iolink/DataType.h>
#include <iolink/FlagSet.h>
#include <iolink/IOLinkAPI.h>
#include <iolink/VectorX.h>
#include <iolink/view/View.h>
 
namespace iolink
{
 
enum class DataFrameCapability
{
  READ = 0x1,    
  WRITE = 0x2,   
  RESHAPE = 0x4, 
};
 
extern template class IOLINK_API_IMPORT FlagSet<DataFrameCapability>;
 
using DataFrameCapabilitySet = FlagSet<DataFrameCapability>;
 
// Define bitwise operators for DataFrameCapability
IOLINK_DEFINE_ENUM_BITWISE_OPERATORS(DataFrameCapability)
 
 
class IOLINK_API DataFrameView : public View
{
public:
  virtual DataFrameCapabilitySet capabilities() const = 0;
 
  virtual const Vector2u64& shape() const = 0;
 
  virtual const std::string& columnName(size_t index) const = 0;
 
  virtual size_t columnIndex(const std::string& name) const = 0;
 
  virtual DataType columnDataType(size_t index) const = 0;
 
  // ==== //
  // READ //
  // ==== //
 
  virtual void read(size_t column, size_t offset, size_t count, void* dst) const;
 
  template <typename T>
  inline T at(size_t column, size_t row) const
  {
    T value;
    this->read(column, row, 1, &value);
    return value;
  }
 
  template <typename T>
  inline T at(const std::string& columnName, size_t row) const
  {
    return this->at<T>(this->columnIndex(columnName), row);
  }
 
  const std::string& unit(size_t columnIndex);
 
  // ===== //
  // WRITE //
  // ===== //
 
  virtual void write(size_t column, size_t offset, size_t count, const void* src);
 
  template <typename T>
  inline void setAt(size_t column, size_t row, T value)
  {
    this->write(column, row, 1, &value);
  }
 
  template <typename T>
  inline void setAt(const std::string& columnName, size_t row, T value)
  {
    this->setAt<T>(this->columnIndex(columnName), row, value);
  }
 
  void setUnit(size_t columnIndex, const std::string& unit);
 
  // ======= //
  // RESHAPE //
  // ======= //
 
  virtual void addColumn(const std::string& name, DataType dtype);
 
  virtual void addRows(size_t offset, size_t count);
 
  virtual void removeColumn(size_t index);
 
  virtual void removeRows(size_t offset, size_t count);
 
  std::string toString() const;
 
  void reshape(const Vector2u64& shape, const std::string* columnNames, const DataType* columnDataTypes);
};
 
} // end namespace iolink