generic-library/cereal
1
0
Fork 0
mirror of https://github.com/USCiLab/cereal.git synced 2025-10-02 21:28:06 +02:00
Code Issues Projects Releases Wiki Activity

Removing versioning completely

Browse Source
This commit is contained in:
Shane Grant
2013-06-12 13:56:32 -07:00
parent be5d1581d4
commit f6f0b37c5b
3 changed files with 30 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
cereal.hpp
View File

@@ -21,10 +21,10 @@ namespace cereal
typename std::enable_if<traits::is_serializable<T, BinaryOutputArchive>() && traits::has_member_serialize<T, BinaryOutputArchive>(),
BinaryOutputArchive &>::type
operator & (T const & t)
{
std::cout << "Member serialize. Version " << cereal_class_version(t) << std::endl;
{
std::cout << "Member serialize" << std::endl;
//t.serialize(*this, traits::version<T>::value)
//t.serialize(*this)
return *this;
}
@@ -32,10 +32,10 @@ namespace cereal
typename std::enable_if<traits::is_serializable<T, BinaryOutputArchive>() && traits::has_non_member_serialize<T, BinaryOutputArchive>(),
BinaryOutputArchive &>::type
operator & (T const & t)
{
std::cout << "Non member serialize. Version " << cereal_class_version(t) << std::endl;
{
std::cout << "Non member serialize" << std::endl;
//serialize(*this, t, traits::version<T>::value)
//serialize(*this, t)
return *this;
}
@@ -43,10 +43,10 @@ namespace cereal
typename std::enable_if<traits::is_serializable<T, BinaryOutputArchive>() && traits::has_member_split<T, BinaryOutputArchive>(),
BinaryOutputArchive &>::type
operator & (T const & t)
{
std::cout << "Member split. Version " << cereal_class_version(t) << std::endl;
{
std::cout << "Member split" << std::endl;
//t.save(*this, traits::version<T>::value);
//t.save(*this);
return *this;
}
@@ -54,21 +54,21 @@ namespace cereal
typename std::enable_if<traits::is_serializable<T, BinaryOutputArchive>() && traits::has_non_member_split<T, BinaryOutputArchive>(),
BinaryOutputArchive &>::type
operator & (T const & t)
{
std::cout << "Non member split. Version " << cereal_class_version(t) << std::endl;
//save(*this, t, traits::version<T>::value);
{
std::cout << "Non member split" << std::endl;
//save(*this, t);
return *this;
}
template<class T>
typename std::enable_if<!traits::is_serializable<T, BinaryOutputArchive>(), BinaryOutputArchive &>::type
operator & (T const & t)
{
{
static_assert(traits::is_serializable<T, BinaryOutputArchive>(), "Trying to serialize an unserializable type.\n\n"
"Types must either have a serialize function, or separate save/load functions (but not both).\n"
"Serialize functions generally have the following signature:\n\n"
"template<class Archive>\n"
" void serialize(int & ar, unsigned int version)\n"
" void serialize(int & ar)\n"
" {\n"
" ar & member1 & member2 & member3;\n"
" }\n\n" );
@@ -76,7 +76,4 @@ namespace cereal
}
};
#define CEREAL_CLASS_VERSION(classname, version) \
unsigned int constexpr cereal_class_version(classname const &) { return version; };
}

16
test.cpp
View File

@@ -8,12 +8,11 @@ struct Test1
std::string b;
template<class Archive>
void serialize(Archive & ar, unsigned int version)
void serialize(Archive & ar)
{
ar & a & b;
}
};
CEREAL_CLASS_VERSION(Test1, 1);
// ###################################
struct Test2
@@ -22,18 +21,17 @@ struct Test2
std::string b;
template<class Archive>
void save(Archive & ar, unsigned int version)
void save(Archive & ar)
{
ar & a & b;
}
template<class Archive>
void load(Archive & ar, unsigned int version)
void load(Archive & ar)
{
ar & a & b;
}
};
CEREAL_CLASS_VERSION(Test2, 2);
// ###################################
struct Test3
@@ -43,12 +41,11 @@ struct Test3
};
template<class Archive>
void serialize(Archive & ar, Test3 & t, unsigned int version)
void serialize(Archive & ar, Test3 & t)
{
//ar & t.a;
//ar & t.b;
}
CEREAL_CLASS_VERSION(Test3, 3);
namespace test4
{
@@ -60,17 +57,16 @@ namespace test4
};
template<class Archive>
void save(Archive & ar, Test4 & t, unsigned int version)
void save(Archive & ar, Test4 & t)
{
ar & t.a & t.b;
}
template<class Archive>
void load(Archive & ar, Test4 & t, unsigned int version)
void load(Archive & ar, Test4 & t)
{
ar & t.a & t.b;
}
CEREAL_CLASS_VERSION(Test4, 4);
}
// ######################################################################

24
traits.hpp
View File

@@ -1,13 +1,9 @@
namespace cereal
{
template<typename T> unsigned int constexpr cereal_class_version(T const &) { return 0; };
namespace traits
{
template<typename> struct Void { typedef void type; };
// ######################################################################
// Member Serialize
template<typename T, class A, typename Sfinae = void>
@@ -16,16 +12,16 @@ namespace cereal
template<typename T, class A>
struct has_member_serialize< T, A,
typename Void<
decltype( std::declval<T&>().serialize( std::declval<A&>(), 0 ) )
decltype( std::declval<T&>().serialize( std::declval<A&>() ) )
>::type
>: std::true_type {};
// ######################################################################
// Non Member Serialize
template<typename T, typename A> char & serialize(A&, T&, unsigned int);
template<typename T, typename A> char & serialize(A&, T&);
template<typename T, typename A>
bool constexpr has_non_member_serialize()
{ return std::is_void<decltype(serialize(std::declval<A&>(), std::declval<T&>(), 0))>::value; };
{ return std::is_void<decltype(serialize(std::declval<A&>(), std::declval<T&>()))>::value; };
// ######################################################################
// Member Load
@@ -35,16 +31,16 @@ namespace cereal
template<typename T, class A>
struct has_member_load< T, A,
typename Void<
decltype( std::declval<T&>().load( std::declval<A&>(), 0 ) )
decltype( std::declval<T&>().load( std::declval<A&>() ) )
>::type
>: std::true_type {};
// ######################################################################
// Non Member Load
template<typename T, typename A> char & load(A&, T&, unsigned int);
template<typename T, typename A> char & load(A&, T&);
template<typename T, typename A>
bool constexpr has_non_member_load()
{ return std::is_void<decltype(load(std::declval<A&>(), std::declval<T&>(), 0))>::value; };
{ return std::is_void<decltype(load(std::declval<A&>(), std::declval<T&>()))>::value; };
// ######################################################################
// Member Save
@@ -54,16 +50,16 @@ namespace cereal
template<typename T, class A>
struct has_member_save< T, A,
typename Void<
decltype( std::declval<T&>().save( std::declval<A&>(), 0 ) )
decltype( std::declval<T&>().save( std::declval<A&>() ) )
>::type
>: std::true_type {};
// ######################################################################
// Non Member Save
template<typename T, typename A> char & save(A&, T&, unsigned int);
template<typename T, typename A> char & save(A&, T&);
template<typename T, typename A>
bool constexpr has_non_member_save()
{ return std::is_void<decltype(save(std::declval<A&>(), std::declval<T&>(), 0))>::value; };
{ return std::is_void<decltype(save(std::declval<A&>(), std::declval<T&>()))>::value; };
// ######################################################################
template <class T, class A>