mirror of
https://github.com/USCiLab/cereal.git
synced 2025-09-27 20:59:32 +02:00
fixing gcc errors
This commit is contained in:
Shane Grant
parent
fa9312534d
commit
06f675743c
3
Makefile
3
Makefile
@ -13,6 +13,9 @@ sandbox_json: sandbox_json.cpp
|
||||
sandbox_rtti: sandbox_rtti.cpp
|
||||
${CC} sandbox_rtti.cpp -o sandbox_rtti ${CPPFLAGS} -O3
|
||||
|
||||
sandbox_vs: sandbox_vs.cpp
|
||||
${CC} sandbox_vs.cpp -o sandbox_vs ${CPPFLAGS}
|
||||
|
||||
unittests: unittests.cpp
|
||||
${CC} unittests.cpp -o unittests -lboost_unit_test_framework ${CPPFLAGS}
|
||||
./unittests --show_progress
|
||||
|
||||
@ -56,9 +56,9 @@ namespace cereal
|
||||
{ }
|
||||
|
||||
//! Writes size bytes of data to the output stream
|
||||
void saveBinary( const void * data, size_t size )
|
||||
void saveBinary( const void * data, std::size_t size )
|
||||
{
|
||||
auto const writtenSize = itsStream.rdbuf()->sputn( reinterpret_cast<const char*>( data ), size );
|
||||
auto const writtenSize = static_cast<std::size_t>( itsStream.rdbuf()->sputn( reinterpret_cast<const char*>( data ), size ) );
|
||||
|
||||
if(writtenSize != size)
|
||||
throw Exception("Failed to write " + std::to_string(size) + " bytes to output stream! Wrote " + std::to_string(writtenSize));
|
||||
@ -85,9 +85,9 @@ namespace cereal
|
||||
{ }
|
||||
|
||||
//! Reads size bytes of data from the input stream
|
||||
void loadBinary( void * const data, size_t size )
|
||||
void loadBinary( void * const data, std::size_t size )
|
||||
{
|
||||
auto const readSize = itsStream.rdbuf()->sgetn( reinterpret_cast<char*>( data ), size );
|
||||
auto const readSize = static_cast<std::size_t>( itsStream.rdbuf()->sgetn( reinterpret_cast<char*>( data ), size ) );
|
||||
|
||||
if(readSize != size)
|
||||
throw Exception("Failed to read " + std::to_string(size) + " bytes from input stream! Read " + std::to_string(readSize));
|
||||
|
||||
@ -49,10 +49,10 @@ namespace cereal
|
||||
/*! @param data The data as a uint8_t pointer
|
||||
@tparam DataSize The true size of the data
|
||||
@ingroup Internal */
|
||||
template <size_t DataSize>
|
||||
template <std::size_t DataSize>
|
||||
inline void swap_bytes( std::uint8_t * data )
|
||||
{
|
||||
for( size_t i = 0, end = DataSize / 2; i < end; ++i )
|
||||
for( std::size_t i = 0, end = DataSize / 2; i < end; ++i )
|
||||
std::swap( data[i], data[DataSize - i - 1] );
|
||||
}
|
||||
} // end namespace portable_binary_detail
|
||||
@ -85,9 +85,9 @@ namespace cereal
|
||||
}
|
||||
|
||||
//! Writes size bytes of data to the output stream
|
||||
void saveBinary( const void * data, size_t size )
|
||||
void saveBinary( const void * data, std::size_t size )
|
||||
{
|
||||
auto const writtenSize = itsStream.rdbuf()->sputn( reinterpret_cast<const char*>( data ), size );
|
||||
auto const writtenSize = static_cast<std::size_t>( itsStream.rdbuf()->sputn( reinterpret_cast<const char*>( data ), size ) );
|
||||
|
||||
if(writtenSize != size)
|
||||
throw Exception("Failed to write " + std::to_string(size) + " bytes to output stream! Wrote " + std::to_string(writtenSize));
|
||||
@ -138,11 +138,11 @@ namespace cereal
|
||||
/*! @param data The data to save
|
||||
@param size The number of bytes in the data
|
||||
@tparam DataSize T The size of the actual type of the data elements being loaded */
|
||||
template <size_t DataSize>
|
||||
void loadBinary( void * const data, size_t size )
|
||||
template <std::size_t DataSize>
|
||||
void loadBinary( void * const data, std::size_t size )
|
||||
{
|
||||
// load data
|
||||
auto const readSize = itsStream.rdbuf()->sgetn( reinterpret_cast<char*>( data ), size );
|
||||
auto const readSize = static_cast<std::size_t>( itsStream.rdbuf()->sgetn( reinterpret_cast<char*>( data ), size ) );
|
||||
|
||||
if(readSize != size)
|
||||
throw Exception("Failed to read " + std::to_string(size) + " bytes from input stream! Read " + std::to_string(readSize));
|
||||
@ -151,7 +151,7 @@ namespace cereal
|
||||
if( itsConvertEndianness )
|
||||
{
|
||||
std::uint8_t * ptr = reinterpret_cast<std::uint8_t*>( data );
|
||||
for( size_t i = 0; i < size; i += DataSize )
|
||||
for( std::size_t i = 0; i < size; i += DataSize )
|
||||
portable_binary_detail::swap_bytes<DataSize>( ptr );
|
||||
}
|
||||
}
|
||||
|
||||
@ -43,25 +43,6 @@ namespace cereal
|
||||
typedef std::true_type yes;
|
||||
typedef std::false_type no;
|
||||
|
||||
|
||||
|
||||
|
||||
////! Tests whether a type has a non const member save function
|
||||
//namespace
|
||||
//{
|
||||
// template <class T, class A>
|
||||
// struct has_non_const_member_save_impl
|
||||
// {
|
||||
// template <class TT, class AA>
|
||||
// static auto test(int) -> decltype( cereal::access::non_const_member_save( std::declval<AA&>(), std::declval<TT&>() ) == 1, yes());
|
||||
// static no test(...);
|
||||
// static const bool value = std::is_same<decltype(test<T, A>(0)), yes>::value;
|
||||
// };
|
||||
//} // end anon namespace
|
||||
|
||||
//template <class T, class A>
|
||||
//struct has_non_const_member_save : std::integral_constant<bool, has_non_const_member_save_impl<T, A>::value> {};
|
||||
|
||||
//! Creates a test for whether a non const member function exists
|
||||
/*! This creates a class derived from std::integral_constant that will be true if
|
||||
the type has the proper member function for the given archive. */
|
||||
@ -79,7 +60,7 @@ namespace cereal
|
||||
}; \
|
||||
} /* end namespace detail */ \
|
||||
template <class T, class A> \
|
||||
struct has_member_##name## : std::integral_constant<bool, detail::has_member_##name##_impl<T, A>::value> {};
|
||||
struct has_member_##name : std::integral_constant<bool, detail::has_member_##name##_impl<T, A>::value> {};
|
||||
|
||||
//! Creates a test for whether a non const non-member function exists
|
||||
/*! This creates a class derived from std::integral_constant that will be true if
|
||||
@ -91,14 +72,14 @@ namespace cereal
|
||||
struct has_non_member_##name##_impl \
|
||||
{ \
|
||||
template <class TT, class AA> \
|
||||
static auto test(int) -> decltype( ##name( std::declval<AA&>(), std::declval<TT&>() ) == 1, yes()); \
|
||||
static auto test(int) -> decltype( name( std::declval<AA&>(), std::declval<TT&>() ) == 1, yes()); \
|
||||
template <class, class> \
|
||||
static no test( ... ); \
|
||||
static const bool value = std::is_same<decltype( test<T, A>( 0 ) ), yes>::value; \
|
||||
static no test( ... ); \
|
||||
static const bool value = std::is_same<decltype( test<T, A>( 0 ) ), yes>::value; \
|
||||
}; \
|
||||
} /* end namespace detail */ \
|
||||
template <class T, class A> \
|
||||
struct has_non_member_##name## : std::integral_constant<bool, detail::has_non_member_##name##_impl<T, A>::value> {};
|
||||
struct has_non_member_##name : std::integral_constant<bool, detail::has_non_member_##name##_impl<T, A>::value> {};
|
||||
|
||||
template<typename> struct Void { typedef void type; };
|
||||
|
||||
|
||||
431
sandbox_vs.cpp
431
sandbox_vs.cpp
@ -1,209 +1,222 @@
|
||||
#define BOOST_ALL_NO_LIB
|
||||
|
||||
#include <cereal/access.hpp>
|
||||
#include <cereal/details/traits.hpp>
|
||||
#include <cereal/details/helpers.hpp>
|
||||
#include <cereal/types/base_class.hpp>
|
||||
#include <cereal/cereal.hpp>
|
||||
|
||||
#include <cereal/types/array.hpp>
|
||||
#include <cereal/types/bitset.hpp>
|
||||
#include <cereal/types/boost_variant.hpp>
|
||||
#include <cereal/types/chrono.hpp>
|
||||
#include <cereal/types/common.hpp>
|
||||
#include <cereal/types/complex.hpp>
|
||||
#include <cereal/types/deque.hpp>
|
||||
#include <cereal/types/forward_list.hpp>
|
||||
#include <cereal/types/list.hpp>
|
||||
#include <cereal/types/map.hpp>
|
||||
#include <cereal/types/memory.hpp>
|
||||
|
||||
#include <cereal/details/util.hpp>
|
||||
|
||||
#include <cereal/details/polymorphic_impl.hpp>
|
||||
#include <cereal/types/polymorphic.hpp>
|
||||
|
||||
#include <cereal/types/queue.hpp>
|
||||
#include <cereal/types/set.hpp>
|
||||
#include <cereal/types/stack.hpp>
|
||||
#include <cereal/types/string.hpp>
|
||||
#include <cereal/types/tuple.hpp>
|
||||
#include <cereal/types/unordered_map.hpp>
|
||||
#include <cereal/types/unordered_set.hpp>
|
||||
#include <cereal/types/utility.hpp>
|
||||
#include <cereal/types/vector.hpp>
|
||||
|
||||
#include <cereal/archives/binary.hpp>
|
||||
#include <cereal/archives/portable_binary.hpp>
|
||||
#include <cereal/archives/xml.hpp>
|
||||
#include <cereal/archives/json.hpp>
|
||||
|
||||
#include <iostream>
|
||||
#include <type_traits>
|
||||
#include <functional>
|
||||
|
||||
struct Archive {};
|
||||
|
||||
struct Test
|
||||
{
|
||||
template <class Archive>
|
||||
void serialize( Archive & ar )
|
||||
{
|
||||
std::cout << "hey there" << std::endl;
|
||||
}
|
||||
|
||||
template <class Archive>
|
||||
void save( Archive & ar ) const
|
||||
{
|
||||
std::cout << "saved by the bell" << std::endl;
|
||||
}
|
||||
|
||||
template <class Archive>
|
||||
void load( Archive & ar )
|
||||
{
|
||||
std::cout << "locked and loaded" << std::endl;
|
||||
}
|
||||
|
||||
template <class Archive>
|
||||
static Test * load_and_allocate( Archive & ar )
|
||||
{ }
|
||||
};
|
||||
|
||||
template <class Archive>
|
||||
void serialize( Archive & ar, Test & t )
|
||||
{ }
|
||||
|
||||
template <class Archive>
|
||||
void load( Archive & ar, Test & t )
|
||||
{ }
|
||||
|
||||
template <class Archive>
|
||||
void save( Archive & ar, Test const & t )
|
||||
{ }
|
||||
|
||||
namespace cereal
|
||||
{
|
||||
template <>
|
||||
struct LoadAndAllocate<Test>
|
||||
{
|
||||
template <class Archive>
|
||||
static Test * load_and_allocate( Archive & ar )
|
||||
{ }
|
||||
};
|
||||
}
|
||||
|
||||
struct A
|
||||
{
|
||||
virtual void foo() = 0;
|
||||
};
|
||||
|
||||
struct B : A
|
||||
{
|
||||
void foo() {}
|
||||
|
||||
template <class Archive>
|
||||
void serialize( Archive & ar )
|
||||
{
|
||||
std::cout << "i'm in your b" << std::endl;
|
||||
}
|
||||
};
|
||||
|
||||
struct C
|
||||
{
|
||||
char a;
|
||||
};
|
||||
|
||||
CEREAL_REGISTER_TYPE(B);
|
||||
|
||||
int main()
|
||||
{
|
||||
typedef Test T;
|
||||
std::cout << std::boolalpha;
|
||||
|
||||
// Test Load and Allocate internal/external
|
||||
std::cout << "\tload_and_allocate" << std::endl;
|
||||
std::cout << cereal::traits::has_member_load_and_allocate<T, Archive>::value << std::endl;
|
||||
std::cout << cereal::traits::has_non_member_load_and_allocate<T, Archive>::value << std::endl;
|
||||
|
||||
// serialize
|
||||
std::cout << "\tserialize" << std::endl;
|
||||
std::cout << cereal::traits::has_member_serialize<T, Archive>::value << std::endl;
|
||||
std::cout << cereal::traits::has_non_member_serialize<T, Archive>::value << std::endl;
|
||||
|
||||
// load
|
||||
std::cout << "\tload" << std::endl;
|
||||
std::cout << cereal::traits::has_member_load<T, Archive>::value << std::endl;
|
||||
std::cout << cereal::traits::has_non_member_load<T, Archive>::value << std::endl;
|
||||
|
||||
// save
|
||||
std::cout << "\tsave" << std::endl;
|
||||
std::cout << cereal::traits::has_member_save<T, Archive>::value << std::endl;
|
||||
std::cout << cereal::traits::has_non_member_save<T, Archive>::value << std::endl;
|
||||
|
||||
// splittable
|
||||
std::cout << "\t splittable" << std::endl;
|
||||
std::cout << cereal::traits::has_member_split<T, Archive, Archive>::value << std::endl;
|
||||
std::cout << cereal::traits::has_non_member_split<T, Archive, Archive>::value << std::endl;
|
||||
|
||||
// serialiable
|
||||
std::cout << "\toutput serializable" << std::endl;
|
||||
std::cout << cereal::traits::is_output_serializable<T, Archive>::value << std::endl;
|
||||
std::cout << cereal::traits::is_input_serializable<T, Archive>::value << std::endl;
|
||||
|
||||
// specialized
|
||||
std::cout << "\tspecialized" << std::endl;
|
||||
std::cout << cereal::traits::detail::is_specialized_member_serialize<T, Archive>::value << std::endl;
|
||||
std::cout << cereal::traits::detail::is_specialized_member_load_save<T, Archive>::value << std::endl;
|
||||
std::cout << cereal::traits::detail::is_specialized_non_member_serialize<T, Archive>::value << std::endl;
|
||||
std::cout << cereal::traits::detail::is_specialized_non_member_load_save<T, Archive>::value << std::endl;
|
||||
std::cout << cereal::traits::detail::is_specialized_error<T, Archive>::value << std::endl;
|
||||
std::cout << cereal::traits::is_specialized<T, Archive>::value << std::endl;
|
||||
|
||||
// array size
|
||||
std::cout << typeid(A).name() << std::endl;
|
||||
std::cout << typeid(cereal::traits::has_load_and_allocate<int, bool>).name() << std::endl;
|
||||
|
||||
Archive a;
|
||||
T t;
|
||||
|
||||
cereal::access::member_save( a, t );
|
||||
cereal::access::member_load( a, t );
|
||||
cereal::access::member_serialize( a, t );
|
||||
|
||||
std::stringstream ss;
|
||||
{
|
||||
cereal::JSONOutputArchive ar( ss );
|
||||
ar( 5 );
|
||||
ar( cereal::make_nvp("hello", 2.4f ) );
|
||||
std::string s = "hey yo";
|
||||
ar( CEREAL_NVP( s ) );
|
||||
int darp [] = { 1, 2, 3 };
|
||||
ar.saveBinaryValue( darp, sizeof(int) * 3, "darp" );
|
||||
std::unique_ptr<A> ptr( new B() );
|
||||
ar( CEREAL_NVP( ptr ) );
|
||||
}
|
||||
{
|
||||
cereal::JSONInputArchive ar( ss );
|
||||
int x;
|
||||
ar( x );
|
||||
assert( x == 5 );
|
||||
float f;
|
||||
ar( f );
|
||||
assert( f == 2.4f );
|
||||
std::string s;
|
||||
ar( s );
|
||||
assert( s == "hey yo" );
|
||||
int darp[3];
|
||||
ar.loadBinaryValue( darp, sizeof(int) * 3 );
|
||||
assert( darp[0] == 1 );
|
||||
assert( darp[1] == 2 );
|
||||
assert( darp[2] == 3 );
|
||||
std::unique_ptr<A> ptr;
|
||||
std::cout << "----------" << std::endl;
|
||||
std::cout << std::is_default_constructible<A>::value << std::endl;
|
||||
std::cout << cereal::traits::has_load_and_allocate<A, cereal::JSONInputArchive>::value << std::endl;
|
||||
ar( ptr );
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
#define BOOST_ALL_NO_LIB
|
||||
|
||||
#include <cereal/access.hpp>
|
||||
#include <cereal/details/traits.hpp>
|
||||
#include <cereal/details/helpers.hpp>
|
||||
#include <cereal/types/base_class.hpp>
|
||||
#include <cereal/cereal.hpp>
|
||||
|
||||
#include <cereal/types/array.hpp>
|
||||
#include <cereal/types/bitset.hpp>
|
||||
#include <cereal/types/boost_variant.hpp>
|
||||
#include <cereal/types/chrono.hpp>
|
||||
#include <cereal/types/common.hpp>
|
||||
#include <cereal/types/complex.hpp>
|
||||
#include <cereal/types/deque.hpp>
|
||||
#include <cereal/types/forward_list.hpp>
|
||||
#include <cereal/types/list.hpp>
|
||||
#include <cereal/types/map.hpp>
|
||||
#include <cereal/types/memory.hpp>
|
||||
|
||||
#include <cereal/details/util.hpp>
|
||||
|
||||
#include <cereal/details/polymorphic_impl.hpp>
|
||||
#include <cereal/types/polymorphic.hpp>
|
||||
|
||||
#include <cereal/types/queue.hpp>
|
||||
#include <cereal/types/set.hpp>
|
||||
#include <cereal/types/stack.hpp>
|
||||
#include <cereal/types/string.hpp>
|
||||
#include <cereal/types/tuple.hpp>
|
||||
#include <cereal/types/unordered_map.hpp>
|
||||
#include <cereal/types/unordered_set.hpp>
|
||||
#include <cereal/types/utility.hpp>
|
||||
#include <cereal/types/vector.hpp>
|
||||
|
||||
#include <cereal/archives/binary.hpp>
|
||||
//#include <cereal/archives/portable_binary.hpp>
|
||||
#include <cereal/archives/xml.hpp>
|
||||
#include <cereal/archives/json.hpp>
|
||||
|
||||
#include <iostream>
|
||||
#include <type_traits>
|
||||
#include <functional>
|
||||
|
||||
struct Archive {};
|
||||
|
||||
struct Test
|
||||
{
|
||||
template <class Archive>
|
||||
void serialize( Archive & ar )
|
||||
{
|
||||
std::cout << "hey there" << std::endl;
|
||||
}
|
||||
|
||||
template <class Archive>
|
||||
void save( Archive & ar ) const
|
||||
{
|
||||
std::cout << "saved by the bell" << std::endl;
|
||||
}
|
||||
|
||||
template <class Archive>
|
||||
void load( Archive & ar )
|
||||
{
|
||||
std::cout << "locked and loaded" << std::endl;
|
||||
}
|
||||
|
||||
template <class Archive>
|
||||
static Test * load_and_allocate( Archive & ar )
|
||||
{
|
||||
return new Test();
|
||||
}
|
||||
};
|
||||
|
||||
template <class Archive>
|
||||
void serialize( Archive & ar, Test & t )
|
||||
{ }
|
||||
|
||||
template <class Archive>
|
||||
void load( Archive & ar, Test & t )
|
||||
{ }
|
||||
|
||||
template <class Archive>
|
||||
void save( Archive & ar, Test const & t )
|
||||
{ }
|
||||
|
||||
namespace cereal
|
||||
{
|
||||
template <>
|
||||
struct LoadAndAllocate<Test>
|
||||
{
|
||||
template <class Archive>
|
||||
static Test * load_and_allocate( Archive & ar )
|
||||
{
|
||||
return new Test();
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
struct A
|
||||
{
|
||||
virtual void foo() = 0;
|
||||
};
|
||||
|
||||
struct B : A
|
||||
{
|
||||
void foo() {}
|
||||
|
||||
template <class Archive>
|
||||
void serialize( Archive & ar )
|
||||
{
|
||||
std::cout << "i'm in your b" << std::endl;
|
||||
}
|
||||
};
|
||||
|
||||
struct C
|
||||
{
|
||||
char a;
|
||||
};
|
||||
|
||||
//CEREAL_REGISTER_TYPE(B);
|
||||
|
||||
template <class T, class A>
|
||||
static auto test(int) -> decltype( cereal::access::member_serialize( std::declval<A&>(), std::declval<T&>() ), std::true_type())
|
||||
{ return {}; }
|
||||
|
||||
template <class T, class A>
|
||||
static auto test(...) -> std::false_type
|
||||
{ return {}; }
|
||||
|
||||
int main()
|
||||
{
|
||||
typedef Test T;
|
||||
std::cout << std::boolalpha;
|
||||
|
||||
// Test Load and Allocate internal/external
|
||||
std::cout << "\tload_and_allocate" << std::endl;
|
||||
std::cout << cereal::traits::has_member_load_and_allocate<T, Archive>::value << std::endl;
|
||||
std::cout << cereal::traits::has_non_member_load_and_allocate<T, Archive>::value << std::endl;
|
||||
|
||||
// serialize
|
||||
std::cout << "\tserialize" << std::endl;
|
||||
std::cout << cereal::traits::has_member_serialize<T, Archive>::value << std::endl;
|
||||
std::cout << cereal::traits::has_non_member_serialize<T, Archive>::value << std::endl;
|
||||
std::cout << test<T, Archive>(0) << std::endl;
|
||||
|
||||
// load
|
||||
std::cout << "\tload" << std::endl;
|
||||
std::cout << cereal::traits::has_member_load<T, Archive>::value << std::endl;
|
||||
std::cout << cereal::traits::has_non_member_load<T, Archive>::value << std::endl;
|
||||
|
||||
// save
|
||||
std::cout << "\tsave" << std::endl;
|
||||
std::cout << cereal::traits::has_member_save<T, Archive>::value << std::endl;
|
||||
std::cout << cereal::traits::has_non_member_save<T, Archive>::value << std::endl;
|
||||
|
||||
// splittable
|
||||
std::cout << "\t splittable" << std::endl;
|
||||
std::cout << cereal::traits::has_member_split<T, Archive, Archive>::value << std::endl;
|
||||
std::cout << cereal::traits::has_non_member_split<T, Archive, Archive>::value << std::endl;
|
||||
|
||||
// serialiable
|
||||
std::cout << "\toutput serializable" << std::endl;
|
||||
std::cout << cereal::traits::is_output_serializable<T, Archive>::value << std::endl;
|
||||
std::cout << cereal::traits::is_input_serializable<T, Archive>::value << std::endl;
|
||||
|
||||
// specialized
|
||||
std::cout << "\tspecialized" << std::endl;
|
||||
std::cout << cereal::traits::detail::is_specialized_member_serialize<T, Archive>::value << std::endl;
|
||||
std::cout << cereal::traits::detail::is_specialized_member_load_save<T, Archive>::value << std::endl;
|
||||
std::cout << cereal::traits::detail::is_specialized_non_member_serialize<T, Archive>::value << std::endl;
|
||||
std::cout << cereal::traits::detail::is_specialized_non_member_load_save<T, Archive>::value << std::endl;
|
||||
std::cout << cereal::traits::detail::is_specialized_error<T, Archive>::value << std::endl;
|
||||
std::cout << cereal::traits::is_specialized<T, Archive>::value << std::endl;
|
||||
|
||||
// array size
|
||||
std::cout << typeid(A).name() << std::endl;
|
||||
std::cout << typeid(cereal::traits::has_load_and_allocate<int, bool>).name() << std::endl;
|
||||
|
||||
//Archive a;
|
||||
//T t;
|
||||
|
||||
//cereal::access::member_save( a, t );
|
||||
//cereal::access::member_load( a, t );
|
||||
//cereal::access::member_serialize( a, t );
|
||||
|
||||
//std::stringstream ss;
|
||||
//{
|
||||
// cereal::JSONOutputArchive ar( ss );
|
||||
// ar( 5 );
|
||||
// ar( cereal::make_nvp("hello", 2.4f ) );
|
||||
// std::string s = "hey yo";
|
||||
// ar( CEREAL_NVP( s ) );
|
||||
// int darp [] = { 1, 2, 3 };
|
||||
// ar.saveBinaryValue( darp, sizeof(int) * 3, "darp" );
|
||||
// std::unique_ptr<A> ptr( new B() );
|
||||
// ar( CEREAL_NVP( ptr ) );
|
||||
//}
|
||||
//{
|
||||
// cereal::JSONInputArchive ar( ss );
|
||||
// int x;
|
||||
// ar( x );
|
||||
// assert( x == 5 );
|
||||
// float f;
|
||||
// ar( f );
|
||||
// assert( f == 2.4f );
|
||||
// std::string s;
|
||||
// ar( s );
|
||||
// assert( s == "hey yo" );
|
||||
// int darp[3];
|
||||
// ar.loadBinaryValue( darp, sizeof(int) * 3 );
|
||||
// assert( darp[0] == 1 );
|
||||
// assert( darp[1] == 2 );
|
||||
// assert( darp[2] == 3 );
|
||||
// std::unique_ptr<A> ptr;
|
||||
// std::cout << "----------" << std::endl;
|
||||
// std::cout << std::is_default_constructible<A>::value << std::endl;
|
||||
// std::cout << cereal::traits::has_load_and_allocate<A, cereal::JSONInputArchive>::value << std::endl;
|
||||
// ar( ptr );
|
||||
//}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user