cpplogging/include/cpplogging/interface/logger.h

#pragma once

#include <sstream>
#include <cpplogging/types.h>

#define cpplogging_log(p_logger, p_level) \
    if (p_logger.is_enabled(::cpplogging::log_level::p_level)) \
        p_logger.log() \
            << ::cpplogging::level(::cpplogging::log_level::p_level) \
            << ::cpplogging::file(__FILE__) \
            << ::cpplogging::line(__LINE__)

namespace cpplogging
{

    struct logger;

    namespace __impl
    {

        /**
         * @brief Helper class to create a log entry.
         */
        struct log_helper
            : public std::ostringstream
        {
        public:
            cpplogging::logger& logger;
            log_entry_ptr_s     entry;

        private:
            /**
             * @brief Move constructor.
             */
            log_helper(log_helper&&) = delete;

            /**
             * @brief Copy constructor.
             */
            log_helper(const log_helper&) = delete;

        public:
            /**
             * @brief Constructor.
             *
             * @param[in] p_logger  Logger this log helper belongs to.
             */
            inline log_helper(cpplogging::logger& p_logger);

            /**
             * @brief Constructor.
             *
             * @param[in] p_logger  Logger this log helper belongs to.
             * @param[in] p_entry   Log entry to create.
             */
            inline log_helper(cpplogging::logger& p_logger, const log_entry_ptr_s& p_entry);

            /**
             * @brief Destructor. Will finally write the log entry.
             */
            inline ~log_helper();
        };

    }

    /**
     * @brief Class to create log messages.
     */
    struct logger
    {
    public:
        friend __impl::log_helper;

    private:
        std::string _name; //!< name of the logger

    private:
        /**
         * @brief Move constructor.
         */
        logger(logger&&) = delete;

        /**
         * @brief Copy constructor.
         */
        logger(const logger&) = delete;

    public:
        /**
         * @brief Constructor.
         */
        inline logger(const std::string name);

        /**
         * @brief Destructor.
         */
        virtual ~logger() = default;

        /**
         * @brief Get the name of the logger.
         */
        inline const std::string& name() const;

        /**
         * @brief Check if the passed log level is enabled.
         *
         * @param[in] level     Level to check.
         *
         * @retval true         The passed log level is enabled.
         * @retval false        The passed log level is disabled.
         */
        virtual bool is_enabled(log_level level) const = 0;

        /**
         * @brief Write a log entry,
         *
         * @return Log helper to create log entry.
         */
        inline __impl::log_helper log();

    protected:
        /**
         * @brief Write a log entry.
         *
         * @param[in] entry Log entry to write.
         */
        virtual void write_entry(const log_entry_ptr_s& entry) const = 0;

    public:
        /**
         * @brief Get the instance on an logger with the passed name.
         *
         * @param[in] name  Name of the loggger.
         *
         * @return          Instance of the requested logger.
         */
        static logger& get(const std::string& name = "");
    };

}

#include "logger.inl"