conversions.hpp

#pragma once
 
#include <optional>
 
#include "api/datatype.pb.h"
 
#include "zmq.h"
 
namespace synapse {

template <typename T>
std::optional<T> parse_protobuf_message(zmq::message_t message) {
  static_assert(std::is_base_of<google::protobuf::Message, T>::value,
                "T must be a protobuf message type");
  if (message.size() == 0) {
    return std::nullopt;
  }
  // TODO: We should probably pass a reference here instead of copying
  T output;
 
  // Parse the protobuf message from the ZMQ message data
  bool success = output.ParseFromArray(message.data(), static_cast<int>(message.size()));
 
  if (!success) {
    // Failed to parse the message
    return std::nullopt;
  }
  return output;
}

template <typename T>
zmq::message_t protobuf_to_zmq_message(const T& message) {
  static_assert(std::is_base_of<google::protobuf::Message, T>::value,
                "T must be a protobuf message type");
  const size_t message_size = message.ByteSizeLong();
  zmq::message_t out_message(message_size);
  if (!message.SerializeToArray(out_message.data(), message_size)) {
    return zmq::message_t(0);
  }
  return out_message;
}

template <typename T>
std::string pack_tensor_data(const std::vector<T>& data) {
  static_assert(std::is_arithmetic_v<T>, "Only arithmetic types are supported");
 
  if (data.empty()) {
    return "";
  }
  std::string result;
  result.resize(data.size() * sizeof(T));
  std::memcpy(result.data(), data.data(), result.size());
  return result;
}

template <typename T>
std::string pack_tensor_data(std::initializer_list<T> data) {
  return pack_tensor_data(std::vector<T>(data));
}
 
}  // namespace synapse