DUNE-DAQ
DUNE Trigger and Data Acquisition software
Loading...
Searching...
No Matches
Namespaces | Macros | Functions | Variables
Serialization.hpp File Reference
#include "ers/Issue.hpp"
#include "logging/Logging.hpp"
#include "boost/preprocessor.hpp"
#include "msgpack.hpp"
#include <algorithm>
#include <string>
#include <vector>
Include dependency graph for Serialization.hpp:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Namespaces

namespace  dunedaq
 The DUNE-DAQ namespace.
 

Macros

#define DUNE_DAQ_TYPESTRING(Type, typestring)
 Declare the datatype_to_string method for the given type.
 
#define DUNE_DAQ_SERIALIZABLE(Type, typestring)
 Macro to define a type as serializable, so it can be sent over the network.
 
#define DUNE_DAQ_SERIALIZE(Type, ...)
 Macro to make a class/struct serializable intrusively.
 
#define OPACK(r, data, elem)
 Helper macro for DUNE_DAQ_SERIALIZE_NON_INTRUSIVE()
 
#define OUNPACK(r, data, elem)
 Helper maro for DUNE_DAQ_SERIALIZE_NON_INTRUSIVE.
 
#define DUNE_DAQ_SERIALIZE_NON_INTRUSIVE(NS, Type, ...)
 Macro to make a class/struct serializable non-intrusively.
 
#define DUNE_DAQ_SERIALIZE_ENUM(Type)
 Macro to declare an enum type to the serialization library.
 

Functions

 dunedaq::ERS_DECLARE_ISSUE (serialization, UnknownSerializationTypeString, "Unknown serialization type "<< t,((std::string) t)) ERS_DECLARE_ISSUE(serialization
 Issue for when the serialization type cannot be determined from an input string.
 
return obj dunedaq::as< T > ()
 
 dunedaq::catch (msgpack::type_error &e)
 
 dunedaq::catch (msgpack::unpack_error &e)
 

Variables

 dunedaq::UnknownSerializationTypeByte
 
Unknown serialization type<< t,((char) t)) template< typename T > inline std::string datatype_to_string() { return "Unknown";} namespace serialization { template< typename T > struct is_serializable :std::false_type {};enum SerializationType { kMsgPack };inline SerializationType from_string(const std::string s) { if(s=="msgpack") return kMsgPack;throw UnknownSerializationTypeString(ERS_HERE, s);} constexpr uint8_t serialization_type_byte(SerializationType stype) { switch(stype) { case kMsgPack:return 'M';default:throw UnknownSerializationTypeEnum(ERS_HERE);} } constexpr SerializationType DEFAULT_SERIALIZATION_TYPE=kMsgPack;template< class T > std::vector< uint8_t > serialize(const T &obj, SerializationType stype=DEFAULT_SERIALIZATION_TYPE) { switch(stype) { case kMsgPack:{ msgpack::sbuffer buf;msgpack::pack(buf, obj);std::vector< uint8_t > ret(buf.size()+1);ret[0]=serialization_type_byte(stype);std::copy(buf.data(), buf.data()+buf.size(), ret.begin()+1);return ret;} default:throw UnknownSerializationTypeEnum(ERS_HERE);} } template< class T, typename CharType=unsigned char > T deserialize(const std::vector< CharType > &v) { switch(v[0]) { case serialization_type_byte(kMsgPack):{ try { msgpack::object_handle oh=msgpack::unpack(const_cast< char * >(reinterpret_cast< const char * >(v.data()+1)), v.size() - 1,[](msgpack::type::object_type, std::size_t, void *) -> dunedaq::bool { return true
 
msgpack::object dunedaq::obj = oh.get()
 
default dunedaq::__pad0__
 
default char dunedaq::v [0]
 

Detailed Description

This is part of the DUNE DAQ Application Framework, copyright 2020. Licensing/copyright details are in the COPYING file that you should have received with this code.

Serialization methods are defined here, currently only MsgPack is supported. For an example of how nlohmann::json was implemented, look at tag v1.4.0 of this file: https://github.com/DUNE-DAQ/serialization/blob/v1.4.0/include/serialization/Serialization.hpp In general, the DUNE_DAQ_SERIALIZE and DUNE_DAQ_SERIALIZE_NON_INTRUSIVE macros need to have definitions for the seralizer, and the serialize and deseralize methods need a case for each serialization type.

Definition in file Serialization.hpp.

Macro Definition Documentation

◆ DUNE_DAQ_SERIALIZABLE

#define DUNE_DAQ_SERIALIZABLE ( Type,
typestring )
Value:
DUNE_DAQ_TYPESTRING(Type, typestring) \
template<> \
struct dunedaq::serialization::is_serializable<Type> \
{ \
static constexpr bool value = true; \
}
DUNE_DAQ_TYPESTRING
#define DUNE_DAQ_TYPESTRING(Type, typestring)
Declare the datatype_to_string method for the given type.
Definition Serialization.hpp:36

Macro to define a type as serializable, so it can be sent over the network.

Definition at line 47 of file Serialization.hpp.

47#define DUNE_DAQ_SERIALIZABLE(Type, typestring) \
48 DUNE_DAQ_TYPESTRING(Type, typestring) \
49 template<> \
50 struct dunedaq::serialization::is_serializable<Type> \
51 { \
52 static constexpr bool value = true; \
53 }

◆ DUNE_DAQ_SERIALIZE

#define DUNE_DAQ_SERIALIZE ( Type,
... )
Value:
MSGPACK_DEFINE(__VA_ARGS__) \
static_assert(true, "")

Macro to make a class/struct serializable intrusively.

Call the macro inside your class declaration, with the first argument being the class name, followed by each of the member variables. Example: 

 struct MyType
 {
   int i;
   std::string s;
   std::vector<double> v;

   DUNE_DAQ_SERIALIZE(MyType, i, s, v);
 };

Definition at line 73 of file Serialization.hpp.

73#define DUNE_DAQ_SERIALIZE(Type, ...) \
74 MSGPACK_DEFINE(__VA_ARGS__) \
75 static_assert(true, "")

◆ DUNE_DAQ_SERIALIZE_ENUM

#define DUNE_DAQ_SERIALIZE_ENUM ( Type)
Value:
MSGPACK_ADD_ENUM(Type)

Macro to declare an enum type to the serialization library.

Definition at line 144 of file Serialization.hpp.

◆ DUNE_DAQ_SERIALIZE_NON_INTRUSIVE

#define DUNE_DAQ_SERIALIZE_NON_INTRUSIVE ( NS,
Type,
... )

Macro to make a class/struct serializable non-intrusively.

Call the macro outside your class declaration, from the global namespace. The first argument is the namespace of your class, the second is the class name, and the rest of the arguments list the member variables. Example: 

 namespace ns {
 struct MyType
 {
   int i;
   std::string s;
   std::vector<double> v;
 }
 }

 DUNE_DAQ_SERIALIZE_NON_INTRUSIVE(ns, MyType, i, s, v);

Definition at line 105 of file Serialization.hpp.

105#define DUNE_DAQ_SERIALIZE_NON_INTRUSIVE(NS, Type, ...) \
106 DUNE_DAQ_SERIALIZABLE(NS::Type, #Type); \
107 namespace msgpack { \
108 MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS) \
109 { \
110 namespace adaptor { \
111 template<> \
112 struct pack<NS::Type> \
113 { \
114 template<typename Stream> \
115 packer<Stream>& operator()(msgpack::packer<Stream>& o, NS::Type const& m) const \
116 { \
117 o.pack_array(BOOST_PP_VARIADIC_SIZE(__VA_ARGS__)); \
118 BOOST_PP_SEQ_FOR_EACH(OPACK, , BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__)) \
119 return o; \
120 } \
121 }; \
122 template<> \
123 struct convert<NS::Type> \
124 { \
125 msgpack::object const& operator()(msgpack::object const& o, NS::Type& m) const \
126 { \
127 if (o.type != msgpack::type::ARRAY) \
128 throw msgpack::type_error(); \
129 if (o.via.array.size != BOOST_PP_VARIADIC_SIZE(__VA_ARGS__)) \
130 throw msgpack::type_error(); \
131 int i = 0; \
132 BOOST_PP_SEQ_FOR_EACH(OUNPACK, , BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__)) \
133 return o; \
134 } \
135 }; \
136 } \
137 } \
138 }

◆ DUNE_DAQ_TYPESTRING

#define DUNE_DAQ_TYPESTRING ( Type,
typestring )
Value:
template<> \
inline std::string dunedaq::datatype_to_string<Type>() \
{ \
return typestring; \
}

Declare the datatype_to_string method for the given type.

Parameters
TypeC++ class
typestringString representation for this class

Definition at line 36 of file Serialization.hpp.

36#define DUNE_DAQ_TYPESTRING(Type, typestring) \
37 template<> \
38 inline std::string dunedaq::datatype_to_string<Type>() \
39 { \
40 return typestring; \
41 }

◆ OPACK

#define OPACK ( r,
data,
elem )
Value:
o.pack(m.elem);

Helper macro for DUNE_DAQ_SERIALIZE_NON_INTRUSIVE()

Definition at line 79 of file Serialization.hpp.

◆ OUNPACK

#define OUNPACK ( r,
data,
elem )
Value:
m.elem = o.via.array.ptr[i++].as<decltype(m.elem)>();

Helper maro for DUNE_DAQ_SERIALIZE_NON_INTRUSIVE.

Definition at line 82 of file Serialization.hpp.

Generated on Sat Aug 23 2025 for DUNE-DAQ by doxygen 1.12.0