Moving things around into folders; starting to add individual files for support for various standard library things.

Pointers will take some careful thought

binary_archive/array.hpp

@@ -0,0 +1,26 @@
+#ifndef CEREAL_BINARY_ARCHIVE_ARRAY_HPP_
+#define CEREAL_BINARY_ARCHIVE_ARRAY_HPP_
+
+#include <cereal/binary_archive/binary_archive.hpp>
+#include <array>
+
+namespace cereal
+{
+  //! Serialization for std::array types to binary
+  template <class T, size_t N>
+  void save( BinaryOutputArchive & ar, std::array<T, N> const & array )
+  {
+    std::cout << "Saving array" << std::endl;
+    ar.save_binary( array.data(), N * sizeof(T) );
+  }
+
+  //! Serialization for std::array to binary
+  template <class T, size_t N>
+  void load( BinaryInputArchive & ar, std::array<T, N> & array )
+  {
+    std::cout << "Loading array" << std::endl;
+    ar.load_binary( array.data(), N * sizeof(T) );
+  }
+} // namespace cereal
+
+#endif // CEREAL_BINARY_ARCHIVE_ARRAY_HPP_

binary_archive/string.hpp

@@ -0,0 +1,34 @@
+#ifndef CEREAL_BINARY_ARCHIVE_STRING_HPP_
+#define CEREAL_BINARY_ARCHIVE_STRING_HPP_
+
+#include <cereal/binary_archive/binary_archive.hpp>
+#include <string>
+
+namespace cereal
+{
+  //! Serialization for basic_string types to binary
+  template<class CharT, class Traits, class Alloc>
+  void save(BinaryOutputArchive & ar, std::basic_string<CharT, Traits, Alloc> const & str)
+  {
+    std::cout << "Saving string" << std::endl;
+
+    // Save number of chars + the data
+    ar & str.size();
+    ar.save_binary(str.data(), str.size() * sizeof(CharT));
+  }
+
+  //! Serialization for basic_string types from binary
+  template<class CharT, class Traits, class Alloc>
+  void load(BinaryInputArchive & ar, std::basic_string<CharT, Traits, Alloc> & str)
+  {
+    std::cout << "Loading string" << std::endl;
+
+    size_t size;
+    ar & size;
+    str.resize(size);
+    ar.load_binary(const_cast<CharT*>(str.data()), size * sizeof(CharT));
+  }
+} // namespace cereal
+
+#endif // CEREAL_BINARY_ARCHIVE_STRING_HPP_
+

binary_archive/vector.hpp

@@ -0,0 +1,39 @@
+#ifndef CEREAL_BINARY_ARCHIVE_VECTOR_HPP_
+#define CEREAL_BINARY_ARCHIVE_VECTOR_HPP_
+
+#include <cereal/binary_archive/binary_archive.hpp>
+#include <vector>
+
+namespace cereal
+{
+  //! Serialization for std::vector types to binary
+  template <class T, class A>
+  void save( BinaryOutputArchive & ar, std::vector<T, A> const & vector )
+  {
+    std::cout << "Saving vector" << std::endl;
+
+    const size_t dataSize = std::addressof(vector.back()) - std::addressof(vector.front());
+
+    ar & vector.size(); // number of elements
+    ar & dataSize;      // size of data (may be larger due to allocator strategy)
+    ar.save_binary( array.data(), size ); // actual data
+  }
+
+  //! Serialization for std::vector to binary
+  template <class T>
+  void load( BinaryInputArchive & ar, std::vector<T, A> & vector )
+  {
+    std::cout << "Loading array" << std::endl;
+
+    size_t dataSize;
+    size_t vectorSize;
+    ar & vectorSize;
+    ar & dataSize;
+
+    vector.resize( vectorSize );
+
+    ar.load_binary( vector.data(), dataSize );
+  }
+} // namespace cereal
+
+#endif // CEREAL_BINARY_ARCHIVE_VECTOR_HPP_

details/traits.hpp

@@ -0,0 +1,103 @@
+#ifndef CEREAL_DETAILS_TRAITS_HPP_
+#define CEREAL_DETAILS_TRAITS_HPP_
+
+#include <type_traits>
+
+namespace cereal
+{
+  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 {};
+
+    template<typename T, class A>
+      struct has_member_serialize< T, A,
+      typename Void<
+        decltype( std::declval<T&>().serialize( std::declval<A&>() ) )
+        >::type
+        >: std::true_type {};
+
+    // ######################################################################
+    // Non Member Serialize
+    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&>()))>::value; };
+
+    // ######################################################################
+    // Member Load
+    template<typename T, class A, typename Sfinae = void>
+      struct has_member_load: std::false_type {};
+
+    template<typename T, class A>
+      struct has_member_load< T, A,
+      typename Void<
+        decltype( std::declval<T&>().load( std::declval<A&>() ) )
+        >::type
+        >: std::true_type {};
+
+    // ######################################################################
+    // Non Member Load
+    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&>()))>::value; };
+
+    // ######################################################################
+    // Member Save
+    template<typename T, class A, typename Sfinae = void>
+      struct has_member_save: std::false_type {};
+
+    template<typename T, class A>
+      struct has_member_save< T, A,
+      typename Void<
+        decltype( std::declval<T&>().save( std::declval<A&>() ) )
+        >::type
+        >: std::true_type {};
+
+    // ######################################################################
+    // Non Member Save
+    template<typename T, typename A> char & save(A&, T const &);
+    template<typename T, typename A>
+      bool constexpr has_non_member_save()
+      { return std::is_void<decltype(save(std::declval<A&>(), std::declval<T&>()))>::value; };
+
+    // ######################################################################
+    template <class T, class InputArchive, class OutputArchive>
+      constexpr bool has_member_split()
+      { return has_member_load<T, InputArchive>() && has_member_save<T, OutputArchive>(); }
+
+    // ######################################################################
+    template <class T, class InputArchive, class OutputArchive>
+      constexpr bool has_non_member_split()
+      { return has_non_member_load<T, InputArchive>() && has_non_member_save<T, OutputArchive>(); }
+
+    // ######################################################################
+    template <class T, class OutputArchive>
+      constexpr bool is_output_serializable()
+      {
+        return
+          has_member_save<T, OutputArchive>() ^
+          has_non_member_save<T, OutputArchive>() ^
+          has_member_serialize<T, OutputArchive>() ^
+          has_non_member_serialize<T, OutputArchive>();
+      }
+
+    // ######################################################################
+    template <class T, class InputArchive>
+      constexpr bool is_input_serializable()
+      {
+        return
+          has_member_load<T, InputArchive>() ^
+          has_non_member_load<T, InputArchive>() ^
+          has_member_serialize<T, InputArchive>() ^
+          has_non_member_serialize<T, InputArchive>();
+      }
+  }
+}
+
+#endif // CEREAL_DETAILS_TRAITS_HPP_