From f0a92f01e72630517e9415d99eb068ba9cab907e Mon Sep 17 00:00:00 2001
From: Antony Polukhin <antoshkka@gmail.com>
Date: Mon, 11 Apr 2016 20:41:37 +0300
Subject: [PATCH] support for empty structures in flat_* methods, slightly more
 compact streaming operators

---
 README.md     |  6 +++---
 magic_get.hpp | 41 +++++++++++++++++++++++++++++++----------
 main.cpp      | 10 ++++++++++
 3 files changed, 44 insertions(+), 13 deletions(-)

diff --git a/README.md b/README.md
index 708697a..5564f83 100644
--- a/README.md
+++ b/README.md
@@ -124,7 +124,7 @@ auto flat_tie(T& val, typename std::enable_if< std::is_trivially_assignable<T, T
 /// Example usage: 
 ///     struct my_struct { int i, short s; };
 ///     my_struct s{12, 13};
-///     flat_write(std::cout, s); // outputs '{ 12, 13 }'
+///     flat_write(std::cout, s); // outputs '{12, 13}'
 template <class Char, class Traits, class T>
 void flat_write(std::basic_ostream<Char, Traits>& out, const T& value);
 
@@ -134,7 +134,7 @@ void flat_write(std::basic_ostream<Char, Traits>& out, const T& value);
 ///     struct my_struct { int i, short s; };
 ///     my_struct s;
 ///     std::stringstream ss;
-///     ss << "{ 12, 13 }";
+///     ss << "{12, 13}";
 ///     ss >> s;
 ///     assert(s.i == 12);
 ///     assert(s.i == 13);
@@ -152,7 +152,7 @@ void flat_read(std::basic_istream<Char, Traits>& in, T& value);
 ///     comparable_struct s1 {0, 1, "Hello", false, 6,7,8,9,10,11};
 ///     comparable_struct s2 {0, 1, "Hello", false, 6,7,8,9,10,11111};
 ///     assert(s1 < s2);
-///     std::cout << s1 << std::endl;   // Outputs: { 0, 1, H, e, l, l, o, , , 0, 6, 7, 8, 9, 10, 11 }
+///     std::cout << s1 << std::endl;   // Outputs: {0, 1, H, e, l, l, o, , , 0, 6, 7, 8, 9, 10, 11}
 namespace pod_ops;
 ```
 
diff --git a/magic_get.hpp b/magic_get.hpp
index 398ba95..8894474 100644
--- a/magic_get.hpp
+++ b/magic_get.hpp
@@ -164,6 +164,18 @@ struct size_array {                         // libc++ misses constexpr on operat
     }
 };
 
+template <>
+struct size_array<0> {                         // libc++ misses constexpr on operator[]
+    typedef std::size_t type;
+    std::size_t data[1];
+    
+    static constexpr std::size_t size() noexcept { return 0; }
+
+    constexpr std::size_t count_nonzeros() const noexcept {
+        return 0;
+    }
+};
+
 template <std::size_t I, std::size_t N>
 constexpr std::size_t get(const size_array<N>& a) noexcept {
     static_assert(I < N, "Array index out of bounds");
@@ -171,7 +183,8 @@ constexpr std::size_t get(const size_array<N>& a) noexcept {
 }
 
 
-template <class T> constexpr size_array<sizeof(T)> fields_count_and_type_ids_with_zeros() noexcept;
+template <class T> constexpr size_array<sizeof(T)> fields_count_and_type_ids_with_zeros(std::enable_if_t<!std::is_empty<T>::value>* = 0) noexcept;
+template <class T> constexpr size_array<0> fields_count_and_type_ids_with_zeros(std::enable_if_t<std::is_empty<T>::value>* = 0) noexcept;
 
 ///////////////////// All the stuff for representing Type as integer and converting integer back to type
 namespace typeid_conversions {
@@ -522,12 +535,17 @@ constexpr void detect_fields_count_and_type_ids(std::size_t*, std::index_sequenc
 
 ///////////////////// Returns array of typeids and zeros
 template <class T>
-constexpr size_array<sizeof(T)> fields_count_and_type_ids_with_zeros() noexcept {
+constexpr size_array<sizeof(T)> fields_count_and_type_ids_with_zeros(std::enable_if_t<!std::is_empty<T>::value>*) noexcept {
     size_array<sizeof(T)> types{};
     detect_fields_count_and_type_ids<T, sizeof(T)>(types.data, std::make_index_sequence<sizeof(T)>{});
     return types;
 }
 
+template <class T>
+constexpr size_array<0> fields_count_and_type_ids_with_zeros(std::enable_if_t<std::is_empty<T>::value>*) noexcept {
+    return size_array<0>{0};
+}
+
 ///////////////////// Returns array of typeids without zeros
 template <class T>
 constexpr auto array_of_type_ids() noexcept {
@@ -556,6 +574,11 @@ constexpr auto as_tuple_impl(std::index_sequence<I...>) noexcept {
     >{};
 }
 
+template <class T>
+constexpr tuple<> as_tuple_impl(std::index_sequence<>) noexcept {
+    return tuple<>{};
+}
+
 template <class T>
 constexpr auto as_tuple() noexcept {
     typedef typename std::remove_cv<T>::type type;
@@ -727,12 +750,12 @@ namespace detail {
 /// Example usage: 
 ///     struct my_struct { int i, short s; };
 ///     my_struct s{12, 13};
-///     flat_write(std::cout, s); // outputs '{ 12, 13 }'
+///     flat_write(std::cout, s); // outputs '{12, 13}'
 template <class Char, class Traits, class T>
 void flat_write(std::basic_ostream<Char, Traits>& out, const T& value) {
-    out << "{ ";
+    out << '{';
     detail::flat_print_impl<0, flat_tuple_size_v<T> >::print(out, value);
-    out << " }";
+    out << '}';
 }
 
 
@@ -745,9 +768,9 @@ namespace detail {
             if (!!I) {
                 in >> ignore;
                 if (ignore != ',') in.setstate(Stream::failbit);
+                in >> ignore;
+                if (ignore != ' ')  in.setstate(Stream::failbit);
             }
-            in >> ignore;
-            if (ignore != ' ')  in.setstate(Stream::failbit);
             in >> flat_get<I>(value);
             flat_read_impl<I + 1, N>::read(in, value);
         }
@@ -779,8 +802,6 @@ void flat_read(std::basic_istream<Char, Traits>& in, T& value) {
     if (parenthis != '{') in.setstate(std::basic_istream<Char, Traits>::failbit);
     detail::flat_read_impl<0, flat_tuple_size_v<T> >::read(in, value);
     
-    in >> parenthis;
-    if (parenthis != ' ') in.setstate(std::basic_istream<Char, Traits>::failbit);
     in >> parenthis;
     if (parenthis != '}') in.setstate(std::basic_istream<Char, Traits>::failbit);
 
@@ -792,7 +813,7 @@ void flat_read(std::basic_istream<Char, Traits>& in, T& value) {
 namespace detail {
     template <class T1, class T2>
     using same_pods_enable = typename std::enable_if< 
-        std::is_same<T1, T2>::value && std::is_pod<T1>::value && std::is_pod<T2>::value,
+        std::is_same<T1, T2>::value && std::is_pod<T1>::value && std::is_class<T1>::value,
         bool
     >::type;
     
diff --git a/main.cpp b/main.cpp
index 11f94ec..1195759 100644
--- a/main.cpp
+++ b/main.cpp
@@ -225,6 +225,15 @@ void test_comparable_struct() {
     assert(i != j);
 }
 
+void test_empty_struct() {
+    struct empty {};
+    using namespace pod_ops;
+
+    std::cout << empty{} << std::endl;
+
+    assert(empty{} == empty{});
+}
+
 int main() {
     test_compiletime<foo>();
     test_compiletime_array<int>();
@@ -251,6 +260,7 @@ int main() {
 
     test_with_enums();
     test_comparable_struct();
+    test_empty_struct();
 
     test_print();
 }