Add a safe timer example. Other minor updates.

Author: endurodave

docs/DETAILS.md

@@ -1831,6 +1831,9 @@ Users create an instance of the timer and register for the expiration. In this c
 m_timer.Expired = MakeDelegate(&myClass, &MyClass::MyCallback, myThread);
 m_timer.Start(std::chrono::milliseconds(1000));
 ```
+
+See example `SafeTimer.cpp` to prevent a latent callback on a dead object and [Object Lifetime and Async Delegates](#object-lifetime-and-async-delegates) for an explaination.
+
 ## `std::async` Thread Targeting Example
 
 An example combining `std::async`/`std::future` and an asynchronous delegate to target a specific worker thread during communication transmission.

example/sample-code/SafeTimer.cpp

@@ -0,0 +1,60 @@
+/// @brief Implement the safe timer test to prevent a latent callback 
+/// on a dead object. 
+/// 
+/// See Object Lifetime and Async Delegates in DETAILS.md for more information.
+
+#include "SafeTimer.h"
+#include "DelegateMQ.h"
+
+using namespace dmq;
+using namespace std;
+
+namespace Example
+{
+    // The SafeTimer class safely creates a timer and registers/unregisters
+    // while preventing any pending timer callbacks on a deleted object. 
+    class SafeTimer : public std::enable_shared_from_this<SafeTimer>
+    {
+    public:
+        SafeTimer() : m_thread("SafeTimer Thread") { }
+
+        void Init() {
+            m_thread.CreateThread();
+
+            // Bind the callback with a shared reference. This ensures the object remains
+            // valid/alive when the timer fires, preventing a crash on a dangling pointer.
+            m_timer.Expired = MakeDelegate(shared_from_this(), &SafeTimer::OnTimer, m_thread);
+            m_timer.Start(std::chrono::milliseconds(100));
+        }
+
+        // Unregister in Term to be clean
+        void Term() {
+            m_timer.Stop();
+            m_timer.Expired.Clear();
+
+            m_thread.ExitThread();
+        }
+
+        ~SafeTimer() {
+            // Even if Shutdown() wasn't called, the shared delegate prevents a crash
+            // if a stray timer event is still pending in workerThread.
+        }
+
+    private:
+        void OnTimer() {
+            std::cout << "Timer fired safely!" << std::endl;
+        }
+
+        Timer m_timer;
+        Thread m_thread;
+    };
+
+    void SafeTimerExample() {
+        auto safeTimer = std::make_shared<SafeTimer>();
+        safeTimer->Init();
+
+        this_thread::sleep_for(chrono::milliseconds(500));
+
+        safeTimer->Term();
+    }
+}

example/sample-code/SafeTimer.h

@@ -0,0 +1,10 @@
+#ifndef SAFE_TIMER_H
+#define SAFE_TIMER_H
+
+namespace Example
+{
+    /// Execute the safe timer test example
+    void SafeTimerExample();
+}
+
+#endif

src/delegate-mq/delegate/DelegateAsync.h

@@ -694,10 +694,6 @@ class DelegateMemberAsync<TClass, RetType(Args...)> : public DelegateMember<TCla
     // </common_code>
 };
 
-// ----------------------------------------------------------------------------------------------
-// NEW CLASS: DelegateMemberAsyncShared
-// ----------------------------------------------------------------------------------------------
-
 template <class C, class R>
 struct DelegateMemberAsyncShared; // Not defined
 

src/delegate-mq/predef/os/stdlib/Thread.cpp

@@ -124,10 +124,17 @@ void Thread::ExitThread()
 	if (!m_thread)
 		return;
 
-	if (m_watchdogTimer)
+	if (m_watchdogTimer) 
+	{
 		m_watchdogTimer->Stop();
-	if (m_threadTimer)
+		m_watchdogTimer->Expired.Clear();
+	}
+
+	if (m_threadTimer) 
+	{
 		m_threadTimer->Stop();
+		m_threadTimer->Expired.Clear();
+	}
 
 	// Create a new ThreadMsg
 	std::shared_ptr<ThreadMsg> threadMsg(new ThreadMsg(MSG_EXIT_THREAD, 0));

src/delegate-mq/predef/util/Timer.h

@@ -7,6 +7,7 @@
 
 /// @brief A timer class provides periodic timer callbacks on the client's 
 /// thread of control. Timer is thread safe.
+/// See example SafeTimer.cpp to prevent a latent callback on a dead object.
 class Timer 
 {
 public:

test/main.cpp

@@ -8,6 +8,7 @@
 // "Porting Guide" within DETAILS.md offers complete porting guidance.
 
 #include "DelegateMQ.h"
+#include "SafeTimer.h"
 #include "ProducerConsumer.h"
 #include "CountdownLatch.h"
 #include "ActiveObject.h"
@@ -292,6 +293,9 @@ void RunAllExamples()
     // Run all target types example
     AllTargetsExample();
 
+    // Run safe timer example
+    SafeTimerExample();
+
     // Run asynchronous API using delegates example 
     AsyncAPIExample();
 
@@ -523,13 +527,17 @@ void RunMiscExamples()
     // Could be helpful if T is very large and two or more clients register to receive asynchronous
     // callbacks.
     CoordinatesHandler coordinatesHandler;
-    CoordinatesHandler::CoordinatesChanged += MakeDelegate(&CoordinatesChangedCallback, workerThread1);
+
+    auto coordDelegate = MakeDelegate(&CoordinatesChangedCallback, workerThread1);
+    CoordinatesHandler::CoordinatesChanged += coordDelegate;
 
     Coordinates coordinates;
     coordinates.x = 11;
     coordinates.y = 99;
     coordinatesHandler.SetData(coordinates);
 
+    CoordinatesHandler::CoordinatesChanged -= coordDelegate;
+
     // Invoke virtual base function example
     std::shared_ptr<Base> base = std::make_shared<Derived>();
     auto baseDelegate = MakeDelegate(base, &Base::display, workerThread1);