Initial Commit
This commit is contained in:
commit
6088fc29ed
978 changed files with 353647 additions and 0 deletions
79
include/cereal/types/array.hpp
Normal file
79
include/cereal/types/array.hpp
Normal 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_
|
||||
55
include/cereal/types/atomic.hpp
Normal file
55
include/cereal/types/atomic.hpp
Normal 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_
|
||||
203
include/cereal/types/base_class.hpp
Normal file
203
include/cereal/types/base_class.hpp
Normal 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_
|
||||
176
include/cereal/types/bitset.hpp
Normal file
176
include/cereal/types/bitset.hpp
Normal 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_
|
||||
164
include/cereal/types/boost_variant.hpp
Normal file
164
include/cereal/types/boost_variant.hpp
Normal 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_
|
||||
72
include/cereal/types/chrono.hpp
Normal file
72
include/cereal/types/chrono.hpp
Normal 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_
|
||||
129
include/cereal/types/common.hpp
Normal file
129
include/cereal/types/common.hpp
Normal 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_
|
||||
56
include/cereal/types/complex.hpp
Normal file
56
include/cereal/types/complex.hpp
Normal 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_
|
||||
73
include/cereal/types/concepts/pair_associative_container.hpp
Normal file
73
include/cereal/types/concepts/pair_associative_container.hpp
Normal 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_
|
||||
62
include/cereal/types/deque.hpp
Normal file
62
include/cereal/types/deque.hpp
Normal 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_
|
||||
68
include/cereal/types/forward_list.hpp
Normal file
68
include/cereal/types/forward_list.hpp
Normal 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_
|
||||
43
include/cereal/types/functional.hpp
Normal file
43
include/cereal/types/functional.hpp
Normal 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_
|
||||
62
include/cereal/types/list.hpp
Normal file
62
include/cereal/types/list.hpp
Normal 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_
|
||||
36
include/cereal/types/map.hpp
Normal file
36
include/cereal/types/map.hpp
Normal 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_
|
||||
425
include/cereal/types/memory.hpp
Normal file
425
include/cereal/types/memory.hpp
Normal 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_
|
||||
65
include/cereal/types/optional.hpp
Normal file
65
include/cereal/types/optional.hpp
Normal 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_
|
||||
483
include/cereal/types/polymorphic.hpp
Normal file
483
include/cereal/types/polymorphic.hpp
Normal 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_
|
||||
132
include/cereal/types/queue.hpp
Normal file
132
include/cereal/types/queue.hpp
Normal 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_
|
||||
103
include/cereal/types/set.hpp
Normal file
103
include/cereal/types/set.hpp
Normal 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_
|
||||
76
include/cereal/types/stack.hpp
Normal file
76
include/cereal/types/stack.hpp
Normal 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_
|
||||
61
include/cereal/types/string.hpp
Normal file
61
include/cereal/types/string.hpp
Normal 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_
|
||||
|
||||
123
include/cereal/types/tuple.hpp
Normal file
123
include/cereal/types/tuple.hpp
Normal 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_
|
||||
36
include/cereal/types/unordered_map.hpp
Normal file
36
include/cereal/types/unordered_map.hpp
Normal 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_
|
||||
99
include/cereal/types/unordered_set.hpp
Normal file
99
include/cereal/types/unordered_set.hpp
Normal 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_
|
||||
47
include/cereal/types/utility.hpp
Normal file
47
include/cereal/types/utility.hpp
Normal 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_
|
||||
89
include/cereal/types/valarray.hpp
Normal file
89
include/cereal/types/valarray.hpp
Normal 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_
|
||||
108
include/cereal/types/variant.hpp
Normal file
108
include/cereal/types/variant.hpp
Normal 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_
|
||||
112
include/cereal/types/vector.hpp
Normal file
112
include/cereal/types/vector.hpp
Normal 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_
|
||||
Loading…
Add table
Add a link
Reference in a new issue