Threads/Inc/threads_actor.hpp

@@ -55,20 +55,20 @@ public:
         : q_(q)
     {}
 
-    void emit(const T& data) override
+    bool emit(const T& data) override
     {
       parent::value_type to_send = data;
-      xQueueSend(q_->msg_queue_, &to_send, 0);
+      const BaseType_t success = xQueueSend(q_->msg_queue_, &to_send, 0);
+      return success == pdTRUE;
     }
 
-    BaseType_t emitFromIsr(const T& data) override
+    std::pair<bool, BaseType_t> emitFromIsr(const T& data) override
     {
       parent::value_type to_send = data;
       BaseType_t was_awoken = pdFALSE;
+      const BaseType_t success = xQueueSendFromISR(q_->msg_queue_, &to_send, &was_awoken);
 
-      xQueueSendFromISR(q_->msg_queue_, &to_send, &was_awoken);
-
-      return was_awoken;
+      return {success == pdTRUE, was_awoken};
     }
 
   private:
@@ -192,21 +192,22 @@ private:
         : q(q)
     {}
 
-    void emit() override
+    bool emit() override
     {
       const int data = 0;
 
-      xQueueSend(q.msg_queue_, &data, 0);
+      const BaseType_t success = xQueueSend(q.msg_queue_, &data, 0);
+      return success == pdTRUE;
     }
 
-    BaseType_t emitFromIsr() override
+    std::pair<bool, BaseType_t> emitFromIsr() override
     {
       const int data = 0;
 
       BaseType_t was_awoken = pdFALSE;
-      xQueueSendFromISR(q.msg_queue_, &data, &was_awoken);
+      const BaseType_t success = xQueueSendFromISR(q.msg_queue_, &data, &was_awoken);
 
-      return was_awoken;
+      return {success == pdTRUE, was_awoken};
     }
   };
 

Threads/Inc/threads_exclusivesignal.hpp

@@ -144,26 +144,28 @@ struct ExclusiveSignal<void> : public Signallable<void>
     return currentThread.notifyWait(timeout);
   }
 
-  void emit() override
-  {
-    if (waiting_thread_)
-    {
-      auto const _ = waiting_thread_->notify(0, eNoAction);
-      (void) _;
-    }
-  }
-
-  BaseType_t emitFromIsr() override
+  bool emit() override
   {
     if (!waiting_thread_)
     {
-      return pdFALSE;
+      return false;
+    } else
+    {
+      return waiting_thread_->notify(0, eNoAction);
+    }
+  }
+
+  std::pair<bool, BaseType_t> emitFromIsr() override
+  {
+    if (!waiting_thread_)
+    {
+      return {false, pdFALSE};
     } else
     {
       auto const [discard, was_notified] = waiting_thread_->notifyFromIsr(0, eNoAction);
       (void) discard;
 
-      return was_notified;
+      return {true, was_notified};
     }
   }
 

Threads/Inc/threads_signal.hpp

@@ -23,8 +23,8 @@ struct Signallable
   static_assert(std::is_trivially_copyable_v<value_type>, "T must be trivially copyable.");
   static_assert(std::is_default_constructible_v<value_type>, "T must be default constructible.");
 
-  virtual void emit(const T& t) = 0;
-  virtual BaseType_t emitFromIsr(const T& t) = 0;
+  virtual bool emit(const T& t) = 0;
+  virtual std::pair<bool, BaseType_t> emitFromIsr(const T& t) = 0;
 };
 
 template<>
@@ -32,8 +32,8 @@ struct Signallable<void>
 {
   using value_type = void;
 
-  virtual void emit() = 0;
-  virtual BaseType_t emitFromIsr() = 0;
+  virtual bool emit() = 0;
+  virtual std::pair<bool, BaseType_t> emitFromIsr() = 0;
 };
 
 template<typename R>

Threads/Inc/threads_signal_mux.hpp

@@ -1,70 +0,0 @@
-/*
- * threads_signal_mux.hpp
- *
- *  Created on: Jun 26, 2021
- *      Author: erki
- */
-
-#ifndef SKULLC_THREADS_SIGNAL_MUX_HPP_
-#define SKULLC_THREADS_SIGNAL_MUX_HPP_
-
-#include "threads_signal.hpp"
-
-#include <algorithm>
-#include <tuple>
-
-namespace Threads
-{
-
-template<typename T, typename... Ss>
-struct SignalMux : Signallable<T>
-{
-  std::tuple<Ss...> signals;
-
-  SignalMux(Ss... args)
-      : signals(std::make_tuple(args...))
-  {}
-
-  SignalMux(Ss&&... args)
-      : signals(std::make_tuple(args...))
-  {}
-
-  void emit(const T& t) override
-  {
-    std::apply([&t](auto&... sig) { (..., sig.emit(t)); }, signals);
-  }
-
-  BaseType_t emitFromIsr(const T& t) override
-  {
-    BaseType_t higher_was_awoken = pdFALSE;
-
-    auto emitSignal = [&higher_was_awoken, &t](auto& sig) {
-      const BaseType_t awoken = sig.emitFromIsr(t);
-      higher_was_awoken = awoken || higher_was_awoken;
-    };
-
-    std::apply([&t, &emitSignal](auto&... sig) {
-      (..., emitSignal(sig));
-    },
-               signals);
-
-    return higher_was_awoken;
-  }
-};
-
-template<typename T, typename... Ss>
-SignalMux<T, Ss...> makeSignalMux(Ss&&... args)
-{
-  return SignalMux<T, Ss...>(std::forward(args...));
-}
-
-template<typename T, typename... Ss>
-SignalMux<T, Ss...> makeSignalMux(Ss... args)
-{
-  return SignalMux<T, Ss...>(args...);
-}
-
-}// namespace Threads
-
-
-#endif /* SKULLC_THREADS_SIGNAL_MUX_HPP_ */