Log.hpp

Go to the documentation of this file.

 
#ifndef FOCS_LOG
#define FOCS_LOG
 
#include "Configuration.hpp"
#include "log/Base.hpp"
#include "log/File.hpp"
#include "log/Stream.hpp"
#include "log/FormattedStream.hpp"
#include "log/FormattedFile.hpp"
 
#include <iostream>
#include <memory>
#include <sstream>
#include <string>
#include <vector>
 
#include <gsl/gsl>
 
#include <boost/format.hpp>
 
#ifdef INTL_FOUND
#include <libintl.h>
#include <locale.h>
#endif
 
namespace focs {
 
class Log {
    public:
        Log() : Log(false){ }
        explicit Log(bool default_loggers){
            if (default_loggers){
                add(std::make_unique<focs::FileStreamLogger>());
            }
        }
        // move constructors (facilities can't easily be moved, needs more work)
        // Log(const Log&) = default;
        // explicit Log(std::vector<std::unique_ptr<LogFacility>> targets) : targets_{std::move(targets)}{}
 
        inline static Log& get_default(){
            static Log _instance{true};
            return _instance;
        }
 
        void add(std::unique_ptr<LogFacility> target){
            targets_.emplace_back(std::move(target));
        }
        void add(int min_severity, std::unique_ptr<LogFacility> target){
            targets_.emplace_back(min_severity, std::move(target));
        }
        void add(int min_severity, int max_severity, std::unique_ptr<LogFacility> target){
            targets_.emplace_back(min_severity, max_severity, std::move(target));
        }
 
        void log_raw(int severity, const std::string& s){
            for (auto& t : targets_){
                if (severity <= t.min_severity() && severity >= t.max_severity()){
                    t.log_facility().log(severity, s);
                }
            }
        }
 
        void log(int severity, const std::string& s){
#ifdef INTL_FOUND
            const auto& final = ::gettext(s.c_str());
            log_raw(severity, final);
#else
            log_raw(severity, s);
#endif
        }
 
 
        template<typename... Arguments>
        void log(int severity, const std::string& fmt, const Arguments&... args){
#ifdef INTL_FOUND
            boost::format f{::gettext(fmt.c_str())};
#else
            boost::format f{fmt};
#endif
            //C++17, fold expression: const auto& s = boost::str((boost::format(fmt) % ... % args));
            using unroll = bool[];
            (void)unroll{(f % std::forward<decltype(args)>(args), false)...}; // <- comma operator
 
            const auto& s = boost::str(f);
            log_raw(severity, s);
        }
        void log(LogSeverity severity, const std::string& s){
            log(static_cast<int>(severity), s);
        }
 
        template<typename... Arguments>
        void log(LogSeverity severity, const std::string& fmt, const Arguments&... args){
            log(static_cast<int>(severity), fmt, args...);
        }
 
        void add(LogSeverity min_severity, std::unique_ptr<LogFacility> target){
            add(static_cast<int>(min_severity), std::move(target));
        }
        void add(LogSeverity min_severity, LogSeverity max_severity, std::unique_ptr<LogFacility> target){
            add(static_cast<int>(min_severity), static_cast<int>(max_severity), std::move(target));
        }
 
        void log_raw(LogSeverity severity, const std::string& s){
            log_raw(static_cast<int>(severity), s);
        }
 
        void debug(const std::string& s){ log(LogSeverity::debug, s); }
        template<typename... Arguments>
        void debug(const std::string& s, const Arguments&... args){ log(LogSeverity::debug, s, args...); }
        void info(const std::string& s){ log(LogSeverity::info, s); }
        template<typename... Arguments>
        void info(const std::string& s, const Arguments&... args){ log(LogSeverity::info, s, args...); }
        void notice(const std::string& s){ log(LogSeverity::notice, s); }
        template<typename... Arguments>
        void notice(const std::string& s, const Arguments&... args){ log(LogSeverity::notice, s, args...); }
        void warning(const std::string& s){ log(LogSeverity::warning, s); }
        template<typename... Arguments>
        void warning(const std::string& s, const Arguments&... args){ log(LogSeverity::warning, s, args...); }
        void error(const std::string& s){ log(LogSeverity::error, s); }
        template<typename... Arguments>
        void error(const std::string& s, const Arguments&... args){ log(LogSeverity::error, s, args...); }
        void critical(const std::string& s){ log(LogSeverity::critical, s); }
        template<typename... Arguments>
        void critical(const std::string& s, const Arguments&... args){ log(LogSeverity::critical, s, args...); }
        void alert(const std::string& s){ log(LogSeverity::alert, s); }
        template<typename... Arguments>
        void alert(const std::string& s, const Arguments&... args){ log(LogSeverity::alert, s, args...); }
        void emergency(const std::string& s){ log(LogSeverity::emergency, s); }
        template<typename... Arguments>
        void emergency(const std::string& s, const Arguments&... args){ log(LogSeverity::emergency, s, args...); }
 
        void warn(const std::string& s){ log(LogSeverity::warn, s); }
        template<typename... Arguments>
        void warn(const std::string& s, const Arguments&... args){ log(LogSeverity::warn, s, args...); }
        void err(const std::string& s){ log(LogSeverity::err, s); }
        template<typename... Arguments>
        void err(const std::string& s, const Arguments&... args){ log(LogSeverity::err, s, args...); }
        void crit(const std::string& s){ log(LogSeverity::crit, s); }
        template<typename... Arguments>
        void crit(const std::string& s, const Arguments&... args){ log(LogSeverity::crit, s, args...); }
        void emerg(const std::string& s){ log(LogSeverity::emerg, s); }
        template<typename... Arguments>
        void emerg(const std::string& s, const Arguments&... args){ log(LogSeverity::emerg, s, args...); }
 
        size_t num_loggers() { return targets_.size(); }
        LogSeverity severity() { return severity_; }
 
        friend Log& operator<<(Log &me, LogSeverity severity){
            me.severity_ = severity;
            return me;
        }
        friend Log& operator<<(Log& me, const std::string& t){
            me.log_raw(static_cast<int>(me.severity_), t);
            return me;
        }
        template<typename T>
        friend Log& operator<<(Log& me, const T& t){
            std::stringbuf buf;
            std::ostream out{&buf};
            out << t;
            me.log_raw(static_cast<int>(me.severity_), buf.str());
            return me;
        }
 
    private:
        std::vector<LogTarget> targets_{};
        LogSeverity severity_{LogSeverity::info};
 
};
} // namespace focs
 
#endif // FOCS_LOG