#include <serializer.h>

Static Public Member Functions
template<event_c event_t>
static nngxx::msg	to_network (event_t &ev)

template<event_c event_t>
static event_t	to_event (const nngxx::msg &m)

Detailed Description

Definition at line 50 of file serializer.h.

Member Function Documentation

◆ to_event()

template<event_c event_t>

static event_t pars::ev::serialize::to_event ( const nngxx::msg & m )

inlinestatic

Definition at line 83 of file serializer.h.

  {
    // 1. compute received and requested event hash
    auto recv_event_hash = hash_from_msg(m);
    auto req_event_hash = uuid<klass<event_t>>::hash;
 
    // 2. check they correspond
    if (recv_event_hash - req_event_hash != 0)
      throw std::runtime_error("Requested event mismatch!");
 
    // 3. deserialize event
    auto body = m.body();
    auto view =
      std::string_view(body.data<char>() + sizeof(uint64_t), body.size());
    auto istring = std::ispanstream(view);
    auto istream = std::istream(istring.rdbuf());
    auto ar = cereal::BinaryInputArchive(istream);
 
    auto ev = event_t{};
    klass<event_t>::serialize(ev, ar);
 
    pars::debug(SL, lf::event, "Serialized Message [{}] to Event [{}]", m, ev);
 
    return ev;
  }

References pars::debug(), pars::event, and SL.

Referenced by pars::ev::job::event().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ to_network()

template<event_c event_t>

static nngxx::msg pars::ev::serialize::to_network ( event_t & ev )

inlinestatic

Definition at line 53 of file serializer.h.

  {
    // 1. serialize the event to a stringstream
    auto ostring = std::ostringstream();
    auto ostream = std::ostream(ostring.rdbuf());
    auto ar = cereal::BinaryOutputArchive(ostream);
    klass<event_t>::serialize(ev, ar);
 
    // 2. compute the event_hash
    auto event_hash = uuid<klass<event_t>>::hash;
 
    // 3. create the nngxx::msg to hold the hash+event
    auto serialization = ostring.rdbuf()->view();
    auto m = nngxx::make_msg(sizeof(event_hash) + serialization.size())
               .value_or_abort();
    auto b = m.body();
 
    // 4. append the event hash
    std::memcpy(b.data<char>(), &event_hash, sizeof(event_hash));
 
    // 5. append the serialized event
    std::memcpy(b.data<char>() + sizeof(event_hash), serialization.data(),
                serialization.size());
 
    pars::debug(SL, lf::event, "Serialized Event [{}] to Message [{}]", ev, m);
 
    return m;
  }