logger.h

#pragma once

// Thread safe logger
// Has log level and vector sinks which do the actual logging
#include<vector>
#include<memory>
#include<mutex>
#include<atomic>
#include <algorithm>

#include "common_types.h"
#include "sinks/base_sink.h"
#include "details/factory.h"

namespace c11log {


namespace details {
class line_logger;
}


class logger {
public:

    typedef std::shared_ptr<sinks::base_sink>  sink_ptr_t;
    typedef std::vector<sink_ptr_t> sinks_vector_t;

    explicit logger(const std::string& name) :
        _logger_name(name),
        _formatter(new formatters::default_formatter()),
        _sinks(),
        _mutex(),
        _atomic_level(level::INFO) {
    }

    ~logger() = default;

    logger(const logger&) = delete;
    logger& operator=(const logger&) = delete;

    void set_name(const std::string& name);
    const std::string& get_name();
    void add_sink(sink_ptr_t sink_ptr);
    void remove_sink(sink_ptr_t sink_ptr);
    void set_formatter(std::unique_ptr<formatters::formatter> formatter);
    void set_level(c11log::level::level_enum level);
    c11log::level::level_enum get_level() const;
    bool should_log(c11log::level::level_enum level) const;

    details::line_logger log(level::level_enum level);
    details::line_logger debug();
    details::line_logger info();
    details::line_logger warn();
    details::line_logger error();
    details::line_logger fatal();

private:
    friend details::line_logger;

    std::string _logger_name = "";
    std::unique_ptr<c11log::formatters::formatter> _formatter;
    sinks_vector_t _sinks;
    std::mutex _mutex;
    std::atomic_int _atomic_level;

    void _log_it(const std::string& msg);

};

logger& get_logger(const std::string& name);




}



//
// Logger inline impl
//
#include "details/line_logger.h"
inline c11log::details::line_logger c11log::logger::log(c11log::level::level_enum msg_level)
{

    if (msg_level >= _atomic_level)
        return details::line_logger(this, msg_level);
    else
        return details::line_logger(nullptr);
}

inline c11log::details::line_logger c11log::logger::debug()
{
    return log(c11log::level::DEBUG);
}
inline c11log::details::line_logger c11log::logger::info()
{
    return log(c11log::level::INFO);
}
inline c11log::details::line_logger c11log::logger::warn()
{
    return log(c11log::level::WARNING);
}
inline c11log::details::line_logger c11log::logger::error()
{
    return log(level::ERROR);
}
inline c11log::details::line_logger c11log::logger::fatal()
{
    return log(c11log::level::FATAL);
}

inline void c11log::logger::set_name(const std::string& name)
{
    std::lock_guard<std::mutex> lock(_mutex);
    _logger_name = name;
}

inline const std::string& c11log::logger::get_name()
{
    std::lock_guard<std::mutex> lock(_mutex);
    return _logger_name;
}

inline void c11log::logger::add_sink(sink_ptr_t sink_ptr)
{
    std::lock_guard<std::mutex> lock(_mutex);
    _sinks.push_back(sink_ptr);
}

inline void c11log::logger::remove_sink(sink_ptr_t sink_ptr)
{
    std::lock_guard<std::mutex> lock(_mutex);
    _sinks.erase(std::remove(_sinks.begin(), _sinks.end(), sink_ptr), _sinks.end());
}

inline void c11log::logger::set_formatter(std::unique_ptr<formatters::formatter> formatter)
{
    std::lock_guard<std::mutex> lock(_mutex);
    _formatter = std::move(formatter);
}

inline void c11log::logger::set_level(c11log::level::level_enum level)
{
    _atomic_level.store(level);
}

inline c11log::level::level_enum c11log::logger::get_level() const
{
    return static_cast<c11log::level::level_enum>(_atomic_level.load());
}

inline bool c11log::logger::should_log(c11log::level::level_enum level) const
{
    return level >= _atomic_level.load();
}
inline void c11log::logger::_log_it(const std::string& msg)
{
    level::level_enum level = static_cast<level::level_enum>(_atomic_level.load());
    std::lock_guard<std::mutex> lock(_mutex);
    for (auto &sink : _sinks)
        sink->log(msg, level);
}

// Static factory function
inline c11log::logger& c11log::get_logger(const std::string& name)
{
    return *(c11log::details::factory::instance().get_logger(name));
}


namespace c11log {
class info_logger {
public:
    info_logger (c11log::logger* logger):_logger(logger) {}
    template<class T>
    details::line_logger& operator<<(const T& msg) {
        return _logger->info() << msg;
    }

private:
    c11log::logger* _logger;
};
}