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

Awesome detection of serialization method works

Browse Source
This commit is contained in:
Randolph Voorhies
2013-06-12 11:04:24 -07:00
parent 149771df0f
commit c8c6846905
3 changed files with 48 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
cereal.hpp
View File

@@ -22,6 +22,7 @@ namespace cereal
BinaryOutputArchive &>::type
operator & (T const & t)
{
std::cout << "Member serialize" << std::endl;
//t.serialize(*this, traits::version<T>::value)
return *this;
}
@@ -31,6 +32,7 @@ namespace cereal
BinaryOutputArchive &>::type
operator & (T const & t)
{
std::cout << "Non member serialize" << std::endl;
//serialize(*this, t, traits::version<T>::value)
return *this;
}
@@ -40,6 +42,7 @@ namespace cereal
BinaryOutputArchive &>::type
operator & (T const & t)
{
std::cout << "Member split" << std::endl;
//t.save(*this, traits::version<T>::value);
return *this;
}
@@ -49,6 +52,7 @@ namespace cereal
BinaryOutputArchive &>::type
operator & (T const & t)
{
std::cout << "Non member split" << std::endl;
//save(*this, t, traits::version<T>::value);
return *this;
}

71
test.cpp
View File

@@ -1,4 +1,5 @@
#include "cereal.hpp"
#include <cxxabi.h>
// ###################################
struct Test1
@@ -37,20 +38,14 @@ struct Test3
{
int a;
std::string b;
};
#if 1
//namespace cereal
//{
template<class Archive>
void serialize(Archive & ar, Test3 & t, unsigned int version)
{
//ar & t.a;
//ar & t.b;
}
//}
#endif
void serialize(Archive & ar, Test3 & t, unsigned int version)
{
//ar & t.a;
//ar & t.b;
}
// ###################################
struct Test4
@@ -58,37 +53,19 @@ struct Test4
int a;
std::string b;
template<class Archive>
void serialize(Archive & ar, unsigned int version)
{
ar & a & b;
}
template<class Archive>
void save(Archive & ar, unsigned int version)
{
ar & a & b;
}
template<class Archive>
void load(Archive & ar, unsigned int version)
{
ar & a & b;
}
};
//// ######################################################################
//template<typename> struct Void { typedef void type; };
//
//template<typename T, class A, typename Sfinae = void>
//struct has_non_member_serialize2: std::false_type {};
//
//template<typename T, class A>
//struct has_non_member_serialize2< T, A,
// typename Void<
//decltype( cereal::serialize( std::declval<A&>(), std::declval<T&>(), 0 ) )
// >::type
// >: std::true_type {};
template<class Archive>
void save(Archive & ar, Test4 & t, unsigned int version)
{
ar & t.a & t.b;
}
template<class Archive>
void load(Archive & ar, Test4 & t, unsigned int version)
{
ar & t.a & t.b;
}
// ######################################################################
int main()
@@ -100,16 +77,10 @@ int main()
Test3 t3;
Test4 t4;
//archive & t1;
//archive & t2;
//archive & t3;
//archive & t4;
//cereal::serialize(archive, t3, 0);
std::cout << cereal::traits::has_non_member_serialize<Test2, cereal::BinaryOutputArchive>() << std::endl;
//std::cout << has_non_member_serialize2<Test3, cereal::BinaryOutputArchive>() << std::endl;
archive & t1;
archive & t2;
archive & t3;
archive & t4;
return 0;
}

79
traits.hpp
View File

@@ -1,17 +1,11 @@
namespace cereal
{
struct BogusType {};
//template<class X, class Y, class Z>
// BogusType serialize(X&,Y&,Z&);
void load();
void save();
namespace traits
{
template<typename> struct Void { typedef void type; };
// ######################################################################
// Member Serialize
template<typename T, class A, typename Sfinae = void>
struct has_member_serialize: std::false_type {};
@@ -23,28 +17,14 @@ namespace cereal
>: std::true_type {};
// ######################################################################
template<typename T, class A, typename Sfinae = void>
struct has_non_member_serialize: std::false_type {};
template<typename T, class A>
struct has_non_member_serialize< T, A,
typename Void<
typename std::enable_if<!
std::is_same<decltype(serialize( std::declval<A&>(), std::declval<T&>(), 0 )), BogusType>::value, void>::type
//decltype( ::cereal::serialize( std::declval<A&>(), std::declval<T&>(), 0 ) )
>::type
>: std::true_type {};
template<typename T, class A>
struct has_non_member_serialize< T, A,
typename Void<
typename std::enable_if<
std::is_same<decltype(serialize( std::declval<A&>(), std::declval<T&>(), 0 )), BogusType>::value, void>::type
//decltype( ::cereal::serialize( std::declval<A&>(), std::declval<T&>(), 0 ) )
>::type
>: std::false_type {};
// Non Member Serialize
template<typename T, typename A> char & serialize(A&, T&, unsigned int);
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; };
// ######################################################################
// Member Load
template<typename T, class A, typename Sfinae = void>
struct has_member_load: std::false_type {};
@@ -54,19 +34,16 @@ namespace cereal
decltype( std::declval<T&>().load( std::declval<A&>(), 0 ) )
>::type
>: std::true_type {};
// ######################################################################
template<typename T, class A, typename Sfinae = void>
struct has_non_member_load: std::false_type {};
template<typename T, class A>
struct has_non_member_load< T, A,
typename Void<
decltype( ::cereal::load( std::declval<A&>(), std::declval<T&>(), 0 ) )
>::type
>: std::true_type {};
// ######################################################################
// Non Member Load
template<typename T, typename A> char & load(A&, T&, unsigned int);
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; };
// ######################################################################
// Member Save
template<typename T, class A, typename Sfinae = void>
struct has_member_save: std::false_type {};
@@ -78,35 +55,25 @@ namespace cereal
>: std::true_type {};
// ######################################################################
template<typename T, class A, typename Sfinae = void>
struct has_non_member_save: std::false_type {};
template<typename T, class A>
struct has_non_member_save< T, A,
typename Void<
decltype( ::cereal::save( std::declval<A&>(), std::declval<T&>(), 0 ) )
>::type
>: std::true_type {};
// Non Member Save
template<typename T, typename A> char & save(A&, T&, unsigned int);
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; };
// ######################################################################
template <class T, class A>
constexpr bool has_member_split()
{
return has_member_load<T, A>() && has_member_save<T, A>();
}
{ return has_member_load<T, A>() && has_member_save<T, A>(); }
// ######################################################################
template <class T, class A>
constexpr bool has_non_member_split()
{
return has_non_member_load<T, A>() && has_non_member_save<T, A>();
}
{ return has_non_member_load<T, A>() && has_non_member_save<T, A>(); }
// ######################################################################
template <class T, class A>
constexpr bool is_serializable()
{
return has_member_split<T, A>() ^ has_member_serialize<T, A>() ^ has_non_member_split<T, A>() ^ has_non_member_serialize<T,A>();
}
{ return has_member_split<T, A>() ^ has_member_serialize<T, A>() ^ has_non_member_split<T, A>() ^ has_non_member_serialize<T,A>(); }
}
}