As it was, the FunctionFusion was actually converting everything into…

… an lvalue right before the call. The static cast here will fix the types so rvalues become rvalues again. Also remove the exception that watchdog servicer was using and make everything use unique pointers until there is something better
Fastcode · Dec 28, 2024 · cfdca5c · cfdca5c
1 parent bf8ac58
commit cfdca5c
Show file tree

Hide file tree

Showing 3 changed files with 14 additions and 15 deletions.
diff --git a/src/Reactor.hpp b/src/Reactor.hpp
@@ -135,9 +135,9 @@ namespace dsl {
             template <typename WatchdogGroup, typename RuntimeType>
             struct WatchdogServicer;
             template <typename WatchdogGroup, typename RuntimeType>
-            WatchdogServicer<WatchdogGroup, RuntimeType> ServiceWatchdog(RuntimeType&& data);
+            std::unique_ptr<WatchdogServicer<WatchdogGroup, RuntimeType>> ServiceWatchdog(RuntimeType&& data);
             template <typename WatchdogGroup>
-            WatchdogServicer<WatchdogGroup, void> ServiceWatchdog();
+            std::unique_ptr<WatchdogServicer<WatchdogGroup, void>> ServiceWatchdog();
         }  // namespace emit
     }  // namespace word
 }  // namespace dsl
@@ -272,10 +272,7 @@ class Reactor {
 
     /// @copydoc dsl::word::emit::ServiceWatchdog
     template <typename WatchdogGroup, typename... Arguments>
-    auto ServiceWatchdog(Arguments&&... args)
-        // THIS IS VERY IMPORTANT, the return type must be dependent on the function call
-        // otherwise it won't check it's valid in SFINAE
-        -> decltype(dsl::word::emit::ServiceWatchdog<WatchdogGroup>(std::forward<Arguments>(args)...)) {
+    auto ServiceWatchdog(Arguments&&... args) {
         return dsl::word::emit::ServiceWatchdog<WatchdogGroup>(std::forward<Arguments>(args)...);
     }
 
@@ -368,7 +365,7 @@ class Reactor {
                 util::CallbackGenerator<DSL, Function>(std::forward<Function>(callback)));
 
             // Get our tuple from binding our reaction
-            auto tuple = DSL::bind(reaction, std::get<Index>(args)...);
+            auto tuple = DSL::bind(reaction, std::move(std::get<Index>(args))...);
 
             auto handle = threading::ReactionHandle(reaction);
             reactor.reaction_handles.push_back(handle);

diff --git a/src/dsl/word/emit/Watchdog.hpp b/src/dsl/word/emit/Watchdog.hpp
@@ -125,8 +125,8 @@ namespace dsl {
              * @return A WatchdogServicer object which will update the service time of the specified watchdog
              */
             template <typename WatchdogGroup, typename RuntimeType>
-            WatchdogServicer<WatchdogGroup, RuntimeType> ServiceWatchdog(RuntimeType&& data) {
-                return WatchdogServicer<WatchdogGroup, RuntimeType>(std::forward<RuntimeType>(data));
+            std::unique_ptr<WatchdogServicer<WatchdogGroup, RuntimeType>> ServiceWatchdog(RuntimeType&& data) {
+                return std::make_unique<WatchdogServicer<WatchdogGroup, RuntimeType>>(std::forward<RuntimeType>(data));
             }
 
             /**
@@ -137,8 +137,8 @@ namespace dsl {
              * @return WatchdogServicer<WatchdogGroup, void>
              */
             template <typename WatchdogGroup>
-            WatchdogServicer<WatchdogGroup, void> ServiceWatchdog() {
-                return WatchdogServicer<WatchdogGroup, void>();
+            std::unique_ptr<WatchdogServicer<WatchdogGroup, void>> ServiceWatchdog() {
+                return std::make_unique<WatchdogServicer<WatchdogGroup, void>>();
             }
 
             /**
@@ -158,9 +158,9 @@ namespace dsl {
 
                 template <typename WatchdogGroup, typename RuntimeType>
                 static void emit(const PowerPlant& /*powerplant*/,
-                                 WatchdogServicer<WatchdogGroup, RuntimeType>& servicer) {
+                                 const std::shared_ptr<WatchdogServicer<WatchdogGroup, RuntimeType>>& servicer) {
                     // Update our service time
-                    servicer.service();
+                    servicer->service();
                 }
             };
 

diff --git a/src/util/FunctionFusion.hpp b/src/util/FunctionFusion.hpp
@@ -48,11 +48,13 @@ namespace util {
      * @return The object returned by the called subfunction
      */
     template <typename Function, int... Shared, int... Selected, typename... Arguments>
-    auto apply_function_fusion_call(const std::tuple<Arguments...>& args,
+    auto apply_function_fusion_call(std::tuple<Arguments...>&& args,
                                     const Sequence<Shared...>& /*shared*/,
                                     const Sequence<Selected...>& /*selected*/)
         -> decltype(Function::call(std::get<Shared>(args)..., std::get<Selected>(args)...)) {
-        return Function::call(std::get<Shared>(args)..., std::get<Selected>(args)...);
+        return Function::call(
+            static_cast<std::tuple_element_t<Shared, std::tuple<Arguments...>>>(std::get<Shared>(args))...,
+            static_cast<std::tuple_element_t<Selected, std::tuple<Arguments...>>>(std::get<Selected>(args))...);
     }
 
     /**