Extend generator support to non-copyable types (#474)

* Extend generator support to non-copyable types

* Handle assosiative container ranges

* Fallback for GCC14 only

Author: Twon

libraries/core/lib/morpheus/core/concurrency/generator.hpp

@@ -65,13 +65,13 @@ struct Generator
         template <std::convertible_to<T> From>
         auto yield_value(From&& from)
         {
-            current_value = std::forward<From>(from);
+            current_value = std::addressof(from);
             return coro::suspend_always{};
         }
 
         void unhandled_exception() { exception = std::current_exception(); }
 
-        T current_value;
+        std::add_pointer_t<std::add_const_t<T>> current_value = nullptr;
         std::exception_ptr exception;
     };
 
@@ -116,7 +116,7 @@ struct Generator
         [[nodiscard]] reference& operator*() const noexcept
         {
             assert(!handle.done() && "Can't dereference generator end iterator");
-            return handle.promise().current_value;
+            return *handle.promise().current_value;
         }
 
         [[nodiscard]] pointer& operator->() const noexcept { return std::addressof(operator*()); }

libraries/core/lib/morpheus/core/serialisation/adapters/std/pair.hpp

@@ -33,7 +33,8 @@ T deserialise(Serialiser& serialiser, std::type_identity<T>)
     static_assert(!std::is_reference_v<typename T::second_type>);
 
     auto const scope = makeScopedSequence(serialiser.reader(), std::tuple_size<T>::value);
-    return T{serialiser.template deserialise<typename T::first_type>(), serialiser.template deserialise<typename T::second_type>()};
+    return T{serialiser.template deserialise<std::remove_const_t<typename T::first_type>>(),
+             serialiser.template deserialise<std::remove_const_t<typename T::second_type>>()};
 }
 
 } // namespace morpheus::serialisation::detail

libraries/core/lib/morpheus/core/serialisation/adapters/std/ranges.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 // IWYU pragma: always_keep
+#include "morpheus/core/base/compiler.hpp"
 #include "morpheus/core/conformance/ranges.hpp"
 #include "morpheus/core/meta/concepts/string.hpp"
 #include "morpheus/core/serialisation/concepts/read_serialisable.hpp"
@@ -35,6 +36,24 @@ void serialise(Serialiser& serialiser, IsRange auto const& range)
     serialiser.writer().endSequence();
 }
 
+template <typename T>
+concept IsAssociativeLike = requires {
+    typename T::value_type;
+    typename T::key_type;
+};
+
+// template <typename T>
+// struct RangeDeserialiseValue
+//{
+//     using type = conf::ranges::range_value_t<T>;
+// };
+//
+// template <IsMapLike T>
+// struct RangeDeserialiseValue<T>
+//{
+//     using type = std::pair<typename T::key_type, typename T::mapped_type>;
+// };
+
 template <concepts::ReadSerialiser Serialiser, IsRange T>
 void deserialise(Serialiser& serialiser, T& range)
 {
@@ -69,14 +88,25 @@ void deserialise(Serialiser& serialiser, T& range)
 template <concepts::ReadSerialiser Serialiser, IsRange T>
 T deserialise(Serialiser& serialiser, std::type_identity<T>)
 {
-#if defined(__cpp_lib_ranges_to_container) && __cpp_lib_ranges_to_container >= 202202L
     using ValueType = conf::ranges::range_value_t<T>;
-    auto seq = serialiser.template sequence<ValueType>();
-    return conf::ranges::to<T>(std::move(seq));
+
+#if defined(__cpp_lib_ranges_to_container) && __cpp_lib_ranges_to_container >= 202202L
+    static constexpr bool isGcc14 = (MORPHEUS_COMPILER == MORPHEUS_GNUC_COMPILER) && (MORPHEUS_COMP_VER >= 140000000) && (MORPHEUS_COMP_VER < 150000000);
+
+    if constexpr (isGcc14 && IsAssociativeLike<T>)
+    {
+        // We must work around Gcc's std::ranges::to implementation for associative containers:
+        // https://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#4121
+        T range;
+        serialiser.deserialise(range);
+        return range;
+    }
+    else
+    {
+        return conf::ranges::to<T>(serialiser.template sequence<ValueType>());
+    }
 #elif defined(__cpp_lib_containers_ranges) && __cpp_lib_containers_ranges >= 202202L
-    using ValueType = conf::ranges::range_value_t<T>;
-    auto seq = serialiser.template sequence<ValueType>();
-    return T(std::from_range, std::move(seq));
+    return T(std::from_range, serialiser.template sequence<ValueType>());
 #else
     T range;
     serialiser.deserialise(range);

libraries/core/lib/morpheus/core/serialisation/adapters/std/tuple.hpp

@@ -33,7 +33,7 @@ T deserialise(Serialiser& serialiser, std::type_identity<T>)
     {
         // More work required to support std::tuples containing references.
         static_assert((!std::is_reference_v<std::tuple_element_t<Indexes, T>> || ...));
-        return T{serialiser.template deserialise<std::tuple_element_t<Indexes, T>>()...};
+        return T{serialiser.template deserialise<std::remove_const_t<std::tuple_element_t<Indexes, T>>>()...};
     }(std::make_index_sequence<size>());
 }
 

libraries/core/tests/serialisation/json_reader.tests.cpp

@@ -6,6 +6,7 @@
 #include "morpheus/core/serialisation/adapters/std/bitset.hpp"
 #include "morpheus/core/serialisation/adapters/std/chrono.hpp"
 #include "morpheus/core/serialisation/adapters/std/indirect.hpp"
+#include "morpheus/core/serialisation/adapters/std/map.hpp"
 #include "morpheus/core/serialisation/adapters/std/monostate.hpp"
 #include "morpheus/core/serialisation/adapters/std/optional.hpp"
 #include "morpheus/core/serialisation/adapters/std/pair.hpp"
@@ -575,6 +576,15 @@ TEST_CASE("Json reader can read std types from underlying text representation",
         REQUIRE(test::deserialise<std::chrono::years>(R"("100y")") == std::chrono::years{100});
         REQUIRE(test::deserialise<std::chrono::months>(R"("12m")") == std::chrono::months{12});
     }
+    SECTION("Container types")
+    {
+        REQUIRE(test::deserialise<std::map<int, std::string>>(R"([[1,"a"],[2,"b"],[3,"b"]])") == std::map<int, std::string>{
+                                                                                                     {1, "a"},
+                                                                                                     {2, "b"},
+                                                                                                     {3, "b"}
+        });
+        REQUIRE(test::deserialise<std::vector<int>>(R"([1, 2, 3, 4, 5])") == std::vector<int>{1, 2, 3, 4, 5});
+    }
     REQUIRE(test::deserialise<std::bitset<4>>(R"("1101")") == std::bitset<4>("1101"));
     REQUIRE(test::deserialise<conf::vt::indirect<int>>(R"({"value":42})") == conf::vt::indirect<int>(42));
     REQUIRE(test::deserialise<std::monostate>(R"({})") == std::monostate{});
@@ -584,7 +594,6 @@ TEST_CASE("Json reader can read std types from underlying text representation",
     REQUIRE(test::deserialise<std::string>(R"("Hello")") == std::string("Hello"));
     REQUIRE(test::deserialise<std::tuple<int, bool, std::string>>(R"([75,true,"Example"])") == std::tuple<int, bool, std::string>{75, true, "Example"});
     //    REQUIRE(test::deserialise<std::variant<int, bool, std::string>>(R"({"type":"bool","value":true})") == std::variant<int, bool, std::string>{true});
-    REQUIRE(test::deserialise<std::vector<int>>(R"([1, 2, 3, 4, 5])") == std::vector<int>{1, 2, 3, 4, 5});
     REQUIRE(*test::deserialise<std::unique_ptr<int>>(R"(50)") == 50);
 }
 

libraries/core/tests/serialisation/json_writer.tests.cpp

@@ -4,6 +4,7 @@
 #include "morpheus/core/serialisation/adapters/std/bitset.hpp"
 #include "morpheus/core/serialisation/adapters/std/chrono.hpp"
 #include "morpheus/core/serialisation/adapters/std/indirect.hpp"
+#include "morpheus/core/serialisation/adapters/std/map.hpp"
 #include "morpheus/core/serialisation/adapters/std/monostate.hpp"
 #include "morpheus/core/serialisation/adapters/std/optional.hpp"
 #include "morpheus/core/serialisation/adapters/std/pair.hpp"
@@ -412,6 +413,15 @@ TEST_CASE("Json writer can write std types to underlying text representation", "
         REQUIRE(test::serialise(std::chrono::years{100}) == R"("100y")");
         REQUIRE(test::serialise(std::chrono::months{12}) == R"("12m")");
     }
+    SECTION("Container types")
+    {
+        REQUIRE(test::serialise(std::map<int, std::string>{
+                    {1, "a"},
+                    {2, "b"},
+                    {3, "b"}
+        }) == R"([[1,"a"],[2,"b"],[3,"b"]])");
+        REQUIRE(test::serialise(std::vector<int>{1, 2, 3, 4, 5}) == R"([1,2,3,4,5])");
+    }
     REQUIRE(test::serialise(std::bitset<4>("1101")) == R"("1101")");
     REQUIRE(test::serialise(conf::vt::indirect<int>(42)) == R"({"value":42})");
     REQUIRE(test::serialise(std::monostate{}) == R"({})");
@@ -422,7 +432,6 @@ TEST_CASE("Json writer can write std types to underlying text representation", "
     REQUIRE(test::serialise(std::tuple<int, bool, std::string>{75, true, "Example"}) == R"([75,true,"Example"])");
     REQUIRE(test::serialise(std::make_unique<int>(123)) == R"(123)");
     REQUIRE(test::serialise(std::variant<int, bool, std::string>{true}) == R"({"type":"bool","value":true})");
-    REQUIRE(test::serialise(std::vector<int>{1, 2, 3, 4, 5}) == R"([1,2,3,4,5])");
 }
 
 TEST_CASE("Json writer can write ranges of composites", "[morpheus.serialisation.range.serialise.composites]")