29 #ifndef CEREAL_CEREAL_HPP_ 30 #define CEREAL_CEREAL_HPP_ 32 #include <type_traits> 35 #include <unordered_map> 36 #include <unordered_set> 53 template <
class T>
inline 56 return {name.c_str(), std::forward<T>(value)};
62 template <
class T>
inline 65 return {name, std::forward<T>(value)};
71 #define CEREAL_NVP(T) ::cereal::make_nvp(#T, T) 79 template <
class T>
inline 82 return {std::forward<T>(data), size};
94 template <
class T>
inline 97 return {std::forward<T>(sz)};
107 template <
class Archive,
class T>
inline 114 template <
class Archive,
class T>
inline 131 enum Flags { AllowEmptyClassElision = 1 };
141 #define CEREAL_REGISTER_ARCHIVE(Archive) \ 142 namespace cereal { namespace detail { \ 143 template <class T, class BindingTag> \ 144 typename polymorphic_serialization_support<Archive, T>::type \ 145 instantiate_polymorphic_binding( T*, Archive*, BindingTag, adl_tag ); \ 199 #define CEREAL_CLASS_VERSION(TYPE, VERSION_NUMBER) \ 200 namespace cereal { namespace detail { \ 201 template <> struct Version<TYPE> \ 203 static const std::uint32_t version; \ 204 static std::uint32_t registerVersion() \ 206 ::cereal::detail::StaticObject<Versions>::getInstance().mapping.emplace( \ 207 std::type_index(typeid(TYPE)).hash_code(), VERSION_NUMBER ); \ 208 return VERSION_NUMBER; \ 210 static void unused() { (void)version; } \ 212 const std::uint32_t Version<TYPE>::version = \ 213 Version<TYPE>::registerVersion(); \ 214 } } // end namespaces 233 template<
class ArchiveType, std::u
int32_t Flags = 0>
239 OutputArchive(ArchiveType *
const derived) : self(derived), itsCurrentPointerId(1), itsCurrentPolymorphicTypeId(1)
246 template <
class ... Types>
inline 249 self->process( std::forward<Types>( args )... );
262 template <
class T>
inline 265 self->process( std::forward<T>( arg ) );
273 template <
class T>
inline 276 self->process( std::forward<T>( arg ) );
293 if(addr == 0)
return 0;
295 auto id = itsSharedPointerMap.find( addr );
296 if(
id == itsSharedPointerMap.end() )
298 auto ptrId = itsCurrentPointerId++;
299 itsSharedPointerMap.insert( {addr, ptrId} );
300 return ptrId | detail::msb_32bit;
316 auto id = itsPolymorphicTypeMap.find( name );
317 if(
id == itsPolymorphicTypeMap.end() )
319 auto polyId = itsCurrentPolymorphicTypeId++;
320 itsPolymorphicTypeMap.insert( {name, polyId} );
321 return polyId | detail::msb_32bit;
329 template <
class T>
inline 330 void process( T && head )
333 self->processImpl( head );
338 template <
class T,
class ... Other>
inline 339 void process( T && head, Other && ... tail )
341 self->process( std::forward<T>( head ) );
342 self->process( std::forward<Other>( tail )... );
347 template <
class T>
inline 351 if(itsBaseClassSet.count(
id) == 0)
353 itsBaseClassSet.insert(
id);
354 self->processImpl( *b.base_ptr );
361 template <
class T>
inline 364 self->processImpl( *b.base_ptr );
375 #define PROCESS_IF(name) \ 376 traits::EnableIf<traits::has_##name<T, ArchiveType>::value, \ 377 !traits::has_invalid_output_versioning<T, ArchiveType>::value, \ 378 (traits::is_output_serializable<T, ArchiveType>::value && \ 379 (traits::is_specialized_##name<T, ArchiveType>::value || \ 380 !traits::is_specialized<T, ArchiveType>::value))> = traits::sfinae 383 template <
class T, PROCESS_IF(member_serialize)>
inline 384 ArchiveType & processImpl(T
const & t)
386 access::member_serialize(*
self, const_cast<T &>(t));
391 template <
class T, PROCESS_IF(non_member_serialize)>
inline 392 ArchiveType & processImpl(T
const & t)
399 template <
class T, PROCESS_IF(member_save)>
inline 400 ArchiveType & processImpl(T
const & t)
402 access::member_save(*
self, t);
407 template <
class T, PROCESS_IF(non_member_save)>
inline 408 ArchiveType & processImpl(T
const & t)
415 template <
class T, PROCESS_IF(member_save_minimal)>
inline 416 ArchiveType & processImpl(T
const & t)
418 self->process( access::member_save_minimal(*
self, t) );
423 template <
class T, PROCESS_IF(non_member_save_minimal)>
inline 424 ArchiveType & processImpl(T
const & t)
433 std::is_empty<T>::value> = traits::sfinae>
inline 434 ArchiveType & processImpl(T
const &)
443 template <class T, traits::EnableIf<traits::has_invalid_output_versioning<T, ArchiveType>::value ||
445 (!(
Flags & AllowEmptyClassElision) || ((
Flags & AllowEmptyClassElision) && !std::is_empty<T>::value)))> = traits::sfinae>
inline 446 ArchiveType & processImpl(T
const &)
449 "cereal could not find any output serialization functions for the provided type and archive combination. \n\n " 450 "Types must either have a serialize function, load/save pair, or load_minimal/save_minimal pair (you may not mix these). \n " 451 "Serialize functions generally have the following signature: \n\n " 452 "template<class Archive> \n " 453 " void serialize(Archive & ar) \n " 455 " ar( member1, member2, member3 ); \n " 459 "cereal found more than one compatible output serialization function for the provided type and archive combination. \n\n " 460 "Types must either have a serialize function, load/save pair, or load_minimal/save_minimal pair (you may not mix these). \n " 461 "Use specialization (see access.hpp) if you need to disambiguate between serialize vs load/save functions. \n " 462 "Note that serialization functions can be inherited which may lead to the aforementioned ambiguities. \n " 463 "In addition, you may not mix versioned with non-versioned serialization functions. \n\n ");
474 template <
class T>
inline 475 std::uint32_t registerClassVersion()
477 static const auto hash = std::type_index(
typeid(T)).hash_code();
478 const auto insertResult = itsVersionedTypes.insert( hash );
483 if( insertResult.second )
484 process( make_nvp<ArchiveType>(
"cereal_class_version", version) );
491 template <
class T, PROCESS_IF(member_versioned_serialize)>
inline 492 ArchiveType & processImpl(T
const & t)
494 access::member_serialize(*
self, const_cast<T &>(t), registerClassVersion<T>());
500 template <
class T, PROCESS_IF(non_member_versioned_serialize)>
inline 501 ArchiveType & processImpl(T
const & t)
509 template <
class T, PROCESS_IF(member_versioned_save)>
inline 510 ArchiveType & processImpl(T
const & t)
512 access::member_save(*
self, t, registerClassVersion<T>());
518 template <
class T, PROCESS_IF(non_member_versioned_save)>
inline 519 ArchiveType & processImpl(T
const & t)
527 template <
class T, PROCESS_IF(member_versioned_save_minimal)>
inline 528 ArchiveType & processImpl(T
const & t)
530 self->process( access::member_save_minimal(*
self, t, registerClassVersion<T>()) );
536 template <
class T, PROCESS_IF(non_member_versioned_save_minimal)>
inline 537 ArchiveType & processImpl(T
const & t)
546 ArchiveType *
const self;
549 std::unordered_set<traits::detail::base_class_id, traits::detail::base_class_id_hash> itsBaseClassSet;
552 std::unordered_map<void const *, std::uint32_t> itsSharedPointerMap;
555 std::uint32_t itsCurrentPointerId;
558 std::unordered_map<char const *, std::uint32_t> itsPolymorphicTypeMap;
561 std::uint32_t itsCurrentPolymorphicTypeId;
564 std::unordered_set<size_type> itsVersionedTypes;
584 template<
class ArchiveType, std::u
int32_t Flags = 0>
593 itsSharedPointerMap(),
594 itsPolymorphicTypeMap(),
602 template <
class ... Types>
inline 605 process( std::forward<Types>( args )... );
618 template <
class T>
inline 621 self->process( std::forward<T>( arg ) );
629 template <
class T>
inline 632 self->process( std::forward<T>( arg ) );
647 if(
id == 0)
return std::shared_ptr<void>(
nullptr);
649 auto iter = itsSharedPointerMap.find(
id );
650 if(iter == itsSharedPointerMap.end())
651 throw Exception(
"Error while trying to deserialize a smart pointer. Could not find id " + std::to_string(
id));
664 std::uint32_t
const stripped_id =
id & ~detail::msb_32bit;
665 itsSharedPointerMap[stripped_id] = ptr;
676 auto name = itsPolymorphicTypeMap.find(
id );
677 if(name == itsPolymorphicTypeMap.end())
679 throw Exception(
"Error while trying to deserialize a polymorphic pointer. Could not find type id " + std::to_string(
id));
692 std::uint32_t
const stripped_id =
id & ~detail::msb_32bit;
693 itsPolymorphicTypeMap.insert( {stripped_id, name} );
698 template <
class T>
inline 699 void process( T && head )
702 self->processImpl( head );
707 template <
class T,
class ... Other>
inline 708 void process( T && head, Other && ... tail )
710 process( std::forward<T>( head ) );
711 process( std::forward<Other>( tail )... );
716 template <
class T>
inline 720 if(itsBaseClassSet.count(
id) == 0)
722 itsBaseClassSet.insert(
id);
723 self->processImpl( *b.base_ptr );
730 template <
class T>
inline 733 self->processImpl( *b.base_ptr );
744 #define PROCESS_IF(name) \ 745 traits::EnableIf<traits::has_##name<T, ArchiveType>::value, \ 746 !traits::has_invalid_input_versioning<T, ArchiveType>::value, \ 747 (traits::is_input_serializable<T, ArchiveType>::value && \ 748 (traits::is_specialized_##name<T, ArchiveType>::value || \ 749 !traits::is_specialized<T, ArchiveType>::value))> = traits::sfinae 752 template <
class T, PROCESS_IF(member_serialize)>
inline 753 ArchiveType & processImpl(T & t)
755 access::member_serialize(*
self, t);
760 template <
class T, PROCESS_IF(non_member_serialize)>
inline 761 ArchiveType & processImpl(T & t)
768 template <
class T, PROCESS_IF(member_load)>
inline 769 ArchiveType & processImpl(T & t)
771 access::member_load(*
self, t);
776 template <
class T, PROCESS_IF(non_member_load)>
inline 777 ArchiveType & processImpl(T & t)
784 template <
class T, PROCESS_IF(member_load_minimal)>
inline 785 ArchiveType & processImpl(T & t)
787 using OutArchiveType =
typename traits::detail::get_output_from_input<ArchiveType>::type;
788 typename traits::has_member_save_minimal<T, OutArchiveType>::type value;
789 self->process( value );
790 access::member_load_minimal(*
self, t, value);
795 template <
class T, PROCESS_IF(non_member_load_minimal)>
inline 796 ArchiveType & processImpl(T & t)
798 using OutArchiveType =
typename traits::detail::get_output_from_input<ArchiveType>::type;
799 typename traits::has_non_member_save_minimal<T, OutArchiveType>::type value;
800 self->process( value );
807 !traits::is_input_serializable<T, ArchiveType>::value,
808 std::is_empty<T>::value> = traits::sfinae>
inline 809 ArchiveType & processImpl(T
const &)
818 template <class T, traits::EnableIf<traits::has_invalid_input_versioning<T, ArchiveType>::value ||
819 (!traits::is_input_serializable<T, ArchiveType>::value &&
820 (!(
Flags & AllowEmptyClassElision) || ((
Flags & AllowEmptyClassElision) && !std::is_empty<T>::value)))> = traits::sfinae>
inline 821 ArchiveType & processImpl(T
const &)
823 static_assert(traits::detail::count_input_serializers<T, ArchiveType>::value != 0,
824 "cereal could not find any input serialization functions for the provided type and archive combination. \n\n " 825 "Types must either have a serialize function, load/save pair, or load_minimal/save_minimal pair (you may not mix these). \n " 826 "Serialize functions generally have the following signature: \n\n " 827 "template<class Archive> \n " 828 " void serialize(Archive & ar) \n " 830 " ar( member1, member2, member3 ); \n " 833 static_assert(traits::detail::count_input_serializers<T, ArchiveType>::value < 2,
834 "cereal found more than one compatible input serialization function for the provided type and archive combination. \n\n " 835 "Types must either have a serialize function, load/save pair, or load_minimal/save_minimal pair (you may not mix these). \n " 836 "Use specialization (see access.hpp) if you need to disambiguate between serialize vs load/save functions. \n " 837 "Note that serialization functions can be inherited which may lead to the aforementioned ambiguities. \n " 838 "In addition, you may not mix versioned with non-versioned serialization functions. \n\n ");
852 template <
class T>
inline 853 std::uint32_t loadClassVersion()
855 static const auto hash = std::type_index(
typeid(T)).hash_code();
856 auto lookupResult = itsVersionedTypes.find( hash );
858 if( lookupResult != itsVersionedTypes.end() )
859 return lookupResult->second;
862 std::uint32_t version;
864 process( make_nvp<ArchiveType>(
"cereal_class_version", version) );
865 itsVersionedTypes.emplace_hint( lookupResult, hash, version );
873 template <
class T, PROCESS_IF(member_versioned_serialize)>
inline 874 ArchiveType & processImpl(T & t)
876 const auto version = loadClassVersion<T>();
877 access::member_serialize(*
self, t, version);
883 template <
class T, PROCESS_IF(non_member_versioned_serialize)>
inline 884 ArchiveType & processImpl(T & t)
886 const auto version = loadClassVersion<T>();
893 template <
class T, PROCESS_IF(member_versioned_load)>
inline 894 ArchiveType & processImpl(T & t)
896 const auto version = loadClassVersion<T>();
897 access::member_load(*
self, t, version);
903 template <
class T, PROCESS_IF(non_member_versioned_load)>
inline 904 ArchiveType & processImpl(T & t)
906 const auto version = loadClassVersion<T>();
913 template <
class T, PROCESS_IF(member_versioned_load_minimal)>
inline 914 ArchiveType & processImpl(T & t)
917 const auto version = loadClassVersion<T>();
918 typename traits::has_member_versioned_save_minimal<T, OutArchiveType>::type value;
919 self->process(value);
920 access::member_load_minimal(*
self, t, value, version);
926 template <
class T, PROCESS_IF(non_member_versioned_load_minimal)>
inline 927 ArchiveType & processImpl(T & t)
930 const auto version = loadClassVersion<T>();
931 typename traits::has_non_member_versioned_save_minimal<T, OutArchiveType>::type value;
932 self->process(value);
940 ArchiveType *
const self;
943 std::unordered_set<traits::detail::base_class_id, traits::detail::base_class_id_hash> itsBaseClassSet;
946 std::unordered_map<std::uint32_t, std::shared_ptr<void>> itsSharedPointerMap;
949 std::unordered_map<std::uint32_t, std::string> itsPolymorphicTypeMap;
952 std::unordered_map<std::size_t, std::uint32_t> itsVersionedTypes;
959 #endif // CEREAL_CEREAL_HPP_ The number of output serialization functions available.
Definition: traits.hpp:1071
A wrapper around size metadata.
Definition: helpers.hpp:271
Casts a derived class to its virtual base class in a way that allows cereal to track inheritance...
Definition: base_class.hpp:186
Support for base classes (virtual and non-virtual)
typename detail::EnableIfHelper< Conditions... >::type EnableIf
Provides a way to enable a function if conditions are met.
Definition: traits.hpp:116
Version information class.
Definition: helpers.hpp:360
NameValuePair< T > make_nvp(std::string const &name, T &&value)
Creates a name value pair.
Definition: cereal.hpp:54
Internal type trait support.
Casts a derived class to its non-virtual base class in a way that safely supports abstract classes...
Definition: base_class.hpp:99
#define CEREAL_SERIALIZE_FUNCTION_NAME
The serialization/deserialization function name to search for.
Definition: macros.hpp:64
#define CEREAL_SAVE_MINIMAL_FUNCTION_NAME
The serialization (save_minimal) function name to search for.
Definition: macros.hpp:92
void prologue(Archive &, T const &)
Definition: cereal.hpp:108
SizeTag< T > make_size_tag(T &&sz)
Creates a size tag from some variable.
Definition: cereal.hpp:95
std::uint32_t registerPolymorphicType(char const *name)
Registers a polymorphic type name with the archive.
Definition: cereal.hpp:314
Support common types - always included automatically.
Internal helper functionality.
Flags
Special flags for archives.
Definition: cereal.hpp:131
static LockGuard lock()
Attempts to lock this static object for the current scope.
Definition: static_object.hpp:109
Definition: access.hpp:40
NameValuePair< T > make_nvp(const char *name, T &&value)
Creates a name value pair.
Definition: cereal.hpp:63
For holding name value pairs.
Definition: helpers.hpp:135
Definition: traits.hpp:1089
Preprocessor macros that can customise the cereal library.
#define CEREAL_LOAD_FUNCTION_NAME
The deserialization (load) function name to search for.
Definition: macros.hpp:71
ArchiveType & operator &(T &&arg)
Serializes passed in data.
Definition: cereal.hpp:263
#define CEREAL_LOAD_MINIMAL_FUNCTION_NAME
The deserialization (load_minimal) function name to search for.
Definition: macros.hpp:85
std::uint32_t registerSharedPointer(void const *addr)
Registers a shared pointer with the archive.
Definition: cereal.hpp:290
A wrapper around data that can be serialized in a binary fashion.
Definition: helpers.hpp:207
OutputArchive(ArchiveType *const derived)
Construct the output archive.
Definition: cereal.hpp:239
Definition: helpers.hpp:228
The base output archive class.
Definition: cereal.hpp:234
#define CEREAL_SAVE_FUNCTION_NAME
The serialization (save) function name to search for.
Definition: macros.hpp:78
ArchiveType & operator()(Types &&... args)
Serializes all passed in data.
Definition: cereal.hpp:247
Definition: traits.hpp:1316
ArchiveType & operator<<(T &&arg)
Serializes passed in data.
Definition: cereal.hpp:274
Definition: traits.hpp:1123
A static, pre-execution object.
Definition: static_object.hpp:67
An exception class thrown when things go wrong at runtime.
Definition: helpers.hpp:48
BinaryData< T > binary_data(T &&data, size_t size)
Convenience function to create binary data for both const and non const pointers. ...
Definition: cereal.hpp:80
void epilogue(Archive &, T const &)
Definition: cereal.hpp:115