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

working on making generic

Browse Source
This commit is contained in:
Shane Grant
2013-06-19 18:03:54 -07:00
parent c67bc00bb7
commit d3a53fbcb4
5 changed files with 75 additions and 55 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
include/cereal/binary_archive/array.hpp
View File

@@ -27,43 +27,47 @@
#ifndef CEREAL_BINARY_ARCHIVE_ARRAY_HPP_ #ifndef CEREAL_BINARY_ARCHIVE_ARRAY_HPP_
#define CEREAL_BINARY_ARCHIVE_ARRAY_HPP_ #define CEREAL_BINARY_ARCHIVE_ARRAY_HPP_
#include <cereal/binary_archive/binary_archive.hpp> #include <cereal/cereal.hpp>
#include <array> #include <array>
namespace cereal namespace cereal
{ {
//! Saving for std::array primitive types to binary //! Saving for std::array primitive types to binary
template <class T, size_t N> inline template <class Archive, class T, size_t N> inline
typename std::enable_if<std::is_arithmetic<T>::value, void>::type typename std::enable_if<traits::is_output_serializable<BinaryData<T>, Archive>()
save( BinaryOutputArchive & ar, std::array<T, N> const & array ) && std::is_arithmetic<T>::value, void>::type
save( Archive & ar, std::array<T, N> const & array )
{ {
ar( binary_data( array.data(), N * sizeof(T) ) ); ar( make_nvp( "data", binary_data( array.data(), N * sizeof(T) ) ) );
} }
//! Loading for std::array primitive types to binary //! Loading for std::array primitive types to binary
template <class T, size_t N> inline template <class Archive, class T, size_t N> inline
typename std::enable_if<std::is_arithmetic<T>::value, void>::type typename std::enable_if<traits::is_input_serializable<BinaryData<T>, Archive>()
load( BinaryInputArchive & ar, std::array<T, N> & array ) && std::is_arithmetic<T>::value, void>::type
load( Archive & ar, std::array<T, N> & array )
{ {
ar( binary_data( array.data(), N * sizeof(T) ) ); ar( make_nvp( "data", binary_data( array.data(), N * sizeof(T) ) ) );
} }
//! Saving for std::array all other types to binary //! Saving for std::array all other types to binary
template <class T, size_t N> inline template <class Archive, class T, size_t N> inline
typename std::enable_if<!std::is_arithmetic<T>::value, void>::type typename std::enable_if<!traits::is_output_serializable<BinaryData<T>, Archive>()
save( BinaryOutputArchive & ar, std::array<T, N> const & array ) || !std::is_arithmetic<T>::value, void>::type
save( Archive & ar, std::array<T, N> const & array )
{ {
for( auto const & i : array ) for( auto const & i : array )
ar( i ); ar( make_nvp( "item", i ) );
} }
//! Loading for std::array all other types to binary //! Loading for std::array all other types to binary
template <class T, size_t N> inline template <class Archive, class T, size_t N> inline
typename std::enable_if<!std::is_arithmetic<T>::value, void>::type typename std::enable_if<!traits::is_input_serializable<BinaryData<T>, Archive>()
load( BinaryInputArchive & ar, std::array<T, N> & array ) || !std::is_arithmetic<T>::value, void>::type
load( Archive & ar, std::array<T, N> & array )
{ {
for( auto & i : array ) for( auto & i : array )
ar( i ); ar( make_nvp( "item", i ) );
} }
} // namespace cereal } // namespace cereal

2
include/cereal/binary_archive/bitset.hpp
View File

@@ -27,7 +27,7 @@
#ifndef CEREAL_BINARY_ARCHIVE_BITSET_HPP_ #ifndef CEREAL_BINARY_ARCHIVE_BITSET_HPP_
#define CEREAL_BINARY_ARCHIVE_BITSET_HPP_ #define CEREAL_BINARY_ARCHIVE_BITSET_HPP_
#include <cereal/binary_archive/binary_archive.hpp> #include <cereal/cereal.hpp>
#include <bitset> #include <bitset>
namespace cereal namespace cereal

72
include/cereal/binary_archive/vector.hpp
View File

@@ -27,57 +27,61 @@
#ifndef CEREAL_BINARY_ARCHIVE_VECTOR_HPP_ #ifndef CEREAL_BINARY_ARCHIVE_VECTOR_HPP_
#define CEREAL_BINARY_ARCHIVE_VECTOR_HPP_ #define CEREAL_BINARY_ARCHIVE_VECTOR_HPP_
#include <cereal/binary_archive/binary_archive.hpp> #include <cereal/cereal.hpp>
#include <vector> #include <vector>
namespace cereal namespace cereal
{ {
//! Serialization for std::vectors of arithmetic (but not bool) types to binary, default allocator //! Serialization for std::vectors of arithmetic (but not bool) types to binary, default allocator
template <class T, class A> inline template <class Archive, class T, class A> inline
typename std::enable_if<std::is_arithmetic<T>::value && !std::is_same<T, bool>::value typename std::enable_if<traits::is_output_serializable<BinaryData<T>, Archive>()
&& std::is_arithmetic<T>::value && !std::is_same<T, bool>::value
&& std::is_same<A, std::allocator<T>>::value, void>::type && std::is_same<A, std::allocator<T>>::value, void>::type
save( BinaryOutputArchive & ar, std::vector<T, A> const & vector ) save( Archive & ar, std::vector<T, A> const & vector )
{ {
ar( vector.size() ); // number of elements ar( make_nvp( "size", vector.size() ) ); // number of elements
ar( binary_data( vector.data(), vector.size() * sizeof(T) ) ); ar( make_nvp( "data", binary_data( vector.data(), vector.size() * sizeof(T) ) ) );
} }
//! Serialization for std::vectors of arithmetic (but not bool) types to binary, default allocator //! Serialization for std::vectors of arithmetic (but not bool) types to binary, default allocator
template <class T, class A> inline template <class Archive, class T, class A> inline
typename std::enable_if<std::is_arithmetic<T>::value && !std::is_same<T, bool>::value typename std::enable_if<traits::is_input_serializable<BinaryData<T>, Archive>()
&& std::is_arithmetic<T>::value && !std::is_same<T, bool>::value
&& std::is_same<A, std::allocator<T>>::value, void>::type && std::is_same<A, std::allocator<T>>::value, void>::type
load( BinaryInputArchive & ar, std::vector<T, A> & vector ) load( Archive & ar, std::vector<T, A> & vector )
{ {
size_t vectorSize; size_t vectorSize;
ar( vectorSize ); ar( make_nvp( "size", vectorSize) );
vector.resize( vectorSize ); vector.resize( vectorSize );
ar( binary_data( vector.data(), vectorSize * sizeof(T) ) ); ar( make_nvp( "data", binary_data( vector.data(), vectorSize * sizeof(T) ) ) );
} }
//! Serialization for std::vectors of arithmetic (but not bool) types to binary, special allocator //! Serialization for std::vectors of arithmetic (but not bool) types to binary, special allocator
template <class T, class A> inline template <class Archive, class T, class A> inline
typename std::enable_if<std::is_arithmetic<T>::value && !std::is_same<T, bool>::value typename std::enable_if<traits::is_output_serializable<BinaryData<T>, Archive>()
&& std::is_arithmetic<T>::value && !std::is_same<T, bool>::value
&& !std::is_same<A, std::allocator<T>>::value, void>::type && !std::is_same<A, std::allocator<T>>::value, void>::type
save( BinaryOutputArchive & ar, std::vector<T, A> const & vector ) save( Archive & ar, std::vector<T, A> const & vector )
{ {
size_t const dataSize = std::addressof(vector.back()) - std::addressof(vector.front()) + 1; size_t const dataSize = std::addressof(vector.back()) - std::addressof(vector.front()) + 1;
ar( vector.size() ); // number of elements ar( make_nvp( "size", vector.size() ) ); // number of elements
ar( dataSize ); // size of data (may be larger due to allocator strategy) ar( make_nvp( "datasize", dataSize) ); // size of data (may be larger due to allocator strategy)
ar( binary_data( vector.data(), dataSize * sizeof(T) ) ); ar( make_nvp( "data", binary_data( vector.data(), dataSize * sizeof(T) ) ) );
} }
//! Serialization for std::vectors of arithmetic (but not bool) types to binary, special allocator //! Serialization for std::vectors of arithmetic (but not bool) types to binary, special allocator
template <class T, class A> inline template <class Archive, class T, class A> inline
typename std::enable_if<std::is_arithmetic<T>::value && !std::is_same<T, bool>::value typename std::enable_if<traits::is_input_serializable<BinaryData<T>, Archive>()
&& std::is_arithmetic<T>::value && !std::is_same<T, bool>::value
&& !std::is_same<A, std::allocator<T>>::value, void>::type && !std::is_same<A, std::allocator<T>>::value, void>::type
load( BinaryInputArchive & ar, std::vector<T, A> & vector ) load( Archive & ar, std::vector<T, A> & vector )
{ {
size_t vectorSize; size_t vectorSize;
size_t dataSize; size_t dataSize;
ar( vectorSize, ar( make_nvp( "size", vectorSize ),
dataSize ); make_nvp( "datasize", dataSize ) );
vector.resize( vectorSize ); vector.resize( vectorSize );
@@ -85,26 +89,30 @@ namespace cereal
} }
//! Serialization for non-arithmetic (and bool) vector types to binary //! Serialization for non-arithmetic (and bool) vector types to binary
template <class T, class A> inline template <class Archive, class T, class A> inline
typename std::enable_if<!std::is_arithmetic<T>::value || std::is_same<T, bool>::value, void>::type typename std::enable_if<!traits::is_output_serializable<BinaryData<T>, Archive>()
save( BinaryOutputArchive & ar, std::vector<T, A> const & vector ) || !std::is_arithmetic<T>::value
|| std::is_same<T, bool>::value, void>::type
save( Archive & ar, std::vector<T, A> const & vector )
{ {
ar( vector.size() ); // number of elements ar( make_nvp( "size", vector.size() ) ); // number of elements
for( auto it = vector.begin(), end = vector.end(); it != end; ++it ) for( auto it = vector.begin(), end = vector.end(); it != end; ++it )
ar( *it ); ar( make_nvp( "item", *it) );
} }
//! Serialization for non-arithmetic (and bool) vector types from binary //! Serialization for non-arithmetic (and bool) vector types from binary
template <class T, class A> inline template <class Archive, class T, class A> inline
typename std::enable_if<!std::is_arithmetic<T>::value || std::is_same<T, bool>::value, void>::type typename std::enable_if<!traits::is_input_serializable<BinaryData<T>, Archive>()
load( BinaryInputArchive & ar, std::vector<T, A> & vector ) || !std::is_arithmetic<T>::value
|| std::is_same<T, bool>::value, void>::type
load( Archive & ar, std::vector<T, A> & vector )
{ {
size_t size; size_t size;
ar( size ); ar( CEREAL_NVP(size) );
vector.resize( size ); vector.resize( size );
for( auto it = vector.begin(), end = vector.end(); it != end; ++it ) for( auto it = vector.begin(), end = vector.end(); it != end; ++it )
ar( *it ); ar( make_nvp( "item", *it) );
} }
} // namespace cereal } // namespace cereal

12
include/cereal/cereal.hpp
View File

@@ -69,15 +69,23 @@ namespace cereal
the NameValuePair will store a copy of it instead of a reference. Thus you should the NameValuePair will store a copy of it instead of a reference. Thus you should
only pass r-values in cases where this makes sense, such as the result of some only pass r-values in cases where this makes sense, such as the result of some
size() call. In either case, any constness will be stripped away */ size() call. In either case, any constness will be stripped away */
NameValuePair( std::string const & n, T && v ) : name(n), value(const_cast<Type>(v)) {} NameValuePair( char const * n, T && v ) : name(n), value(const_cast<Type>(v)) {}
std::string name; //std::string name;
char const * name;
Type value; Type value;
}; };
//! Creates a name value pair //! Creates a name value pair
template <class T> inline template <class T> inline
NameValuePair<T> make_nvp( std::string const & name, T && value ) NameValuePair<T> make_nvp( std::string const & name, T && value )
{
return {name.c_str(), std::forward<T>(value)};
}
//! Creates a name value pair
template <class T> inline
NameValuePair<T> make_nvp( const char * name, T && value )
{ {
return {name, std::forward<T>(value)}; return {name, std::forward<T>(value)};
} }

6
performance.cpp
View File

@@ -135,7 +135,7 @@ struct binary
template <class SerializationT, class DataT> template <class SerializationT, class DataT>
void test( std::string const & name, void test( std::string const & name,
DataT const & data, DataT const & data,
size_t numAverages = 10, size_t numAverages = 100,
bool validateData = false ) bool validateData = false )
{ {
std::cout << "-----------------------------------" << std::endl; std::cout << "-----------------------------------" << std::endl;
@@ -332,7 +332,7 @@ int main()
test<binary>( name.str(), data ); test<binary>( name.str(), data );
}; };
vectorCharTest(1024*1024*1024, randomize); // 1 GB vectorCharTest(1024*1024*64, randomize); // 1 GB
//######################################## //########################################
auto vectorPoDStructTest = [&](size_t s) auto vectorPoDStructTest = [&](size_t s)
@@ -348,7 +348,7 @@ int main()
vectorPoDStructTest(64); vectorPoDStructTest(64);
vectorPoDStructTest(1024); vectorPoDStructTest(1024);
vectorPoDStructTest(1024*1024); vectorPoDStructTest(1024*1024);
vectorPoDStructTest(1024*1024*64); vectorPoDStructTest(1024*1024*4);
//######################################## //########################################
auto vectorPoDChildTest = [&](size_t s) auto vectorPoDChildTest = [&](size_t s)