LookUpTable.h

#pragma once
 
#include <algorithm>
 
#include <iolink/DataType.h>
#include <iolink/DataTypeTraits.h>
#include <iolink/IOLinkAPI.h>
 
namespace iolink
{
 
class IOLINK_API LookUpTable
{
public:
  LookUpTable();
 
  LookUpTable(DataType dtype, size_t count);
 
  LookUpTable(DataType dtype, const void* src, size_t count);
 
  template <typename T>
  LookUpTable(std::initializer_list<T> init)
      : LookUpTable(DataTypeTraits<T>::toDataType(), init.size())
  {
    T* dst = reinterpret_cast<T*>(buffer());
    std::copy_n(init.begin(), init.size(), dst);
  }
 
  template <typename InputIt>
  LookUpTable(InputIt first, InputIt last)
      : LookUpTable(DataTypeTraits<typename InputIt::value_type>::toDataType(), std::distance(first, last))
  {
    using ValueType = typename InputIt::value_type;
    ValueType* dst = reinterpret_cast<ValueType*>(buffer());
    std::copy_n(first, count(), dst);
  }
 
  ~LookUpTable();
 
  LookUpTable(const LookUpTable& other);
  LookUpTable& operator=(const LookUpTable& other);
  LookUpTable(LookUpTable&& other) noexcept;
  LookUpTable& operator=(LookUpTable&& other) noexcept;
 
  DataType dtype() const;
 
  size_t count() const;
 
  void read(size_t offset, void* dst, size_t count) const;
 
  template <typename T>
  inline T at(size_t index) const
  {
    T value;
    read(index, &value, 1);
    return value;
  }
 
  size_t bufferSize() const;
 
  void* buffer();
 
  const void* buffer() const;
 
private:
  class Private;
  Private* m_private;
};
 
} // end namespace iolink