yeah you close

include/utils/App/App.h

@@ -15,17 +15,19 @@ namespace Archimedes {
                     std::abort();
                 }
                 instance = this;
+                roInsert = runOrder.begin();
             }
 
             virtual ~App() {
 
-                for(auto it = modules.begin(); it != modules.end(); it++) {
-                    void* handle = (*it)->getHandle();
-                    delete *it;
+                for(std::string s : runOrder) {
+                    void* handle = modules[s]->getHandle();
+                    delete modules[s];
                     if(handle)
                         dlclose(handle);
-                    it = modules.erase(it);
+                    modules[s] = nullptr;
                 }
+                runOrder.clear();
             }
 
 
@@ -35,7 +37,7 @@ namespace Archimedes {
             
             virtual void run() = 0;
 
-            virtual void stopModule(std::list<Module*>::iterator it) { toClose.push_back(*it); }
+            virtual void stopModule(std::string lib) { toClose.push_back(lib); }
 
             virtual void startModule(std::string lib) { toOpen.push_back(lib); }
 
@@ -43,6 +45,8 @@ namespace Archimedes {
 
         private:
 
+            std::list<std::string>::iterator roInsert;
+        
             inline static App* instance = nullptr;
         
         protected:
@@ -52,7 +56,7 @@ namespace Archimedes {
             std::unordered_map<std::string, Module*> modules;
             std::list<std::string> runOrder;
 
-            std::list<Module*> toClose;
+            std::list<std::string> toClose;
             std::list<std::string> toOpen;
 
             virtual Module* dynamicLoad(std::string lib) {
@@ -75,12 +79,12 @@ namespace Archimedes {
                 return create(h, Get());
             }
 
-            virtual Module* load(std::string modulePath, std::list<std::string>::iterator ins) {
+            virtual Module* load(std::string modulePath) {
                 Module* m = dynamicLoad(modulePath);
-                return load(m, ins);
+                return load(m);
             }
             
-            virtual Module* load(Module* m, std::list<std::string>::iterator ins) {
+            virtual Module* load(Module* m) {
 
                 if(!m) {
                     return nullptr;
@@ -97,36 +101,51 @@ namespace Archimedes {
                     }
                 }
 
-                bool skip = false;
+                modules[m->getName()] = m;
+
                 for(auto it = runOrder.begin(); it != runOrder.end(); it++) {
 
                     if(m->deps.find(*it) != m->deps.end()) {
-                        skip = true;
                         m->depsInstances[*it] = modules[*it];
+                        //modules should be located after their dependencies
+                        if(std::distance(roInsert, it) <= 0) {
+                            roInsert = ++it--;
                         }
-                    if(skip) {
-                        skip = false;
-                        continue;
-                    } else {
+                    } 
+                }
+
+                //insert temporarily to avoid circular dependencies
+                runOrder.insert(roInsert, m->getName());
+
+                for(auto it = runOrder.begin(); it != runOrder.end(); it++) {
+
+                    if(m->deps.find(*it) == m->deps.end()) {
                         if(std::holds_alternative<std::string>(m->deps[*it]))
-                            m->depsInstances[*it] = load(std::get<std::string>(m->deps[*it]), ins);
+                            m->depsInstances[*it] = load(std::get<std::string>(m->deps[*it]));
                         else
-                            m->depsInstances[*it] = load(std::get<Module*>(m->deps[*it]), ins);
+                            m->depsInstances[*it] = load(std::get<Module*>(m->deps[*it]));
                     }
                 }
 
+                //reinsert once final order has been reached
+                runOrder.remove(m->getName());
+                
+                runOrder.insert(roInsert, m->getName());
+
                 return m;
             }
 
-            virtual void unload(std::list<Module*>::iterator it) {
-                Module* m = *it;
+            virtual void unload(std::string name) {
+                Module* m = modules[name];
                 void* h = m->getHandle();
 
-                modules.erase(m->self);
+                modules[name] = nullptr;
                 delete m;
                 
                 if(h)
                     dlclose(h);
+
+                runOrder.remove(name);
             }
 
             virtual void printHelp() = 0;

src/example_apps/MinimalApp/MinimalApp.cpp

@@ -2,23 +2,23 @@
 
 void MinimalApp::run() {
 
-    for(auto* m : modules)
-        m->onLoad();
+    for(auto m : runOrder)
+        modules[m]->onLoad();
 
     // Main loop
-    while (!done && !modules.empty()) {
+    while (!done && !runOrder.empty()) {
 
-        for(auto* m : modules) {
-            m->run();
+        for(auto m : runOrder) {
+            modules[m]->run();
         }
 
-        for(auto it = toClose.begin(); it != toClose.end(); it++) {
-            unload(it);
+        for(auto m : toClose) {
+            unload(m);
         }
         toClose.clear();
 
-        for(std::string s : toOpen) {
-            load(s, modules.begin());
+        for(std::string m : toOpen) {
+            load(m);
         }
         toOpen.clear();
     }

src/example_apps/MinimalApp/MinimalApp.h

@@ -14,7 +14,7 @@ class MinimalApp : public Archimedes::App {
         void handleArgs(const int& argc, char* argv[]) {
             if(argc > 1) {
                 for(int i = 1; i < argc; i++)
-                    load(dynamicLoad(argv[i]), modules.begin());
+                    load(dynamicLoad(argv[i]));
             } else {
                 std::cout << "No modules to load\n";
                 end();