logger.hpp

    #pragma once
 
#include <tom-util/defines.hpp>
#include <tom-util/scalar.hpp>
#include <spdlog/spdlog.h>
#include <unordered_map>
#include <memory>
 
namespace tom
{
    class spdlogdog;
    class logger;
 
    class spdlogdog
    {
    public:
        explicit spdlogdog(std::shared_ptr<spdlog::logger> l) : m_spdlog(l) {}
 
        template <class... Args>
        void
        info(const std::string &fmt, Args... args)
        {
            m_spdlog->info(fmt, args...);
        }
 
        template <class... Args>
        void
        warn(const std::string &fmt, Args... args)
        {
            m_spdlog->warn(fmt, args...);
        }
 
        template <class... Args>
        void
        error(const std::string &fmt, Args... args)
        {
            m_spdlog->error(fmt, args...);
        }
 
        template <class... Args>
        void
        debug(const std::string &fmt, Args... args)
        {
            m_spdlog->debug(fmt, args...);
        }
 
        template <class... Args>
        void
        fatal(const std::string &fmt, Args... args)
        {
            m_spdlog->error(fmt, args...);
        }
 
    private:
        std::shared_ptr<spdlog::logger> m_spdlog;
    };
 
    class TOM_UTIL_API logger
    {
    public:
        static void
        configure(const char *path, const char *level, const char *format, const char *type);
 
        const tom::String &
        get_name() const { return m_name; }
 
        static logger &
        get_logger(const tom::observation &name) { return get_logger(tom::String(name)); }
 
        static logger &
        get_logger(const tom::String &name) { return get_logger(name.value().c_str()); }
 
        static logger &
        get_logger(const char *name);
 
        static logger &
        get_logger();
 
        void
        debug(const tom::observation &message) { debug(tom::String(message)); }
        void
        debug(const tom::String &message) { debug(message.value().c_str()); }
        void
        debug(const char *message);
 
        template <class... Args>
        void
        debug(const std::string &fmt, Args... args)
        {
            m_log->debug(fmt, args...);
        }
 
        void
        info(const tom::observation &message) { info(tom::String(message)); }
        void
        info(const tom::String &message) { info(message.value().c_str()); }
        void
        info(const char *message);
 
        template <class... Args>
        void
        info(const std::string &fmt, Args... args)
        {
            m_log->info(fmt, args...);
        }
 
        void
        warn(const tom::observation &message) { warn(tom::String(message)); }
        void
        warn(const tom::String &message) { warn(message.value().c_str()); }
        void
        warn(const char *message);
 
        template <class... Args>
        void
        warn(const std::string &fmt, Args... args)
        {
            m_log->warn(fmt, args...);
        }
 
        void
        error(const tom::observation &message) { error(tom::String(message)); }
        void
        error(const tom::String &message) { error(message.value().c_str()); }
        void
        error(const char *message);
 
        template <class... Args>
        void
        error(const std::string &fmt, Args... args)
        {
            m_log->error(fmt, args...);
        }
 
        void
        fatal(const tom::observation &message) { fatal(tom::String(message)); }
        void
        fatal(const tom::String &message) { fatal(message.value().c_str()); }
        void
        fatal(const char *message);
 
        template <class... Args>
        void
        fatal(const std::string &fmt, Args... args)
        {
            m_log->error(fmt, args...);
        }
 
    private:
        explicit logger(const std::string &name);
 
        static std::string DEFAULT_LOG;
        typedef std::unordered_map<std::string, std::shared_ptr<logger>> logger_map_t;
 
        tom::String m_name;
        std::shared_ptr<spdlogdog> m_log;
 
        // child loggers live here
        static logger_map_t s_logs;
    };
 
} // end tom namespace