Change naming convention of class properties

src/api/Server.cpp

@@ -3,7 +3,7 @@
 namespace Plains {
 namespace API {
 
-Server::Server(EventBus& eventBus) : eventBus_(eventBus) {
+Server::Server(EventBus& eventBus) : _eventBus(eventBus) {
     //Constructor
 }
 

src/api/include/Server.hpp

@@ -8,7 +8,7 @@ namespace API {
 using Core::EventBus;
 
 class Server {
-    const EventBus& eventBus_;
+    const EventBus& _eventBus;
 
     public:
     Server(EventBus& eventBus);

src/core/ConfigManager.cpp

@@ -8,12 +8,12 @@ namespace Core {
 using std::string;
 
 ConfigManager::ConfigManager(Logger& logger, vector<string>& parameters) :
-    logger_(logger),
-    parameters_(parameters)
+    _logger(logger),
+    _parameters(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("Interpreting Paremters...");
     
     /*
     for (unsigned i = 0; i < (numParameters-1); ++i) {
@@ -21,8 +21,8 @@ ConfigManager::ConfigManager(Logger& logger, vector<string>& parameters) :
         string v = string(parameters[i+1]);
         // Check if this parameter is an argument or an argument value:
         if ( p.compare(0,1,"-") == 0 ) {
-            logger_.debug("Interpreting parameter " << p);
-            if ( ! p.compare("--initial-peer") ) logger_.debug("Peer " << v << " set");
+            _logger.debug("Interpreting parameter " << p);
+            if ( ! p.compare("--initial-peer") ) _logger.debug("Peer " << v << " set");
         }
     }
     */

src/core/EventBus.cpp

@@ -4,20 +4,20 @@
 namespace Plains {
 namespace Core {
 
-EventBus::EventBus(Logger& logger) : logger_(logger), thread_(&EventBus::run, this) {
-    logger_.debug.ln("Hi from EventBus Constructor. Not Theaded");
+EventBus::EventBus(Logger& logger) : _logger(logger), _thread(&EventBus::run, this) {
+    _logger.debug.ln("Hi from EventBus Constructor. Not Theaded");
 }
 
 EventBus::~EventBus() {
-    thread_.join();
+    _thread.join();
 }
 
 void EventBus::test() {
-    logger_.debug << "Testing from within EventBus!" << Logger::commit;
+    _logger.debug << "Testing from within EventBus!" << Logger::commit;
 }
 
 void EventBus::run() {
-    logger_.debug.ln("Hi from EventBus run method! From within Event Thread!");
+    _logger.debug.ln("Hi from EventBus run method! From within Event Thread!");
 }
 
 

src/core/Logger.cpp

@@ -58,86 +58,86 @@ void Logger::log(Level lvl, const char* msg) {
 }
 
 Logger::Sink::Sink (const Level level, Logger& parent) :
-    level_(level),
-    parent_(parent),
-    lineIsPrefixed_(false) {}
+    _level(level),
+    _parent(parent),
+    _lineIsPrefixed(false) {}
 
 void Logger::Sink::ln  ( const string& msg ) {
     ln(msg.c_str());
 }
 
 void Logger::Sink::ln  ( const char* msg ) {
-    if ( level_ >= parent_.logLevel ) {
+    if ( _level>= _parent.logLevel ) {
         // If line has already been started, abort it and start new one:
-        if(lineIsPrefixed_) *parent_.output << endl;
+        if(_lineIsPrefixed) *_parent.output << endl;
         prefixLine(true);
-        *parent_.output <<  msg << endl;
+        *_parent.output <<  msg << endl;
     }
 }
 
 void Logger::Sink::prefixLine(bool resetToFalse) {
-    if (!lineIsPrefixed_) {
+    if (!_lineIsPrefixed) {
         const char* lvlString;
-        switch ( level_ )
+        switch ( _level)
         {
             case DEBUG: lvlString = "DEBUG"; break;
             case INFO:  lvlString = "INFO";  break;
             case WARN:  lvlString = "WARN";  break;
             case FATAL: lvlString = "FATAL"; break;
         }
-        *parent_.output << Logger::genTimeStamp() << " [" << lvlString << "] ";
-        lineIsPrefixed_ = resetToFalse ? false : true;
+        *_parent.output << Logger::genTimeStamp() << " [" << lvlString << "] ";
+        _lineIsPrefixed = resetToFalse ? false : true;
     }
 }
 
 Logger::Sink& Logger::Sink::operator<<(const string& msg) {
-    if ( level_ >= parent_.logLevel ) {
+    if ( _level>= _parent.logLevel ) {
         prefixLine();
-        *parent_.output << msg;
+        *_parent.output << msg;
     }
     return *this;
 }
 
 Logger::Sink& Logger::Sink::operator<<(const char* msg) {
-    if ( level_ >= parent_.logLevel ) {
+    if ( _level>= _parent.logLevel ) {
         prefixLine();
-        *parent_.output << msg;
+        *_parent.output << msg;
     }
     return *this;
 }
 
 
 Logger::Sink& Logger::Sink::operator<<(const int msg) {
-    if ( level_ >= parent_.logLevel ) {
+    if ( _level>= _parent.logLevel ) {
         prefixLine();
-        *parent_.output << msg;
+        *_parent.output << msg;
     }
     return *this;
 }
 
 Logger::Sink& Logger::Sink::operator<<(const long msg) {
-    if ( level_ >= parent_.logLevel ) {
+    if ( _level>= _parent.logLevel ) {
         prefixLine();
-        *parent_.output << msg;
+        *_parent.output << msg;
     }
     return *this;
 }
 
 Logger::Sink& Logger::Sink::operator<<(const unsigned long msg) {
-    if ( level_ >= parent_.logLevel ) {
+    if ( _level>= _parent.logLevel ) {
         prefixLine();
-        *parent_.output << msg;
+        *_parent.output << msg;
     }
     return *this;
 }
 
 Logger::Sink& Logger::Sink::operator<<(const char character) {
-    if ( level_ >= parent_.logLevel ) {
+    if ( _level>= _parent.logLevel ) {
         switch(character) {
             // COMMIT - End message line
             case 0:
-              *parent_.output << endl;
-              lineIsPrefixed_ = false;
+              *_parent.output << endl;
+              _lineIsPrefixed = false;
             break;
         }
     }

src/core/dns/include/Record.hpp

@@ -14,9 +14,9 @@ using std::string;
 class Record : public Resource
 {
     public:
-    const uint16_t id_;
+    const uint16_t _id;
     string serialize();
-    Record(const uint16_t id) : id_(id) {}
+    Record(const uint16_t id) : _id(id) {}
 };
 
 class ARecord : public Record { ARecord(); };

src/core/include/ConfigManager.hpp

@@ -16,8 +16,8 @@ class ConfigManager
     ConfigManager(Logger& logger, vector<string>& parameters);
 
     private:
-    Logger& logger_;
-    const vector<string>& parameters_;
+    Logger& _logger;
+    const vector<string>& _parameters;
 };
 
 }}

src/core/include/EventBus.hpp

@@ -11,9 +11,9 @@ using std::thread;
 
 class EventBus {
     private:
-    Logger& logger_;
-    //thread* thread_;
-    thread thread_;
+    Logger& _logger;
+    //thread* _thread
+    thread _thread;
 
     public:
     EventBus(Logger& logger);

src/core/include/Logger.hpp

@@ -23,9 +23,9 @@ class Logger {
 
     class Sink {
         private:
-        bool lineIsPrefixed_;
-        Logger& parent_;
-        const Logger::Level level_;
+        bool _lineIsPrefixed;
+        Logger& _parent;
+        const Logger::Level _level;
         void prefixLine(bool resetToFalse = false);
         public:
         Sink(const Level level, Logger& parent);

src/dhcp/Server.cpp

@@ -3,7 +3,7 @@
 namespace Plains {
 namespace DHCP {
 
-Server::Server(EventBus& eventBus) : eventBus_(eventBus) {
+Server::Server(EventBus& eventBus) : _eventBus(eventBus) {
     //Constructor
 }
 

src/dhcp/include/Server.hpp

@@ -8,7 +8,7 @@ namespace DHCP {
 using Core::EventBus;
 
 class Server {
-    const EventBus& eventBus_;
+    const EventBus& _eventBus;
 
     public:
     Server(EventBus& eventBus);

src/resolver/Server.cpp

@@ -50,13 +50,13 @@ static char* intToHex(unsigned byteCount, int c) {
 }
 
 Server::Server(Logger& logger, EventBus& eventBus)
-  : logger_(logger),
-    eventBus_(eventBus)
+  : _logger(logger),
+    _eventBus(eventBus)
 {
-    logger_.debug << "Testing some stuff..." << Logger::commit;
-    logger_.debug << "Message header overall size: " << sizeof(Message::Header) << Logger::commit;
-//    logger_.debug << "Message::Header size:" << sizeof(Message::Header) << endl;
-//    logger_.debug << "Message::QR:RESPONSE Enum:" << Message::QR::RESPONSE << endl;
+    _logger.debug << "Testing some stuff..." << Logger::commit;
+    _logger.debug << "Message header overall size: " << sizeof(Message::Header) << Logger::commit;
+//    _logger.debug << "Message::Header size:" << sizeof(Message::Header) << endl;
+//    _logger.debug << "Message::QR:RESPONSE Enum:" << Message::QR::RESPONSE << endl;
 
     std::fstream myfile;
     std::streampos beg,end;
@@ -68,11 +68,11 @@ Server::Server(Logger& logger, EventBus& eventBus)
     const unsigned long size = end-beg;
     Message::Header* header = new Message::Header;
     myfile.read ((char*)header, sizeof(Message));
-    logger_.debug << "size is: " << size << " bytes." << Logger::commit;
+    _logger.debug << "size is: " << size << " bytes." << Logger::commit;
 
-    logger_.debug << "Header: " << Logger::commit;
-    //logger_.debug << "ID: " << 0x1ef8 <<
-    logger_.debug << "ID: " << intToHex(2, header->id) <<
+    _logger.debug << "Header: " << Logger::commit;
+    //_logger.debug << "ID: " << 0x1ef8 <<
+    _logger.debug << "ID: " << intToHex(2, header->id) <<
     "   QR: " << byteToHex(header->qr) <<
     "   OPCode: " << byteToHex(header->opCode) << Logger::commit <<
     "Authoritive Answer: " << byteToHex(header->aa) << Logger::commit <<
@@ -87,7 +87,7 @@ Server::Server(Logger& logger, EventBus& eventBus)
     myfile.close();
     //Testing over
 
-    socket_ = new udp::socket(io_context_, udp::endpoint(udp::v4(), 8853));
+    _socket = new udp::socket(_io_context, udp::endpoint(udp::v4(), 8853));
 }
 
 Server::~Server() {
@@ -95,14 +95,14 @@ Server::~Server() {
 }
 
 void Server::run() {
-    io_context_.run();
+    _io_context.run();
     do_receive();
 }
 
 void Server::do_receive()
 {
-  socket_->async_receive_from(
-      asio::buffer(data_, 1024), sender_endpoint_,
+  _socket->async_receive_from(
+      asio::buffer(_data, 1024), _sender_endpoint,
       [this](std::error_code ec, std::size_t bytes_recvd)
       {
         if (!ec && bytes_recvd > 0)
@@ -118,9 +118,9 @@ void Server::do_receive()
 
 void Server::do_send(std::size_t length)
 {
-  socket_->async_send_to(
-      asio::buffer(data_, length), sender_endpoint_,
-      [this](std::error_code /*ec*/, std::size_t /*bytes_sent*/)
+  _socket->async_send_to (
+      asio::buffer(_data, length), _sender_endpoint,
+      [this](std::error_code /*ec*/, std::size_t /*_bytessent*/)
       {
         do_receive();
       });

src/resolver/include/Server.hpp

@@ -15,12 +15,12 @@ using Core::Logger;
 class Server
 {
     private:
-    EventBus& eventBus_;
-    Logger& logger_;
-    asio::io_context io_context_;
-    asio::ip::udp::socket* socket_;
-    asio::ip::udp::endpoint sender_endpoint_;
-    char data_[1024];
+    EventBus& _eventBus;
+    Logger& _logger;
+    asio::io_context _io_context;
+    asio::ip::udp::socket* _socket;
+    asio::ip::udp::endpoint _sender_endpoint;
+    char _data[1024];
 
     void do_receive();
     void do_send(std::size_t length);