- Fixing Thread

Author: LK-Simon

src/ESPressio_IThread.hpp

@@ -26,6 +26,11 @@ namespace ESPressio {
         */
         class IThread  {
             public:
+            // Type Defs
+
+                typedef std::function<void(IThread*)> ThreadCallback;
+                typedef std::function<void(IThread*, ThreadState, ThreadState)> ThreadStateChangeCallback;
+
             // Methods
 
                 /// `Initialize` is invoked automatically for all Threads when the `ThreadManager` is initialized in your `main()` (or `setup()` for MCU projects) function.
@@ -77,20 +82,23 @@ namespace ESPressio {
 
             // Callback Getters
 
+                /// `GetOnDestroy` returns the callback to be invoked when the Thread is destroyed.
+                virtual ThreadCallback GetOnDestroy() = 0;
+
                 /// `GetOnInitialized` returns the callback to be invoked when the Thread is initialized.
-                virtual std::function<void(IThread*)> GetOnInitialize() = 0;
+                virtual ThreadCallback GetOnInitialize() = 0;
 
                 /// `GetOnStarted` returns the callback to be invoked when the Thread is started.
-                virtual std::function<void(IThread*)> GetOnStart() = 0;
+                virtual ThreadCallback GetOnStart() = 0;
 
                 /// `GetOnPaused` returns the callback to be invoked when the Thread is paused.
-                virtual std::function<void(IThread*)> GetOnPause() = 0;
+                virtual ThreadCallback GetOnPause() = 0;
 
                 /// `GetOnTerminated` returns the callback to be invoked when the Thread is terminated.
-                virtual std::function<void(IThread*)> GetOnTerminate() = 0;
+                virtual ThreadCallback GetOnTerminate() = 0;
 
                 /// `GetOnStateChange` returns the callback to be invoked when the Thread's state changes.
-                virtual std::function<void(IThread*, ThreadState, ThreadState)> GetOnStateChange() = 0;
+                virtual ThreadStateChangeCallback GetOnStateChange() = 0;
 
             // Setters
 
@@ -108,25 +116,29 @@ namespace ESPressio {
 
             // Callback Setters
 
+                /// `SetOnDestroy` sets the callback to be invoked when the Thread is destroyed.
+                /// The callback function takes `IThread*` and ideally named `sender`.
+                virtual void SetOnDestroy(ThreadCallback) = 0;
+
                 /// `SetOnInitialized` sets the callback to be invoked when the Thread is initialized.
                 /// The callback function takes `IThread*` and ideally named `sender`.
-                virtual void SetOnInitialize(std::function<void(IThread*)>) = 0;
+                virtual void SetOnInitialize(ThreadCallback) = 0;
 
                 /// `SetOnStarted` sets the callback to be invoked when the Thread is started.
                 /// The callback function takes `IThread*` and ideally named `sender`.
-                virtual void SetOnStart(std::function<void(IThread*)>) = 0;
+                virtual void SetOnStart(ThreadCallback) = 0;
 
                 /// `SetOnPaused` sets the callback to be invoked when the Thread is paused.
                 /// The callback function takes `IThread*` and ideally named `sender`.
-                virtual void SetOnPause(std::function<void(IThread*)>) = 0;
+                virtual void SetOnPause(ThreadCallback) = 0;
 
                 /// `SetOnTerminated` sets the callback to be invoked when the Thread is terminated.
                 /// The callback function takes `IThread*` and ideally named `sender`.
-                virtual void SetOnTerminate(std::function<void(IThread*)>) = 0;
+                virtual void SetOnTerminate(ThreadCallback) = 0;
 
                 /// `SetOnStateChange` sets the callback to be invoked when the Thread's state changes.
                 /// The callback function takes `IThread*` and ideally named `sender`, `ThreadState` for the previous state and `ThreadState` for the new state.
-                virtual void SetOnStateChange(std::function<void(IThread*, ThreadState, ThreadState)>) = 0;
+                virtual void SetOnStateChange(ThreadStateChangeCallback) = 0;
         };
 
     }

src/ESPressio_IThreadGarbageCollector.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "ESPressio_Thread.hpp"
+#include "ESPressio_ThreadManager.hpp"
+
+#ifndef ESPRESSIO_THREAD_GARBAGE_COLLECTOR_STACK_SIZE
+    #define ESPRESSIO_THREAD_GARBAGE_COLLECTOR_STACK_SIZE 2000 // You are encouraged to determine the appropriate stack size for your application, and define it in your platformio.ini file.
+#endif
+
+namespace ESPressio {
+
+    namespace Threads {
+
+        class IThreadGarbageCollector {
+            public:             
+                virtual void CleanUp() = 0;
+        };
+
+    }
+}

src/ESPressio_Thread.cpp

@@ -14,7 +14,7 @@ namespace ESPressio {
         }
 
         Thread::~Thread() {
-            DoNotifyDestroy();
+            if (_onDestroy() != nullptr) { _onDestroy(); }
             SetThreadState(ThreadState::Destroyed);
             _deleteTask();
         }

src/ESPressio_Thread.hpp

@@ -39,6 +39,7 @@ namespace ESPressio {
                 ReadWriteMutex<UBaseType_t> _priority = ReadWriteMutex<UBaseType_t>(2);
                 ReadWriteMutex<BaseType_t> _coreID = ReadWriteMutex<BaseType_t>(0);
             // Callbacks
+                TOnThreadEvent _onDestroy = nullptr;
                 TOnThreadEvent _onInitialize = nullptr;
                 TOnThreadEvent _onStart = nullptr;
                 TOnThreadEvent _onPause = nullptr;
@@ -205,23 +206,27 @@ namespace ESPressio {
 
             // Callback Getters
 
-                std::function<void(IThread*)> GetOnInitialize() {
+                TOnThreadEvent GetOnDestroy() {
+                    return _onDestroy;
+                }
+
+                TOnThreadEvent GetOnInitialize() {
                     return _onInitialize;
                 }
 
-                std::function<void(IThread*)> GetOnStart() {
+                TOnThreadEvent GetOnStart() {
                     return _onStart;
                 }
 
-                std::function<void(IThread*)> GetOnPause() {
+                TOnThreadEvent GetOnPause() {
                     return _onPause;
                 }
 
-                std::function<void(IThread*)> GetOnTerminate() {
+                TOnThreadEvent GetOnTerminate() {
                     return _onTerminate;
                 }
 
-                std::function<void(IThread*, ThreadState, ThreadState)> GetOnStateChange() {
+                TOnThreadStateChangeEvent GetOnStateChange() {
                     return _onStateChange;
                 }
 
@@ -249,23 +254,27 @@ namespace ESPressio {
 
             // Callback Setters
 
-                void SetOnInitialize(std::function<void(IThread*)> value) {
+                void SetOnDestroy(TOnThreadEvent value) {
+                    _onDestroy = value;
+                }
+
+                void SetOnInitialize(TOnThreadEvent value) {
                     _onInitialize = value;
                 }
 
-                void SetOnStart(std::function<void(IThread*)> value) {
+                void SetOnStart(TOnThreadEvent value) {
                     _onStart = value;
                 }
 
-                void SetOnPause(std::function<void(IThread*)> value) {
+                void SetOnPause(TOnThreadEvent value) {
                     _onPause = value;
                 }
 
-                void SetOnTerminate(std::function<void(IThread*)> value) {
+                void SetOnTerminate(TOnThreadEvent value) {
                     _onTerminate = value;
                 }
 
-                void SetOnStateChange(std::function<void(IThread*, ThreadState, ThreadState)> value) {
+                void SetOnStateChange(TOnThreadStateChangeEvent value) {
                     _onStateChange = value;
                 }
         };

src/ESPressio_ThreadGarbageCollector.hpp

@@ -2,6 +2,7 @@
 
 #include "ESPressio_Thread.hpp"
 #include "ESPressio_ThreadManager.hpp"
+#include "ESPressio_IThreadGarbageCollector.hpp"
 
 #ifndef ESPRESSIO_THREAD_GARBAGE_COLLECTOR_STACK_SIZE
     #define ESPRESSIO_THREAD_GARBAGE_COLLECTOR_STACK_SIZE 2000 // You are encouraged to determine the appropriate stack size for your application, and define it in your platformio.ini file.
@@ -11,7 +12,7 @@ namespace ESPressio {
 
     namespace Threads {
 
-        class ThreadGarbageCollector : public Thread {
+        class ThreadGarbageCollector : public Thread, public IThreadGarbageCollector {
             private:
                 // A semaphore for our loop to wait on (so that it doesn't consume CPU cycles when there's nothing to do).
                 SemaphoreHandle_t _semaphore = xSemaphoreCreateBinary();
@@ -34,7 +35,7 @@ namespace ESPressio {
                     return instance;
                 }
 
-                void CleanUp() {
+                void CleanUp() override {
                     // Signal the semaphore to wake up the thread.
                     xSemaphoreGive(_semaphore);
                 }