dunedaq::serialization Namespace Reference

Classes
struct	is_serializable

Enumerations
enum	SerializationType { kMsgPack }
	Serialization methods that are available. More...

Functions
SerializationType	from_string (const std::string s)
	Convert string to SerializationType.
constexpr uint8_t	serialization_type_byte (SerializationType stype)
template<class T >
std::vector< uint8_t >	serialize (const T &obj, SerializationType stype)
	Serialize object obj using serialization method stype.
template<class T , typename CharType = unsigned char>
T	deserialize (const std::vector< CharType > &v)
	Deserialize vector of bytes v into an instance of class T.

Enumeration Type Documentation

SerializationType

enum dunedaq::serialization::SerializationType

Serialization methods that are available.

Enumerator
kMsgPack

Definition at line 163 of file Serialization.hpp.

{
  kMsgPack
};

Function Documentation

deserialize()

template<class T , typename CharType = unsigned char>

T dunedaq::serialization::deserialize

(

const std::vector< CharType > &

v

)

Deserialize vector of bytes v into an instance of class T.

Definition at line 221 of file Serialization.hpp.

{
  // The first byte in the array indicates the serialization format;
  // the rest is the actual message
  switch (v[0]) {
    case serialization_type_byte(kMsgPack): {
      try {
        // The lambda function here is of type `unpack_reference_func`
        // as described at
        // https://github.com/msgpack/msgpack-c/wiki/v2_0_cpp_unpacker#memory-management
        // . It is called for every STR, BIN and EXT field in the
        // MsgPack data. If the function returns false, the object is
        // copied into MsgPack's "zone", otherwise a pointer to the
        // original buffer is stored. Our input buffer is going to exist
        // at least until the end of this function, so it's safe to
        // return true (ie, store a pointer in the MsgPack object; no
        // copy) everywhere. Doing so results in a factor ~2 speedup in
        // deserializing Fragment, which is just a large BIN field
        msgpack::object_handle oh = msgpack::unpack(
          const_cast<char*>(reinterpret_cast<const char*>(v.data() + 1)),
          v.size() - 1,
          [](msgpack::type::object_type /*typ*/, std::size_t /*length*/, void* /*user_data*/) -> bool { return true; });
        msgpack::object obj = oh.get();
        return obj.as<T>();
      } catch (msgpack::type_error& e) {
        throw CannotDeserializeMessage(ERS_HERE, e);
      } catch (msgpack::unpack_error& e) {
        throw CannotDeserializeMessage(ERS_HERE, e);
      }
    }
    default:
      throw UnknownSerializationTypeByte(ERS_HERE, (char)v[0]); // NOLINT
  }
}

from_string()

SerializationType dunedaq::serialization::from_string ( const std::string s )

inline

Convert string to SerializationType.

Definition at line 172 of file Serialization.hpp.

{
  if (s == "msgpack")
    return kMsgPack;
  throw UnknownSerializationTypeString(ERS_HERE, s);
}

serialization_type_byte()

uint8_t dunedaq::serialization::serialization_type_byte ( SerializationType stype )

constexpr

Definition at line 180 of file Serialization.hpp.

{
  switch (stype) {
    case kMsgPack:
      return 'M';
    default:
      throw UnknownSerializationTypeEnum(ERS_HERE);
  }
}

serialize()

template<class T >

std::vector< uint8_t > dunedaq::serialization::serialize	(	const T &	obj,
		SerializationType	stype )

Serialize object obj using serialization method stype.

Definition at line 195 of file Serialization.hpp.

{
  switch (stype) {
    case kMsgPack: {
      // Serialize into the sbuffer and then copy to a
      // std::vector. Seems like it would be more efficient to
      // write directly to the vector (by creating a class that
      // implements `void write(char* buf, size_t len)`), but my
      // tests aren't any faster than this
      msgpack::sbuffer buf;
      msgpack::pack(buf, obj);
      std::vector<uint8_t> ret(buf.size() + 1); // NOLINT(build/unsigned)
      ret[0] = serialization_type_byte(stype);
      std::copy(buf.data(), buf.data() + buf.size(), ret.begin() + 1); // NOLINT
      return ret;
    }
    default:
      throw UnknownSerializationTypeEnum(ERS_HERE);
  }
}