binary.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "irsol/assert.hpp"
#include "irsol/logging.hpp"
#include "irsol/macros.hpp"
#include "irsol/types.hpp"
 
#include <array>
#include <numeric>
#include <sstream>
#include <string_view>
#include <vector>
 
namespace irsol {
namespace protocol {
 
struct BinaryDataAttribute
{
  BinaryDataAttribute(const std::string& identifier, irsol::types::protocol_value_t value);
 
  std::string identifier;
 
  irsol::types::protocol_value_t value;
 
  std::string toString() const;
 
  bool hasInt() const;
 
  bool hasDouble() const;
 
  bool hasString() const;
};
 
namespace internal {
 
template<std::uint8_t N>
struct BinaryDataBufferName
{
  static constexpr std::string_view name()
  {
    if constexpr(N == 1) {
      return "BinaryDataBuffer";
    } else if constexpr(N == 2) {
      return "BinaryDataBuffer2D";
    } else if constexpr(N == 3) {
      return "BinaryDataBuffer3D";
    } else {
      IRSOL_STATIC_UNREACHABLE("Unsupported dimensionality for BinaryDataBuffer");
    }
  }
};
 
template<std::uint8_t NBytes, std::uint8_t N>
struct BinaryData
{
  IRSOL_STATIC_ASSERT((NBytes == 1 || NBytes == 2), "Binary data element byte size must be 1 or 2");
  IRSOL_STATIC_ASSERT(N >= 1, "Binary data dimensionality must be at least 1");
 
  static constexpr uint8_t BYTES_PER_ELEMENT = NBytes;
 
  static constexpr uint8_t DIM = N;
 
  BinaryData(
    std::vector<irsol::types::byte_t>&& data,
    const std::array<uint64_t, N>&      shape,
    std::vector<BinaryDataAttribute>&&  attributes = {})
    : data(std::move(data))
    , shape(shape)
    , numElements(std::accumulate(shape.begin(), shape.end(), 1ull, std::multiplies<>{}))
    , numBytes(numElements * BYTES_PER_ELEMENT)
    , attributes(std::move(attributes))
  {
    IRSOL_LOG_TRACE("BinaryData constructed: {}", toString());
    IRSOL_ASSERT_ERROR(
      this->data.size() == this->numBytes,
      "Data size (%lu) does not match the number of elements (%lu) multiplied by bytes per element "
      "(%d).",
      this->data.size(),
      this->numElements,
      this->BYTES_PER_ELEMENT);
  }
 
  BinaryData(BinaryData&& other) = default;
 
  // Disable copy semantics.
  BinaryData(const BinaryData&) = delete;
  BinaryData& operator=(const BinaryData&) = delete;
 
  // Disable move assignment to avoid accidental reassignment.
  BinaryData& operator=(BinaryData&& other) noexcept = delete;
 
  std::vector<irsol::types::byte_t> data;
 
  std::array<uint64_t, DIM> shape;
 
  uint64_t numElements;
 
  uint64_t numBytes;
 
  std::vector<BinaryDataAttribute> attributes;
 
  std::string toString() const
  {
    std::stringstream ss;
    ss << BinaryDataBufferName<N>::name() << "u" << (BYTES_PER_ELEMENT == 1 ? "8" : "16")
       << "[shape=(" << std::to_string(shape[0]);
    for(uint8_t i = 1; i < DIM; ++i) {
      ss << "x" << std::to_string(shape[i]);
    }
    ss << ")](" << std::to_string(numBytes) << " bytes)";
    return ss.str();
  }
};
 
}  // namespace internal
 
using BinaryDataBuffer = internal::BinaryData<2, 1>;
 
using ImageBinaryData = internal::BinaryData<2, 2>;
 
using ColorImageBinaryData = internal::BinaryData<2, 3>;
 
}  // namespace protocol
}  // namespace irsol