tklb::Logger Class Reference

#include <TLog.hpp>

Collaboration diagram for tklb::Logger:

Public Types
enum	Level {   DEBUG = 0 , INFO , WARN , ERROR ,   CRITICAL }

Static Public Member Functions
static void	setLevel (Level loglevel)
static void	debug (const std::string &msg)
static void	info (const std::string &msg)
static void	warn (const std::string &msg)
static void	error (const std::string &msg)
static void	critical (const std::string &msg)

Private Member Functions
	Logger ()
	~Logger ()
	Logger (const Logger &)=delete
Logger &	operator= (const Logger &)=delete

Static Private Member Functions
static Logger &	instance ()
static void	print (const char *msg, const Level level=Level::INFO)

Private Attributes
std::ofstream	mLogFile
std::mutex	mWriteLock
Level	mLevel = Level::DEBUG

Detailed Description

Definition at line 21 of file TLog.hpp.

Member Enumeration Documentation

Level

enum tklb::Logger::Level

Enumerator
DEBUG
INFO
WARN
ERROR
CRITICAL

Definition at line 23 of file TLog.hpp.

                   {
            DEBUG = 0,
            INFO,
            WARN,
            ERROR,
            CRITICAL
        };

Constructor & Destructor Documentation

Logger() [1/2]

tklb::Logger::Logger ( )

inlineprivate

Definition at line 65 of file TLog.hpp.

                 {
            mLogFile.open("log.txt", std::ofstream::trunc);
            if (!mLogFile.is_open()) {
                std::cerr << "ERROR:\tCould not open log file!" << std::endl;
            }
        }

~Logger()

tklb::Logger::~Logger ( )

inlineprivate

Definition at line 72 of file TLog.hpp.

                  {
            if (mLogFile.is_open()) {
                print("Shutting down...");
                mLogFile.close();
            }
        }

Here is the call graph for this function:

Logger() [2/2]

tklb::Logger::Logger ( const Logger &  )

privatedelete

Member Function Documentation

critical()

static void tklb::Logger::critical ( const std::string &  msg )

inlinestatic

Definition at line 107 of file TLog.hpp.

                                                   {
            print(msg.c_str(), Level::CRITICAL);
        };

Here is the call graph for this function:

debug()

static void tklb::Logger::debug ( const std::string &  msg )

inlinestatic

Definition at line 89 of file TLog.hpp.

                                                {
    #ifndef NDEBUG
            print(msg.c_str(), Level::DEBUG);
    #endif
        };

Here is the call graph for this function:

error()

static void tklb::Logger::error ( const std::string &  msg )

inlinestatic

Definition at line 103 of file TLog.hpp.

                                                {
            print(msg.c_str(), Level::ERROR);
        };

Here is the call graph for this function:

info()

static void tklb::Logger::info ( const std::string &  msg )

inlinestatic

Definition at line 95 of file TLog.hpp.

                                               {
            print(msg.c_str(), Level::INFO);
        };

Here is the call graph for this function:

instance()

static Logger & tklb::Logger::instance ( )

inlinestaticprivate

Definition at line 36 of file TLog.hpp.

                                  {
            static Logger _instance;
            return _instance;
        }

Here is the caller graph for this function:

operator=()

Logger & tklb::Logger::operator= ( const Logger &  )

privatedelete

print()

static void tklb::Logger::print ( const char *  msg, const Level  level = Level::INFO  )

inlinestaticprivate

Definition at line 41 of file TLog.hpp.

                                                                          {
            auto& inst = instance();
            if (level < inst.mLevel) { return; }
 
            const char* prefix = nullptr;
            if (level == Level::DEBUG) { prefix = "DEBUG:"; }
            if (level == Level::INFO) { prefix = "INFO:"; }
            if (level == Level::WARN) { prefix = "WARN:"; }
            if (level == Level::ERROR) { prefix = "ERROR:"; }
            if (level == Level::CRITICAL) { prefix = "CRITICAL:"; }
 
            if (level > Level::WARN) {
                std::cerr << prefix << "\t" << msg << std::endl;
            } else {
                std::cout << prefix << "\t" << msg << std::endl;
            }
 
            if (!inst.mLogFile.is_open()) { return; }
            inst.mWriteLock.lock();
            inst.mLogFile << prefix << "\t" << msg << std::endl;
            inst.mLogFile.flush();
            inst.mWriteLock.unlock();
        }

Here is the call graph for this function:

Here is the caller graph for this function:

setLevel()

static void tklb::Logger::setLevel ( Level  loglevel )

inlinestatic

Definition at line 84 of file TLog.hpp.

                                             {
            instance().mLevel = loglevel;
        }

Here is the call graph for this function:

warn()

static void tklb::Logger::warn ( const std::string &  msg )

inlinestatic

Definition at line 99 of file TLog.hpp.

                                               {
            print(msg.c_str(), Level::WARN);
        };

Here is the call graph for this function:

Member Data Documentation

mLevel

Level tklb::Logger::mLevel = Level::DEBUG

private

Definition at line 34 of file TLog.hpp.

mLogFile

std::ofstream tklb::Logger::mLogFile

private

Definition at line 32 of file TLog.hpp.

mWriteLock

std::mutex tklb::Logger::mWriteLock

private

Definition at line 33 of file TLog.hpp.

---

The documentation for this class was generated from the following file:

• TLog.hpp