serialization.h File Reference

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
namespace	serialization
namespace	detail
	declaration and default definition for the functions used the API
namespace	serialization::detail

Macros
#define	BLOB_SERIALIZER(T)
	makes the type have a blob serializer trait defined
#define	FREE_SERIALIZER(T)
	adds the has_free_serializer to the type
#define	VARIANT_TAG(Archive, Type, Tag)
	Adds the tag \tag to the Archive of Type.
#define	BEGIN_SERIALIZE()
	Begins the environment of the DSL \detailed for describing how to serialize an of an archive type.
#define	BEGIN_SERIALIZE_OBJECT()
	begins the environment of the DSL \detailed for described the serialization of an object
#define	PREPARE_CUSTOM_VECTOR_SERIALIZATION(size, vec)
#define	PREPARE_CUSTOM_DEQUE_SERIALIZATION(size, vec)
#define	END_SERIALIZE()
	self-explanatory
#define	VALUE(f)
	the same as FIELD(f)
#define	FIELD_N(t, f)
	serializes a field f tagged t
#define	FIELD(f)
	tags the field with the variable name and then serializes it
#define	FIELDS(f)
	does not add a tag to the serialized value
#define	VARINT_FIELD(f)
	tags and serializes the varint f
#define	VARINT_FIELD_N(t, f)
	tags (as t) and serializes the varint f

Functions
template<class Archive, class T>
bool	do_serialize (Archive &ar, T &v)
	just calls the serialize function defined for ar and v...
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.

Definition in file serialization.h.

Macro Definition Documentation

BEGIN_SERIALIZE

#define BEGIN_SERIALIZE

(

)

Value:

template <bool W, template <bool> class Archive>          \
bool do_serialize(Archive<W> &ar) {

Begins the environment of the DSL \detailed for describing how to serialize an of an archive type.

\macro BEGIN_SERIALIZE

Definition at line 182 of file hash.h.

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

Definition at line 191 of file hash.h.

BLOB_SERIALIZER

#define BLOB_SERIALIZER

(

T

)

Value:

template<>                                \
struct is_blob_type<T> {                      \
  typedef boost::true_type type;                  \
}

makes the type have a blob serializer trait defined

\macro BLOB_SERIALIZER

Definition at line 148 of file hash.h.

END_SERIALIZE

#define END_SERIALIZE

(

)

Value:

return ar.stream().good();            \
}

self-explanatory

\macro END_SERIALIZE

Definition at line 215 of file hash.h.

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)

Definition at line 244 of file hash.h.

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)

Definition at line 233 of file hash.h.

FIELDS

#define FIELDS

(

f

)

Value:

do {                                  \
  bool r = ::do_serialize(ar, f);                 \
  if (!r || !ar.stream().good()) return false;            \
} while(0);

does not add a tag to the serialized value

\macro FIELDS(f)

Definition at line 255 of file hash.h.

FREE_SERIALIZER

#define FREE_SERIALIZER

(

T

)

Value:

template<>                                \
struct has_free_serializer<T> {                   \
  typedef boost::true_type type;                  \
}

adds the has_free_serializer to the type

\macro FREE_SERIALIZER

Definition at line 158 of file hash.h.

PREPARE_CUSTOM_DEQUE_SERIALIZATION

#define PREPARE_CUSTOM_DEQUE_SERIALIZATION	(		size,
			vec )

Value:

::serialization::detail::prepare_custom_deque_serialization(size, vec, typename Archive<W>::is_saving())

\macro PREPARE_CUSTOM_DEQUE_SERIALIZATION

Definition at line 209 of file hash.h.

PREPARE_CUSTOM_VECTOR_SERIALIZATION

#define PREPARE_CUSTOM_VECTOR_SERIALIZATION	(		size,
			vec )

Value:

::serialization::detail::prepare_custom_vector_serialization(size, vec, typename Archive<W>::is_saving())

\macro PREPARE_CUSTOM_VECTOR_SERIALIZATION

Definition at line 204 of file hash.h.

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)

Definition at line 222 of file hash.h.

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;                           \
  }                                   \
}

Adds the tag \tag to the Archive of Type.

\macro VARIANT_TAG

Definition at line 168 of file hash.h.

VARINT_FIELD

#define VARINT_FIELD

(

f

)

Value:

do {                      \
  ar.tag(#f);                 \
  ar.serialize_varint(f);         \
  if (!ar.stream().good()) return false;  \
} while(0);

tags and serializes the varint f

\macro VARINT_FIELD(f)

Definition at line 264 of file hash.h.

VARINT_FIELD_N

#define VARINT_FIELD_N	(		t,
			f )

Value:

do {                      \
  ar.tag(t);                  \
  ar.serialize_varint(f);         \
  if (!ar.stream().good()) return false;  \
} while(0);

tags (as t) and serializes the varint f

\macro VARINT_FIELD_N(t, f)

Definition at line 275 of file hash.h.

Function Documentation

do_serialize() [1/2]

template<class Archive>

bool do_serialize ( Archive & ar, bool & v )

inline

Definition at line 128 of file serialization.h.

{
  ar.serialize_blob(&v, sizeof(v));
  return true;
}

Here is the call graph for this function:

do_serialize() [2/2]

template<class Archive, class T>

bool do_serialize ( Archive & ar, T & v )

inline

just calls the serialize function defined for ar and v...

Definition at line 123 of file serialization.h.

{
  return ::serializer<Archive, T>::serialize(ar, v);
}

Here is the call graph for this function:

Here is the caller graph for this function: