flake parts
This commit is contained in:
285
src/include/utils/App/App.h
Normal file
285
src/include/utils/App/App.h
Normal file
@@ -0,0 +1,285 @@
|
||||
#ifndef APP_H
|
||||
#define APP_H
|
||||
|
||||
#include "pch.hpp"
|
||||
#include "utils/Module/Module.h"
|
||||
#include "utils/Events/Event.h"
|
||||
|
||||
namespace Archimedes {
|
||||
|
||||
class App {
|
||||
|
||||
public:
|
||||
App() {
|
||||
if(instance != nullptr) {
|
||||
std::cout << "App already exists\nThere can only be one!\n";
|
||||
std::abort();
|
||||
}
|
||||
instance = this;
|
||||
roInsert = runOrder.begin();
|
||||
|
||||
registerEvent(AnonymousEvent());
|
||||
|
||||
registerEvent(DoLoadModuleEvent());
|
||||
registerEvent(DoUnloadModuleEvent());
|
||||
|
||||
registerEvent(LoadModuleEvent());
|
||||
registerEvent(UnloadModuleEvent());
|
||||
}
|
||||
|
||||
virtual ~App() {
|
||||
|
||||
unregisterEvent(AnonymousEvent());
|
||||
|
||||
unregisterEvent(DoLoadModuleEvent());
|
||||
unregisterEvent(DoUnloadModuleEvent());
|
||||
|
||||
unregisterEvent(LoadModuleEvent());
|
||||
unregisterEvent(UnloadModuleEvent());
|
||||
|
||||
for(std::string s : runOrder) {
|
||||
void* handle = modules[s]->getHandle();
|
||||
delete modules[s];
|
||||
if(handle)
|
||||
dlclose(handle);
|
||||
modules[s] = nullptr;
|
||||
}
|
||||
runOrder.clear();
|
||||
}
|
||||
|
||||
|
||||
static App* Get() { return instance; }
|
||||
|
||||
std::list<std::string> getModuleNames() const { return runOrder; }
|
||||
|
||||
virtual void handleArgs(const int&, char*[]) = 0;
|
||||
|
||||
virtual void run() = 0;
|
||||
|
||||
|
||||
void end() { done = true; }
|
||||
|
||||
bool isDone() const { return done; }
|
||||
|
||||
void emitEvent(Event* e) { events.push_back(e); }
|
||||
|
||||
unsigned int getEventType(std::string event) { return eventTypes[event]; }
|
||||
|
||||
void registerEvent(std::string type) {
|
||||
//only add each type once
|
||||
if(eventTypes.find(type) == eventTypes.end())
|
||||
eventTypes[type] = nextEventType++;
|
||||
}
|
||||
|
||||
void unregisterEvent(std::string type) {
|
||||
//only erase registered types
|
||||
auto it = eventTypes.find(type);
|
||||
if(it != eventTypes.end())
|
||||
eventTypes.erase(it);
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
std::list<std::string>::iterator roInsert;
|
||||
|
||||
inline static App* instance = nullptr;
|
||||
|
||||
unsigned int nextEventType = 0;
|
||||
protected:
|
||||
|
||||
bool done = false;
|
||||
|
||||
std::unordered_map<std::string, Module*> modules;
|
||||
std::unordered_map<std::string, unsigned int> eventTypes;
|
||||
|
||||
std::list<Event*> events;
|
||||
|
||||
std::list<std::string> runOrder;
|
||||
|
||||
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& event) = 0;
|
||||
|
||||
void handleEvents() {
|
||||
static bool handled;
|
||||
|
||||
while(!events.empty()) {
|
||||
|
||||
handled = false;
|
||||
|
||||
for(auto it = runOrder.rbegin(); it != runOrder.rend(); it++) {
|
||||
|
||||
handled = modules[*it]->onEvent(*events.front());
|
||||
|
||||
if(handled) {
|
||||
Event* e = events.front();
|
||||
events.pop_front();
|
||||
delete e;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if(!handled) {
|
||||
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;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
virtual Module* dynamicLoad(std::string lib) {
|
||||
|
||||
void* h = dlopen(lib.c_str(), RTLD_NOW);
|
||||
|
||||
if(!h) {
|
||||
std::cout << "could not open lib at: \"" << lib.c_str() << "\"\nError: " << dlerror() << std::endl;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
Module::create_t* create = (Module::create_t*) dlsym(h, "create");
|
||||
char* err = dlerror();
|
||||
if(err) {
|
||||
std::cout << "error finding create function in file: " << lib << std::endl;
|
||||
std::cout << "dlerror(): " << err << std::endl;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return create(Get(), h);
|
||||
}
|
||||
|
||||
virtual Module* reload(std::string lib) {
|
||||
|
||||
for(std::string s : runOrder) {
|
||||
if(s == lib) {
|
||||
return modules[lib];
|
||||
}
|
||||
}
|
||||
|
||||
return modules.find(lib) != modules.end() ? load(modules[lib]) : nullptr;
|
||||
}
|
||||
|
||||
virtual Module* load(std::string moduleNameOrPath) {
|
||||
Module* m = dynamicLoad(moduleNameOrPath);
|
||||
//return m != nullptr ? load(m) : reload(moduleNameOrPath);
|
||||
return load(m);
|
||||
}
|
||||
|
||||
virtual Module* load(Module* m) {
|
||||
|
||||
if(!m) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void* h = m->getHandle();
|
||||
for(auto it = runOrder.begin(); it != runOrder.end(); it++) {
|
||||
if(*it == static_cast<std::string>(*m)) {
|
||||
std::cout << "Module \"" << *it << "\" is already loaded!\n";
|
||||
delete m;
|
||||
if(h) {
|
||||
dlclose(h);
|
||||
}
|
||||
return modules[*it];
|
||||
}
|
||||
}
|
||||
|
||||
if(modules.find(*m) == modules.end())
|
||||
modules[*m] = m;
|
||||
|
||||
for(auto it = runOrder.begin(); it != runOrder.end(); it++) {
|
||||
|
||||
if(m->deps.find(*it) != m->deps.end()) {
|
||||
m->moduleInstances[*it] = modules[*it];
|
||||
//modules should be located after their dependencies
|
||||
if(std::distance(roInsert, it) <= 0) {
|
||||
roInsert = ++it--;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//insert temporarily to avoid circular dependencies
|
||||
runOrder.insert(roInsert, *m);
|
||||
|
||||
bool skip = false;
|
||||
for(auto it : m->deps) {
|
||||
for(auto s : runOrder) {
|
||||
if(s == it.first) {
|
||||
skip = true;
|
||||
m->moduleInstances[s] = modules[s];
|
||||
}
|
||||
}
|
||||
|
||||
if(skip)
|
||||
continue;
|
||||
|
||||
if(std::holds_alternative<std::string>(it.second))
|
||||
m->moduleInstances[it.first] = load(std::get<std::string>(it.second));
|
||||
else
|
||||
m->moduleInstances[it.first] = load(std::get<Module*>(it.second));
|
||||
}
|
||||
|
||||
//reinsert once final order has been reached
|
||||
runOrder.remove(*m);
|
||||
|
||||
runOrder.insert(roInsert, *m);
|
||||
|
||||
emitEvent(new LoadModuleEvent(*m));
|
||||
|
||||
return m;
|
||||
}
|
||||
|
||||
virtual void unload(std::string name) {
|
||||
|
||||
if(modules.find(name) == modules.end())
|
||||
return;
|
||||
|
||||
Module* m = modules[name];
|
||||
void* h = m->getHandle();
|
||||
|
||||
modules[name] = nullptr;
|
||||
modules.erase(name);
|
||||
|
||||
runOrder.remove(name);
|
||||
|
||||
if(h) {
|
||||
//don't dlclose if other modules are still in runOrder!
|
||||
bool closable = true;
|
||||
for(auto s = runOrder.begin(); s != runOrder.end(); s++) {
|
||||
if(modules[*s]->getHandle() == h) {
|
||||
closable = false;
|
||||
}
|
||||
}
|
||||
|
||||
delete m;
|
||||
|
||||
if(closable) {
|
||||
dlclose(h);
|
||||
}
|
||||
}
|
||||
|
||||
emitEvent(new UnloadModuleEvent(name));
|
||||
}
|
||||
|
||||
virtual void printHelp() = 0;
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user