Initial Commit

This commit is contained in:
Yousef Khadadeh 2025-07-06 20:43:53 +03:00
commit 6088fc29ed
978 changed files with 353647 additions and 0 deletions

View file

@ -0,0 +1,79 @@
/*! \file array.hpp
\brief Support for types found in \<array\>
\ingroup STLSupport */
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_ARRAY_HPP_
#define CEREAL_TYPES_ARRAY_HPP_
#include "cereal/cereal.hpp"
#include <array>
namespace cereal
{
//! Saving for std::array primitive types
//! using binary serialization, if supported
template <class Archive, class T, size_t N> inline
typename std::enable_if<traits::is_output_serializable<BinaryData<T>, Archive>::value
&& std::is_arithmetic<T>::value, void>::type
CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::array<T, N> const & array )
{
ar( binary_data( array.data(), sizeof(array) ) );
}
//! Loading for std::array primitive types
//! using binary serialization, if supported
template <class Archive, class T, size_t N> inline
typename std::enable_if<traits::is_input_serializable<BinaryData<T>, Archive>::value
&& std::is_arithmetic<T>::value, void>::type
CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::array<T, N> & array )
{
ar( binary_data( array.data(), sizeof(array) ) );
}
//! Saving for std::array all other types
template <class Archive, class T, size_t N> inline
typename std::enable_if<!traits::is_output_serializable<BinaryData<T>, Archive>::value
|| !std::is_arithmetic<T>::value, void>::type
CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::array<T, N> const & array )
{
for( auto const & i : array )
ar( i );
}
//! Loading for std::array all other types
template <class Archive, class T, size_t N> inline
typename std::enable_if<!traits::is_input_serializable<BinaryData<T>, Archive>::value
|| !std::is_arithmetic<T>::value, void>::type
CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::array<T, N> & array )
{
for( auto & i : array )
ar( i );
}
} // namespace cereal
#endif // CEREAL_TYPES_ARRAY_HPP_

View file

@ -0,0 +1,55 @@
/*! \file atomic.hpp
\brief Support for types found in \<atomic\>
\ingroup STLSupport */
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_ATOMIC_HPP_
#define CEREAL_TYPES_ATOMIC_HPP_
#include <cereal/cereal.hpp>
#include <atomic>
namespace cereal
{
//! Serializing (save) for std::atomic
template <class Archive, class T> inline
void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::atomic<T> const & a )
{
ar( CEREAL_NVP_("atomic_data", a.load()) );
}
//! Serializing (load) for std::atomic
template <class Archive, class T> inline
void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::atomic<T> & a )
{
T tmp;
ar( CEREAL_NVP_("atomic_data", tmp) );
a.store( tmp );
}
} // namespace cereal
#endif // CEREAL_TYPES_ATOMIC_HPP_

View file

@ -0,0 +1,203 @@
/*! \file base_class.hpp
\brief Support for base classes (virtual and non-virtual)
\ingroup OtherTypes */
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_BASE_CLASS_HPP_
#define CEREAL_TYPES_BASE_CLASS_HPP_
#include "cereal/details/traits.hpp"
#include "cereal/details/polymorphic_impl_fwd.hpp"
namespace cereal
{
namespace base_class_detail
{
//! Used to register polymorphic relations and avoid the need to include
//! polymorphic.hpp when no polymorphism is used
/*! @internal */
template <class Base, class Derived, bool IsPolymorphic = std::is_polymorphic<Base>::value>
struct RegisterPolymorphicBaseClass
{
static void bind()
{ }
};
//! Polymorphic version
/*! @internal */
template <class Base, class Derived>
struct RegisterPolymorphicBaseClass<Base, Derived, true>
{
static void bind()
{ detail::RegisterPolymorphicCaster<Base, Derived>::bind(); }
};
}
//! Casts a derived class to its non-virtual base class in a way that safely supports abstract classes
/*! This should be used in cases when a derived type needs to serialize its base type. This is better than directly
using static_cast, as it allows for serialization of pure virtual (abstract) base classes.
This also automatically registers polymorphic relation between the base and derived class, assuming they
are indeed polymorphic. Note this is not the same as polymorphic type registration. For more information
see the documentation on polymorphism. If using a polymorphic class, be sure to include support for
polymorphism (cereal/types/polymorphic.hpp).
\sa virtual_base_class
@code{.cpp}
struct MyBase
{
int x;
virtual void foo() = 0;
template <class Archive>
void serialize( Archive & ar )
{
ar( x );
}
};
struct MyDerived : public MyBase //<-- Note non-virtual inheritance
{
int y;
virtual void foo() {};
template <class Archive>
void serialize( Archive & ar )
{
ar( cereal::base_class<MyBase>(this) );
ar( y );
}
};
@endcode */
template<class Base>
struct base_class : private traits::detail::BaseCastBase
{
template<class Derived>
base_class(Derived const * derived) :
base_ptr(const_cast<Base*>(static_cast<Base const *>(derived)))
{
static_assert( std::is_base_of<Base, Derived>::value, "Can only use base_class on a valid base class" );
base_class_detail::RegisterPolymorphicBaseClass<Base, Derived>::bind();
}
Base * base_ptr;
};
//! Casts a derived class to its virtual base class in a way that allows cereal to track inheritance
/*! This should be used in cases when a derived type features virtual inheritance from some
base type. This allows cereal to track the inheritance and to avoid making duplicate copies
during serialization.
It is safe to use virtual_base_class in all circumstances for serializing base classes, even in cases
where virtual inheritance does not take place, though it may be slightly faster to utilize
cereal::base_class<> if you do not need to worry about virtual inheritance.
This also automatically registers polymorphic relation between the base and derived class, assuming they
are indeed polymorphic. Note this is not the same as polymorphic type registration. For more information
see the documentation on polymorphism. If using a polymorphic class, be sure to include support for
polymorphism (cereal/types/polymorphic.hpp).
\sa base_class
@code{.cpp}
struct MyBase
{
int x;
template <class Archive>
void serialize( Archive & ar )
{
ar( x );
}
};
struct MyLeft : virtual MyBase //<-- Note the virtual inheritance
{
int y;
template <class Archive>
void serialize( Archive & ar )
{
ar( cereal::virtual_base_class<MyBase>( this ) );
ar( y );
}
};
struct MyRight : virtual MyBase
{
int z;
template <class Archive>
void serialize( Archive & ar )
{
ar( cereal::virtual_base_clas<MyBase>( this ) );
ar( z );
}
};
// diamond virtual inheritance; contains one copy of each base class
struct MyDerived : virtual MyLeft, virtual MyRight
{
int a;
template <class Archive>
void serialize( Archive & ar )
{
ar( cereal::virtual_base_class<MyLeft>( this ) ); // safely serialize data members in MyLeft
ar( cereal::virtual_base_class<MyRight>( this ) ); // safely serialize data members in MyRight
ar( a );
// Because we used virtual_base_class, cereal will ensure that only one instance of MyBase is
// serialized as we traverse the inheritance heirarchy. This means that there will be one copy
// each of the variables x, y, z, and a
// If we had chosen to use static_cast<> instead, cereal would perform no tracking and
// assume that every base class should be serialized (in this case leading to a duplicate
// serialization of MyBase due to diamond inheritance
};
}
@endcode */
template<class Base>
struct virtual_base_class : private traits::detail::BaseCastBase
{
template<class Derived>
virtual_base_class(Derived const * derived) :
base_ptr(const_cast<Base*>(static_cast<Base const *>(derived)))
{
static_assert( std::is_base_of<Base, Derived>::value, "Can only use virtual_base_class on a valid base class" );
base_class_detail::RegisterPolymorphicBaseClass<Base, Derived>::bind();
}
Base * base_ptr;
};
} // namespace cereal
#endif // CEREAL_TYPES_BASE_CLASS_HPP_

View file

@ -0,0 +1,176 @@
/*! \file bitset.hpp
\brief Support for types found in \<bitset\>
\ingroup STLSupport */
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_BITSET_HPP_
#define CEREAL_TYPES_BITSET_HPP_
#include "cereal/cereal.hpp"
#include "cereal/types/string.hpp"
#include <bitset>
namespace cereal
{
namespace bitset_detail
{
//! The type the bitset is encoded with
/*! @internal */
enum class type : uint8_t
{
ulong,
ullong,
string,
bits
};
}
//! Serializing (save) for std::bitset when BinaryData optimization supported
template <class Archive, size_t N,
traits::EnableIf<traits::is_output_serializable<BinaryData<std::uint32_t>, Archive>::value>
= traits::sfinae> inline
void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::bitset<N> const & bits )
{
ar( CEREAL_NVP_("type", bitset_detail::type::bits) );
// Serialize 8 bit chunks
std::uint8_t chunk = 0;
std::uint8_t mask = 0x80;
// Set each chunk using a rotating mask for the current bit
for( std::size_t i = 0; i < N; ++i )
{
if( bits[i] )
chunk |= mask;
mask = static_cast<std::uint8_t>(mask >> 1);
// output current chunk when mask is empty (8 bits)
if( mask == 0 )
{
ar( chunk );
chunk = 0;
mask = 0x80;
}
}
// serialize remainder, if it exists
if( mask != 0x80 )
ar( chunk );
}
//! Serializing (save) for std::bitset when BinaryData is not supported
template <class Archive, size_t N,
traits::DisableIf<traits::is_output_serializable<BinaryData<std::uint32_t>, Archive>::value>
= traits::sfinae> inline
void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::bitset<N> const & bits )
{
try
{
auto const b = bits.to_ulong();
ar( CEREAL_NVP_("type", bitset_detail::type::ulong) );
ar( CEREAL_NVP_("data", b) );
}
catch( std::overflow_error const & )
{
try
{
auto const b = bits.to_ullong();
ar( CEREAL_NVP_("type", bitset_detail::type::ullong) );
ar( CEREAL_NVP_("data", b) );
}
catch( std::overflow_error const & )
{
ar( CEREAL_NVP_("type", bitset_detail::type::string) );
ar( CEREAL_NVP_("data", bits.to_string()) );
}
}
}
//! Serializing (load) for std::bitset
template <class Archive, size_t N> inline
void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::bitset<N> & bits )
{
bitset_detail::type t;
ar( CEREAL_NVP_("type", t) );
switch( t )
{
case bitset_detail::type::ulong:
{
unsigned long b;
ar( CEREAL_NVP_("data", b) );
bits = std::bitset<N>( b );
break;
}
case bitset_detail::type::ullong:
{
unsigned long long b;
ar( CEREAL_NVP_("data", b) );
bits = std::bitset<N>( b );
break;
}
case bitset_detail::type::string:
{
std::string b;
ar( CEREAL_NVP_("data", b) );
bits = std::bitset<N>( b );
break;
}
case bitset_detail::type::bits:
{
// Normally we would use BinaryData to route this at compile time,
// but doing this at runtime doesn't break any old serialization
std::uint8_t chunk = 0;
std::uint8_t mask = 0;
bits.reset();
// Load one chunk at a time, rotating through the chunk
// to set bits in the bitset
for( std::size_t i = 0; i < N; ++i )
{
if( mask == 0 )
{
ar( chunk );
mask = 0x80;
}
if( chunk & mask )
bits[i] = 1;
mask = static_cast<std::uint8_t>(mask >> 1);
}
break;
}
default:
throw Exception("Invalid bitset data representation");
}
}
} // namespace cereal
#endif // CEREAL_TYPES_BITSET_HPP_

View file

@ -0,0 +1,164 @@
/*! \file boost_variant.hpp
\brief Support for boost::variant
\ingroup OtherTypes */
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_BOOST_VARIANT_HPP_
#define CEREAL_TYPES_BOOST_VARIANT_HPP_
//! @internal
#if defined(_MSC_VER) && _MSC_VER < 1911
#define CEREAL_CONSTEXPR_LAMBDA
#else // MSVC 2017 or newer, all other compilers
#define CEREAL_CONSTEXPR_LAMBDA constexpr
#endif
#include "cereal/cereal.hpp"
#include <boost/variant/variant_fwd.hpp>
#include <boost/variant/static_visitor.hpp>
namespace cereal
{
namespace boost_variant_detail
{
//! @internal
template <class Archive>
struct variant_save_visitor : boost::static_visitor<>
{
variant_save_visitor(Archive & ar_) : ar(ar_) {}
template<class T>
void operator()(T const & value) const
{
ar( CEREAL_NVP_("data", value) );
}
Archive & ar;
};
//! @internal
template <class Archive, class T>
struct LoadAndConstructLoadWrapper
{
using ST = typename std::aligned_storage<sizeof(T), CEREAL_ALIGNOF(T)>::type;
LoadAndConstructLoadWrapper() :
construct( reinterpret_cast<T *>( &st ) )
{ }
~LoadAndConstructLoadWrapper()
{
if (construct.itsValid)
{
construct->~T();
}
}
void CEREAL_SERIALIZE_FUNCTION_NAME( Archive & ar )
{
::cereal::detail::Construct<T, Archive>::load_andor_construct( ar, construct );
}
ST st;
::cereal::construct<T> construct;
};
//! @internal
template <class T> struct load_variant_wrapper;
//! Avoid serializing variant void_ type
/*! @internal */
template <>
struct load_variant_wrapper<boost::detail::variant::void_>
{
template <class Variant, class Archive>
static void load_variant( Archive &, Variant & )
{ }
};
//! @internal
template <class T>
struct load_variant_wrapper
{
// default constructible
template <class Archive, class Variant>
static void load_variant_impl( Archive & ar, Variant & variant, std::true_type )
{
T value;
ar( CEREAL_NVP_("data", value) );
variant = std::move(value);
}
// not default constructible
template<class Variant, class Archive>
static void load_variant_impl(Archive & ar, Variant & variant, std::false_type )
{
LoadAndConstructLoadWrapper<Archive, T> loadWrapper;
ar( CEREAL_NVP_("data", loadWrapper) );
variant = std::move(*loadWrapper.construct.ptr());
}
//! @internal
template<class Variant, class Archive>
static void load_variant(Archive & ar, Variant & variant)
{
load_variant_impl( ar, variant, typename std::is_default_constructible<T>::type() );
}
};
} // namespace boost_variant_detail
//! Saving for boost::variant
template <class Archive, typename ... VariantTypes> inline
void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, boost::variant<VariantTypes...> const & variant )
{
int32_t which = variant.which();
ar( CEREAL_NVP_("which", which) );
boost_variant_detail::variant_save_visitor<Archive> visitor(ar);
variant.apply_visitor(visitor);
}
//! Loading for boost::variant
template <class Archive, typename ... VariantTypes> inline
void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, boost::variant<VariantTypes...> & variant )
{
int32_t which;
ar( CEREAL_NVP_("which", which) );
using LoadFuncType = void(*)(Archive &, boost::variant<VariantTypes...> &);
CEREAL_CONSTEXPR_LAMBDA LoadFuncType loadFuncArray[] = {&boost_variant_detail::load_variant_wrapper<VariantTypes>::load_variant...};
if(which >= int32_t(sizeof(loadFuncArray)/sizeof(loadFuncArray[0])))
throw Exception("Invalid 'which' selector when deserializing boost::variant");
loadFuncArray[which](ar, variant);
}
} // namespace cereal
#undef CEREAL_CONSTEXPR_LAMBDA
#endif // CEREAL_TYPES_BOOST_VARIANT_HPP_

View file

@ -0,0 +1,72 @@
/*! \file chrono.hpp
\brief Support for types found in \<chrono\>
\ingroup STLSupport */
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_CHRONO_HPP_
#define CEREAL_TYPES_CHRONO_HPP_
#include <chrono>
namespace cereal
{
//! Saving std::chrono::duration
template <class Archive, class R, class P> inline
void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::chrono::duration<R, P> const & dur )
{
ar( CEREAL_NVP_("count", dur.count()) );
}
//! Loading std::chrono::duration
template <class Archive, class R, class P> inline
void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::chrono::duration<R, P> & dur )
{
R count;
ar( CEREAL_NVP_("count", count) );
dur = std::chrono::duration<R, P>{count};
}
//! Saving std::chrono::time_point
template <class Archive, class C, class D> inline
void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::chrono::time_point<C, D> const & dur )
{
ar( CEREAL_NVP_("time_since_epoch", dur.time_since_epoch()) );
}
//! Loading std::chrono::time_point
template <class Archive, class C, class D> inline
void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::chrono::time_point<C, D> & dur )
{
D elapsed;
ar( CEREAL_NVP_("time_since_epoch", elapsed) );
dur = std::chrono::time_point<C, D>{elapsed};
}
} // namespace cereal
#endif // CEREAL_TYPES_CHRONO_HPP_

View file

@ -0,0 +1,129 @@
/*! \file common.hpp
\brief Support common types - always included automatically
\ingroup OtherTypes */
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_COMMON_HPP_
#define CEREAL_TYPES_COMMON_HPP_
#include "cereal/cereal.hpp"
namespace cereal
{
namespace common_detail
{
//! Serialization for arrays if BinaryData is supported and we are arithmetic
/*! @internal */
template <class Archive, class T> inline
void serializeArray( Archive & ar, T & array, std::true_type /* binary_supported */ )
{
ar( binary_data( array, sizeof(array) ) );
}
//! Serialization for arrays if BinaryData is not supported or we are not arithmetic
/*! @internal */
template <class Archive, class T> inline
void serializeArray( Archive & ar, T & array, std::false_type /* binary_supported */ )
{
for( auto & i : array )
ar( i );
}
namespace
{
//! Gets the underlying type of an enum
/*! @internal */
template <class T, bool IsEnum>
struct enum_underlying_type : std::false_type {};
//! Gets the underlying type of an enum
/*! Specialization for when we actually have an enum
@internal */
template <class T>
struct enum_underlying_type<T, true> { using type = typename std::underlying_type<T>::type; };
} // anon namespace
//! Checks if a type is an enum
/*! This is needed over simply calling std::is_enum because the type
traits checking at compile time will attempt to call something like
load_minimal with a special NoConvertRef struct that wraps up the true type.
This will strip away any of that and also expose the true underlying type.
@internal */
template <class T>
class is_enum
{
private:
using DecayedT = typename std::decay<T>::type;
using StrippedT = typename ::cereal::traits::strip_minimal<DecayedT>::type;
public:
static const bool value = std::is_enum<StrippedT>::value;
using type = StrippedT;
using base_type = typename enum_underlying_type<StrippedT, value>::type;
};
}
//! Saving for enum types
template <class Archive, class T> inline
typename std::enable_if<common_detail::is_enum<T>::value,
typename common_detail::is_enum<T>::base_type>::type
CEREAL_SAVE_MINIMAL_FUNCTION_NAME( Archive const &, T const & t )
{
return static_cast<typename common_detail::is_enum<T>::base_type>(t);
}
//! Loading for enum types
template <class Archive, class T> inline
typename std::enable_if<common_detail::is_enum<T>::value, void>::type
CEREAL_LOAD_MINIMAL_FUNCTION_NAME( Archive const &, T && t,
typename common_detail::is_enum<T>::base_type const & value )
{
t = reinterpret_cast<typename common_detail::is_enum<T>::type const &>( value );
}
//! Serialization for raw pointers
/*! This exists only to throw a static_assert to let users know we don't support raw pointers. */
template <class Archive, class T> inline
void CEREAL_SERIALIZE_FUNCTION_NAME( Archive &, T * & )
{
static_assert(cereal::traits::detail::delay_static_assert<T>::value,
"Cereal does not support serializing raw pointers - please use a smart pointer");
}
//! Serialization for C style arrays
template <class Archive, class T> inline
typename std::enable_if<std::is_array<T>::value, void>::type
CEREAL_SERIALIZE_FUNCTION_NAME(Archive & ar, T & array)
{
common_detail::serializeArray( ar, array,
std::integral_constant<bool, traits::is_output_serializable<BinaryData<T>, Archive>::value &&
std::is_arithmetic<typename std::remove_all_extents<T>::type>::value>() );
}
} // namespace cereal
#endif // CEREAL_TYPES_COMMON_HPP_

View file

@ -0,0 +1,56 @@
/*! \file complex.hpp
\brief Support for types found in \<complex\>
\ingroup STLSupport */
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_COMPLEX_HPP_
#define CEREAL_TYPES_COMPLEX_HPP_
#include <complex>
namespace cereal
{
//! Serializing (save) for std::complex
template <class Archive, class T> inline
void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::complex<T> const & comp )
{
ar( CEREAL_NVP_("real", comp.real()),
CEREAL_NVP_("imag", comp.imag()) );
}
//! Serializing (load) for std::complex
template <class Archive, class T> inline
void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::complex<T> & bits )
{
T real, imag;
ar( CEREAL_NVP_("real", real),
CEREAL_NVP_("imag", imag) );
bits = {real, imag};
}
} // namespace cereal
#endif // CEREAL_TYPES_COMPLEX_HPP_

View file

@ -0,0 +1,73 @@
/*! \file pair_associative_container.hpp
\brief Support for the PairAssociativeContainer refinement of the
AssociativeContainer concept.
\ingroup TypeConcepts */
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_CONCEPTS_PAIR_ASSOCIATIVE_CONTAINER_HPP_
#define CEREAL_CONCEPTS_PAIR_ASSOCIATIVE_CONTAINER_HPP_
#include "cereal/cereal.hpp"
namespace cereal
{
//! Saving for std-like pair associative containers
template <class Archive, template <typename...> class Map, typename... Args, typename = typename Map<Args...>::mapped_type> inline
void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, Map<Args...> const & map )
{
ar( make_size_tag( static_cast<size_type>(map.size()) ) );
for( const auto & i : map )
ar( make_map_item(i.first, i.second) );
}
//! Loading for std-like pair associative containers
template <class Archive, template <typename...> class Map, typename... Args, typename = typename Map<Args...>::mapped_type> inline
void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, Map<Args...> & map )
{
size_type size;
ar( make_size_tag( size ) );
map.clear();
auto hint = map.begin();
for( size_t i = 0; i < size; ++i )
{
typename Map<Args...>::key_type key;
typename Map<Args...>::mapped_type value;
ar( make_map_item(key, value) );
#ifdef CEREAL_OLDER_GCC
hint = map.insert( hint, std::make_pair(std::move(key), std::move(value)) );
#else // NOT CEREAL_OLDER_GCC
hint = map.emplace_hint( hint, std::move( key ), std::move( value ) );
#endif // NOT CEREAL_OLDER_GCC
}
}
} // namespace cereal
#endif // CEREAL_CONCEPTS_PAIR_ASSOCIATIVE_CONTAINER_HPP_

View file

@ -0,0 +1,62 @@
/*! \file deque.hpp
\brief Support for types found in \<deque\>
\ingroup STLSupport */
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_DEQUE_HPP_
#define CEREAL_TYPES_DEQUE_HPP_
#include "cereal/cereal.hpp"
#include <deque>
namespace cereal
{
//! Saving for std::deque
template <class Archive, class T, class A> inline
void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::deque<T, A> const & deque )
{
ar( make_size_tag( static_cast<size_type>(deque.size()) ) );
for( auto const & i : deque )
ar( i );
}
//! Loading for std::deque
template <class Archive, class T, class A> inline
void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::deque<T, A> & deque )
{
size_type size;
ar( make_size_tag( size ) );
deque.resize( static_cast<size_t>( size ) );
for( auto & i : deque )
ar( i );
}
} // namespace cereal
#endif // CEREAL_TYPES_DEQUE_HPP_

View file

@ -0,0 +1,68 @@
/*! \file forward_list.hpp
\brief Support for types found in \<forward_list\>
\ingroup STLSupport */
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_FORWARD_LIST_HPP_
#define CEREAL_TYPES_FORWARD_LIST_HPP_
#include "cereal/cereal.hpp"
#include <forward_list>
namespace cereal
{
//! Saving for std::forward_list all other types
template <class Archive, class T, class A> inline
void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::forward_list<T, A> const & forward_list )
{
// write the size - note that this is slow because we need to traverse
// the entire list. there are ways we could avoid this but this was chosen
// since it works in the most general fashion with any archive type
size_type const size = std::distance( forward_list.begin(), forward_list.end() );
ar( make_size_tag( size ) );
// write the list
for( const auto & i : forward_list )
ar( i );
}
//! Loading for std::forward_list all other types from
template <class Archive, class T, class A>
void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::forward_list<T, A> & forward_list )
{
size_type size;
ar( make_size_tag( size ) );
forward_list.resize( static_cast<size_t>( size ) );
for( auto & i : forward_list )
ar( i );
}
} // namespace cereal
#endif // CEREAL_TYPES_FORWARD_LIST_HPP_

View file

@ -0,0 +1,43 @@
/*! \file functional.hpp
\brief Support for types found in \<functional\>
\ingroup STLSupport */
/*
Copyright (c) 2016, Randolph Voorhies, Shane Grant
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_FUNCTIONAL_HPP_
#define CEREAL_TYPES_FUNCTIONAL_HPP_
#include <functional>
namespace cereal
{
//! Saving for std::less
template <class Archive, class T> inline
void serialize( Archive &, std::less<T> & )
{ }
} // namespace cereal
#endif // CEREAL_TYPES_FUNCTIONAL_HPP_

View file

@ -0,0 +1,62 @@
/*! \file list.hpp
\brief Support for types found in \<list\>
\ingroup STLSupport */
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_LIST_HPP_
#define CEREAL_TYPES_LIST_HPP_
#include "cereal/cereal.hpp"
#include <list>
namespace cereal
{
//! Saving for std::list
template <class Archive, class T, class A> inline
void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::list<T, A> const & list )
{
ar( make_size_tag( static_cast<size_type>(list.size()) ) );
for( auto const & i : list )
ar( i );
}
//! Loading for std::list
template <class Archive, class T, class A> inline
void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::list<T, A> & list )
{
size_type size;
ar( make_size_tag( size ) );
list.resize( static_cast<size_t>( size ) );
for( auto & i : list )
ar( i );
}
} // namespace cereal
#endif // CEREAL_TYPES_LIST_HPP_

View file

@ -0,0 +1,36 @@
/*! \file map.hpp
\brief Support for types found in \<map\>
\ingroup STLSupport */
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_MAP_HPP_
#define CEREAL_TYPES_MAP_HPP_
#include "cereal/types/concepts/pair_associative_container.hpp"
#include <map>
#endif // CEREAL_TYPES_MAP_HPP_

View file

@ -0,0 +1,425 @@
/*! \file memory.hpp
\brief Support for types found in \<memory\>
\ingroup STLSupport */
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_SHARED_PTR_HPP_
#define CEREAL_TYPES_SHARED_PTR_HPP_
#include "cereal/cereal.hpp"
#include <memory>
#include <cstring>
namespace cereal
{
namespace memory_detail
{
//! A wrapper class to notify cereal that it is ok to serialize the contained pointer
/*! This mechanism allows us to intercept and properly handle polymorphic pointers
@internal */
template<class T>
struct PtrWrapper
{
PtrWrapper(T && p) : ptr(std::forward<T>(p)) {}
T & ptr;
PtrWrapper( PtrWrapper const & ) = default;
PtrWrapper & operator=( PtrWrapper const & ) = delete;
};
//! Make a PtrWrapper
/*! @internal */
template<class T> inline
PtrWrapper<T> make_ptr_wrapper(T && t)
{
return {std::forward<T>(t)};
}
//! A struct that acts as a wrapper around calling load_andor_construct
/*! The purpose of this is to allow a load_and_construct call to properly enter into the
'data' NVP of the ptr_wrapper
@internal */
template <class Archive, class T>
struct LoadAndConstructLoadWrapper
{
LoadAndConstructLoadWrapper( T * ptr ) :
construct( ptr )
{ }
//! Constructor for embedding an early call for restoring shared_from_this
template <class F>
LoadAndConstructLoadWrapper( T * ptr, F && sharedFromThisFunc ) :
construct( ptr, sharedFromThisFunc )
{ }
inline void CEREAL_SERIALIZE_FUNCTION_NAME( Archive & ar )
{
::cereal::detail::Construct<T, Archive>::load_andor_construct( ar, construct );
}
::cereal::construct<T> construct;
};
//! A helper struct for saving and restoring the state of types that derive from
//! std::enable_shared_from_this
/*! This special struct is necessary because when a user uses load_and_construct,
the weak_ptr (or whatever implementation defined variant) that allows
enable_shared_from_this to function correctly will not be initialized properly.
This internal weak_ptr can also be modified by the shared_ptr that is created
during the serialization of a polymorphic pointer, where cereal creates a
wrapper shared_ptr out of a void pointer to the real data.
In the case of load_and_construct, this happens because it is the allocation
of shared_ptr that perform this initialization, which we let happen on a buffer
of memory (aligned_storage). This buffer is then used for placement new
later on, effectively overwriting any initialized weak_ptr with a default
initialized one, eventually leading to issues when the user calls shared_from_this.
To get around these issues, we will store the memory for the enable_shared_from_this
portion of the class and replace it after whatever happens to modify it (e.g. the
user performing construction or the wrapper shared_ptr in saving).
Note that this goes into undefined behavior territory, but as of the initial writing
of this, all standard library implementations of std::enable_shared_from_this are
compatible with this memory manipulation. It is entirely possible that this may someday
break or may not work with convoluted use cases.
Example usage:
@code{.cpp}
T * myActualPointer;
{
EnableSharedStateHelper<T> helper( myActualPointer ); // save the state
std::shared_ptr<T> myPtr( myActualPointer ); // modifies the internal weak_ptr
// helper restores state when it goes out of scope
}
@endcode
When possible, this is designed to be used in an RAII fashion - it will save state on
construction and restore it on destruction. The restore can be done at an earlier time
(e.g. after construct() is called in load_and_construct) in which case the destructor will
do nothing. Performing the restore immediately following construct() allows a user to call
shared_from_this within their load_and_construct function.
@tparam T Type pointed to by shared_ptr
@internal */
template <class T>
class EnableSharedStateHelper
{
// typedefs for parent type and storage type
using BaseType = typename ::cereal::traits::get_shared_from_this_base<T>::type;
using ParentType = std::enable_shared_from_this<BaseType>;
using StorageType = typename std::aligned_storage<sizeof(ParentType), CEREAL_ALIGNOF(ParentType)>::type;
public:
//! Saves the state of some type inheriting from enable_shared_from_this
/*! @param ptr The raw pointer held by the shared_ptr */
inline EnableSharedStateHelper( T * ptr ) :
itsPtr( static_cast<ParentType *>( ptr ) ),
itsState(),
itsRestored( false )
{
std::memcpy( &itsState, itsPtr, sizeof(ParentType) );
}
//! Restores the state of the held pointer (can only be done once)
inline void restore()
{
if( !itsRestored )
{
// void * cast needed when type has no trivial copy-assignment
std::memcpy( static_cast<void *>(itsPtr), &itsState, sizeof(ParentType) );
itsRestored = true;
}
}
//! Restores the state of the held pointer if not done previously
inline ~EnableSharedStateHelper()
{
restore();
}
private:
ParentType * itsPtr;
StorageType itsState;
bool itsRestored;
}; // end EnableSharedStateHelper
//! Performs loading and construction for a shared pointer that is derived from
//! std::enable_shared_from_this
/*! @param ar The archive
@param ptr Raw pointer held by the shared_ptr
@internal */
template <class Archive, class T> inline
void loadAndConstructSharedPtr( Archive & ar, T * ptr, std::true_type /* has_shared_from_this */ )
{
memory_detail::EnableSharedStateHelper<T> state( ptr );
memory_detail::LoadAndConstructLoadWrapper<Archive, T> loadWrapper( ptr, [&](){ state.restore(); } );
// let the user perform their initialization, shared state will be restored as soon as construct()
// is called
ar( CEREAL_NVP_("data", loadWrapper) );
}
//! Performs loading and construction for a shared pointer that is NOT derived from
//! std::enable_shared_from_this
/*! This is the typical case, where we simply pass the load wrapper to the
archive.
@param ar The archive
@param ptr Raw pointer held by the shared_ptr
@internal */
template <class Archive, class T> inline
void loadAndConstructSharedPtr( Archive & ar, T * ptr, std::false_type /* has_shared_from_this */ )
{
memory_detail::LoadAndConstructLoadWrapper<Archive, T> loadWrapper( ptr );
ar( CEREAL_NVP_("data", loadWrapper) );
}
} // end namespace memory_detail
//! Saving std::shared_ptr for non polymorphic types
template <class Archive, class T> inline
typename std::enable_if<!std::is_polymorphic<T>::value, void>::type
CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::shared_ptr<T> const & ptr )
{
ar( CEREAL_NVP_("ptr_wrapper", memory_detail::make_ptr_wrapper( ptr )) );
}
//! Loading std::shared_ptr, case when no user load and construct for non polymorphic types
template <class Archive, class T> inline
typename std::enable_if<!std::is_polymorphic<T>::value, void>::type
CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::shared_ptr<T> & ptr )
{
ar( CEREAL_NVP_("ptr_wrapper", memory_detail::make_ptr_wrapper( ptr )) );
}
//! Saving std::weak_ptr for non polymorphic types
template <class Archive, class T> inline
typename std::enable_if<!std::is_polymorphic<T>::value, void>::type
CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::weak_ptr<T> const & ptr )
{
auto const sptr = ptr.lock();
ar( CEREAL_NVP_("ptr_wrapper", memory_detail::make_ptr_wrapper( sptr )) );
}
//! Loading std::weak_ptr for non polymorphic types
template <class Archive, class T> inline
typename std::enable_if<!std::is_polymorphic<T>::value, void>::type
CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::weak_ptr<T> & ptr )
{
std::shared_ptr<T> sptr;
ar( CEREAL_NVP_("ptr_wrapper", memory_detail::make_ptr_wrapper( sptr )) );
ptr = sptr;
}
//! Saving std::unique_ptr for non polymorphic types
template <class Archive, class T, class D> inline
typename std::enable_if<!std::is_polymorphic<T>::value, void>::type
CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::unique_ptr<T, D> const & ptr )
{
ar( CEREAL_NVP_("ptr_wrapper", memory_detail::make_ptr_wrapper( ptr )) );
}
//! Loading std::unique_ptr, case when user provides load_and_construct for non polymorphic types
template <class Archive, class T, class D> inline
typename std::enable_if<!std::is_polymorphic<T>::value, void>::type
CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::unique_ptr<T, D> & ptr )
{
ar( CEREAL_NVP_("ptr_wrapper", memory_detail::make_ptr_wrapper( ptr )) );
}
// ######################################################################
// Pointer wrapper implementations follow below
//! Saving std::shared_ptr (wrapper implementation)
/*! @internal */
template <class Archive, class T> inline
void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, memory_detail::PtrWrapper<std::shared_ptr<T> const &> const & wrapper )
{
auto & ptr = wrapper.ptr;
uint32_t id = ar.registerSharedPointer( ptr );
ar( CEREAL_NVP_("id", id) );
if( id & detail::msb_32bit )
{
ar( CEREAL_NVP_("data", *ptr) );
}
}
//! Loading std::shared_ptr, case when user load and construct (wrapper implementation)
/*! @internal */
template <class Archive, class T> inline
typename std::enable_if<traits::has_load_and_construct<T, Archive>::value, void>::type
CEREAL_LOAD_FUNCTION_NAME( Archive & ar, memory_detail::PtrWrapper<std::shared_ptr<T> &> & wrapper )
{
uint32_t id;
ar( CEREAL_NVP_("id", id) );
if( id & detail::msb_32bit )
{
// Storage type for the pointer - since we can't default construct this type,
// we'll allocate it using std::aligned_storage and use a custom deleter
using ST = typename std::aligned_storage<sizeof(T), CEREAL_ALIGNOF(T)>::type;
// Valid flag - set to true once construction finishes
// This prevents us from calling the destructor on
// uninitialized data.
auto valid = std::make_shared<bool>( false );
// Allocate our storage, which we will treat as
// uninitialized until initialized with placement new
using NonConstT = typename std::remove_const<T>::type;
std::shared_ptr<NonConstT> ptr(reinterpret_cast<NonConstT *>(new ST()),
[=]( NonConstT * t )
{
if( *valid )
t->~T();
delete reinterpret_cast<ST *>( t );
} );
// Register the pointer
ar.registerSharedPointer( id, ptr );
// Perform the actual loading and allocation
memory_detail::loadAndConstructSharedPtr( ar, ptr.get(), typename ::cereal::traits::has_shared_from_this<NonConstT>::type() );
// Mark pointer as valid (initialized)
*valid = true;
wrapper.ptr = std::move(ptr);
}
else
wrapper.ptr = std::static_pointer_cast<T>(ar.getSharedPointer(id));
}
//! Loading std::shared_ptr, case when no user load and construct (wrapper implementation)
/*! @internal */
template <class Archive, class T> inline
typename std::enable_if<!traits::has_load_and_construct<T, Archive>::value, void>::type
CEREAL_LOAD_FUNCTION_NAME( Archive & ar, memory_detail::PtrWrapper<std::shared_ptr<T> &> & wrapper )
{
uint32_t id;
ar( CEREAL_NVP_("id", id) );
if( id & detail::msb_32bit )
{
using NonConstT = typename std::remove_const<T>::type;
std::shared_ptr<NonConstT> ptr( detail::Construct<NonConstT, Archive>::load_andor_construct() );
ar.registerSharedPointer( id, ptr );
ar( CEREAL_NVP_("data", *ptr) );
wrapper.ptr = std::move(ptr);
}
else
wrapper.ptr = std::static_pointer_cast<T>(ar.getSharedPointer(id));
}
//! Saving std::unique_ptr (wrapper implementation)
/*! @internal */
template <class Archive, class T, class D> inline
void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, memory_detail::PtrWrapper<std::unique_ptr<T, D> const &> const & wrapper )
{
auto & ptr = wrapper.ptr;
// unique_ptr get one byte of metadata which signifies whether they were a nullptr
// 0 == nullptr
// 1 == not null
if( !ptr )
ar( CEREAL_NVP_("valid", uint8_t(0)) );
else
{
ar( CEREAL_NVP_("valid", uint8_t(1)) );
ar( CEREAL_NVP_("data", *ptr) );
}
}
//! Loading std::unique_ptr, case when user provides load_and_construct (wrapper implementation)
/*! @internal */
template <class Archive, class T, class D> inline
typename std::enable_if<traits::has_load_and_construct<T, Archive>::value, void>::type
CEREAL_LOAD_FUNCTION_NAME( Archive & ar, memory_detail::PtrWrapper<std::unique_ptr<T, D> &> & wrapper )
{
uint8_t isValid;
ar( CEREAL_NVP_("valid", isValid) );
auto & ptr = wrapper.ptr;
if( isValid )
{
using NonConstT = typename std::remove_const<T>::type;
// Storage type for the pointer - since we can't default construct this type,
// we'll allocate it using std::aligned_storage
using ST = typename std::aligned_storage<sizeof(NonConstT), CEREAL_ALIGNOF(NonConstT)>::type;
// Allocate storage - note the ST type so that deleter is correct if
// an exception is thrown before we are initialized
std::unique_ptr<ST> stPtr( new ST() );
// Use wrapper to enter into "data" nvp of ptr_wrapper
memory_detail::LoadAndConstructLoadWrapper<Archive, NonConstT> loadWrapper( reinterpret_cast<NonConstT *>( stPtr.get() ) );
// Initialize storage
ar( CEREAL_NVP_("data", loadWrapper) );
// Transfer ownership to correct unique_ptr type
ptr.reset( reinterpret_cast<T *>( stPtr.release() ) );
}
else
ptr.reset( nullptr );
}
//! Loading std::unique_ptr, case when no load_and_construct (wrapper implementation)
/*! @internal */
template <class Archive, class T, class D> inline
typename std::enable_if<!traits::has_load_and_construct<T, Archive>::value, void>::type
CEREAL_LOAD_FUNCTION_NAME( Archive & ar, memory_detail::PtrWrapper<std::unique_ptr<T, D> &> & wrapper )
{
uint8_t isValid;
ar( CEREAL_NVP_("valid", isValid) );
if( isValid )
{
using NonConstT = typename std::remove_const<T>::type;
std::unique_ptr<NonConstT, D> ptr( detail::Construct<NonConstT, Archive>::load_andor_construct() );
ar( CEREAL_NVP_( "data", *ptr ) );
wrapper.ptr = std::move(ptr);
}
else
{
wrapper.ptr.reset( nullptr );
}
}
} // namespace cereal
// automatically include polymorphic support
#include "cereal/types/polymorphic.hpp"
#endif // CEREAL_TYPES_SHARED_PTR_HPP_

View file

@ -0,0 +1,65 @@
/*! \file optional.hpp
\brief Support for std::optional
\ingroup STLSupport */
/*
Copyright (c) 2017, Juan Pedro Bolivar Puente
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_STD_OPTIONAL_
#define CEREAL_TYPES_STD_OPTIONAL_
#include "cereal/cereal.hpp"
#include <optional>
namespace cereal {
//! Saving for std::optional
template <class Archive, typename T> inline
void CEREAL_SAVE_FUNCTION_NAME(Archive& ar, const std::optional<T>& optional)
{
if(!optional) {
ar(CEREAL_NVP_("nullopt", true));
} else {
ar(CEREAL_NVP_("nullopt", false),
CEREAL_NVP_("data", *optional));
}
}
//! Loading for std::optional
template <class Archive, typename T> inline
void CEREAL_LOAD_FUNCTION_NAME(Archive& ar, std::optional<T>& optional)
{
bool nullopt;
ar(CEREAL_NVP_("nullopt", nullopt));
if (nullopt) {
optional = std::nullopt;
} else {
optional.emplace();
ar(CEREAL_NVP_("data", *optional));
}
}
} // namespace cereal
#endif // CEREAL_TYPES_STD_OPTIONAL_

View file

@ -0,0 +1,483 @@
/*! \file polymorphic.hpp
\brief Support for pointers to polymorphic base classes
\ingroup OtherTypes */
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_POLYMORPHIC_HPP_
#define CEREAL_TYPES_POLYMORPHIC_HPP_
#include "cereal/cereal.hpp"
#include "cereal/types/memory.hpp"
#include "cereal/details/util.hpp"
#include "cereal/details/helpers.hpp"
#include "cereal/details/traits.hpp"
#include "cereal/details/polymorphic_impl.hpp"
#if defined(_MSC_VER) && _MSC_VER < 1916
#define CEREAL_STATIC_CONSTEXPR static
#else
#define CEREAL_STATIC_CONSTEXPR static constexpr
#endif
//! Registers a derived polymorphic type with cereal
/*! Polymorphic types must be registered before smart
pointers to them can be serialized. Note that base
classes do not need to be registered.
Registering a type lets cereal know how to properly
serialize it when a smart pointer to a base object is
used in conjunction with a derived class.
This assumes that all relevant archives have also
previously been registered. Registration for archives
is usually done in the header file in which they are
defined. This means that type registration needs to
happen after specific archives to be used are included.
It is recommended that type registration be done in
the header file in which the type is declared.
Registration can also be placed in a source file,
but this may require the use of the
CEREAL_REGISTER_DYNAMIC_INIT macro (see below).
Registration may be called repeatedly for the same
type in different translation units to add support
for additional archives if they are not initially
available (included and registered).
When building serialization support as a DLL on
Windows, registration must happen in the header file.
On Linux and Mac things should still work properly
if placed in a source file, but see the above comments
on registering in source files.
Polymorphic support in cereal requires RTTI to be
enabled */
#define CEREAL_REGISTER_TYPE(...) \
namespace cereal { \
namespace detail { \
template <> \
struct binding_name<__VA_ARGS__> \
{ \
CEREAL_STATIC_CONSTEXPR char const * name() { return #__VA_ARGS__; } \
}; \
} } /* end namespaces */ \
CEREAL_BIND_TO_ARCHIVES(__VA_ARGS__)
//! Registers a polymorphic type with cereal, giving it a
//! user defined name
/*! In some cases the default name used with
CEREAL_REGISTER_TYPE (the name of the type) may not be
suitable. This macro allows any name to be associated
with the type. The name should be unique */
#define CEREAL_REGISTER_TYPE_WITH_NAME(T, Name) \
namespace cereal { \
namespace detail { \
template <> \
struct binding_name<T> \
{ CEREAL_STATIC_CONSTEXPR char const * name() { return Name; } }; \
} } /* end namespaces */ \
CEREAL_BIND_TO_ARCHIVES(T)
//! Registers the base-derived relationship for a polymorphic type
/*! When polymorphic serialization occurs, cereal needs to know how to
properly cast between derived and base types for the polymorphic
type. Normally this happens automatically whenever cereal::base_class
or cereal::virtual_base_class are used to serialize a base class. In
cases where neither of these is ever called but a base class still
exists, this explicit registration is required.
The Derived class should be the most derived type that will be serialized,
and the Base type any possible base that has not been covered under a base
class serialization that will be used to store a Derived pointer.
Placement of this is the same as for CEREAL_REGISTER_TYPE. */
#define CEREAL_REGISTER_POLYMORPHIC_RELATION(Base, Derived) \
namespace cereal { \
namespace detail { \
template <> \
struct PolymorphicRelation<Base, Derived> \
{ static void bind() { RegisterPolymorphicCaster<Base, Derived>::bind(); } }; \
} } /* end namespaces */
//! Adds a way to force initialization of a translation unit containing
//! calls to CEREAL_REGISTER_TYPE
/*! In C++, dynamic initialization of non-local variables of a translation
unit may be deferred until "the first odr-use of any function or variable
defined in the same translation unit as the variable to be initialized."
Informally, odr-use means that your program takes the address of or binds
a reference directly to an object, which must have a definition.
Since polymorphic type support in cereal relies on the dynamic
initialization of certain global objects happening before
serialization is performed, it is important to ensure that something
from files that call CEREAL_REGISTER_TYPE is odr-used before serialization
occurs, otherwise the registration will never take place. This may often
be the case when serialization is built as a shared library external from
your main program.
This macro, with any name of your choosing, should be placed into the
source file that contains calls to CEREAL_REGISTER_TYPE.
Its counterpart, CEREAL_FORCE_DYNAMIC_INIT, should be placed in its
associated header file such that it is included in the translation units
(source files) in which you want the registration to appear.
@relates CEREAL_FORCE_DYNAMIC_INIT
*/
#define CEREAL_REGISTER_DYNAMIC_INIT(LibName) \
namespace cereal { \
namespace detail { \
void CEREAL_DLL_EXPORT dynamic_init_dummy_##LibName() {} \
} } /* end namespaces */
//! Forces dynamic initialization of polymorphic support in a
//! previously registered source file
/*! @sa CEREAL_REGISTER_DYNAMIC_INIT
See CEREAL_REGISTER_DYNAMIC_INIT for detailed explanation
of how this macro should be used. The name used should
match that for CEREAL_REGISTER_DYNAMIC_INIT. */
#define CEREAL_FORCE_DYNAMIC_INIT(LibName) \
namespace cereal { \
namespace detail { \
void CEREAL_DLL_EXPORT dynamic_init_dummy_##LibName(); \
} /* end detail */ \
} /* end cereal */ \
namespace { \
struct dynamic_init_##LibName { \
dynamic_init_##LibName() { \
::cereal::detail::dynamic_init_dummy_##LibName(); \
} \
} dynamic_init_instance_##LibName; \
} /* end anonymous namespace */
namespace cereal
{
namespace polymorphic_detail
{
//! Error message used for unregistered polymorphic types
/*! @internal */
#define UNREGISTERED_POLYMORPHIC_EXCEPTION(LoadSave, Name) \
throw cereal::Exception("Trying to " #LoadSave " an unregistered polymorphic type (" + Name + ").\n" \
"Make sure your type is registered with CEREAL_REGISTER_TYPE and that the archive " \
"you are using was included (and registered with CEREAL_REGISTER_ARCHIVE) prior to calling CEREAL_REGISTER_TYPE.\n" \
"If your type is already registered and you still see this error, you may need to use CEREAL_REGISTER_DYNAMIC_INIT.");
//! Get an input binding from the given archive by deserializing the type meta data
/*! @internal */
template<class Archive> inline
typename ::cereal::detail::InputBindingMap<Archive>::Serializers getInputBinding(Archive & ar, std::uint32_t const nameid)
{
// If the nameid is zero, we serialized a null pointer
if(nameid == 0)
{
typename ::cereal::detail::InputBindingMap<Archive>::Serializers emptySerializers;
emptySerializers.shared_ptr = [](void*, std::shared_ptr<void> & ptr, std::type_info const &) { ptr.reset(); };
emptySerializers.unique_ptr = [](void*, std::unique_ptr<void, ::cereal::detail::EmptyDeleter<void>> & ptr, std::type_info const &) { ptr.reset( nullptr ); };
return emptySerializers;
}
std::string name;
if(nameid & detail::msb_32bit)
{
ar( CEREAL_NVP_("polymorphic_name", name) );
ar.registerPolymorphicName(nameid, name);
}
else
name = ar.getPolymorphicName(nameid);
auto const & bindingMap = detail::StaticObject<detail::InputBindingMap<Archive>>::getInstance().map;
auto binding = bindingMap.find(name);
if(binding == bindingMap.end())
UNREGISTERED_POLYMORPHIC_EXCEPTION(load, name)
return binding->second;
}
//! Serialize a shared_ptr if the 2nd msb in the nameid is set, and if we can actually construct the pointee
/*! This check lets us try and skip doing polymorphic machinery if we can get away with
using the derived class serialize function
Note that on MSVC 2013 preview, is_default_constructible<T> returns true for abstract classes with
default constructors, but on clang/gcc this will return false. So we also need to check for that here.
@internal */
template<class Archive, class T> inline
typename std::enable_if<(traits::is_default_constructible<T>::value
|| traits::has_load_and_construct<T, Archive>::value)
&& !std::is_abstract<T>::value, bool>::type
serialize_wrapper(Archive & ar, std::shared_ptr<T> & ptr, std::uint32_t const nameid)
{
if(nameid & detail::msb2_32bit)
{
ar( CEREAL_NVP_("ptr_wrapper", memory_detail::make_ptr_wrapper(ptr)) );
return true;
}
return false;
}
//! Serialize a unique_ptr if the 2nd msb in the nameid is set, and if we can actually construct the pointee
/*! This check lets us try and skip doing polymorphic machinery if we can get away with
using the derived class serialize function
@internal */
template<class Archive, class T, class D> inline
typename std::enable_if<(traits::is_default_constructible<T>::value
|| traits::has_load_and_construct<T, Archive>::value)
&& !std::is_abstract<T>::value, bool>::type
serialize_wrapper(Archive & ar, std::unique_ptr<T, D> & ptr, std::uint32_t const nameid)
{
if(nameid & detail::msb2_32bit)
{
ar( CEREAL_NVP_("ptr_wrapper", memory_detail::make_ptr_wrapper(ptr)) );
return true;
}
return false;
}
//! Serialize a shared_ptr if the 2nd msb in the nameid is set, and if we can actually construct the pointee
/*! This case is for when we can't actually construct the shared pointer. Normally this would be caught
as the pointer itself is serialized, but since this is a polymorphic pointer, if we tried to serialize
the pointer we'd end up back here recursively. So we have to catch the error here as well, if
this was a polymorphic type serialized by its proper pointer type
@internal */
template<class Archive, class T> inline
typename std::enable_if<(!traits::is_default_constructible<T>::value
&& !traits::has_load_and_construct<T, Archive>::value)
|| std::is_abstract<T>::value, bool>::type
serialize_wrapper(Archive &, std::shared_ptr<T> &, std::uint32_t const nameid)
{
if(nameid & detail::msb2_32bit)
throw cereal::Exception("Cannot load a polymorphic type that is not default constructable and does not have a load_and_construct function");
return false;
}
//! Serialize a unique_ptr if the 2nd msb in the nameid is set, and if we can actually construct the pointee
/*! This case is for when we can't actually construct the unique pointer. Normally this would be caught
as the pointer itself is serialized, but since this is a polymorphic pointer, if we tried to serialize
the pointer we'd end up back here recursively. So we have to catch the error here as well, if
this was a polymorphic type serialized by its proper pointer type
@internal */
template<class Archive, class T, class D> inline
typename std::enable_if<(!traits::is_default_constructible<T>::value
&& !traits::has_load_and_construct<T, Archive>::value)
|| std::is_abstract<T>::value, bool>::type
serialize_wrapper(Archive &, std::unique_ptr<T, D> &, std::uint32_t const nameid)
{
if(nameid & detail::msb2_32bit)
throw cereal::Exception("Cannot load a polymorphic type that is not default constructable and does not have a load_and_construct function");
return false;
}
} // polymorphic_detail
// ######################################################################
// Pointer serialization for polymorphic types
//! Saving std::shared_ptr for polymorphic types, abstract
template <class Archive, class T> inline
typename std::enable_if<std::is_polymorphic<T>::value && std::is_abstract<T>::value, void>::type
CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::shared_ptr<T> const & ptr )
{
if(!ptr)
{
// same behavior as nullptr in memory implementation
ar( CEREAL_NVP_("polymorphic_id", std::uint32_t(0)) );
return;
}
std::type_info const & ptrinfo = typeid(*ptr.get());
static std::type_info const & tinfo = typeid(T);
// ptrinfo can never be equal to T info since we can't have an instance
// of an abstract object
// this implies we need to do the lookup
auto const & bindingMap = detail::StaticObject<detail::OutputBindingMap<Archive>>::getInstance().map;
auto binding = bindingMap.find(std::type_index(ptrinfo));
if(binding == bindingMap.end())
UNREGISTERED_POLYMORPHIC_EXCEPTION(save, cereal::util::demangle(ptrinfo.name()))
binding->second.shared_ptr(&ar, ptr.get(), tinfo);
}
//! Saving std::shared_ptr for polymorphic types, not abstract
template <class Archive, class T> inline
typename std::enable_if<std::is_polymorphic<T>::value && !std::is_abstract<T>::value, void>::type
CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::shared_ptr<T> const & ptr )
{
if(!ptr)
{
// same behavior as nullptr in memory implementation
ar( CEREAL_NVP_("polymorphic_id", std::uint32_t(0)) );
return;
}
std::type_info const & ptrinfo = typeid(*ptr.get());
static std::type_info const & tinfo = typeid(T);
if(ptrinfo == tinfo)
{
// The 2nd msb signals that the following pointer does not need to be
// cast with our polymorphic machinery
ar( CEREAL_NVP_("polymorphic_id", detail::msb2_32bit) );
ar( CEREAL_NVP_("ptr_wrapper", memory_detail::make_ptr_wrapper(ptr)) );
return;
}
auto const & bindingMap = detail::StaticObject<detail::OutputBindingMap<Archive>>::getInstance().map;
auto binding = bindingMap.find(std::type_index(ptrinfo));
if(binding == bindingMap.end())
UNREGISTERED_POLYMORPHIC_EXCEPTION(save, cereal::util::demangle(ptrinfo.name()))
binding->second.shared_ptr(&ar, ptr.get(), tinfo);
}
//! Loading std::shared_ptr for polymorphic types
template <class Archive, class T> inline
typename std::enable_if<std::is_polymorphic<T>::value, void>::type
CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::shared_ptr<T> & ptr )
{
std::uint32_t nameid;
ar( CEREAL_NVP_("polymorphic_id", nameid) );
// Check to see if we can skip all of this polymorphism business
if(polymorphic_detail::serialize_wrapper(ar, ptr, nameid))
return;
auto binding = polymorphic_detail::getInputBinding(ar, nameid);
std::shared_ptr<void> result;
binding.shared_ptr(&ar, result, typeid(T));
ptr = std::static_pointer_cast<T>(result);
}
//! Saving std::weak_ptr for polymorphic types
template <class Archive, class T> inline
typename std::enable_if<std::is_polymorphic<T>::value, void>::type
CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::weak_ptr<T> const & ptr )
{
auto const sptr = ptr.lock();
ar( CEREAL_NVP_("locked_ptr", sptr) );
}
//! Loading std::weak_ptr for polymorphic types
template <class Archive, class T> inline
typename std::enable_if<std::is_polymorphic<T>::value, void>::type
CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::weak_ptr<T> & ptr )
{
std::shared_ptr<T> sptr;
ar( CEREAL_NVP_("locked_ptr", sptr) );
ptr = sptr;
}
//! Saving std::unique_ptr for polymorphic types that are abstract
template <class Archive, class T, class D> inline
typename std::enable_if<std::is_polymorphic<T>::value && std::is_abstract<T>::value, void>::type
CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::unique_ptr<T, D> const & ptr )
{
if(!ptr)
{
// same behavior as nullptr in memory implementation
ar( CEREAL_NVP_("polymorphic_id", std::uint32_t(0)) );
return;
}
std::type_info const & ptrinfo = typeid(*ptr.get());
static std::type_info const & tinfo = typeid(T);
// ptrinfo can never be equal to T info since we can't have an instance
// of an abstract object
// this implies we need to do the lookup
auto const & bindingMap = detail::StaticObject<detail::OutputBindingMap<Archive>>::getInstance().map;
auto binding = bindingMap.find(std::type_index(ptrinfo));
if(binding == bindingMap.end())
UNREGISTERED_POLYMORPHIC_EXCEPTION(save, cereal::util::demangle(ptrinfo.name()))
binding->second.unique_ptr(&ar, ptr.get(), tinfo);
}
//! Saving std::unique_ptr for polymorphic types, not abstract
template <class Archive, class T, class D> inline
typename std::enable_if<std::is_polymorphic<T>::value && !std::is_abstract<T>::value, void>::type
CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::unique_ptr<T, D> const & ptr )
{
if(!ptr)
{
// same behavior as nullptr in memory implementation
ar( CEREAL_NVP_("polymorphic_id", std::uint32_t(0)) );
return;
}
std::type_info const & ptrinfo = typeid(*ptr.get());
static std::type_info const & tinfo = typeid(T);
if(ptrinfo == tinfo)
{
// The 2nd msb signals that the following pointer does not need to be
// cast with our polymorphic machinery
ar( CEREAL_NVP_("polymorphic_id", detail::msb2_32bit) );
ar( CEREAL_NVP_("ptr_wrapper", memory_detail::make_ptr_wrapper(ptr)) );
return;
}
auto const & bindingMap = detail::StaticObject<detail::OutputBindingMap<Archive>>::getInstance().map;
auto binding = bindingMap.find(std::type_index(ptrinfo));
if(binding == bindingMap.end())
UNREGISTERED_POLYMORPHIC_EXCEPTION(save, cereal::util::demangle(ptrinfo.name()))
binding->second.unique_ptr(&ar, ptr.get(), tinfo);
}
//! Loading std::unique_ptr, case when user provides load_and_construct for polymorphic types
template <class Archive, class T, class D> inline
typename std::enable_if<std::is_polymorphic<T>::value, void>::type
CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::unique_ptr<T, D> & ptr )
{
std::uint32_t nameid;
ar( CEREAL_NVP_("polymorphic_id", nameid) );
// Check to see if we can skip all of this polymorphism business
if(polymorphic_detail::serialize_wrapper(ar, ptr, nameid))
return;
auto binding = polymorphic_detail::getInputBinding(ar, nameid);
std::unique_ptr<void, ::cereal::detail::EmptyDeleter<void>> result;
binding.unique_ptr(&ar, result, typeid(T));
ptr.reset(static_cast<T*>(result.release()));
}
#undef UNREGISTERED_POLYMORPHIC_EXCEPTION
} // namespace cereal
#endif // CEREAL_TYPES_POLYMORPHIC_HPP_

View file

@ -0,0 +1,132 @@
/*! \file queue.hpp
\brief Support for types found in \<queue\>
\ingroup STLSupport */
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_QUEUE_HPP_
#define CEREAL_TYPES_QUEUE_HPP_
#include "cereal/details/helpers.hpp"
#include <queue>
// The default container for queue is deque, so let's include that too
#include "cereal/types/deque.hpp"
// The default comparator for queue is less
#include "cereal/types/functional.hpp"
namespace cereal
{
namespace queue_detail
{
//! Allows access to the protected container in queue
/*! @internal */
template <class T, class C> inline
C const & container( std::queue<T, C> const & queue )
{
struct H : public std::queue<T, C>
{
static C const & get( std::queue<T, C> const & q )
{
return q.*(&H::c);
}
};
return H::get( queue );
}
//! Allows access to the protected container in priority queue
/*! @internal */
template <class T, class C, class Comp> inline
C const & container( std::priority_queue<T, C, Comp> const & priority_queue )
{
struct H : public std::priority_queue<T, C, Comp>
{
static C const & get( std::priority_queue<T, C, Comp> const & pq )
{
return pq.*(&H::c);
}
};
return H::get( priority_queue );
}
//! Allows access to the protected comparator in priority queue
/*! @internal */
template <class T, class C, class Comp> inline
Comp const & comparator( std::priority_queue<T, C, Comp> const & priority_queue )
{
struct H : public std::priority_queue<T, C, Comp>
{
static Comp const & get( std::priority_queue<T, C, Comp> const & pq )
{
return pq.*(&H::comp);
}
};
return H::get( priority_queue );
}
}
//! Saving for std::queue
template <class Archive, class T, class C> inline
void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::queue<T, C> const & queue )
{
ar( CEREAL_NVP_("container", queue_detail::container( queue )) );
}
//! Loading for std::queue
template <class Archive, class T, class C> inline
void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::queue<T, C> & queue )
{
C container;
ar( CEREAL_NVP_("container", container) );
queue = std::queue<T, C>( std::move( container ) );
}
//! Saving for std::priority_queue
template <class Archive, class T, class C, class Comp> inline
void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::priority_queue<T, C, Comp> const & priority_queue )
{
ar( CEREAL_NVP_("comparator", queue_detail::comparator( priority_queue )) );
ar( CEREAL_NVP_("container", queue_detail::container( priority_queue )) );
}
//! Loading for std::priority_queue
template <class Archive, class T, class C, class Comp> inline
void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::priority_queue<T, C, Comp> & priority_queue )
{
Comp comparator;
ar( CEREAL_NVP_("comparator", comparator) );
C container;
ar( CEREAL_NVP_("container", container) );
priority_queue = std::priority_queue<T, C, Comp>( comparator, std::move( container ) );
}
} // namespace cereal
#endif // CEREAL_TYPES_QUEUE_HPP_

View file

@ -0,0 +1,103 @@
/*! \file set.hpp
\brief Support for types found in \<set\>
\ingroup STLSupport */
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_SET_HPP_
#define CEREAL_TYPES_SET_HPP_
#include "cereal/cereal.hpp"
#include <set>
namespace cereal
{
namespace set_detail
{
//! @internal
template <class Archive, class SetT> inline
void save( Archive & ar, SetT const & set )
{
ar( make_size_tag( static_cast<size_type>(set.size()) ) );
for( const auto & i : set )
ar( i );
}
//! @internal
template <class Archive, class SetT> inline
void load( Archive & ar, SetT & set )
{
size_type size;
ar( make_size_tag( size ) );
set.clear();
auto hint = set.begin();
for( size_type i = 0; i < size; ++i )
{
typename SetT::key_type key;
ar( key );
#ifdef CEREAL_OLDER_GCC
hint = set.insert( hint, std::move( key ) );
#else // NOT CEREAL_OLDER_GCC
hint = set.emplace_hint( hint, std::move( key ) );
#endif // NOT CEREAL_OLDER_GCC
}
}
}
//! Saving for std::set
template <class Archive, class K, class C, class A> inline
void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::set<K, C, A> const & set )
{
set_detail::save( ar, set );
}
//! Loading for std::set
template <class Archive, class K, class C, class A> inline
void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::set<K, C, A> & set )
{
set_detail::load( ar, set );
}
//! Saving for std::multiset
template <class Archive, class K, class C, class A> inline
void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::multiset<K, C, A> const & multiset )
{
set_detail::save( ar, multiset );
}
//! Loading for std::multiset
template <class Archive, class K, class C, class A> inline
void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::multiset<K, C, A> & multiset )
{
set_detail::load( ar, multiset );
}
} // namespace cereal
#endif // CEREAL_TYPES_SET_HPP_

View file

@ -0,0 +1,76 @@
/*! \file stack.hpp
\brief Support for types found in \<stack\>
\ingroup STLSupport */
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_STACK_HPP_
#define CEREAL_TYPES_STACK_HPP_
#include "cereal/cereal.hpp"
#include <stack>
// The default container for stack is deque, so let's include that too
#include "cereal/types/deque.hpp"
namespace cereal
{
namespace stack_detail
{
//! Allows access to the protected container in stack
template <class T, class C> inline
C const & container( std::stack<T, C> const & stack )
{
struct H : public std::stack<T, C>
{
static C const & get( std::stack<T, C> const & s )
{
return s.*(&H::c);
}
};
return H::get( stack );
}
}
//! Saving for std::stack
template <class Archive, class T, class C> inline
void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::stack<T, C> const & stack )
{
ar( CEREAL_NVP_("container", stack_detail::container( stack )) );
}
//! Loading for std::stack
template <class Archive, class T, class C> inline
void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::stack<T, C> & stack )
{
C container;
ar( CEREAL_NVP_("container", container) );
stack = std::stack<T, C>( std::move( container ) );
}
} // namespace cereal
#endif // CEREAL_TYPES_STACK_HPP_

View file

@ -0,0 +1,61 @@
/*! \file string.hpp
\brief Support for types found in \<string\>
\ingroup STLSupport */
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_STRING_HPP_
#define CEREAL_TYPES_STRING_HPP_
#include "cereal/cereal.hpp"
#include <string>
namespace cereal
{
//! Serialization for basic_string types, if binary data is supported
template<class Archive, class CharT, class Traits, class Alloc> inline
typename std::enable_if<traits::is_output_serializable<BinaryData<CharT>, Archive>::value, void>::type
CEREAL_SAVE_FUNCTION_NAME(Archive & ar, std::basic_string<CharT, Traits, Alloc> const & str)
{
// Save number of chars + the data
ar( make_size_tag( static_cast<size_type>(str.size()) ) );
ar( binary_data( str.data(), str.size() * sizeof(CharT) ) );
}
//! Serialization for basic_string types, if binary data is supported
template<class Archive, class CharT, class Traits, class Alloc> inline
typename std::enable_if<traits::is_input_serializable<BinaryData<CharT>, Archive>::value, void>::type
CEREAL_LOAD_FUNCTION_NAME(Archive & ar, std::basic_string<CharT, Traits, Alloc> & str)
{
size_type size;
ar( make_size_tag( size ) );
str.resize(static_cast<std::size_t>(size));
ar( binary_data( const_cast<CharT *>( str.data() ), static_cast<std::size_t>(size) * sizeof(CharT) ) );
}
} // namespace cereal
#endif // CEREAL_TYPES_STRING_HPP_

View file

@ -0,0 +1,123 @@
/*! \file tuple.hpp
\brief Support for types found in \<tuple\>
\ingroup STLSupport */
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_TUPLE_HPP_
#define CEREAL_TYPES_TUPLE_HPP_
#include "cereal/cereal.hpp"
#include <tuple>
namespace cereal
{
namespace tuple_detail
{
//! Creates a c string from a sequence of characters
/*! The c string created will always be prefixed by "tuple_element"
Based on code from: http://stackoverflow/a/20973438/710791
@internal */
template<char...Cs>
struct char_seq_to_c_str
{
static const int size = 14;// Size of array for the word: tuple_element
typedef const char (&arr_type)[sizeof...(Cs) + size];
static const char str[sizeof...(Cs) + size];
};
// the word tuple_element plus a number
//! @internal
template<char...Cs>
const char char_seq_to_c_str<Cs...>::str[sizeof...(Cs) + size] =
{'t','u','p','l','e','_','e','l','e','m','e','n','t', Cs..., '\0'};
//! Converts a number into a sequence of characters
/*! @tparam Q The quotient of dividing the original number by 10
@tparam R The remainder of dividing the original number by 10
@tparam C The sequence built so far
@internal */
template <size_t Q, size_t R, char ... C>
struct to_string_impl
{
using type = typename to_string_impl<Q/10, Q%10, static_cast<char>(R+std::size_t{'0'}), C...>::type;
};
//! Base case with no quotient
/*! @internal */
template <size_t R, char ... C>
struct to_string_impl<0, R, C...>
{
using type = char_seq_to_c_str<static_cast<char>(R+std::size_t{'0'}), C...>;
};
//! Generates a c string for a given index of a tuple
/*! Example use:
@code{cpp}
tuple_element_name<3>::c_str();// returns "tuple_element3"
@endcode
@internal */
template<size_t T>
struct tuple_element_name
{
using type = typename to_string_impl<T/10, T%10>::type;
static const typename type::arr_type c_str(){ return type::str; }
};
// unwinds a tuple to save it
//! @internal
template <size_t Height>
struct serialize
{
template <class Archive, class ... Types> inline
static void apply( Archive & ar, std::tuple<Types...> & tuple )
{
serialize<Height - 1>::template apply( ar, tuple );
ar( CEREAL_NVP_(tuple_element_name<Height - 1>::c_str(),
std::get<Height - 1>( tuple )) );
}
};
// Zero height specialization - nothing to do here
//! @internal
template <>
struct serialize<0>
{
template <class Archive, class ... Types> inline
static void apply( Archive &, std::tuple<Types...> & )
{ }
};
}
//! Serializing for std::tuple
template <class Archive, class ... Types> inline
void CEREAL_SERIALIZE_FUNCTION_NAME( Archive & ar, std::tuple<Types...> & tuple )
{
tuple_detail::serialize<std::tuple_size<std::tuple<Types...>>::value>::template apply( ar, tuple );
}
} // namespace cereal
#endif // CEREAL_TYPES_TUPLE_HPP_

View file

@ -0,0 +1,36 @@
/*! \file unordered_map.hpp
\brief Support for types found in \<unordered_map\>
\ingroup STLSupport */
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_UNORDERED_MAP_HPP_
#define CEREAL_TYPES_UNORDERED_MAP_HPP_
#include "cereal/types/concepts/pair_associative_container.hpp"
#include <unordered_map>
#endif // CEREAL_TYPES_UNORDERED_MAP_HPP_

View file

@ -0,0 +1,99 @@
/*! \file unordered_set.hpp
\brief Support for types found in \<unordered_set\>
\ingroup STLSupport */
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_UNORDERED_SET_HPP_
#define CEREAL_TYPES_UNORDERED_SET_HPP_
#include "cereal/cereal.hpp"
#include <unordered_set>
namespace cereal
{
namespace unordered_set_detail
{
//! @internal
template <class Archive, class SetT> inline
void save( Archive & ar, SetT const & set )
{
ar( make_size_tag( static_cast<size_type>(set.size()) ) );
for( const auto & i : set )
ar( i );
}
//! @internal
template <class Archive, class SetT> inline
void load( Archive & ar, SetT & set )
{
size_type size;
ar( make_size_tag( size ) );
set.clear();
set.reserve( static_cast<std::size_t>( size ) );
for( size_type i = 0; i < size; ++i )
{
typename SetT::key_type key;
ar( key );
set.emplace( std::move( key ) );
}
}
}
//! Saving for std::unordered_set
template <class Archive, class K, class H, class KE, class A> inline
void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::unordered_set<K, H, KE, A> const & unordered_set )
{
unordered_set_detail::save( ar, unordered_set );
}
//! Loading for std::unordered_set
template <class Archive, class K, class H, class KE, class A> inline
void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::unordered_set<K, H, KE, A> & unordered_set )
{
unordered_set_detail::load( ar, unordered_set );
}
//! Saving for std::unordered_multiset
template <class Archive, class K, class H, class KE, class A> inline
void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::unordered_multiset<K, H, KE, A> const & unordered_multiset )
{
unordered_set_detail::save( ar, unordered_multiset );
}
//! Loading for std::unordered_multiset
template <class Archive, class K, class H, class KE, class A> inline
void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::unordered_multiset<K, H, KE, A> & unordered_multiset )
{
unordered_set_detail::load( ar, unordered_multiset );
}
} // namespace cereal
#endif // CEREAL_TYPES_UNORDERED_SET_HPP_

View file

@ -0,0 +1,47 @@
/*! \file utility.hpp
\brief Support for types found in \<utility\>
\ingroup STLSupport */
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_UTILITY_HPP_
#define CEREAL_TYPES_UTILITY_HPP_
#include "cereal/cereal.hpp"
#include <utility>
namespace cereal
{
//! Serializing for std::pair
template <class Archive, class T1, class T2> inline
void CEREAL_SERIALIZE_FUNCTION_NAME( Archive & ar, std::pair<T1, T2> & pair )
{
ar( CEREAL_NVP_("first", pair.first),
CEREAL_NVP_("second", pair.second) );
}
} // namespace cereal
#endif // CEREAL_TYPES_UTILITY_HPP_

View file

@ -0,0 +1,89 @@
/*! \file valarray.hpp
\brief Support for types found in \<valarray\>
\ingroup STLSupport */
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of cereal nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_VALARRAY_HPP_
#define CEREAL_TYPES_VALARRAY_HPP_
#include "cereal/cereal.hpp"
#include <valarray>
namespace cereal
{
//! Saving for std::valarray arithmetic types, using binary serialization, if supported
template <class Archive, class T> inline
typename std::enable_if<traits::is_output_serializable<BinaryData<T>, Archive>::value
&& std::is_arithmetic<T>::value, void>::type
CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::valarray<T> const & valarray )
{
ar( make_size_tag( static_cast<size_type>(valarray.size()) ) ); // number of elements
ar( binary_data( &valarray[0], valarray.size() * sizeof(T) ) ); // &valarray[0] ok since guaranteed contiguous
}
//! Loading for std::valarray arithmetic types, using binary serialization, if supported
template <class Archive, class T> inline
typename std::enable_if<traits::is_input_serializable<BinaryData<T>, Archive>::value
&& std::is_arithmetic<T>::value, void>::type
CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::valarray<T> & valarray )
{
size_type valarraySize;
ar( make_size_tag( valarraySize ) );
valarray.resize( static_cast<std::size_t>( valarraySize ) );
ar( binary_data( &valarray[0], static_cast<std::size_t>( valarraySize ) * sizeof(T) ) );
}
//! Saving for std::valarray all other types
template <class Archive, class T> inline
typename std::enable_if<!traits::is_output_serializable<BinaryData<T>, Archive>::value
|| !std::is_arithmetic<T>::value, void>::type
CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::valarray<T> const & valarray )
{
ar( make_size_tag( static_cast<size_type>(valarray.size()) ) ); // number of elements
for(auto && v : valarray)
ar(v);
}
//! Loading for std::valarray all other types
template <class Archive, class T> inline
typename std::enable_if<!traits::is_input_serializable<BinaryData<T>, Archive>::value
|| !std::is_arithmetic<T>::value, void>::type
CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::valarray<T> & valarray )
{
size_type valarraySize;
ar( make_size_tag( valarraySize ) );
valarray.resize( static_cast<size_t>( valarraySize ) );
for(auto && v : valarray)
ar(v);
}
} // namespace cereal
#endif // CEREAL_TYPES_VALARRAY_HPP_

View file

@ -0,0 +1,108 @@
/*! \file variant.hpp
\brief Support for std::variant
\ingroup STLSupport */
/*
Copyright (c) 2014, 2017, Randolph Voorhies, Shane Grant, Juan Pedro
Bolivar Puente. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_STD_VARIANT_HPP_
#define CEREAL_TYPES_STD_VARIANT_HPP_
#include "cereal/cereal.hpp"
#include <variant>
#include <cstdint>
namespace cereal
{
namespace variant_detail
{
//! @internal
template <class Archive>
struct variant_save_visitor
{
variant_save_visitor(Archive & ar_) : ar(ar_) {}
template<class T>
void operator()(T const & value) const
{
ar( CEREAL_NVP_("data", value) );
}
Archive & ar;
};
//! @internal
template<int N, class Variant, class Archive>
typename std::enable_if<N == std::variant_size_v<Variant>, void>::type
load_variant(Archive & /*ar*/, int /*target*/, Variant & /*variant*/)
{
throw ::cereal::Exception("Error traversing variant during load");
}
//! @internal
template<int N, class Variant, class Archive>
typename std::enable_if<N < std::variant_size_v<Variant>, void>::type
load_variant(Archive & ar, int target, Variant & variant)
{
if(N == target)
{
variant.template emplace<N>();
ar( CEREAL_NVP_("data", std::get<N>(variant)) );
}
else
load_variant<N+1>(ar, target, variant);
}
} // namespace variant_detail
//! Saving for std::variant
template <class Archive, typename VariantType1, typename... VariantTypes> inline
void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::variant<VariantType1, VariantTypes...> const & variant )
{
std::int32_t index = static_cast<std::int32_t>(variant.index());
ar( CEREAL_NVP_("index", index) );
variant_detail::variant_save_visitor<Archive> visitor(ar);
std::visit(visitor, variant);
}
//! Loading for std::variant
template <class Archive, typename... VariantTypes> inline
void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::variant<VariantTypes...> & variant )
{
using variant_t = typename std::variant<VariantTypes...>;
std::int32_t index;
ar( CEREAL_NVP_("index", index) );
if(index >= static_cast<std::int32_t>(std::variant_size_v<variant_t>))
throw Exception("Invalid 'index' selector when deserializing std::variant");
variant_detail::load_variant<0>(ar, index, variant);
}
//! Serializing a std::monostate
template <class Archive>
void CEREAL_SERIALIZE_FUNCTION_NAME( Archive &, std::monostate const & ) {}
} // namespace cereal
#endif // CEREAL_TYPES_STD_VARIANT_HPP_

View file

@ -0,0 +1,112 @@
/*! \file vector.hpp
\brief Support for types found in \<vector\>
\ingroup STLSupport */
/*
Copyright (c) 2014, Randolph Voorhies, Shane Grant
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef CEREAL_TYPES_VECTOR_HPP_
#define CEREAL_TYPES_VECTOR_HPP_
#include "cereal/cereal.hpp"
#include <vector>
namespace cereal
{
//! Serialization for std::vectors of arithmetic (but not bool) using binary serialization, if supported
template <class Archive, class T, class A> inline
typename std::enable_if<traits::is_output_serializable<BinaryData<T>, Archive>::value
&& std::is_arithmetic<T>::value && !std::is_same<T, bool>::value, void>::type
CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::vector<T, A> const & vector )
{
ar( make_size_tag( static_cast<size_type>(vector.size()) ) ); // number of elements
ar( binary_data( vector.data(), vector.size() * sizeof(T) ) );
}
//! Serialization for std::vectors of arithmetic (but not bool) using binary serialization, if supported
template <class Archive, class T, class A> inline
typename std::enable_if<traits::is_input_serializable<BinaryData<T>, Archive>::value
&& std::is_arithmetic<T>::value && !std::is_same<T, bool>::value, void>::type
CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::vector<T, A> & vector )
{
size_type vectorSize;
ar( make_size_tag( vectorSize ) );
vector.resize( static_cast<std::size_t>( vectorSize ) );
ar( binary_data( vector.data(), static_cast<std::size_t>( vectorSize ) * sizeof(T) ) );
}
//! Serialization for non-arithmetic vector types
template <class Archive, class T, class A> inline
typename std::enable_if<(!traits::is_output_serializable<BinaryData<T>, Archive>::value
|| !std::is_arithmetic<T>::value) && !std::is_same<T, bool>::value, void>::type
CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::vector<T, A> const & vector )
{
ar( make_size_tag( static_cast<size_type>(vector.size()) ) ); // number of elements
for(auto && v : vector)
ar( v );
}
//! Serialization for non-arithmetic vector types
template <class Archive, class T, class A> inline
typename std::enable_if<(!traits::is_input_serializable<BinaryData<T>, Archive>::value
|| !std::is_arithmetic<T>::value) && !std::is_same<T, bool>::value, void>::type
CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::vector<T, A> & vector )
{
size_type size;
ar( make_size_tag( size ) );
vector.resize( static_cast<std::size_t>( size ) );
for(auto && v : vector)
ar( v );
}
//! Serialization for bool vector types
template <class Archive, class A> inline
void CEREAL_SAVE_FUNCTION_NAME( Archive & ar, std::vector<bool, A> const & vector )
{
ar( make_size_tag( static_cast<size_type>(vector.size()) ) ); // number of elements
for(const auto v : vector)
ar( static_cast<bool>(v) );
}
//! Serialization for bool vector types
template <class Archive, class A> inline
void CEREAL_LOAD_FUNCTION_NAME( Archive & ar, std::vector<bool, A> & vector )
{
size_type size;
ar( make_size_tag( size ) );
vector.resize( static_cast<std::size_t>( size ) );
for(auto && v : vector)
{
bool b;
ar( b );
v = b;
}
}
} // namespace cereal
#endif // CEREAL_TYPES_VECTOR_HPP_