changed naming of signals from sig to signal to avoid confusion with signatures.

Author: frameworklabs

include/proto_activities.h

@@ -20,9 +20,6 @@
 #ifdef _PA_ENABLE_CPP
 #include <functional> /* for std::function */
 #include <type_traits> /* for std::true_type, std::void_t, std::enable_if etc. */
-#if __cplusplus >= 201703L
-#include <optional>
-#endif
 #endif
 
 /* Types */
@@ -509,61 +506,67 @@ namespace proto_activities {
         }
         Signal(const Signal&) = delete;
         Signal& operator=(const Signal&) {
-            value_ = false;
+            is_present_ = false;
             return *this;
         }
         void emit() {
-            value_ = true;
+            is_present_ = true;
         }
         operator bool() const {
-            return value_;
+            return is_present_;
         }
         void update() final {
-            value_ = false;
+            is_present_ = false;
         }
     private:
-        bool value_;
+        bool is_present_{};
     };
-#if __cplusplus >= 201703L
+
     template <typename T>
     struct ValSignal final : Updatable {
         ValSignal(Enter& enter) {
             enter.add(this);
         }
         ValSignal(const ValSignal&) = delete;
         ValSignal& operator=(const ValSignal&) {
-            value_.reset();
+            is_present_ = false;
+            has_emitted_val_ = false;
+            value_ = {};
             return *this;
         }
-        void emit(T&& t) {
-            value_.emplace(std::move(t));
+        void emit(T&& val) {
+            is_present_ = true;
+            has_emitted_val_ = true;
+            value_ = std::move(val);
         }
         operator bool() const {
-            return value_.has_value();
+            return is_present_;
+        }
+        bool has_emitted_val() const {
+            return has_emitted_val_;
         }
         const T& val() const {
-            return *value_;
+            return value_;
         }
         void update() final {
-            value_.reset();
+            is_present_ = false;
         }
     private:
-        std::optional<T> value_;
+        bool is_present_{};
+        bool has_emitted_val_{};
+        T value_{};
     };
-#endif
 }
 
-using pa_sig = proto_activities::Signal;
-#define pa_sig_res pa_enter_res
-#define pa_def_sig(nm) pa_sig nm{_pa_enter};
+using pa_signal = proto_activities::Signal;
+#define pa_signal_res pa_enter_res
+#define pa_def_signal(sig) pa_signal sig{_pa_enter};
 #define pa_emit(sig) sig.emit();
 
-#if __cplusplus >= 201703L
 template <typename T>
-using pa_val_sig = proto_activities::ValSignal<T>;
-#define pa_def_val_sig(ty, nm) pa_val_sig<ty> nm{_pa_enter};
+using pa_val_signal = proto_activities::ValSignal<T>;
+#define pa_def_val_signal(ty, sig) pa_val_signal<ty> sig{_pa_enter};
 #define pa_emit_val(sig, val) sig.emit(val);
-#endif
 
 #endif
 

tests_cpp/tests.cpp

@@ -809,7 +809,7 @@ pa_activity (TestLifecycle, pa_ctx(pa_co_res(2); pa_use(TestLifecycleBody); pa_u
 
 // Signal Tests
 
-pa_activity (TestSignalsBodySub, pa_ctx(), pa_sig& s1, pa_sig& s2) {
+pa_activity (TestSignalsBodySub, pa_ctx(), pa_signal& s1, pa_signal& s2) {
     assert(!s1); assert(!s2);
     pa_pause;
 
@@ -822,8 +822,8 @@ pa_activity (TestSignalsBodySub, pa_ctx(), pa_sig& s1, pa_sig& s2) {
     pa_pause;
 } pa_end
 
-pa_activity (TestSignalsBody, pa_ctx(pa_sig_res; pa_use(TestSignalsBodySub);
-                                     pa_def_sig(s1); pa_def_sig(s2))) {
+pa_activity (TestSignalsBody, pa_ctx(pa_signal_res; pa_use(TestSignalsBodySub);
+                                     pa_def_signal(s1); pa_def_signal(s2))) {
     assert(!pa_self.s1); assert(!pa_self.s2);
     pa_pause;
 
@@ -845,34 +845,42 @@ pa_activity (TestSignals, pa_ctx_tm(pa_use(TestSignalsBody))) {
     pa_run (TestSignalsBody); // Test re-invocation after abort
 } pa_end
 
-#if __cplusplus >= 201703L
-
-pa_activity (TestValSignalsBodySub, pa_ctx(), pa_val_sig<int>& s1, pa_val_sig<float>& s2) {
+pa_activity (TestValSignalsBodySub, pa_ctx(), pa_val_signal<int>& s1, pa_val_signal<float>& s2) {
     assert(!s1); assert(!s2);
+    assert(s1.has_emitted_val()); assert(s2.has_emitted_val());
     pa_pause;
 
     assert(!s1); assert(!s2);
+    assert(s1.has_emitted_val()); assert(s2.has_emitted_val());
+
     pa_emit_val(s1, 42); pa_emit_val(s2, 3.14f);
     assert(s1); assert(s2);
+    assert(s1.has_emitted_val()); assert(s2.has_emitted_val());
     assert(s1.val() == 42); assert(s2.val() != 0.0f);
     pa_pause;
 
     assert(!s1); assert(!s2);
+    assert(s1.has_emitted_val()); assert(s2.has_emitted_val());
     pa_pause;
 } pa_end
 
-pa_activity (TestValSignalsBody, pa_ctx(pa_sig_res; pa_use(TestValSignalsBodySub);
-                                        pa_def_val_sig(int, s1); pa_def_val_sig(float, s2))) {
+pa_activity (TestValSignalsBody, pa_ctx(pa_signal_res; pa_use(TestValSignalsBodySub);
+                                        pa_def_val_signal(int, s1); pa_def_val_signal(float, s2))) {
     assert(!pa_self.s1); assert(!pa_self.s2);
+    assert(!pa_self.s1.has_emitted_val()); assert(!pa_self.s2.has_emitted_val());
     pa_pause;
 
     assert(!pa_self.s1); assert(!pa_self.s2);
+    assert(!pa_self.s1.has_emitted_val()); assert(!pa_self.s2.has_emitted_val());
+
     pa_emit_val(pa_self.s1, 42); pa_emit_val(pa_self.s2, 3.14f);
     assert(pa_self.s1); assert(pa_self.s2);
+    assert(pa_self.s1.has_emitted_val()); assert(pa_self.s2.has_emitted_val());
     assert(pa_self.s1.val() == 42); assert(pa_self.s2.val() != 0.0f);
     pa_pause;
 
     assert(!pa_self.s1); assert(!pa_self.s2);
+    assert(pa_self.s1.has_emitted_val()); assert(pa_self.s2.has_emitted_val());
     pa_pause;
 
     pa_run(TestValSignalsBodySub, pa_self.s1, pa_self.s2);
@@ -885,8 +893,6 @@ pa_activity (TestValSignals, pa_ctx_tm(pa_use(TestValSignalsBody))) {
     pa_run (TestValSignalsBody); // Test re-invocation after abort
 } pa_end
 
-#endif
-
 } // namespace tests
 
 // Test Driver