Completed logging class to rudementary level. Extra operator overloadings still needed

src/core/ConfigManager.cpp

@@ -1,30 +1,32 @@
 #include "ConfigManager.hpp"
-#include <iostream>
 #include <stdio.h>
 #include <unistd.h>
-#include <string>
 
 namespace Plains {
 namespace Core {
 
-using std::cout;
-using std::endl;
 using std::string;
 
-ConfigManager::ConfigManager(int numParameters, char **parameters) {
+ConfigManager::ConfigManager(Logger& logger, vector<string>& parameters) :
+    logger(logger),
+    parameters(parameters)
+{
     // move this to a function that can return an error code?
-    if ( numParameters <= 1 ) return;
-    cout << "Interpreting Paremters..." << endl;
+    if ( parameters.size() == 0 ) return;
+    logger.debug.ln("Interpreting Paremters...");
     
+    /*
     for (unsigned i = 0; i < (numParameters-1); ++i) {
         string p = string(parameters[i]);
         string v = string(parameters[i+1]);
         // Check if this parameter is an argument or an argument value:
         if ( p.compare(0,1,"-") == 0 ) {
-            cout << "Interpreting parameter " << p << endl;
-            if ( ! p.compare("--initial-peer") ) cout << "Peer " << v << " set" << endl;
+            logger.debug("Interpreting parameter " << p);
+            if ( ! p.compare("--initial-peer") ) logger.debug("Peer " << v << " set");
         }
     }
+    */
 }
 
+
 }}

src/core/Logger.cpp

@@ -13,8 +13,13 @@ using std::endl;
 
 Logger::Logger(enum Level logLevel, EventBus& eventBus) :
     logLevel(logLevel),
-    eventBus(eventBus)
+    eventBus(eventBus),
+    debug(DEBUG, *this),
+    info(INFO, *this),
+    warn(WARN, *this),
+    fatal(FATAL, *this)
 {
+    //info(this);
     logFile = ofstream("plains.log");
 
     if (!logFile) {
@@ -39,43 +44,33 @@ void Logger::log(Level lvl, const string& msg) { log ( lvl, msg.c_str() ); }
 
 void Logger::log(Level lvl, const char* msg) {
     switch ( lvl ) {
-        case DEBUG: debug (msg); break;
-        case INFO:  info  (msg); break;
-        case WARN:  warn  (msg); break;
-        case FATAL: fatal (msg); break;
+        case DEBUG: debug.ln (msg); break;
+        case INFO:  info.ln  (msg); break;
+        case WARN:  warn.ln  (msg); break;
+        case FATAL: fatal.ln (msg); break;
     }
 }
 
-void Logger::debug ( const string& msg ) {
-    logFile << "DATESTAMP [DEBUG] " << msg << endl;
+Logger::Sink::Sink (const Level level, Logger& parent) : level(level), parent(parent) {}
+
+void Logger::Sink::ln  ( const string& msg ) {
+    if ( level >= parent.logLevel ) parent.logFile << "DATESTAMP [" << level << "]  " << msg << endl;
 }
 
-void Logger::debug ( const char* msg ) {
-    logFile << "DATESTAMP [DEBUG] " << msg << endl;
+void Logger::Sink::ln  ( const char* msg ) {
+    if ( level >= parent.logLevel ) parent.logFile << "DATESTAMP [" << level << "]  " << msg << endl;
 }
 
-void Logger::info  ( const string& msg ) {
-    if ( logLevel >= INFO ) logFile << "DATESTAMP [INFO]  " << msg << endl;
+Logger::Sink& Logger::Sink::operator<<(const string& msg) {
+    if ( level >= parent.logLevel ) parent.logFile << "DATESTAMP [" << level << "]  " << msg;
+    return *this;
 }
 
-void Logger::info  ( const char* msg ) {
-    if ( logLevel >= INFO ) logFile << "DATESTAMP [INFO]  " << msg << endl;
+Logger::Sink& Logger::Sink::operator<<(const char* msg) {
+    if ( level >= parent.logLevel ) parent.logFile << "DATESTAMP [" << level << "]  " << msg;
+    return *this;
 }
 
-void Logger::warn  ( const string& msg ) {
-    if ( logLevel >= WARN ) logFile << "DATESTAMP [WARN]  " << msg << endl;
-}
 
-void Logger::warn  ( const char* msg ) {
-    if ( logLevel >= WARN ) logFile << "DATESTAMP [WARN]  " << msg << endl;
-}
-
-void Logger::fatal ( const string& msg ) {
-    if ( logLevel == FATAL ) logFile << "DATESTAMP [FATAL] " << msg << endl;
-}
-
-void Logger::fatal ( const char* msg ) {
-    if ( logLevel == FATAL ) logFile << "DATESTAMP [FATAL] " << msg << endl;
-}
 
 }}

src/core/include/ConfigManager.hpp

@@ -1,13 +1,23 @@
 #ifndef CONFIG_MANAGER_HPP
 #define CONFIG_MANAGER_HPP
+#include <vector>
+#include <string>
+#include "Logger.hpp"
 
 namespace Plains {
 namespace Core {
 
+using std::vector;
+using std::string;
+
 class ConfigManager
 {
     public:
-    ConfigManager(int numParameters, char **parameters);
+    ConfigManager(Logger& logger, vector<string>& parameters);
+
+    private:
+    Logger& logger;
+    const vector<string>& parameters;
 };
 
 }}

src/core/include/Logger.hpp

@@ -2,13 +2,15 @@
 #define LOGGER_HPP
 #include <string>
 #include <fstream>
-#include "Core.hpp"
+#include <ostream>
+#include "EventBus.hpp"
 
 namespace Plains {
 namespace Core {
 
 using std::string;
 using std::ofstream;
+using std::ostream;
 using std::streambuf;
 
 class Logger {
@@ -19,14 +21,23 @@ class Logger {
     void setLogLevel(Level level);
     void log(Level lvl, const char* msg);
     void log(Level lvl, const string& msg);
-    void debug(const string& msg);
-    void debug(const char* msg);
-    void info(const  string& msg);
-    void info(const  char* msg);
-    void warn(const  string& msg);
-    void warn(const  char* msg);
-    void fatal(const string& msg);
-    void fatal(const char* msg);
+
+    class Sink {
+        private:
+        Logger& parent;
+        const Logger::Level level;
+        public:
+        Sink(const Level level, Logger& parent);
+        void ln (const string& msg);
+        void ln (const char* msg);
+        Sink& operator<<(const string& msg);
+        Sink& operator<<(const char* msg);
+    };
+
+    Sink debug;
+    Sink info;
+    Sink warn;
+    Sink fatal;
 
     private:
     EventBus& eventBus;
@@ -37,5 +48,6 @@ class Logger {
 
 
 
+
 }}
 #endif

src/core/main.cpp

@@ -1,20 +1,30 @@
 #include "Resolver.hpp"
 #include "Core.hpp"
 #include "DNS.hpp"
+#include <vector>
+#include <string>
 
 int main(int args, char **argv) {
 
     using namespace Plains;
-    //using namespace Core;
- 
-    Core::ConfigManager cfg(args, argv);
-    Core::EventBus      eventBus;
-    Core::Logger        logger(Core::Logger::DEBUG, eventBus);
+    using namespace Core;
+    using std::vector;
+    using std::string;
+
+    vector<string> arguments;
+    for ( unsigned index = 0; index < args; ++index ) {
+        arguments.push_back (argv[index]);
+    }
+
+    EventBus      eventBus;
+    Logger        logger(Logger::DEBUG, eventBus);
+    ConfigManager cfg(logger, arguments);
     Resolver::Server resolver(logger, eventBus);
 
     //Record testrec = ARecord();
 
-    logger.debug ("Booting complete.");
+    logger.info << "Testing overloading!" << " with chaining!\n";
+    logger.debug.ln ("Booting complete.");
 
     //Run eventBus on main thread.
     eventBus.run();

src/resolver/Server.cpp

@@ -4,20 +4,16 @@
 #include <asio/ts/internet.hpp>
 
 //Testing:
-#include <iostream>
 #include "Message.hpp"
 
 namespace Plains {
 namespace Resolver {
 
-using std::cout;
-using std::endl;
-
 Server::Server(Logger& logger, EventBus& eventBus) : logger(logger), eventBus(eventBus) {
-    cout << "Testing some stuff..." << endl;
-    cout << "Message class overall size:" << sizeof(Message) << endl;
-    cout << "Message::Header size:" << sizeof(Message::Header) << endl;
-    cout << "Message::QR:RESPONSE Enum:" << Message::QR::RESPONSE << endl;
+//    logger.debug << "Testing some stuff..." << endl;
+//    logger.debug << "Message class overall size:" << sizeof(Message) << endl;
+//    logger.debug << "Message::Header size:" << sizeof(Message::Header) << endl;
+//    logger.debug << "Message::QR:RESPONSE Enum:" << Message::QR::RESPONSE << endl;
 
     //test:
     eventBus.test();
@@ -27,4 +23,6 @@ Server::~Server() {
     
 }
 
+
+
 }}