sir.hh

Go to the documentation of this file.

 
#ifndef _SIR_HH_INCLUDED
# define _SIR_HH_INCLUDED
 
# include "sir.h"
# include "sir/helpers.h"
# include "sir/internal.h"
# include <type_traits>
# include <stdexcept>
# include <algorithm>
# include <exception>
# include <iostream>
# include <cstring>
# include <memory>
# include <tuple>
# include <string>
# include <array>
 
# if HAS_INCLUDE(<format>) && !defined (SIR_NO_STD_FORMAT) && \
     !defined(_LIBCPP_HAS_NO_INCOMPLETE_FORMAT)
#  include <format>
#  define __SIR_HAVE_STD_FORMAT__
# endif
# if HAS_INCLUDE(<boost/format.hpp>) && !defined(SIR_NO_BOOST_FORMAT)
#  include <boost/format.hpp>
#  define __SIR_HAVE_BOOST_FORMAT__
# endif
# if HAS_INCLUDE(<fmt/format.h>) && !defined(SIR_NO_FMT_FORMAT)
#  define FMT_HEADER_ONLY
#  include <fmt/format.h>
#  define __SIR_HAVE_FMT_FORMAT__
# endif
# if !defined(SIR_NO_STD_IOSTREAM)
#  include <iostream>
# endif
 
namespace sir
{
    struct error {
        uint16_t code {};    
        std::string message; 
        constexpr bool is_os_error() const noexcept {
            return code == SIR_E_PLATFORM;
        }
 
        static error from_last_error() {
            std::string message(SIR_MAXERROR, '\0');
            const auto code = sir_geterror(message.data());
            return { code, std::move(message) };
        }
    };
 
    struct error_info : public error {
        std::string func;       
        std::string file;       
        uint32_t line {};       
        int os_code {};         
        std::string os_message; 
        static error_info from_last_error() {
            sir_errorinfo errinfo {};
            sir_geterrorinfo(&errinfo);
            return { { errinfo.code, errinfo.msg }, errinfo.func, errinfo.file,
                errinfo.line, errinfo.os_code, errinfo.os_msg };
        }
    };
 
    class exception : public std::runtime_error {
    public:
        using std::runtime_error::runtime_error;
 
        exception() = delete;
        explicit exception(const error& err) : exception(err.message) { }
        ~exception() override = default;
    };
 
    class policy {
    protected:
        policy() = default;
        virtual ~policy() = default;
 
    public:
        virtual bool get_init_data(sirinit& data) const noexcept = 0;
 
        virtual bool on_init_complete() const noexcept = 0;
 
        static constexpr bool throw_on_error() noexcept {
            return false;
        }
    };
 
    template<typename T>
    concept DerivedFromPolicy = std::is_base_of_v<policy, T>;
 
    class default_policy : public policy {
    public:
        default_policy() = default;
        ~default_policy() override = default;
 
        bool get_init_data(sirinit& data) const noexcept final {
            return sir_makeinit(&data);
        }
 
        constexpr bool on_init_complete() const noexcept final {
            return true;
        }
 
        static constexpr bool throw_on_error() noexcept {
            return true;
        }
    };
 
    class adapter {
    protected:
        adapter() = default;
        virtual ~adapter() = default;
    };
 
    template<DerivedFromPolicy TPolicy>
    static inline bool throw_on_policy(bool expr) noexcept(false) {
        if (!expr) {
            SIR_ASSERT(expr);
            if constexpr(TPolicy::throw_on_error()) {
                throw exception(error::from_last_error());
            }
        }
        return expr;
    }
 
    template<DerivedFromPolicy TPolicy>
    class default_adapter : public adapter {
    public:
        default_adapter() = default;
        ~default_adapter() override = default;
 
        PRINTF_FORMAT_ATTR(2, 3)
        bool debug(PRINTF_FORMAT const char* format, ...) const {
            _SIR_L_START(format);
            ret = _sir_logv(SIRL_DEBUG, format, args);
            _SIR_L_END();
            return throw_on_policy<TPolicy>(ret);
        }
 
        PRINTF_FORMAT_ATTR(2, 3)
        bool info(PRINTF_FORMAT const char* format, ...) const {
            _SIR_L_START(format);
            ret = _sir_logv(SIRL_INFO, format, args);
            _SIR_L_END();
            return throw_on_policy<TPolicy>(ret);
        }
 
        PRINTF_FORMAT_ATTR(2, 3)
        bool notice(PRINTF_FORMAT const char* format, ...) const {
            _SIR_L_START(format);
            ret = _sir_logv(SIRL_NOTICE, format, args);
            _SIR_L_END();
            return throw_on_policy<TPolicy>(ret);
        }
 
        PRINTF_FORMAT_ATTR(2, 3)
        bool warn(PRINTF_FORMAT const char* format, ...) const {
            _SIR_L_START(format);
            ret = _sir_logv(SIRL_WARN, format, args);
            _SIR_L_END();
            return throw_on_policy<TPolicy>(ret);
        }
 
        PRINTF_FORMAT_ATTR(2, 3)
        bool error(PRINTF_FORMAT const char* format, ...) const {
            _SIR_L_START(format);
            ret = _sir_logv(SIRL_ERROR, format, args);
            _SIR_L_END();
            return throw_on_policy<TPolicy>(ret);
        }
 
        PRINTF_FORMAT_ATTR(2, 3)
        bool crit(PRINTF_FORMAT const char* format, ...) const {
            _SIR_L_START(format);
            ret = _sir_logv(SIRL_CRIT, format, args);
            _SIR_L_END();
            return throw_on_policy<TPolicy>(ret);
        }
 
        PRINTF_FORMAT_ATTR(2, 3)
        bool alert(PRINTF_FORMAT const char* format, ...) const {
            _SIR_L_START(format);
            ret = _sir_logv(SIRL_ALERT, format, args);
            _SIR_L_END();
            return throw_on_policy<TPolicy>(ret);
        }
 
        PRINTF_FORMAT_ATTR(2, 3)
        bool emerg(PRINTF_FORMAT const char* format, ...) const {
            _SIR_L_START(format);
            ret = _sir_logv(SIRL_EMERG, format, args);
            _SIR_L_END();
            return throw_on_policy<TPolicy>(ret);
        }
    };
 
# if defined(__SIR_HAVE_STD_FORMAT__)
    template<DerivedFromPolicy TPolicy>
    class std_format_adapter : public adapter {
    public:
        std_format_adapter() = default;
        ~std_format_adapter() override = default;
 
        template<typename... Args>
        inline bool debug_std(std::format_string<Args...> fmt, Args&&... args) const {
            const auto str = std::vformat(fmt.get(), std::make_format_args(args...));
            const bool ret = sir_debug("%s", str.c_str());
            return throw_on_policy<TPolicy>(ret);
        }
 
        template<typename... Args>
        inline bool info_std(std::format_string<Args...> fmt, Args&&... args) const {
            const auto str = std::vformat(fmt.get(), std::make_format_args(args...));
            const bool ret = sir_info("%s", str.c_str());
            return throw_on_policy<TPolicy>(ret);
        }
 
        template<typename... Args>
        inline bool notice_std(std::format_string<Args...> fmt, Args&&... args) const {
            const auto str = std::vformat(fmt.get(), std::make_format_args(args...));
            const bool ret = sir_notice("%s", str.c_str());
            return throw_on_policy<TPolicy>(ret);
        }
 
        template<typename... Args>
        inline bool warn_std(std::format_string<Args...> fmt, Args&&... args) const {
            const auto str = std::vformat(fmt.get(), std::make_format_args(args...));
            const bool ret = sir_warn("%s", str.c_str());
            return throw_on_policy<TPolicy>(ret);
        }
 
        template<typename... Args>
        inline bool error_std(std::format_string<Args...> fmt, Args&&... args) const {
            const auto str = std::vformat(fmt.get(), std::make_format_args(args...));
            const bool ret = sir_error("%s", str.c_str());
            return throw_on_policy<TPolicy>(ret);
        }
 
        template<typename... Args>
        inline bool crit_std(std::format_string<Args...> fmt, Args&&... args) const {
            const auto str = std::vformat(fmt.get(), std::make_format_args(args...));
            const bool ret = sir_crit("%s", str.c_str());
            return throw_on_policy<TPolicy>(ret);
        }
 
        template<typename... Args>
        inline bool alert_std(std::format_string<Args...> fmt, Args&&... args) const {
            const auto str = std::vformat(fmt.get(), std::make_format_args(args...));
            const bool ret = sir_alert("%s", str.c_str());
            return throw_on_policy<TPolicy>(ret);
        }
 
        template<typename... Args>
        inline bool emerg_std(std::format_string<Args...> fmt, Args&&... args) const {
            const auto str = std::vformat(fmt.get(), std::make_format_args(args...));
            const bool ret = sir_emerg("%s", str.c_str());
            return throw_on_policy<TPolicy>(ret);
        }
    };
# endif // !__SIR_HAVE_STD_FORMAT__
 
# if defined(__SIR_HAVE_BOOST_FORMAT__)
    template<DerivedFromPolicy TPolicy>
    class boost_format_adapter : public adapter {
    public:
        boost_format_adapter() = default;
        ~boost_format_adapter() override = default;
 
        bool debug_bf(const boost::format& fmt) const {
            const bool ret = sir_debug("%s", fmt.str().c_str());
            return throw_on_policy<TPolicy>(ret);
        }
 
        bool info_bf(const boost::format& fmt) const {
            const bool ret = sir_info("%s", fmt.str().c_str());
            return throw_on_policy<TPolicy>(ret);
        }
 
        bool notice_bf(const boost::format& fmt) const {
            const bool ret = sir_notice("%s", fmt.str().c_str());
            return throw_on_policy<TPolicy>(ret);
        }
 
        bool warn_bf(const boost::format& fmt) const {
            const bool ret = sir_warn("%s", fmt.str().c_str());
            return throw_on_policy<TPolicy>(ret);
        }
 
        bool error_bf(const boost::format& fmt) const {
            const bool ret = sir_error("%s", fmt.str().c_str());
            return throw_on_policy<TPolicy>(ret);
        }
 
        bool crit_bf(const boost::format& fmt) const {
            const bool ret = sir_crit("%s", fmt.str().c_str());
            return throw_on_policy<TPolicy>(ret);
        }
 
        bool alert_bf(const boost::format& fmt) const {
            const bool ret = sir_alert("%s", fmt.str().c_str());
            return throw_on_policy<TPolicy>(ret);
        }
 
        bool emerg_bf(const boost::format& fmt) const {
            const bool ret = sir_emerg("%s", fmt.str().c_str());
            return throw_on_policy<TPolicy>(ret);
        }
    };
# endif // !__SIR_HAVE_BOOST_FORMAT__
 
# if defined(__SIR_HAVE_FMT_FORMAT__)
    template<DerivedFromPolicy TPolicy>
    class fmt_format_adapter : public adapter {
    public:
        fmt_format_adapter() = default;
        ~fmt_format_adapter() override = default;
 
        template<typename... Args>
        inline bool debug_fmt(fmt::format_string<Args...> fmt, Args&&... args) const {
            const auto str = fmt::vformat(fmt, fmt::make_format_args(args...));
            const auto ret = sir_debug("%s", str.c_str());
            return throw_on_policy<TPolicy>(ret);
        }
 
        template<typename... Args>
        inline bool info_fmt(fmt::format_string<Args...> fmt, Args&&... args) const {
            const auto str = fmt::vformat(fmt, fmt::make_format_args(args...));
            const auto ret = sir_info("%s", str.c_str());
            return throw_on_policy<TPolicy>(ret);
        }
 
        template<typename... Args>
        inline bool notice_fmt(fmt::format_string<Args...> fmt, Args&&... args) const {
            const auto str = fmt::vformat(fmt, fmt::make_format_args(args...));
            const auto ret = sir_notice("%s", str.c_str());
            return throw_on_policy<TPolicy>(ret);
        }
 
        template<typename... Args>
        inline bool warn_fmt(fmt::format_string<Args...> fmt, Args&&... args) const {
            const auto str = fmt::vformat(fmt, fmt::make_format_args(args...));
            const auto ret = sir_warn("%s", str.c_str());
            return throw_on_policy<TPolicy>(ret);
        }
 
        template<typename... Args>
        inline bool error_fmt(fmt::format_string<Args...> fmt, Args&&... args) const {
            const auto str = fmt::vformat(fmt, fmt::make_format_args(args...));
            const auto ret = sir_error("%s", str.c_str());
            return throw_on_policy<TPolicy>(ret);
        }
 
        template<typename... Args>
        inline bool crit_fmt(fmt::format_string<Args...> fmt, Args&&... args) const {
            const auto str = fmt::vformat(fmt, fmt::make_format_args(args...));
            const auto ret = sir_crit("%s", str.c_str());
            return throw_on_policy<TPolicy>(ret);
        }
 
        template<typename... Args>
        inline bool alert_fmt(fmt::format_string<Args...> fmt, Args&&... args) const {
            const auto str = fmt::vformat(fmt, fmt::make_format_args(args...));
            const auto ret = sir_alert("%s", str.c_str());
            return throw_on_policy<TPolicy>(ret);
        }
 
        template<typename... Args>
        inline bool emerg_fmt(fmt::format_string<Args...> fmt, Args&&... args) const {
            const auto str = fmt::vformat(fmt, fmt::make_format_args(args...));
            const auto ret = sir_emerg("%s", str.c_str());
            return throw_on_policy<TPolicy>(ret);
        }
    };
# endif // !__SIR_HAVE_FMT_FORMAT__
 
# if !defined(SIR_NO_STD_IOSTREAM)
    template<typename T>
    concept DerivedFromStreamBuf = std::is_base_of_v<std::streambuf, T>;
 
    template<DerivedFromPolicy TPolicy>
    class std_iostream_adapter : public adapter {
    public:
        std_iostream_adapter() = default;
        ~std_iostream_adapter() override = default;
 
        template<typename TFunc>
        class buffer : public std::streambuf {
        public:
            using array_type = std::array<char_type, SIR_MAXMESSAGE>;
 
            buffer() = delete;
 
            explicit buffer(TFunc pfn) : _pfn(pfn) {
                [[maybe_unused]]
                bool ok = throw_on_policy<TPolicy>(pfn != nullptr && _arr != nullptr);
                reset();
            }
 
            ~buffer() override = default;
 
        protected:
            void reset() {
                if (_arr) {
                    _arr->fill('\0');
                    setp(_arr->data(), _arr->data() + _arr->size() - 1);
                }
            }
 
            bool write_out() {
                for (auto it = _arr->rbegin(); it != _arr->rend(); it++) {
                    if ((*it != '\0') && (*it == '\n')) {
                        *it = '\0';
                        break;
                    }
                }
 
                const bool write = _pfn ? _pfn(_arr->data()) : false;
                reset();
                return throw_on_policy<TPolicy>(write);
            }
 
            int_type overflow(int_type ch) override {
                if (ch != traits_type::eof() && write_out()) {
                    return ch;
                }
                return traits_type::eof();
            }
 
            int sync() override {
                return write_out() ? 0 : -1;
            }
 
            std::streamsize xsputn(const char_type* s, std::streamsize count) override {
                std::streamsize written = 0;
                do {
                    ptrdiff_t left = epptr() - pptr();
                    if (!left) {
                        int_type ch = overflow(traits_type::to_int_type(*(s + written)));
                        if (ch != traits_type::eof()) {
                            continue;
                        } else {
                            break;
                        }
                    }
 
                    auto this_write = std::min(static_cast<std::streamsize>(left),
                        count - written);
                    std::memcpy(pptr(), s + written, static_cast<std::size_t>(this_write));
                    pbump(static_cast<int>(this_write));
                    written += this_write;
                } while (written < count);
 
                return written;
            }
 
        private:
            std::shared_ptr<array_type> _arr = std::make_shared<array_type>();
            TFunc _pfn = nullptr;
        };
 
        template<DerivedFromStreamBuf TBuffer>
        class stream : public std::ostream {
        public:
            explicit stream(const TBuffer& buf) : std::ostream(&_buf), _buf(buf) {}
            ~stream() override = default;
 
        private:
            TBuffer _buf;
        };
 
        using log_func = bool(*)(const char*, ...);
        using buffer_type = buffer<log_func>;
        using stream_type = stream<buffer_type>;
 
        stream_type debug_stream  {buffer_type {&sir_debug}};
        stream_type info_stream   {buffer_type {&sir_info}};
        stream_type notice_stream {buffer_type {&sir_notice}};
        stream_type warn_stream   {buffer_type {&sir_warn}};
        stream_type error_stream  {buffer_type {&sir_error}};
        stream_type crit_stream   {buffer_type {&sir_crit}};
        stream_type alert_stream  {buffer_type {&sir_alert}};
        stream_type emerg_stream  {buffer_type {&sir_emerg}};
    };
# endif // SIR_NO_STD_IOSTREAM
 
    template<size_t N, typename ...Ts>
    using NthTypeOf = typename std::tuple_element<N, std::tuple<Ts...>>::type;
 
    template<size_t N, typename TBase, typename ...Ts>
    consteval auto all_derived_from_t() {
        if constexpr(!std::is_base_of_v<TBase, NthTypeOf<N, Ts...>>)
            return std::false_type::value;
        if constexpr(N == 0)
            return std::true_type::value;
        else
            return all_derived_from_t<N - 1, TBase, Ts...>();
    }
 
    template<class TBase, class ...Ts>
    concept DerivedFromT = all_derived_from_t<sizeof...(Ts) - 1, TBase, Ts...>();
 
    template<bool RAII, DerivedFromPolicy TPolicy, template<class> class ...TAdapters>
    requires DerivedFromT<adapter, TAdapters<TPolicy>...>
    class logger : public TAdapters<TPolicy>... {
    public:
        logger() : TAdapters<TPolicy>()... {
            if constexpr(RAII) {
                [[maybe_unused]]
                bool ok = throw_on_policy<TPolicy>(_init());
            }
        }
 
        logger(const logger&) = delete;
        logger(const logger&&) = delete;
 
        ~logger() override {
            if constexpr(RAII) {
                if (!cleanup()) {
                    SIR_ASSERT(false);
                }
            }
        }
 
        logger& operator=(const logger&) = delete;
        logger& operator=(const logger&&) = delete;
 
        bool init() const noexcept {
            return is_initialized() ? false: _init();
        }
 
        bool cleanup() const noexcept {
            return is_initialized() ? sir_cleanup() : false;
        }
 
        bool is_initialized() const noexcept {
            return sir_isinitialized();
        }
 
        error get_error() const {
            return error::from_last_error();
        }
 
        error_info get_error_info() const {
            return error_info::from_last_error();
        }
 
        sirfileid add_file(const std::string& path, const sir_levels& levels,
            const sir_options& opts) const {
            const bool add = sir_addfile(path.c_str(), levels, opts);
            return throw_on_policy<TPolicy>(add);
        }
 
        bool rem_file(const sirfileid& id) const {
            const bool rem = sir_remfile(id);
            return throw_on_policy<TPolicy>(rem);
        }
 
        sirpluginid load_plugin(const std::string& path) const {
            const bool load = sir_loadplugin(path.c_str());
            return throw_on_policy<TPolicy>(load);
        }
 
        bool unload_plugin(const sirpluginid& id) const {
            const bool unload = sir_unloadplugin(id);
            return throw_on_policy<TPolicy>(unload);
        }
 
        bool set_file_levels(const sirfileid& id, const sir_levels& levels) const {
            const bool set = sir_filelevels(id, levels);
            return throw_on_policy<TPolicy>(set);
        }
 
        bool set_file_options(const sirfileid& id, const sir_options& opts) const {
            const bool set = sir_fileopts(id, opts);
            return throw_on_policy<TPolicy>(set);
        }
 
        bool set_text_style(const sir_level& level, const sir_textattr& attr,
            const sir_textcolor& fg, const sir_textcolor& bg) const {
            const bool set = sir_settextstyle(level, attr, fg, bg);
            return throw_on_policy<TPolicy>(set);
        }
 
        bool reset_text_styles() const {
            const bool reset = sir_resettextstyles();
            return throw_on_policy<TPolicy>(reset);
        }
 
        sir_textcolor make_rgb(const sir_textcolor& r, const sir_textcolor& g,
            const sir_textcolor& b) const {
            const bool make = sir_makergb(r, g, b);
            return throw_on_policy<TPolicy>(make);
        }
 
        bool set_color_mode(const sir_colormode& mode) const {
            const bool set = sir_setcolormode(mode);
            return throw_on_policy<TPolicy>(set);
        }
 
        bool set_stdout_levels(const sir_levels& levels) const {
            const bool set = sir_stdoutlevels(levels);
            return throw_on_policy<TPolicy>(set);
        }
 
        bool set_stdout_options(const sir_options& opts) const {
            const bool set = sir_stdoutopts(opts);
            return throw_on_policy<TPolicy>(set);
        }
 
        bool set_stderr_levels(const sir_levels& levels) const {
            const bool set = sir_stderrlevels(levels);
            return throw_on_policy<TPolicy>(set);
        }
 
        bool set_stderr_options(const sir_options& opts) const {
            const bool set = sir_stderropts(opts);
            return throw_on_policy<TPolicy>(set);
        }
 
        bool set_syslog_levels(const sir_levels& levels) const {
            const bool set = sir_sysloglevels(levels);
            return throw_on_policy<TPolicy>(set);
        }
 
        bool set_syslog_options(const sir_options& opts) const {
            const bool set = sir_syslogopts(opts);
            return throw_on_policy<TPolicy>(set);
        }
 
        bool set_syslog_id(const std::string& id) const {
            const bool set = sir_syslogid(id.c_str());
            return throw_on_policy<TPolicy>(set);
        }
 
        bool set_syslog_category(const std::string& category) const {
            const bool set = sir_syslogcat(category.c_str());
            return throw_on_policy<TPolicy>(set);
        }
 
        std::string get_version_string() const {
            return sir_getversionstring();
        }
 
        uint32_t get_version_hex() const noexcept {
            return sir_getversionhex();
        }
 
        bool is_prerelease() const noexcept {
            return sir_isprerelease();
        }
 
    protected:
        bool _init() const noexcept {
            TPolicy policy {};
            sirinit si {};
            if (const bool init = policy.get_init_data(si) && sir_init(&si) &&
                policy.on_init_complete(); !init) {
                return false;
            }
            return true;
        }
    };
 
    using default_logger = logger<true, default_policy, default_adapter>;
 
# if defined(__SIR_HAVE_STD_FORMAT__)
    using std_format_logger = logger
    <
        true,
        default_policy,
        default_adapter,
        std_format_adapter
    >;
# endif
 
# if defined(__SIR_HAVE_BOOST_FORMAT__)
    using boost_logger = logger
    <
        true,
        default_policy,
        default_adapter,
        boost_format_adapter
    >;
# endif
 
# if defined(__SIR_HAVE_FMT_FORMAT__)
    using fmt_logger = logger
    <
        true,
        default_policy,
        default_adapter,
        fmt_format_adapter
    >;
# endif
 
# if !defined(SIR_NO_STD_IOSTREAM)
    using iostream_logger = logger
    <
        true,
        default_policy,
        default_adapter,
        std_iostream_adapter
    >;
# endif
 
} // ! namespace sir
 
#endif // !_SIR_HH_INCLUDED