Simple DSL AAPI based on. More...
#include <vector>#include <deque>#include <list>#include <set>#include <unordered_set>#include <string>#include <boost/type_traits/is_integral.hpp>#include <boost/type_traits/integral_constant.hpp>
Include dependency graph for serialization.h:
This graph shows which files directly or indirectly include this file:
Go to the source code of this file.
Classes | |
| struct | is_blob_type< T > |
| a descriptor for dispatching serialize More... | |
| struct | has_free_serializer< T > |
| a descriptor for dispatching serialize More... | |
| struct | is_basic_type< T > |
| a descriptor for dispatching serialize More... | |
| struct | is_basic_type< std::pair< F, S > > |
| struct | is_basic_type< std::string > |
| struct | serializer< Archive, T > |
| ... wouldn't a class be better? More... | |
Namespaces | |
| serialization | |
| detail | |
| declaration and default definition for the functions used the API | |
| serialization::detail | |
Macros | |
| #define | BLOB_SERIALIZER(T) |
| makes the type have a blob serializer trait defined More... | |
| #define | FREE_SERIALIZER(T) |
| adds the has_free_serializer to the type More... | |
| #define | VARIANT_TAG(Archive, Type, Tag) |
| Adds the tag \tag to the Archive of Type. More... | |
| #define | BEGIN_SERIALIZE() |
| Begins the environment of the DSL \detailed for describing how to serialize an of an archive type. More... | |
| #define | BEGIN_SERIALIZE_OBJECT() |
| begins the environment of the DSL \detailed for described the serialization of an object More... | |
| #define | PREPARE_CUSTOM_VECTOR_SERIALIZATION(size, vec) ::serialization::detail::prepare_custom_vector_serialization(size, vec, typename Archive<W>::is_saving()) |
| #define | PREPARE_CUSTOM_DEQUE_SERIALIZATION(size, vec) ::serialization::detail::prepare_custom_deque_serialization(size, vec, typename Archive<W>::is_saving()) |
| #define | END_SERIALIZE() |
| self-explanatory More... | |
| #define | VALUE(f) |
| the same as FIELD(f) More... | |
| #define | FIELD_N(t, f) |
| serializes a field f tagged t More... | |
| #define | FIELD(f) |
| tags the field with the variable name and then serializes it More... | |
| #define | FIELDS(f) |
| does not add a tag to the serialized value More... | |
| #define | VARINT_FIELD(f) |
| tags and serializes the varint f More... | |
| #define | VARINT_FIELD_N(t, f) |
| tags (as t) and serializes the varint f More... | |
Functions | |
| template<class Archive , class T > | |
| bool | do_serialize (Archive &ar, T &v) |
| just calls the serialize function defined for ar and v... More... | |
| template<class Archive > | |
| bool | do_serialize (Archive &ar, bool &v) |
| template<typename T > | |
| void | serialization::detail::prepare_custom_vector_serialization (size_t size, std::vector< T > &vec, const boost::mpl::bool_< true > &) |
| template<typename T > | |
| void | serialization::detail::prepare_custom_vector_serialization (size_t size, std::vector< T > &vec, const boost::mpl::bool_< false > &) |
| template<typename T > | |
| void | serialization::detail::prepare_custom_deque_serialization (size_t size, std::deque< T > &vec, const boost::mpl::bool_< true > &) |
| template<typename T > | |
| void | serialization::detail::prepare_custom_deque_serialization (size_t size, std::deque< T > &vec, const boost::mpl::bool_< false > &) |
| template<class Stream > | |
| bool | serialization::detail::do_check_stream_state (Stream &s, boost::mpl::bool_< true >, bool noeof) |
| template<class Stream > | |
| bool | serialization::detail::do_check_stream_state (Stream &s, boost::mpl::bool_< false >, bool noeof) |
| template<class Archive > | |
| bool | serialization::check_stream_state (Archive &ar, bool noeof=false) |
| template<class Archive , class T > | |
| bool | serialization::serialize (Archive &ar, T &v) |
| template<class Archive , class T > | |
| bool | serialization::serialize_noeof (Archive &ar, T &v) |
Detailed Description
Simple DSL AAPI based on.
\detailed is_blob_type and has_free_serializer are both descriptors for dispatching on to the serialize function.
The API itself defines a domain specific language via dirty macro hacks. Greenspun's tenth rule is very much in action throughout this entire code base.
Macro Definition Documentation
◆ BEGIN_SERIALIZE
| #define BEGIN_SERIALIZE | ( | ) |
Value:
template <bool W, template <bool> class Archive> \
bool do_serialize(Archive<W> &ar) {
bool do_serialize(Archive &ar, T &v)
just calls the serialize function defined for ar and v...
Definition: serialization.h:123
Begins the environment of the DSL \detailed for describing how to serialize an of an archive type.
\macro BEGIN_SERIALIZE
◆ BEGIN_SERIALIZE_OBJECT
| #define BEGIN_SERIALIZE_OBJECT | ( | ) |
Value:
template <bool W, template <bool> class Archive> \
bool do_serialize(Archive<W> &ar) { \
ar.begin_object(); \
bool r = do_serialize_object(ar); \
ar.end_object(); \
return r; \
} \
template <bool W, template <bool> class Archive> \
bool do_serialize_object(Archive<W> &ar){
begins the environment of the DSL \detailed for described the serialization of an object
\macro BEGIN_SERIALIZE_OBJECT
◆ BLOB_SERIALIZER
| #define BLOB_SERIALIZER | ( | T | ) |
Value:
makes the type have a blob serializer trait defined
\macro BLOB_SERIALIZER
◆ END_SERIALIZE
| #define END_SERIALIZE | ( | ) |
Value:
return ar.stream().good(); \
}
self-explanatory
\macro END_SERIALIZE
◆ FIELD
| #define FIELD | ( | f | ) |
Value:
do { \
ar.tag(#f); \
bool r = ::do_serialize(ar, f); \
if (!r || !ar.stream().good()) return false; \
} while(0);
tags the field with the variable name and then serializes it
\macro FIELD(f)
◆ FIELD_N
| #define FIELD_N | ( | t, | |
| f | |||
| ) |
Value:
do { \
ar.tag(t); \
bool r = ::do_serialize(ar, f); \
if (!r || !ar.stream().good()) return false; \
} while(0);
serializes a field f tagged t
\macro FIELD_N(t,f)
◆ FIELDS
| #define FIELDS | ( | f | ) |
Value:
does not add a tag to the serialized value
\macro FIELDS(f)
◆ FREE_SERIALIZER
| #define FREE_SERIALIZER | ( | T | ) |
Value:
adds the has_free_serializer to the type
\macro FREE_SERIALIZER
◆ PREPARE_CUSTOM_DEQUE_SERIALIZATION
| #define PREPARE_CUSTOM_DEQUE_SERIALIZATION | ( | size, | |
| vec | |||
| ) | ::serialization::detail::prepare_custom_deque_serialization(size, vec, typename Archive<W>::is_saving()) |
\macro PREPARE_CUSTOM_DEQUE_SERIALIZATION
◆ PREPARE_CUSTOM_VECTOR_SERIALIZATION
| #define PREPARE_CUSTOM_VECTOR_SERIALIZATION | ( | size, | |
| vec | |||
| ) | ::serialization::detail::prepare_custom_vector_serialization(size, vec, typename Archive<W>::is_saving()) |
\macro PREPARE_CUSTOM_VECTOR_SERIALIZATION
◆ VALUE
| #define VALUE | ( | f | ) |
Value:
do { \
ar.tag(#f); \
bool r = ::do_serialize(ar, f); \
if (!r || !ar.stream().good()) return false; \
} while(0);
the same as FIELD(f)
\macro VALUE(f)
◆ VARIANT_TAG
| #define VARIANT_TAG | ( | Archive, | |
| Type, | |||
| Tag | |||
| ) |
Value:
template <bool W> \
struct variant_serialization_traits<Archive<W>, Type> { \
static inline typename Archive<W>::variant_tag_type get_tag() { \
return Tag; \
} \
}
Definition: variant.h:57
Adds the tag \tag to the Archive of Type.
\macro VARIANT_TAG
◆ VARINT_FIELD
| #define VARINT_FIELD | ( | f | ) |
Value:
tags and serializes the varint f
\macro VARINT_FIELD(f)
◆ VARINT_FIELD_N
| #define VARINT_FIELD_N | ( | t, | |
| f | |||
| ) |
Value:
tags (as t) and serializes the varint f
\macro VARINT_FIELD_N(t, f)
Function Documentation
◆ do_serialize() [1/2]
◆ do_serialize() [2/2]
template<class Archive , class T >
|
inline |
just calls the serialize function defined for ar and v...
