Template CxPlatAsync

inc/cxplat.hpp

@@ -19,46 +19,34 @@
 #include "cxplat.h"
 #include "cxplat_sal_stub.h"
 
-typedef void* CxPlatCallback(
-    _Inout_ void* Context
-);
-
-class CxPlatAsync {
+template <typename T, typename R = void>
+class CxPlatAsyncT {
 private:
-    struct CxPlatAsyncContext {
-        void* UserContext;
-        CxPlatCallback *UserCallback;
-        void* ReturnValue;
+    typedef R CallbackT(_Inout_ T* Context);
+
+    struct ContextT {
+        T* UserContext;
+        CallbackT *UserCallback;
+        R ReturnValue;
     };
 
-    static CXPLAT_THREAD_CALLBACK(CxPlatAsyncWrapperCallback, Context)
-    {
-        struct CxPlatAsyncContext* AsyncContext = (struct CxPlatAsyncContext*)Context;
+    static CXPLAT_THREAD_CALLBACK(ThreadCallback, Context) {
+        auto AsyncContext = (ContextT*)Context;
         AsyncContext->ReturnValue = AsyncContext->UserCallback(AsyncContext->UserContext);
         CXPLAT_THREAD_RETURN(0);
     }
 
+    struct ContextT AsyncContext {0, 0, 0};
+    CXPLAT_THREAD_CONFIG ThreadConfig {0, 0, "CxPlatAsync", ThreadCallback, &AsyncContext};
     CXPLAT_THREAD Thread {0};
-    CXPLAT_THREAD_CONFIG ThreadConfig {0};
-    struct CxPlatAsyncContext AsyncContext {0};
-    bool Initialized = false;
-    bool ThreadCompleted = false;
+    bool ThreadCompleted {false};
+    bool Initialized;
 public:
-    CxPlatAsync(CxPlatCallback Callback, void* UserContext = nullptr) noexcept {
-        AsyncContext.UserContext = UserContext;
-        AsyncContext.UserCallback = Callback;
-        AsyncContext.ReturnValue = nullptr;
-
-        ThreadConfig.Name = "CxPlatAsync";
-        ThreadConfig.Callback = CxPlatAsyncWrapperCallback;
-        ThreadConfig.Context = &AsyncContext;
-        if (CxPlatThreadCreate(&ThreadConfig, &Thread) != 0) {
-            Initialized = false;
-            return;
-        }
-        Initialized = true;
+    CxPlatAsyncT(CallbackT Callback, T* UserContext = nullptr) noexcept
+        : AsyncContext({UserContext, Callback, 0}),
+          Initialized(CxPlatThreadCreate(&ThreadConfig, &Thread) == 0) {
     }
-    ~CxPlatAsync() noexcept {
+    ~CxPlatAsyncT() noexcept {
         if (Initialized) {
             if (!ThreadCompleted) {
                 CxPlatThreadWaitForever(&Thread);
@@ -77,17 +65,67 @@ class CxPlatAsync {
 #if defined(CX_PLATFORM_WINUSER) || defined(CX_PLATFORM_WINKERNEL)
     bool WaitFor(uint32_t TimeoutMs) noexcept {
         if (Initialized) {
-            if (CxPlatThreadWaitWithTimeout(&Thread, TimeoutMs)) {
-                return true;
-            }
+            return (ThreadCompleted = CxPlatThreadWaitWithTimeout(&Thread, TimeoutMs));
         }
         return false;
     }
 #endif
 
-    void* Get() noexcept {
+    R Get() noexcept {
         return AsyncContext.ReturnValue;
     }
 };
 
+template <typename T>
+class CxPlatAsyncT <T, void>{
+private:
+    typedef void CallbackT(_Inout_ T* Context);
+
+    struct ContextT {
+        T* UserContext;
+        CallbackT *UserCallback;
+    };
+
+    static CXPLAT_THREAD_CALLBACK(ThreadCallback, Context) {
+        auto AsyncContext = (ContextT*)Context;
+        AsyncContext->UserCallback(AsyncContext->UserContext);
+        CXPLAT_THREAD_RETURN(0);
+    }
+
+    struct ContextT AsyncContext {0, 0};
+    CXPLAT_THREAD_CONFIG ThreadConfig {0, 0, "CxPlatAsync", ThreadCallback, &AsyncContext};
+    CXPLAT_THREAD Thread {0};
+    bool ThreadCompleted {false};
+    bool Initialized;
+public:
+    CxPlatAsyncT(CallbackT Callback, T* UserContext = nullptr) noexcept
+        : AsyncContext({UserContext, Callback}),
+          Initialized(CxPlatThreadCreate(&ThreadConfig, &Thread) == 0) {
+    }
+    ~CxPlatAsyncT() noexcept {
+        if (Initialized) {
+            if (!ThreadCompleted) {
+                CxPlatThreadWaitForever(&Thread);
+            }
+            CxPlatThreadDelete(&Thread);
+        }
+    }
+
+    void Wait() noexcept {
+        if (Initialized) {
+            CxPlatThreadWaitForever(&Thread);
+            ThreadCompleted = true;
+        }
+    }
+
+#if defined(CX_PLATFORM_WINUSER) || defined(CX_PLATFORM_WINKERNEL)
+    bool WaitFor(uint32_t TimeoutMs) noexcept {
+        if (Initialized) {
+            return (ThreadCompleted = CxPlatThreadWaitWithTimeout(&Thread, TimeoutMs));
+        }
+        return false;
+    }
+#endif
+};
+
 #endif

src/test/lib/ThreadTest.cpp

@@ -64,48 +64,51 @@ void CxPlatTestThreadBasic()
 void CxPlatTestThreadAsync()
 {
     {
-        CxPlatAsync Async([](void*) -> void* {
+        CxPlatAsyncT<void,void*> Async([](void*) -> void* {
             return nullptr;
         });
     }
 
+    {
+        CxPlatAsyncT<void> Async([](void*) -> void {
+            // no-op
+        });
+    }
+
     {
         struct TempCtx {
             uint32_t Value;
-        } TempCtx = { 0 };
-        CxPlatAsync Async([](void* Ctx) -> void* {
-            struct TempCtx* TempCtx = (struct TempCtx*)Ctx;
-            TempCtx->Value = 123;
-            return nullptr;
-        }, &TempCtx);
+        } Ctx = { 0 };
+        CxPlatAsyncT<TempCtx> Async([](TempCtx* Ctx) -> void {
+            Ctx->Value = 123;
+        }, &Ctx);
         Async.Wait();
-        TEST_EQUAL(123, TempCtx.Value);
-    }   
+        TEST_EQUAL(123, Ctx.Value);
+    }
 
     {
         CXPLAT_THREAD_ID ThreadId = INITIAL_THREAD_ID_VALUE;
-        CxPlatAsync Async([](void* Ctx) -> void* {
-            CXPLAT_THREAD_ID* ThreadId = (CXPLAT_THREAD_ID*)Ctx;
-            *ThreadId = CxPlatCurThreadID();
-            return (void*)(intptr_t)(*ThreadId);
+        CxPlatAsyncT<CXPLAT_THREAD_ID,CXPLAT_THREAD_ID> Async([](CXPLAT_THREAD_ID* Ctx) -> CXPLAT_THREAD_ID {
+            *Ctx = CxPlatCurThreadID();
+            return *Ctx;
         }, &ThreadId);
 
         Async.Wait();
-        TEST_EQUAL((CXPLAT_THREAD_ID)((intptr_t)Async.Get()), ThreadId);
+        TEST_EQUAL(Async.Get(), ThreadId);
         TEST_NOT_EQUAL(INITIAL_THREAD_ID_VALUE, ThreadId);
     }
 
 #if defined(CX_PLATFORM_WINUSER) || defined(CX_PLATFORM_WINKERNEL)
     {
-        CxPlatAsync Async([](void*) -> void* {
-            CxPlatSleep(2000);   
-            return (void*)(intptr_t)(0xdeadbeaf);
+        CxPlatAsyncT<void,intptr_t> Async([](void*) -> intptr_t {
+            CxPlatSleep(2000);
+            return (intptr_t)(0xdeadbeaf);
         });
 
         TEST_FALSE(Async.WaitFor(50));
-        TEST_EQUAL(Async.Get(), nullptr);
+        TEST_EQUAL(Async.Get(), 0);
         Async.Wait();
-        TEST_NOT_EQUAL(Async.Get(), nullptr);
+        TEST_NOT_EQUAL(Async.Get(), 0);
     }
 #endif
 }