cpplogging/include/cpplogging/interface/logger.inl

#pragma once

#include <cxxabi.h>
#include "logger.h"

namespace cpplogging
{

    namespace __impl
    {

        /* log_helper */

        log_helper
            ::log_helper(logger& p_logger)
                : _logger   (p_logger)
                , _entry    (new log_entry())
                { _entry->name = p_logger.name(); }

        log_helper
            ::log_helper(logger& p_logger, const log_entry_ptr_s& p_entry)
                : _logger   (p_logger)
                , _entry    (p_entry)
                { _entry->name = p_logger.name(); }

        log_helper
            ::~log_helper()
        {
            _entry->message += str();
            _logger.write_entry(_entry);
        }

        log_helper& log_helper
            ::level(log_level level)
        {
            _entry->level = level;
            return *this;
        }

        log_helper& log_helper
            ::sender(const void * sender)
        {
            _entry->sender = sender;
            return *this;
        }

        template<typename T_sender>
        log_helper& log_helper
            ::sender(const T_sender * sender)
        {
            int status;
            auto name = abi::__cxa_demangle(typeid(T_sender).name(), 0, 0, &status);
            _entry->sender_type = std::string(name ? name : typeid(T_sender).name());
            _entry->sender = sender;
            return *this;
        }

        log_helper& log_helper
            ::sender_type(const std::string& sender_type)
        {
            _entry->sender_type = sender_type;
            return *this;
        }

        log_helper& log_helper
            ::file(const char * file)
        {
            _entry->file = file;
            return *this;
        }

        log_helper& log_helper
            ::line(int line)
        {
            _entry->line = line;
            return *this;
        }

        log_helper& log_helper
            ::message(const std::string& msg)
        {
            _entry->message = msg;
            return *this;
        }

        log_helper& log_helper
            ::add_message(const std::string& msg)
        {
            _entry->message += msg;
            return *this;
        }

        template<typename... T_args>
        log_helper& log_helper
            ::format(const std::string& fmt, T_args&&... args)
        {
            _entry->message = format(fmt, 0x8000, std::forward<T_args>(args)...);
            return *this;
        }

        template<typename... T_args>
        log_helper& log_helper
            ::add_format(const std::string& fmt, T_args&&... args)
        {
            _entry->message += format(fmt, 0x8000, std::forward<T_args>(args)...);
            return *this;
        }

        template<typename... T_args>
        std::string log_helper
            ::format(const std::string& fmt, size_t sz, T_args&&... args)
        {
            std::unique_ptr<char, decltype(&free)> buff(static_cast<char*>(malloc(sz)), &free);
            auto len = snprintf(buff.get(), sz, fmt.c_str(), std::forward<T_args>(args)...);
            if (len < 0)
                throw std::runtime_error("unable to format string");
            return std::string(buff.get(), len);
        }

    }

    /* logger */

    logger
        ::logger(const std::string name)
            : _name(name)
            { }

    const std::string& logger
        ::name() const
        { return _name; }

    __impl::log_helper logger
        ::log()
        { return __impl::log_helper(*this); }

}