Logger.h

#ifndef TENDUKE_LOG_LOGGER_H
#define TENDUKE_LOG_LOGGER_H
 
#include <string>
#include <utility>
 
namespace tenduke { namespace log {
 
class Logger {
 
public:
    enum LOG_LEVEL {
        LOG_OFF,
        LOG_ERROR,
        LOG_WARNING,
        LOG_INFO,
        LOG_DEBUG,
        LOG_TRACE
    };
 
public:
    explicit Logger(std::string name = "", enum LOG_LEVEL level = LOG_INFO) : logLevel(level), name(std::move(name)) {}
    virtual ~Logger() = default;
 
    virtual void debug(const char *message) {this->log(LOG_DEBUG, message);}
 
    virtual void debug(const std::string &message) {this->debug(message.c_str());}
 
    virtual void error(const char *message) {this->log(LOG_ERROR, message);}
 
    virtual void error(const std::string &message) {this->error(message.c_str());}
 
    virtual void info(const char *message) {this->log(LOG_INFO, message);}
 
    virtual void info(const std::string &message) {this->info(message.c_str());}
 
    virtual void trace(const char *message) {this->log(LOG_TRACE, message);}
 
    virtual void trace(const std::string &message) {this->trace(message.c_str());};
 
    virtual void warning(const char *message) {this->log(LOG_WARNING, message);}
 
    virtual void warning(const std::string &message) {this->warning(message.c_str());}
 
    virtual void log(enum LOG_LEVEL atLevel, const char * message)
    {
        if (logLevel >= atLevel) {
            write(atLevel, message);
        }
    }
 
    virtual void setLogLevel(enum LOG_LEVEL level)
    {
        logLevel = level;
    }
 
protected:
    virtual void write(enum LOG_LEVEL level, const char * message) = 0;
 
    const std::string name;
private:
    enum LOG_LEVEL logLevel;
};
 
 
}}
#endif //TENDUKE_LOG_LOGGER_H