cereal
A C++11 library for serialization
cereal.hpp
Go to the documentation of this file.
1 
3 /*
4  Copyright (c) 2014, Randolph Voorhies, Shane Grant
5  All rights reserved.
6 
7  Redistribution and use in source and binary forms, with or without
8  modification, are permitted provided that the following conditions are met:
9  * Redistributions of source code must retain the above copyright
10  notice, this list of conditions and the following disclaimer.
11  * Redistributions in binary form must reproduce the above copyright
12  notice, this list of conditions and the following disclaimer in the
13  documentation and/or other materials provided with the distribution.
14  * Neither the name of cereal nor the
15  names of its contributors may be used to endorse or promote products
16  derived from this software without specific prior written permission.
17 
18  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
19  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
22  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29 #ifndef CEREAL_CEREAL_HPP_
30 #define CEREAL_CEREAL_HPP_
31 
32 #include <type_traits>
33 #include <string>
34 #include <memory>
35 #include <unordered_map>
36 #include <unordered_set>
37 #include <vector>
38 #include <cstddef>
39 #include <cstdint>
40 #include <functional>
41 
42 #include <cereal/macros.hpp>
46 
47 namespace cereal
48 {
49  // ######################################################################
51 
53  template <class T> inline
54  NameValuePair<T> make_nvp( std::string const & name, T && value )
55  {
56  return {name.c_str(), std::forward<T>(value)};
57  }
58 
60 
62  template <class T> inline
63  NameValuePair<T> make_nvp( const char * name, T && value )
64  {
65  return {name, std::forward<T>(value)};
66  }
67 
69 
71  #define CEREAL_NVP(T) ::cereal::make_nvp(#T, T)
72 
73  // ######################################################################
75 
79  template <class T> inline
80  BinaryData<T> binary_data( T && data, size_t size )
81  {
82  return {std::forward<T>(data), size};
83  }
84 
85  // ######################################################################
87 
94  template <class T>
96  {
97  return {std::forward<T>(sz)};
98  }
99 
100  // ######################################################################
103 
107  template <class Archive, class T>
108  void prologue( Archive & /* archive */, T const & /* data */)
109  { }
110 
113 
114  template <class Archive, class T>
115  void epilogue( Archive & /* archive */, T const & /* data */)
116  { }
117 
118  // ######################################################################
120 
131  enum Flags { AllowEmptyClassElision = 1 };
132 
133  // ######################################################################
135 
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 ); \
146  } } /* end namespaces */
147 
148  // ######################################################################
150 
199  #define CEREAL_CLASS_VERSION(TYPE, VERSION_NUMBER) \
200  namespace cereal { namespace detail { \
201  template <> struct Version<TYPE> \
202  { \
203  static const std::uint32_t version; \
204  static std::uint32_t registerVersion() \
205  { \
206  ::cereal::detail::StaticObject<Versions>::getInstance().mapping.emplace( \
207  std::type_index(typeid(TYPE)).hash_code(), VERSION_NUMBER ); \
208  return VERSION_NUMBER; \
209  } \
210  static void unused() { (void)version; } \
211  }; /* end Version */ \
212  const std::uint32_t Version<TYPE>::version = \
213  Version<TYPE>::registerVersion(); \
214  } } // end namespaces
215 
216  // ######################################################################
218 
233  template<class ArchiveType, std::uint32_t Flags = 0>
235  {
236  public:
238 
239  OutputArchive(ArchiveType * const derived) : self(derived), itsCurrentPointerId(1), itsCurrentPolymorphicTypeId(1)
240  { }
241 
242  OutputArchive & operator=( OutputArchive const & ) = delete;
243 
245 
246  template <class ... Types> inline
247  ArchiveType & operator()( Types && ... args )
248  {
249  self->process( std::forward<Types>( args )... );
250  return *self;
251  }
252 
256 
259 
262  template <class T> inline
263  ArchiveType & operator&( T && arg )
264  {
265  self->process( std::forward<T>( arg ) );
266  return *self;
267  }
268 
270 
273  template <class T> inline
274  ArchiveType & operator<<( T && arg )
275  {
276  self->process( std::forward<T>( arg ) );
277  return *self;
278  }
279 
281 
283 
290  inline std::uint32_t registerSharedPointer( void const * addr )
291  {
292  // Handle null pointers by just returning 0
293  if(addr == 0) return 0;
294 
295  auto id = itsSharedPointerMap.find( addr );
296  if( id == itsSharedPointerMap.end() )
297  {
298  auto ptrId = itsCurrentPointerId++;
299  itsSharedPointerMap.insert( {addr, ptrId} );
300  return ptrId | detail::msb_32bit; // mask MSB to be 1
301  }
302  else
303  return id->second;
304  }
305 
307 
314  inline std::uint32_t registerPolymorphicType( char const * name )
315  {
316  auto id = itsPolymorphicTypeMap.find( name );
317  if( id == itsPolymorphicTypeMap.end() )
318  {
319  auto polyId = itsCurrentPolymorphicTypeId++;
320  itsPolymorphicTypeMap.insert( {name, polyId} );
321  return polyId | detail::msb_32bit; // mask MSB to be 1
322  }
323  else
324  return id->second;
325  }
326 
327  private:
329  template <class T> inline
330  void process( T && head )
331  {
332  prologue( *self, head );
333  self->processImpl( head );
334  epilogue( *self, head );
335  }
336 
338  template <class T, class ... Other> inline
339  void process( T && head, Other && ... tail )
340  {
341  self->process( std::forward<T>( head ) );
342  self->process( std::forward<Other>( tail )... );
343  }
344 
346 
347  template <class T> inline
348  ArchiveType & processImpl(virtual_base_class<T> const & b)
349  {
350  traits::detail::base_class_id id(b.base_ptr);
351  if(itsBaseClassSet.count(id) == 0)
352  {
353  itsBaseClassSet.insert(id);
354  self->processImpl( *b.base_ptr );
355  }
356  return *self;
357  }
358 
360 
361  template <class T> inline
362  ArchiveType & processImpl(base_class<T> const & b)
363  {
364  self->processImpl( *b.base_ptr );
365  return *self;
366  }
367 
369 
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
381 
383  template <class T, PROCESS_IF(member_serialize)> inline
384  ArchiveType & processImpl(T const & t)
385  {
386  access::member_serialize(*self, const_cast<T &>(t));
387  return *self;
388  }
389 
391  template <class T, PROCESS_IF(non_member_serialize)> inline
392  ArchiveType & processImpl(T const & t)
393  {
394  CEREAL_SERIALIZE_FUNCTION_NAME(*self, const_cast<T &>(t));
395  return *self;
396  }
397 
399  template <class T, PROCESS_IF(member_save)> inline
400  ArchiveType & processImpl(T const & t)
401  {
402  access::member_save(*self, t);
403  return *self;
404  }
405 
407  template <class T, PROCESS_IF(non_member_save)> inline
408  ArchiveType & processImpl(T const & t)
409  {
410  CEREAL_SAVE_FUNCTION_NAME(*self, t);
411  return *self;
412  }
413 
415  template <class T, PROCESS_IF(member_save_minimal)> inline
416  ArchiveType & processImpl(T const & t)
417  {
418  self->process( access::member_save_minimal(*self, t) );
419  return *self;
420  }
421 
423  template <class T, PROCESS_IF(non_member_save_minimal)> inline
424  ArchiveType & processImpl(T const & t)
425  {
426  self->process( CEREAL_SAVE_MINIMAL_FUNCTION_NAME(*self, t) );
427  return *self;
428  }
429 
431  template <class T, traits::EnableIf<(Flags & AllowEmptyClassElision),
433  std::is_empty<T>::value> = traits::sfinae> inline
434  ArchiveType & processImpl(T const &)
435  {
436  return *self;
437  }
438 
440 
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 &)
447  {
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 "
454  " { \n "
455  " ar( member1, member2, member3 ); \n "
456  " } \n\n " );
457 
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 ");
464 
465  return *self;
466  }
467 
469 
474  template <class T> inline
475  std::uint32_t registerClassVersion()
476  {
477  static const auto hash = std::type_index(typeid(T)).hash_code();
478  const auto insertResult = itsVersionedTypes.insert( hash );
479  const auto version =
481 
482  if( insertResult.second ) // insertion took place, serialize the version number
483  process( make_nvp<ArchiveType>("cereal_class_version", version) );
484 
485  return version;
486  }
487 
489 
490  template <class T, PROCESS_IF(member_versioned_serialize)> inline
491  ArchiveType & processImpl(T const & t)
492  {
493  access::member_serialize(*self, const_cast<T &>(t), registerClassVersion<T>());
494  return *self;
495  }
496 
498 
499  template <class T, PROCESS_IF(non_member_versioned_serialize)> inline
500  ArchiveType & processImpl(T const & t)
501  {
502  CEREAL_SERIALIZE_FUNCTION_NAME(*self, const_cast<T &>(t), registerClassVersion<T>());
503  return *self;
504  }
505 
507 
508  template <class T, PROCESS_IF(member_versioned_save)> inline
509  ArchiveType & processImpl(T const & t)
510  {
511  access::member_save(*self, t, registerClassVersion<T>());
512  return *self;
513  }
514 
516 
517  template <class T, PROCESS_IF(non_member_versioned_save)> inline
518  ArchiveType & processImpl(T const & t)
519  {
520  CEREAL_SAVE_FUNCTION_NAME(*self, t, registerClassVersion<T>());
521  return *self;
522  }
523 
525 
526  template <class T, PROCESS_IF(member_versioned_save_minimal)> inline
527  ArchiveType & processImpl(T const & t)
528  {
529  self->process( access::member_save_minimal(*self, t, registerClassVersion<T>()) );
530  return *self;
531  }
532 
534 
535  template <class T, PROCESS_IF(non_member_versioned_save_minimal)> inline
536  ArchiveType & processImpl(T const & t)
537  {
538  self->process( CEREAL_SAVE_MINIMAL_FUNCTION_NAME(*self, t, registerClassVersion<T>()) );
539  return *self;
540  }
541 
542  #undef PROCESS_IF
543 
544  private:
545  ArchiveType * const self;
546 
548  std::unordered_set<traits::detail::base_class_id, traits::detail::base_class_id_hash> itsBaseClassSet;
549 
551  std::unordered_map<void const *, std::uint32_t> itsSharedPointerMap;
552 
554  std::uint32_t itsCurrentPointerId;
555 
557  std::unordered_map<char const *, std::uint32_t> itsPolymorphicTypeMap;
558 
560  std::uint32_t itsCurrentPolymorphicTypeId;
561 
563  std::unordered_set<size_type> itsVersionedTypes;
564  }; // class OutputArchive
565 
566  // ######################################################################
568 
583  template<class ArchiveType, std::uint32_t Flags = 0>
585  {
586  public:
588 
589  InputArchive(ArchiveType * const derived) :
590  self(derived),
591  itsBaseClassSet(),
592  itsSharedPointerMap(),
593  itsPolymorphicTypeMap(),
594  itsVersionedTypes()
595  { }
596 
597  InputArchive & operator=( InputArchive const & ) = delete;
598 
600 
601  template <class ... Types> inline
602  ArchiveType & operator()( Types && ... args )
603  {
604  process( std::forward<Types>( args )... );
605  return *self;
606  }
607 
611 
614 
617  template <class T> inline
618  ArchiveType & operator&( T && arg )
619  {
620  self->process( std::forward<T>( arg ) );
621  return *self;
622  }
623 
625 
628  template <class T> inline
629  ArchiveType & operator>>( T && arg )
630  {
631  self->process( std::forward<T>( arg ) );
632  return *self;
633  }
634 
636 
638 
644  inline std::shared_ptr<void> getSharedPointer(std::uint32_t const id)
645  {
646  if(id == 0) return std::shared_ptr<void>(nullptr);
647 
648  auto iter = itsSharedPointerMap.find( id );
649  if(iter == itsSharedPointerMap.end())
650  throw Exception("Error while trying to deserialize a smart pointer. Could not find id " + std::to_string(id));
651 
652  return iter->second;
653  }
654 
656 
661  inline void registerSharedPointer(std::uint32_t const id, std::shared_ptr<void> ptr)
662  {
663  std::uint32_t const stripped_id = id & ~detail::msb_32bit;
664  itsSharedPointerMap[stripped_id] = ptr;
665  }
666 
668 
673  inline std::string getPolymorphicName(std::uint32_t const id)
674  {
675  auto name = itsPolymorphicTypeMap.find( id );
676  if(name == itsPolymorphicTypeMap.end())
677  {
678  throw Exception("Error while trying to deserialize a polymorphic pointer. Could not find type id " + std::to_string(id));
679  }
680  return name->second;
681  }
682 
684 
689  inline void registerPolymorphicName(std::uint32_t const id, std::string const & name)
690  {
691  std::uint32_t const stripped_id = id & ~detail::msb_32bit;
692  itsPolymorphicTypeMap.insert( {stripped_id, name} );
693  }
694 
695  private:
697  template <class T> inline
698  void process( T && head )
699  {
700  prologue( *self, head );
701  self->processImpl( head );
702  epilogue( *self, head );
703  }
704 
706  template <class T, class ... Other> inline
707  void process( T && head, Other && ... tail )
708  {
709  process( std::forward<T>( head ) );
710  process( std::forward<Other>( tail )... );
711  }
712 
714 
715  template <class T> inline
716  ArchiveType & processImpl(virtual_base_class<T> & b)
717  {
718  traits::detail::base_class_id id(b.base_ptr);
719  if(itsBaseClassSet.count(id) == 0)
720  {
721  itsBaseClassSet.insert(id);
722  self->processImpl( *b.base_ptr );
723  }
724  return *self;
725  }
726 
728 
729  template <class T> inline
730  ArchiveType & processImpl(base_class<T> & b)
731  {
732  self->processImpl( *b.base_ptr );
733  return *self;
734  }
735 
737 
743  #define PROCESS_IF(name) \
744  traits::EnableIf<traits::has_##name<T, ArchiveType>::value, \
745  !traits::has_invalid_input_versioning<T, ArchiveType>::value, \
746  (traits::is_input_serializable<T, ArchiveType>::value && \
747  (traits::is_specialized_##name<T, ArchiveType>::value || \
748  !traits::is_specialized<T, ArchiveType>::value))> = traits::sfinae
749 
751  template <class T, PROCESS_IF(member_serialize)> inline
752  ArchiveType & processImpl(T & t)
753  {
754  access::member_serialize(*self, t);
755  return *self;
756  }
757 
759  template <class T, PROCESS_IF(non_member_serialize)> inline
760  ArchiveType & processImpl(T & t)
761  {
763  return *self;
764  }
765 
767  template <class T, PROCESS_IF(member_load)> inline
768  ArchiveType & processImpl(T & t)
769  {
770  access::member_load(*self, t);
771  return *self;
772  }
773 
775  template <class T, PROCESS_IF(non_member_load)> inline
776  ArchiveType & processImpl(T & t)
777  {
778  CEREAL_LOAD_FUNCTION_NAME(*self, t);
779  return *self;
780  }
781 
783  template <class T, PROCESS_IF(member_load_minimal)> inline
784  ArchiveType & processImpl(T & t)
785  {
786  using OutArchiveType = typename traits::detail::get_output_from_input<ArchiveType>::type;
787  typename traits::has_member_save_minimal<T, OutArchiveType>::type value;
788  self->process( value );
789  access::member_load_minimal(*self, t, value);
790  return *self;
791  }
792 
794  template <class T, PROCESS_IF(non_member_load_minimal)> inline
795  ArchiveType & processImpl(T & t)
796  {
797  using OutArchiveType = typename traits::detail::get_output_from_input<ArchiveType>::type;
798  typename traits::has_non_member_save_minimal<T, OutArchiveType>::type value;
799  self->process( value );
800  CEREAL_LOAD_MINIMAL_FUNCTION_NAME(*self, t, value);
801  return *self;
802  }
803 
805  template <class T, traits::EnableIf<(Flags & AllowEmptyClassElision),
806  !traits::is_input_serializable<T, ArchiveType>::value,
807  std::is_empty<T>::value> = traits::sfinae> inline
808  ArchiveType & processImpl(T const &)
809  {
810  return *self;
811  }
812 
814 
817  template <class T, traits::EnableIf<traits::has_invalid_input_versioning<T, ArchiveType>::value ||
818  (!traits::is_input_serializable<T, ArchiveType>::value &&
819  (!(Flags & AllowEmptyClassElision) || ((Flags & AllowEmptyClassElision) && !std::is_empty<T>::value)))> = traits::sfinae> inline
820  ArchiveType & processImpl(T const &)
821  {
822  static_assert(traits::detail::count_input_serializers<T, ArchiveType>::value != 0,
823  "cereal could not find any input serialization functions for the provided type and archive combination. \n\n "
824  "Types must either have a serialize function, load/save pair, or load_minimal/save_minimal pair (you may not mix these). \n "
825  "Serialize functions generally have the following signature: \n\n "
826  "template<class Archive> \n "
827  " void serialize(Archive & ar) \n "
828  " { \n "
829  " ar( member1, member2, member3 ); \n "
830  " } \n\n " );
831 
832  static_assert(traits::detail::count_input_serializers<T, ArchiveType>::value < 2,
833  "cereal found more than one compatible input serialization function for the provided type and archive combination. \n\n "
834  "Types must either have a serialize function, load/save pair, or load_minimal/save_minimal pair (you may not mix these). \n "
835  "Use specialization (see access.hpp) if you need to disambiguate between serialize vs load/save functions. \n "
836  "Note that serialization functions can be inherited which may lead to the aforementioned ambiguities. \n "
837  "In addition, you may not mix versioned with non-versioned serialization functions. \n\n ");
838 
839  return *self;
840  }
841 
843 
848  template <class T> inline
849  std::uint32_t loadClassVersion()
850  {
851  static const auto hash = std::type_index(typeid(T)).hash_code();
852  auto lookupResult = itsVersionedTypes.find( hash );
853 
854  if( lookupResult != itsVersionedTypes.end() ) // already exists
855  return lookupResult->second;
856  else // need to load
857  {
858  std::uint32_t version;
859 
860  process( make_nvp<ArchiveType>("cereal_class_version", version) );
861  itsVersionedTypes.emplace_hint( lookupResult, hash, version );
862 
863  return version;
864  }
865  }
866 
868 
869  template <class T, PROCESS_IF(member_versioned_serialize)> inline
870  ArchiveType & processImpl(T & t)
871  {
872  const auto version = loadClassVersion<T>();
873  access::member_serialize(*self, t, version);
874  return *self;
875  }
876 
878 
879  template <class T, PROCESS_IF(non_member_versioned_serialize)> inline
880  ArchiveType & processImpl(T & t)
881  {
882  const auto version = loadClassVersion<T>();
883  CEREAL_SERIALIZE_FUNCTION_NAME(*self, t, version);
884  return *self;
885  }
886 
888 
889  template <class T, PROCESS_IF(member_versioned_load)> inline
890  ArchiveType & processImpl(T & t)
891  {
892  const auto version = loadClassVersion<T>();
893  access::member_load(*self, t, version);
894  return *self;
895  }
896 
898 
899  template <class T, PROCESS_IF(non_member_versioned_load)> inline
900  ArchiveType & processImpl(T & t)
901  {
902  const auto version = loadClassVersion<T>();
903  CEREAL_LOAD_FUNCTION_NAME(*self, t, version);
904  return *self;
905  }
906 
908 
909  template <class T, PROCESS_IF(member_versioned_load_minimal)> inline
910  ArchiveType & processImpl(T & t)
911  {
912  using OutArchiveType = typename traits::detail::get_output_from_input<ArchiveType>::type;
913  const auto version = loadClassVersion<T>();
914  typename traits::has_member_versioned_save_minimal<T, OutArchiveType>::type value;
915  self->process(value);
916  access::member_load_minimal(*self, t, value, version);
917  return *self;
918  }
919 
921 
922  template <class T, PROCESS_IF(non_member_versioned_load_minimal)> inline
923  ArchiveType & processImpl(T & t)
924  {
925  using OutArchiveType = typename traits::detail::get_output_from_input<ArchiveType>::type;
926  const auto version = loadClassVersion<T>();
927  typename traits::has_non_member_versioned_save_minimal<T, OutArchiveType>::type value;
928  self->process(value);
929  CEREAL_LOAD_MINIMAL_FUNCTION_NAME(*self, t, value, version);
930  return *self;
931  }
932 
933  #undef PROCESS_IF
934 
935  private:
936  ArchiveType * const self;
937 
939  std::unordered_set<traits::detail::base_class_id, traits::detail::base_class_id_hash> itsBaseClassSet;
940 
942  std::unordered_map<std::uint32_t, std::shared_ptr<void>> itsSharedPointerMap;
943 
945  std::unordered_map<std::uint32_t, std::string> itsPolymorphicTypeMap;
946 
948  std::unordered_map<std::size_t, std::uint32_t> itsVersionedTypes;
949  }; // class InputArchive
950 } // namespace cereal
951 
952 // This include needs to come after things such as binary_data, make_nvp, etc
953 #include <cereal/types/common.hpp>
954 
955 #endif // CEREAL_CEREAL_HPP_
ArchiveType & operator()(Types &&...args)
Serializes all passed in data.
Definition: cereal.hpp:602
The number of output serialization functions available.
Definition: traits.hpp:1017
A wrapper around size metadata.
Definition: helpers.hpp:250
Casts a derived class to its virtual base class in a way that allows cereal to track inheritance...
Definition: base_class.hpp:152
Support for base classes (virtual and non-virtual)
std::shared_ptr< void > getSharedPointer(std::uint32_t const id)
Retrieves a shared pointer given a unique key for it.
Definition: cereal.hpp:644
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:339
NameValuePair< T > make_nvp(std::string const &name, T &&value)
Creates a name value pair.
Definition: cereal.hpp:54
Internal type trait support.
std::string getPolymorphicName(std::uint32_t const id)
Retrieves the string for a polymorphic type given a unique key for it.
Definition: cereal.hpp:673
Casts a derived class to its non-virtual base class in a way that safely supports abstract classes...
Definition: base_class.hpp:72
The base input archive class.
Definition: cereal.hpp:584
#define CEREAL_SERIALIZE_FUNCTION_NAME
The serialization/deserialization function name to search for.
Definition: macros.hpp:51
InputArchive(ArchiveType *const derived)
Construct the output archive.
Definition: cereal.hpp:589
#define CEREAL_SAVE_MINIMAL_FUNCTION_NAME
The serialization (save_minimal) function name to search for.
Definition: macros.hpp:79
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
Definition: access.hpp:39
NameValuePair< T > make_nvp(const char *name, T &&value)
Creates a name value pair.
Definition: cereal.hpp:63
ArchiveType & operator&(T &&arg)
Serializes passed in data.
Definition: cereal.hpp:263
For holding name value pairs.
Definition: helpers.hpp:135
Definition: traits.hpp:1035
Preprocessor macros that can customise the cereal library.
void registerSharedPointer(std::uint32_t const id, std::shared_ptr< void > ptr)
Registers a shared pointer to its unique identifier.
Definition: cereal.hpp:661
#define CEREAL_LOAD_FUNCTION_NAME
The deserialization (load) function name to search for.
Definition: macros.hpp:58
#define CEREAL_LOAD_MINIMAL_FUNCTION_NAME
The deserialization (load_minimal) function name to search for.
Definition: macros.hpp:72
std::uint32_t registerSharedPointer(void const *addr)
Registers a shared pointer with the archive.
Definition: cereal.hpp:290
void registerPolymorphicName(std::uint32_t const id, std::string const &name)
Registers a polymorphic name string to its unique identifier.
Definition: cereal.hpp:689
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
ArchiveType & operator>>(T &&arg)
Serializes passed in data.
Definition: cereal.hpp:629
Definition: helpers.hpp:228
ArchiveType & operator()(Types &&...args)
Serializes all passed in data.
Definition: cereal.hpp:247
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:65
ArchiveType & operator&(T &&arg)
Serializes passed in data.
Definition: cereal.hpp:618
Definition: helpers.hpp:229
ArchiveType & operator<<(T &&arg)
Serializes passed in data.
Definition: cereal.hpp:274
Definition: traits.hpp:1069
A static, pre-execution object.
Definition: static_object.hpp:61
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