WIP: Work done on EventBus

src/core/ConfigManager.cpp

@@ -13,7 +13,7 @@ ConfigManager::ConfigManager(Logger& logger, vector<string>& parameters) :
 {
     // move this to a function that can return an error code?
     if ( parameters.size() == 0 ) return;
-    _logger.debug.ln("Interpreting Paremters...");
+    _logger.debug.ln ("Loading Configuration...");
     
     /*
     for (unsigned i = 0; i < (numParameters-1); ++i) {
@@ -26,6 +26,8 @@ ConfigManager::ConfigManager(Logger& logger, vector<string>& parameters) :
         }
     }
     */
+
+   _logger.debug.ln ("Configuration successfully parsed");
 }
 
 

src/core/EventBus.cpp

@@ -4,22 +4,44 @@
 namespace Plains {
 namespace Core {
 
-EventBus::EventBus(Logger& logger) : _logger(logger), _thread(&EventBus::run, this) {
-    _logger.debug.ln("Hi from EventBus Constructor. Not Theaded");
+// EventBus Class
+
+EventBus::EventBus(Logger& logger) : _logger(logger) {
+    _logger.debug.ln ("Starting Event Bus...");
+    _thread = thread(&EventBus::run, this);
 }
 
 EventBus::~EventBus() {
     _thread.join();
+    // destroy all events in _events vector
+    _logger.debug.ln ("EventBus has been shut down.");
 }
 
-void EventBus::test() {
-    _logger.debug << "Testing from within EventBus!" << Logger::commit;
+Event* EventBus::registerEvent(const string eventID) {
+    _logger.debug << "Registering new Event " << eventID << Logger::commit;
+    //If event with that id does not exist, create it:
+    Event* event = new Event(eventID);
+    _events.push_back(event);
+    return event;
+}
+
+Event* EventBus::getEvent(const string& eventID) {
+    _logger.debug.ln("Registering new Event...");
+    //Temporarily return nothing:
+    return NULL;
 }
 
 void EventBus::run() {
     _logger.debug.ln("Hi from EventBus run method! From within Event Thread!");
 }
 
+// Event Class
+
+Event::Event(const string id) : _id(id) {}
+
+void Event::subscribe(EventSubscriber* es) { _subscribers.push_back(es); }
+
+
 
 
 }}

src/core/Logger.cpp

@@ -85,7 +85,7 @@ void Logger::Sink::prefixLine(bool resetToFalse) {
             case WARN:  lvlString = "WARN ";  break;
             case FATAL: lvlString = "FATAL"; break;
         }
-        *_parent._output << Logger::genTimeStamp() << " [" << lvlString << "] ";
+        *_parent._output << Logger::genTimeStamp() << " " << lvlString << "  ";
         _lineIsPrefixed = resetToFalse ? false : true;
     }
 }

src/core/include/EventBus.hpp

@@ -2,23 +2,45 @@
 #define EVENT_BUS_HPP
 #include "Logger.hpp"
 #include <thread>
-
+#include <string>
+#include <vector>
 
 namespace Plains {
 namespace Core {
 
 using std::thread;
+using std::string;
+using std::vector;
+
+class EventSubscriber {
+    public:
+    virtual void callback() = 0;
+};
+
+class Event {
+    public:
+    Event(const string _id);
+    string& getID() const;
+    void fire();
+    void subscribe(EventSubscriber* es);
+
+    private:
+    const string _id;
+    vector<EventSubscriber*> _subscribers;
+};
 
 class EventBus {
-    private:
-    Logger& _logger;
-    //thread* _thread
-    thread _thread;
-
     public:
     EventBus(Logger& logger);
     ~EventBus();
-    void test();
+    Event* registerEvent(string eventID);
+    Event* getEvent(const string& eventID);
+    
+    private:
+    Logger& _logger;
+    thread _thread;
+    vector<Event*> _events;
+
     void run();
 };
 

src/core/main.cpp

@@ -21,15 +21,13 @@ int main(int args, char **argv) {
             arguments.push_back (argv[index]);
         }
 
-        logger.debug.ln ("Loading Configuration...");
         ConfigManager    cfg(logger, arguments);
-
-        logger.debug.ln ("Start Event Bus...");
         EventBus         eventBus(logger);
-
-        logger.debug.ln ("Start DNS resolver...");
         Resolver::Server resolver(logger, eventBus);
 
+        Event* e = eventBus.registerEvent("Test Event");
+        //e->subscribe()
+
         //Record testrec = ARecord();
         //logger.debug.ln ("Running DNS resolver...");
         //resolver.run();

src/resolver/Server.cpp

@@ -53,6 +53,7 @@ Server::Server(Logger& logger, EventBus& eventBus)
   : _logger(logger),
     _eventBus(eventBus)
 {
+    _logger.debug.ln ("Starting Resolver...");
 /*
     _logger.debug << "Testing some stuff..." << Logger::commit;
     _logger.debug << "Message header overall size: " << sizeof(Message::Header) << Logger::commit;