Did some hackypooos for Jtest 3

include/Base.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <functional>
+
+//template< class RT, class CallableT, class... ArgTypes >
+template<class CallableT, class... ArgTypes >
+class Callable {
+    static_assert(std::is_invocable_v<CallableT(ArgTypes...)>);
+    using invoke = CallableT;
+public:
+    invoke;
+    //CallableT invoke = CallableT();
+    //ArgTypes... args
+    //invoke() { /*return CallableT(args...);*/ return CallableT(RT()); }
+};
+
+template< class R, class Fn, class... ArgTypes >
+class Cunt {
+    static_assert(std::is_invocable_r_v<R, Fn, ArgTypes...>);
+};
+
+
+
+
+template< class RT, class... ArgTypes>
+class EventBase {
+public:
+    //using delegate = CallableT;
+    using delegate = std::function<RT(ArgTypes...)>;
+public:
+    RT Invoke(ArgTypes... args);
+    RT operator()(ArgTypes... args);
+protected:
+    delegate callback;
+
+};
+
+
+};
+

include/Event.h

@@ -25,18 +25,19 @@ class Connection;
 template <typename delegate, typename ... Args>
 class BasicEvent {
 public:
+    friend Connection<delegate, Args ...>;
     using connection = Connection<delegate, Args ...>;
     using event_ptr = std::shared_ptr<connection>;
 public:
     void Await(Args& ... arg);
-    void Invoke(Args... args);
+    virtual void Invoke(Args... args);
     void operator()(Args... args);
     connection Connect(delegate callback);
     void Disconnect(connection &conn);
     connection operator+=(delegate callback);
-private:
+protected:
     std::vector<event_ptr> listeners;
-    uint64_t listenerCounter = 0;
+    //uint64_t listenerCounter = 0;
 };
 
 template<typename delegate, typename... Args>

include/EventConnection.h

@@ -16,14 +16,19 @@ class BasicEvent;
 /// A type that represents a handle to an active event connection.
 template <typename delegate, typename ... Args>
 class Connection {
-private:
+public:
+    friend BasicEvent<delegate, Args...>;
 public:
     Connection(BasicEvent<delegate, Args...> *creator, delegate cb);
     bool Disconnect(); // Breaks the event connection, but does not destroy the instance
     void Invoke(Args... e);
+public:
+    // Fuck it make this public
+    // Don't be stupid!!
+    delegate callback;
 private:
     BasicEvent<delegate, Args...> * owner;
-    delegate callback;
+    //delegate callback;
     bool active = true;
 };