Base.hpp

Go to the documentation of this file.

 
#ifndef FOCS_LOG_BASE
#define FOCS_LOG_BASE
 
#include <limits>
#include <memory>
#include <string>
 
namespace focs {
 
enum class LogSeverity : int {
    debug = 7,      
    info = 6,       
    notice = 5,     
    warning = 4,    
    error = 3,      
    critical = 2,   
    alert = 1,      
    emergency = 0,  
 
    warn = warning,    
    err = error,       
    crit = critical,   
    emerg = emergency, 
 
    min = std::numeric_limits<int>::max(), 
    max = std::numeric_limits<int>::min()  
};
class LogFacility {
    public:
        virtual ~LogFacility(){}
 
        virtual void log(int severity, const std::string& s) = 0;
        virtual void log(LogSeverity severity, const std::string& s){ this->log(static_cast<int>(severity), s); }
};
class LogTarget {
    public:
        LogTarget(int min_severity, int max_severity, std::unique_ptr<LogFacility> f) : min_severity_{min_severity}, max_severity_{max_severity}, log_facility_{std::move(f)} {}
        LogTarget(int min_severity, std::unique_ptr<LogFacility> f) : min_severity_{min_severity}, log_facility_{std::move(f)}{}
        LogTarget(std::unique_ptr<LogFacility> f) : log_facility_{std::move(f)}{}
 
        // move
        LogTarget(LogTarget&& other){
            swap(std::move(other));
        }
        LogTarget& operator=(LogTarget&& other){
            swap(std::move(other));
            return *this;
        }
 
        // no copying
        LogTarget(const LogTarget&) = delete;
        LogTarget& operator=(const LogTarget&) = delete;
 
        int min_severity(){ return min_severity_; }
        int max_severity(){ return max_severity_; }
        LogFacility& log_facility(){ return *log_facility_; }
 
    private:
        int min_severity_{static_cast<int>(LogSeverity::info)};
        int max_severity_{static_cast<int>(LogSeverity::max)};
        std::unique_ptr<LogFacility> log_facility_;
 
        void swap(LogTarget&& other){
            auto min = min_severity_;
            auto max = max_severity_;
            auto log = std::move(log_facility_);
            min_severity_ = other.min_severity_;
            max_severity_ = other.max_severity_;
            log_facility_ = std::move(other.log_facility_);
            other.min_severity_ = min;
            other.max_severity_ = max;
            other.log_facility_ = std::move(log);
        }
};
} // namespace focs
 
#endif // FOCS_LOG_BASE