chatGPT - EventDispatcher C++ seems to work, needs more testing

chatGPT - EventDispatcher C++14/.vs/chatGPT - EventDispatcher C++14/v17/DocumentLayout.backup.json

@@ -13,7 +13,7 @@
       "VerticalTabListWidth": 256,
       "DocumentGroups": [
         {
-          "DockedWidth": 305,
+          "DockedWidth": 155,
           "SelectedChildIndex": 0,
           "Children": [
             {
@@ -24,7 +24,7 @@
               "RelativeDocumentMoniker": "chatGPT - EventDispatcher C\u002B\u002B14\\chatGPT - EventDispatcher C\u002B\u002B14.cpp",
               "ToolTip": "C:\\Users\\sfreunde\\source\\repos\\chatGPT - EventDispatcher C\u002B\u002B14\\chatGPT - EventDispatcher C\u002B\u002B14\\chatGPT - EventDispatcher C\u002B\u002B14.cpp",
               "RelativeToolTip": "chatGPT - EventDispatcher C\u002B\u002B14\\chatGPT - EventDispatcher C\u002B\u002B14.cpp",
-              "ViewState": "AgIAAJ0AAAAAAAAAAAAAAKcAAAApAAAAAAAAAA==",
+              "ViewState": "AgIAAGUBAAAAAAAAAAAAAHMBAAAFAAAAAAAAAA==",
               "Icon": "ae27a6b0-e345-4288-96df-5eaf394ee369.000677|",
               "WhenOpened": "2025-05-06T14:11:43.253Z",
               "EditorCaption": ""

chatGPT - EventDispatcher C++14/.vs/chatGPT - EventDispatcher C++14/v17/DocumentLayout.json

@@ -13,7 +13,7 @@
       "VerticalTabListWidth": 256,
       "DocumentGroups": [
         {
-          "DockedWidth": 305,
+          "DockedWidth": 155,
           "SelectedChildIndex": 0,
           "Children": [
             {
@@ -24,7 +24,7 @@
               "RelativeDocumentMoniker": "chatGPT - EventDispatcher C\u002B\u002B14\\chatGPT - EventDispatcher C\u002B\u002B14.cpp",
               "ToolTip": "C:\\Users\\sfreunde\\source\\repos\\chatGPT - EventDispatcher C\u002B\u002B14\\chatGPT - EventDispatcher C\u002B\u002B14\\chatGPT - EventDispatcher C\u002B\u002B14.cpp",
               "RelativeToolTip": "chatGPT - EventDispatcher C\u002B\u002B14\\chatGPT - EventDispatcher C\u002B\u002B14.cpp",
-              "ViewState": "AgIAAKUAAAAAAAAAAAAmwLAAAAAAAAAAAAAAAA==",
+              "ViewState": "AgIAAGUBAAAAAAAAAAAAAIABAAA2AAAAAAAAAA==",
               "Icon": "ae27a6b0-e345-4288-96df-5eaf394ee369.000677|",
               "WhenOpened": "2025-05-06T14:11:43.253Z",
               "EditorCaption": ""

chatGPT - EventDispatcher C++14/chatGPT - EventDispatcher C++14/chatGPT - EventDispatcher C++14.cpp

@@ -7,24 +7,10 @@
 #include <memory>
 #include <typeindex>
 
-#include <iostream>
-#include <vector>
-#include <functional>
-#include <memory>
 #include <typeinfo>
-#include <typeindex>
 #include <tuple>
 #include <stdexcept>
-#include <algorithm>
-
-#include <iostream>
-#include <functional>
 #include <unordered_map>
-#include <vector>
-#include <tuple>
-#include <typeindex>
-#include <string>
-#include <algorithm>
 #include <cassert>
 
 enum class EventType {
@@ -56,6 +42,8 @@ public:
             vec.end());
     }
 
+
+#if 0
     // Emit: returns vector of return values from all handlers of matching type/signature
     template<typename R = void, typename... Args>
     std::vector<R> emit(EventType type, Args&&... args) {
@@ -72,10 +60,70 @@ public:
                         results.push_back(handler->func(std::forward<Args>(args)...));
                     }
                 }
+                // std::cout << "Error handler NULL" << std::endl; 
             }
         }
         return results;
     }
+#else
+    template<typename R = void, typename... Args>
+    std::vector<R> emit(EventType type, Args&&... args) {
+        // Log Args... information
+        // std::cout << "Args... types: ";
+		// printArgs<Args...>();
+        // std::cout << std::endl;
+
+        std::vector<R> results;
+        auto it = handlers.find(type);
+        if (it != handlers.end()) {
+            for (auto& handlerBase : it->second) {
+                std::cout << "\n------------------------- emit ------------------------" << std::endl;
+				if (std::is_void<R>::value) {
+					std::cout << "Handler is void" << std::endl;
+                    // Call handlers with a void return type
+                    auto handler = dynamic_cast<Handler<void, Args...>*>(handlerBase.get());
+                    std::cout << "Dynamic cast result (void): " << handler << std::endl;
+                    if (handler) {
+                        handler->func(std::forward<Args>(args)...);
+                    }
+				}
+				else {
+					std::cout << "Handler is not void" << std::endl;
+                    // Call handlers with a non-void return type
+                    auto handler = dynamic_cast<Handler<R, Args...>*>(handlerBase.get());
+                    // Add debug information to identify the type mismatch issue in dynamic_cast
+                    if (!handler) {
+                        std::cerr << "Dynamic cast failed. Handler is NULL. Possible type mismatch or invalid handler." << std::endl;
+                        std::cerr << "Expected Handler type: " << typeid(Handler<R, Args...>).name() << std::endl;
+                        std::cerr << "Actual HandlerBase type: " << typeid(*handlerBase).name() << std::endl;
+                        std::cerr << "HandlerBase pointer: " << handlerBase.get() << std::endl;
+                        std::cerr << "Args... types: ";
+                        printArgs<Args...>();
+                        std::cerr << std::endl;
+                    }
+
+                    std::cout << "Dynamic cast result (non-void): " << handler << std::endl;
+                    if (handler) {
+                        results.push_back(handler->func(std::forward<Args>(args)...));
+                    }
+                }
+            }
+		}
+		else {
+			std::cout << "No handlers found for EventType: " << static_cast<int>(type) << std::endl;
+		}
+        return results;
+    }
+#endif 
+
+    template<typename... Args>
+    void printArgs() {
+        using expander = int[];
+        (void)expander {
+            0, (std::cout << typeid(Args).name() << " ", 0)...
+        };
+    }
+
 
 private:
     struct HandlerBase {
@@ -121,30 +169,184 @@ private:
         using ArgsTuple = std::tuple<Args...>;
     };
 
-    // Implementation: avoid constructing tuple-of-references!
+    template<EventType T>
+    struct HandlerTraits;
+
+    // Specialize HandlerTraits for each EventType to define the expected return type.
+    template<>
+    struct HandlerTraits<EventType::Click> {
+        using ReturnType = bool; // Example: Click events return bool.
+        using ArgsTuple = std::tuple<int>; // Example: Click events take an int argument.
+    };
+
+    template<>
+    struct HandlerTraits<EventType::Hover> {
+        using ReturnType = bool; // Example: Hover events return bool.
+        using ArgsTuple = std::tuple<std::string>; // Example: Hover events take a string argument.
+    };
+
+    template<>
+    struct HandlerTraits<EventType::Custom> {
+        using ReturnType = void; // Example: Custom events return void.
+        using ArgsTuple = std::tuple<>; // Example: Custom events take no arguments.
+    };
+
     template<typename R, typename F, typename... Args>
     HandlerID addHandlerImpl(EventType type, F&& f, std::tuple<Args...>*) {
-        auto handler = std::make_unique<Handler<R, Args...>>(nextHandlerID, std::function<R(Args...)>(std::forward<F>(f)));
+        // Explicitly construct std::function with the correct return type
+        auto func = std::function<R(Args...)>(std::forward<F>(f));
+        if (!func) {
+            std::cerr << "Error: std::function construction failed!" << std::endl;
+        }
+
+        auto handler = std::make_unique<Handler<R, Args...>>(nextHandlerID, func);
+        std::cout << "\n-------------------- AddHandlerImp --------------------" << std::endl;
+        std::cout << "Args... types: ";
+        printArgs<Args...>();
+        std::cout << std::endl;
+        std::cerr << "Expected Handler type: " << typeid(Handler<R, Args...>).name() << std::endl;
+        std::cerr << "Actual HandlerBase type: " << typeid(*handler).name() << std::endl;
+        std::cerr << "HandlerBase pointer: " << handler.get() << std::endl;
         handlers[type].emplace_back(std::move(handler));
         return nextHandlerID++;
     }
+
+#if 0
+    // Implementation: avoid constructing tuple-of-references!
+       template<typename R, typename F, typename... Args>
+       HandlerID addHandlerImpl(EventType type, F&& f, std::tuple<Args...>*) {
+           // To resolve the issues, you need to define the `HandlerTraits` struct.  
+           // Below is the corrected code with the `HandlerTraits` definition added.
+           // Now the original code will work as expected.
+           //using ExpectedReturnType = typename HandlerTraits<EventType>::ReturnType;
+           //static_assert(std::is_same<R, ExpectedReturnType>::value,
+           //    "Handler return type does not match the expected return type for this event type.");
+
+           // using ExpectedReturnType = typename HandlerTraits<EventType::Click>::ReturnType; // Default to Click
+
+
+           // Validate return type
+           //static_assert(std::is_same<R, ExpectedReturnType>::value,
+           //    "Handler return type does not match the expected return type for this event type.");
+
+           // Ensure the type is correctly cast to EventType
+           // static_assert(std::is_enum<EventType>::value, "EventType must be an enum.");
+           auto eventType = static_cast<EventType>(static_cast<int>(type));
+//		   std::cout << "EventType: " << eventTypeToString(type) << std::endl;
+//           std::cerr << "Args... types: ";
+//           printArgs<Args...>();
+//           std::cerr << std::endl;
+
+
+
+           auto func = std::function<R(Args...)>(std::forward<F>(f));
+           if (!func) {
+               std::cerr << "Error: std::function construction failed!" << std::endl;
+           }
+          
+           // Diagnostic information for type mismatch
+           // using ExpectedReturnType = typename HandlerTraits<EventType::Click>::ReturnType;
+           // using ExpectedReturnType = typename HandlerTraits< static_cast<EventType>(type) > ::ReturnType;
+            
+           // std::cout << "Expected Return Type: " << ExpectedReturnType << std::endl;
+           // Replace the problematic line with the following code to fix the issue:
+           // std::cout << "Expected Return Type: " << typeid(ExpectedReturnType).name() << std::endl;
+          // static_assert(std::is_same<R, ExpectedReturnType>::value,
+          //     "Handler return type does not match the expected return type for this event type.");
+
+    #if 0
+           // Diagnostic information for type mismatch
+           if (!std::is_same<R, typename HandlerTraits<type>::ReturnType>::value) {
+               std::cerr << "Type mismatch detected in addHandlerImpl!" << std::endl;
+               std::cerr << "Expected return type: " << typeid(typename HandlerTraits<static_cast<EventType>(type)>::ReturnType).name() << std::endl;
+               std::cerr << "Provided return type: " << typeid(R).name() << std::endl;
+           }
+    #endif 
+           // std::cerr << "Type mismatch detected in addHandlerImpl!" << std::endl;
+           // std::cerr << "Expected return type: " << typeid(typename HandlerTraits<static_cast<EventType>(type)>::ReturnType).name() << std::endl;
+           //std::cerr << "Expected return type: " << typeid(ExpectedReturnType).name() << std::endl;
+           //std::cerr << "Provided return type: " << typeid(R).name() << std::endl;
+           //std::cout << "Adding handler with callable type: " << typeid(F).name() << std::endl;
+
+           auto handler = std::make_unique<Handler<R, Args...>>(nextHandlerID, func);
+           std::cout << "\n-------------------- AddHandlerImp --------------------" << std::endl; 
+           std::cout << "Args... types: ";
+           printArgs<Args...>();
+           std::cout << std::endl;
+           std::cerr << "Expected Handler type: " << typeid(Handler<R, Args...>).name() << std::endl;
+           std::cerr << "Actual HandlerBase type: " << typeid(*handler).name() << std::endl;
+           std::cerr << "HandlerBase pointer: " << handler.get() << std::endl;
+           handlers[eventType].emplace_back(std::move(handler));
+           return nextHandlerID++;
+       }
+
+       std::string eventTypeToString(EventType type) {
+           switch (type) {
+           case EventType::Click: return "Click";
+           case EventType::Hover: return "Hover";
+           case EventType::Custom: return "Custom";
+           default: return "Unknown";
+           }
+       }
+ //       std::cerr << "Provided return type: " << typeid(R).name() << std::endl;
+ //       std::cout << "Adding handler with callable type: " << typeid(F).name() << std::endl;
+
+ //       auto handler = std::make_unique<Handler<R, Args...>>(nextHandlerID, std::function<R(Args...)>(std::forward<F>(f)));
+ //       handlers[type].emplace_back(std::move(handler));
+ //       return nextHandlerID++;
+ //   }
+#endif
+
+#if 0
+
+    // Implementation: avoid constructing tuple-of-references!
+    template<typename R, typename F, typename... Args>
+    HandlerID addHandlerImpl(EventType type, F&& f, std::tuple<Args...>*) {
+        // Ensure the type is correctly cast to EventType
+        static_assert(std::is_enum<EventType>::value, "EventType must be an enum.");
+        auto eventType = static_cast<EventType>(type);
+
+        // Correctly construct the std::function to avoid moving from a temporary
+        auto func = std::function<R(Args...)>(f);
+        if (!func) {
+            std::cerr << "Error: std::function construction failed!" << std::endl;
+        }
+
+        // Diagnostic information for type mismatch
+        using ExpectedReturnType = typename HandlerTraits<eventType>::ReturnType;
+        static_assert(std::is_same<R, ExpectedReturnType>::value,
+            "Handler return type does not match the expected return type for this event type.");
+
+        std::cerr << "Expected return type: " << typeid(ExpectedReturnType).name() << std::endl;
+        std::cerr << "Provided return type: " << typeid(R).name() << std::endl;
+        std::cout << "Adding handler with callable type: " << typeid(F).name() << std::endl;
+
+        auto handler = std::make_unique<Handler<R, Args...>>(nextHandlerID, func);
+        handlers[eventType].emplace_back(std::move(handler));
+        return nextHandlerID++;
+    }
+#endif
 };
 
 struct Widget {
-    void onClick(int x) {
+    bool onClick(int x) {
         std::cout << "Widget::onClick(" << x << ")\n";
+        return true; 
     }
 
-    void onClick_1(int x) {
+    bool onClick_1(int x) {
         std::cout << "Widget::onClick_1(" << x << ")\n";
+        return false;
     }
 
-    void onClick_2(int x) {
+    bool onClick_2(int x) {
         std::cout << "Widget::onClick_2(" << x << ")\n";
+		return false;
     }
 
-    void onClick_3(int x) {
+    bool onClick_3(int x) {
         std::cout << "Widget::onClick_2(" << x << ")\n";
+        return true; 
     }
 
     bool onHover(const std::string& msg) {
@@ -154,45 +356,74 @@ struct Widget {
 };
 
 bool globalHandler(int x) {
-    std::cout << "globalHandler(" << x << ")\n";
+    std::cout << "free standing globalHandler(" << x << ") return: true\n";
     return x > 0;
 }
 
+bool globalHandler1(int x) {
+    std::cout << "free standing globalHandler_1(" << x << ") return: false\n";
+    return x < 0;
+}
+
+
 int main() {
     EventDispatcher dispatcher;
     Widget w;
-
+#if 1
     // Register handlers and keep their IDs for removal
+	std::cout << "Click Handler registered ...\n" << std::endl;
     auto id1 = dispatcher.addHandler(EventType::Click, globalHandler);
+    auto id1_1 = dispatcher.addHandler(EventType::Click, globalHandler1);
 
     auto id2 = dispatcher.addHandler(EventType::Click, [](int x) {
-        std::cout << "lambda(" << x << ")\n";
+        std::cout << "function lambda(" << x << ") return true\n";
         return x % 2 == 0;
         });
-    auto id3 = dispatcher.addHandler(EventType::Click, [&w](int x) { w.onClick(x); });
-    dispatcher.addHandler(EventType::Click, [&w](int x) { w.onClick_1(x); });    
-    dispatcher.addHandler(EventType::Click, [&w](int x) { w.onClick_2(x); });
-    dispatcher.addHandler(EventType::Click, [&w](int x) { w.onClick_3(x); });
 
-    auto id4 = dispatcher.addHandler(EventType::Hover, [&w](const std::string& msg) { return w.onHover(msg); });
-
-    // Emit events; collect return values if any
     auto clickResults = dispatcher.emit<bool>(EventType::Click, 42);
-    auto hoverResults = dispatcher.emit<bool>(EventType::Hover, std::string("hello"));
-
     std::cout << "Click results: ";
     for (bool b : clickResults) std::cout << b << " ";
     std::cout << "\n";
 
+    dispatcher.removeHandler(EventType::Click, id2);
+    dispatcher.removeHandler(EventType::Click, id1);
+    dispatcher.removeHandler(EventType::Click, id1_1);
+
+#endif
+
+	std::cout << "------------------------------------------------------------" << std::endl;
+    std::cout << "New Click Handler registered ... (onClick, onClick_1, onClick_2, onClick_3)" << std::endl;
+    auto id3 = dispatcher.addHandler(EventType::Click, [&w](int x) { w.onClick(x); });
+    dispatcher.addHandler(EventType::Click, [&w](int x) -> bool { return w.onClick_1(x); });    
+    dispatcher.addHandler(EventType::Click, [&w](int x) -> bool { return w.onClick_2(x); });
+    dispatcher.addHandler(EventType::Click, [&w](int x) -> bool { return w.onClick_3(x); });
+
+    // Emit events; collect return values if any
+    auto clickResults_1 = dispatcher.emit<bool>(EventType::Click, 24);
+    std::cout << "Click results: ";
+    if (clickResults_1.size() == 0)
+		std::cout << "Error" << std::endl;
+    for (bool b : clickResults_1) std::cout << b << " ";
+    std::cout << "\n";
+
+    std::cout << "------------------------------------------------------------" << std::endl;
+    std::cout << "Hover Handler registered ...\n" << std::endl;
+    auto id4 = dispatcher.addHandler(EventType::Hover, [&w](const std::string& msg) { return w.onHover(msg); });
+    auto hoverResults = dispatcher.emit<bool>(EventType::Hover, std::string("hello"));
+
     std::cout << "Hover results: ";
     for (bool b : hoverResults) std::cout << b << " ";
     std::cout << "\n";
 
+
     // Remove a handler and emit again
-    dispatcher.removeHandler(EventType::Click, id1);
-    clickResults = dispatcher.emit<bool>(EventType::Click, 7);
+    std::cout << "------------------------------------------------------------" << std::endl;
+    std::cout << "Remove Handler Click ID 1 ...\n" << std::endl;
+
+//    dispatcher.removeHandler(EventType::Click, id1);
+//    clickResults = dispatcher.emit<bool>(EventType::Click, 7);
     std::cout << "Click results after removal: ";
-    for (bool b : clickResults) std::cout << b << " ";
+//    for (bool b : clickResults) std::cout << b << " ";
     std::cout << "\n";
 }
 

chatGPT - EventDispatcher C++14/chatGPT - EventDispatcher C++14/x64/Debug/chatGPT - EventDispatcher C++14.Build.CppClean.log

@@ -0,0 +1,11 @@
+c:\users\sfreunde\source\repos\chatgpt - eventdispatcher c++14\x64\debug\chatgpt - eventdispatcher c++14.exe
+c:\users\sfreunde\source\repos\chatgpt - eventdispatcher c++14\x64\debug\chatgpt - eventdispatcher c++14.pdb
+c:\users\sfreunde\source\repos\chatgpt - eventdispatcher c++14\chatgpt - eventdispatcher c++14\x64\debug\chatgpt - eventdispatcher c++14.ilk
+c:\users\sfreunde\source\repos\chatgpt - eventdispatcher c++14\chatgpt - eventdispatcher c++14\x64\debug\vc143.idb
+c:\users\sfreunde\source\repos\chatgpt - eventdispatcher c++14\chatgpt - eventdispatcher c++14\x64\debug\vc143.pdb
+c:\users\sfreunde\source\repos\chatgpt - eventdispatcher c++14\chatgpt - eventdispatcher c++14\x64\debug\chatgpt .742afb35.tlog\cl.command.1.tlog
+c:\users\sfreunde\source\repos\chatgpt - eventdispatcher c++14\chatgpt - eventdispatcher c++14\x64\debug\chatgpt .742afb35.tlog\cl.items.tlog
+c:\users\sfreunde\source\repos\chatgpt - eventdispatcher c++14\chatgpt - eventdispatcher c++14\x64\debug\chatgpt .742afb35.tlog\link.command.1.tlog
+c:\users\sfreunde\source\repos\chatgpt - eventdispatcher c++14\chatgpt - eventdispatcher c++14\x64\debug\chatgpt .742afb35.tlog\link.read.1.tlog
+c:\users\sfreunde\source\repos\chatgpt - eventdispatcher c++14\chatgpt - eventdispatcher c++14\x64\debug\chatgpt .742afb35.tlog\link.secondary.1.tlog
+c:\users\sfreunde\source\repos\chatgpt - eventdispatcher c++14\chatgpt - eventdispatcher c++14\x64\debug\chatgpt .742afb35.tlog\link.write.1.tlog

chatGPT - EventDispatcher C++14/chatGPT - EventDispatcher C++14/x64/Debug/chatGPT - EventDispatcher C++14.log

@@ -1,6 +1,2 @@
   chatGPT - EventDispatcher C++14.cpp
-C:\Users\sfreunde\source\repos\chatGPT - EventDispatcher C++14\chatGPT - EventDispatcher C++14\chatGPT - EventDispatcher C++14.cpp(68,21): warning C4984: 'if constexpr' is a C++17 language extension
-      C:\Users\sfreunde\source\repos\chatGPT - EventDispatcher C++14\chatGPT - EventDispatcher C++14\chatGPT - EventDispatcher C++14.cpp(61,20):
-      This diagnostic occurred in the compiler generated function 'std::vector<R,std::allocator<_Ty>> EventDispatcher::emit(EventType,Args ...)'
-  
   chatGPT - EventDispatcher C++14.vcxproj -> C:\Users\sfreunde\source\repos\chatGPT - EventDispatcher C++14\x64\Debug\chatGPT - EventDispatcher C++14.exe