introduce active and passive events

include/utils/App/App.h

@@ -17,10 +17,22 @@ namespace Archimedes {
                 }
                 instance = this;
                 roInsert = runOrder.begin();
+
+                registerEvent(DoLoadModuleEvent());
+                registerEvent(DoUnloadModuleEvent());
+
+                registerEvent(LoadModuleEvent());
+                registerEvent(UnloadModuleEvent());
             }
 
             virtual ~App() {
 
+                unregisterEvent(DoLoadModuleEvent());
+                unregisterEvent(DoUnloadModuleEvent());
+
+                unregisterEvent(LoadModuleEvent());
+                unregisterEvent(UnloadModuleEvent());
+
                 for(std::string s : runOrder) {
                     void* handle = modules[s]->getHandle();
                     delete modules[s];
@@ -40,17 +52,6 @@ namespace Archimedes {
             
             virtual void run() = 0;
 
-            virtual void stopModule(std::string lib) { 
-                //unload modules that depend on the one we are unloading
-                for(std::string s : runOrder) {
-                    if(modules[s]->deps.find(lib) != modules[s]->deps.end()) {
-                        stopModule(s);
-                    }
-                }
-                toClose.push_back(lib); 
-            }
-
-            virtual void startModule(std::variant<std::string, Module*> m) { toOpen.push_back(m); }
 
             void end() { done = true; }
 
@@ -94,8 +95,23 @@ namespace Archimedes {
             std::list<std::string> toClose;
             std::list<std::variant<std::string, Module*>> toOpen;
 
+            virtual void stopModule(std::string lib) { 
+                //unload modules that depend on the one we are unloading
+                for(std::string s : runOrder) {
+                    if(modules[s]->deps.find(lib) != modules[s]->deps.end()) {
+                        stopModule(s);
+                    }
+                }
+                toClose.push_back(lib); 
+            }
+
+            virtual void startModule(std::variant<std::string, Module*> m) { toOpen.push_back(m); }
+
+            virtual bool onEvent(const Event&) = 0;
+
             void handleEvents() {
                 static bool handled;                 
+                
                 while(!events.empty()) {
                     
                     handled = false;
@@ -113,7 +129,13 @@ namespace Archimedes {
                     }
 
                     if(!handled) {
-                        std::cout << "Error: Unhandled Event: " << (std::string) *events.front() << std::endl; 
+                        if(this->onEvent(*events.front())) {
+                            Event* e = events.front();
+                            events.pop_front();
+                            delete e;
+                        } else {
+                            std::cout << "Error: Unhandled Event: " << (std::string) *events.front() << std::endl; 
+                        }
                     }
                 }
             }
@@ -212,13 +234,12 @@ namespace Archimedes {
                 
                 runOrder.insert(roInsert, *m);
 
+                emitEvent(new LoadModuleEvent(*m));
                 return m;
             }
 
             virtual void unload(std::string name) {
 
-                std::cout << "Attempting to unload module: " << name << std::endl;
-
                 if(modules.find(name) == modules.end())
                     return;
 
@@ -246,7 +267,7 @@ namespace Archimedes {
                     }
                 }
 
-                std::cout << "Successfully unloaded module: " << name << std::endl;
+                emitEvent(new UnloadModuleEvent(name));
             }
 
             virtual void printHelp() = 0;

include/utils/Events/BasicEvents.h

@@ -0,0 +1,74 @@
+#ifndef BASICEVENTS_H
+#define BASICEVENTS_H
+
+#include "Event.h"
+
+namespace Archimedes {
+
+    class Module;
+
+    class LoadModuleEvent : public Event {
+
+        public:
+
+            LoadModuleEvent() {}
+            
+            LoadModuleEvent(std::string n) : module(n) {}
+
+            ~LoadModuleEvent() {}
+
+            operator std::string() const override { return "LoadModuleEvent"; }
+
+            std::string module;
+
+    };
+
+    class DoLoadModuleEvent : public Event {
+
+        public:
+
+            DoLoadModuleEvent() {}
+            
+            DoLoadModuleEvent(std::variant<std::string, Module*> n) : module(n) {}
+
+            ~DoLoadModuleEvent() {}
+
+            operator std::string() const override { return "DoLoadModuleEvent"; }
+
+            std::variant<std::string, Module*> module;
+
+    };
+ 
+    class UnloadModuleEvent : public Event {
+
+        public:
+            
+            UnloadModuleEvent() {}
+            
+            UnloadModuleEvent(std::string n) : module(n) {}
+
+            ~UnloadModuleEvent() {}
+
+            operator std::string() const override { return "UnloadModuleEvent"; }
+
+            std::string module;
+    };
+    
+    class DoUnloadModuleEvent : public Event {
+
+        public:
+
+            DoUnloadModuleEvent() {}
+            
+            DoUnloadModuleEvent(std::string n) : module(n) {}
+
+            ~DoUnloadModuleEvent() {}
+
+            operator std::string() const override { return "DoUnloadModuleEvent"; }
+
+            std::string module;
+
+    };   
+}
+
+#endif

include/utils/Events/Event.h

@@ -16,4 +16,6 @@ namespace Archimedes {
     };
 }
 
+#include "BasicEvents.h"
+
 #endif