details.h

Go to the documentation of this file.

/*
  This file is part of KDSpdSetup.
 
  SPDX-FileCopyrightText: 2023 Klarälvdalens Datakonsult AB, a KDAB Group company <info@kdab.com>
 
  SPDX-License-Identifier: MIT
 
  Contact KDAB at <info@kdab.com> for commercial licensing options.
*/
#pragma once
 
#include <unordered_map>
#include <map>
#include <vector>
 
#include <spdlog/async.h>
#include <spdlog/spdlog.h>
#include <spdlog/async_logger.h>
#include <spdlog/pattern_formatter.h>
#include <spdlog/sinks/basic_file_sink.h>
#include <spdlog/sinks/daily_file_sink.h>
#include <spdlog/sinks/null_sink.h>
#include <spdlog/sinks/rotating_file_sink.h>
#include <spdlog/sinks/stdout_color_sinks.h>
#include <spdlog/sinks/stdout_sinks.h>
#ifdef __linux__
#include <spdlog/sinks/syslog_sink.h>
#elif _WIN32
#include <spdlog/sinks/msvc_sink.h>
#endif
 
#include <toml.hpp>
 
namespace KDSPDSetup::details {
 
static auto const stdStrs{ std::vector<std::string>{ "stdout_sink_st", "stdout_sink_mt", "stdout_color_sink_st",
                                                     "stdout_color_sink_mt", "color_stdout_sink_st",
                                                     "color_stdout_sink_mt", "stderr_sink_st", "stderr_sink_mt",
                                                     "stderr_color_sink_st", "stderr_color_sink_mt",
                                                     "color_stderr_sink_st", "color_stderr_sink_mt" } };
 
static auto const fileStrs{ std::vector<std::string>{ "basic_file_sink_st", "basic_file_sink_mt" } };
 
static auto const rotateStrs{ std::vector<std::string>{ "rotating_file_sink_st", "rotating_file_sink_mt" } };
 
static auto const dailyStrs{ std::vector<std::string>{ "daily_file_sink_st", "daily_file_sink_mt" } };
 
static auto const nullStrs{ std::vector<std::string>{ "null_sink_st", "null_sink_mt" } };
 
static auto const linuxStrs{ std::vector<std::string>{ "syslog_sink_st", "syslog_sink_mt" } };
 
static auto const winStrs{ std::vector<std::string>{ "msvc_sink_st", "msvc_sink_mt" } };
 
static auto const levelMap{ std::unordered_map<std::string, spdlog::level::level_enum>{
        { "critical", spdlog::level::level_enum::critical },
        { "debug", spdlog::level::level_enum::debug },
        { "err", spdlog::level::level_enum::err },
        { "info", spdlog::level::level_enum::info },
        { "n_levels", spdlog::level::level_enum::n_levels },
        { "off", spdlog::level::level_enum::off },
        { "trace", spdlog::level::level_enum::trace },
        { "warn", spdlog::level::level_enum::warn },
} };
 
static auto const overflowMap{ std::map<toml::string, spdlog::async_overflow_policy>{
        { "overrun_oldest", spdlog::async_overflow_policy::overrun_oldest },
        { "block", spdlog::async_overflow_policy::block },
} };
 
class SPDMaps
{
public:
    static auto sinkMap() -> std::map<toml::string, spdlog::sink_ptr> const &;
 
    static auto patternMap() -> std::map<toml::string, toml::string> const &;
 
    static auto threadPoolMap() -> std::map<toml::string, std::pair<std::size_t, std::size_t>> const &;
 
    static void emplaceSinkMap(std::pair<toml::string, spdlog::sink_ptr> &&_pr);
 
    static void emplacePatternMap(std::pair<toml::string, toml::string> &&_pr);
 
    static void emplaceThreadPoolMap(std::pair<toml::string, std::pair<std::size_t, std::size_t>> &&_pr);
 
private:
    static inline std::map<toml::string, spdlog::sink_ptr> mSinkMap{};
 
    static inline std::map<toml::string, toml::string> mPatternMap{};
 
    static inline std::map<toml::string, std::pair<std::size_t, std::size_t>> mThreadPoolMap{};
};
 
#define createRotatingFileSinkStPtr createRotatingFileSinkPtr<spdlog::details::null_mutex>
 
#define createRotatingFileSinkMtPtr createRotatingFileSinkPtr<std::mutex>
 
#define createFileSinkStPtr createFileSinkPtr<spdlog::details::null_mutex>
 
#define createFileSinkMtPtr createFileSinkPtr<std::mutex>
 
#define createDailyFileSinkStPtr createDailyFileSinkPtr<spdlog::details::null_mutex>
 
#define createDailyFileSinkMtPtr createDailyFileSinkPtr<std::mutex>
 
#define createStdoutSinkStPtr createStdoutSinkPtr<spdlog::details::console_nullmutex>
 
#define createStdoutSinkMtPtr createStdoutSinkPtr<spdlog::details::console_mutex>
 
#define createStderrSinkStPtr createStderrSinkPtr<spdlog::details::console_nullmutex>
#define createStderrSinkMtPtr createStderrSinkPtr<spdlog::details::console_mutex>
 
#define createStdoutColorSinkStPtr createStdoutColorSinkPtr<spdlog::details::console_nullmutex>
 
#define createStdoutColorSinkMtPtr createStdoutColorSinkPtr<spdlog::details::console_mutex>
 
#define createStderrColorSinkStPtr createStderrColorSinkPtr<spdlog::details::console_nullmutex>
#define createStderrColorSinkMtPtr createStderrColorSinkPtr<spdlog::details::console_mutex>
 
#ifdef __linux__
#define createSyslogSinkStPtr createSyslogSinkPtr<spdlog::details::null_mutex>
 
#define createSyslogSinkMtPtr createSyslogSinkPtr<std::mutex>
 
#elif _WIN32
#define createMsvcSinkStPtr createMsvcSinkPtr<spdlog::details::null_mutex>
 
#define createMsvcSinkMtPtr createMsvcSinkPtr<std::mutex>
#endif
 
bool inTypelist(std::string const &typeStr, std::vector<std::string> const &strList);
 
auto createRotatingFileSinkTuple(toml::table const &sinkTable, toml::string &&baseFilename,
                                 std::size_t const &maxFiles)
        -> std::tuple<toml::string const, std::size_t const, std::size_t const>;
 
template<typename Mutex>
auto createRotatingFileSinkPtr(toml::table const &sinkTable, toml::string &&baseFilename,
                               std::size_t const &maxFiles)
        -> std::shared_ptr<spdlog::sinks::rotating_file_sink<Mutex>>
{
    auto tup = createRotatingFileSinkTuple(sinkTable, std::move(baseFilename), maxFiles);
    return std::make_shared<spdlog::sinks::rotating_file_sink<Mutex>>(std::get<0>(tup), std::get<1>(tup),
                                                                      std::get<2>(tup));
}
 
auto createFileSinkTuple(toml::table const &sinkTable, bool const &truncate)
        -> std::tuple<toml::string const, bool const>;
 
template<typename Mutex>
auto createFileSinkPtr(toml::table const &sinkTable, bool const &truncate)
        -> std::shared_ptr<spdlog::sinks::basic_file_sink<Mutex>>
{
    auto tup = createFileSinkTuple(sinkTable, truncate);
    return std::make_shared<spdlog::sinks::basic_file_sink<Mutex>>(std::get<0>(tup), std::get<1>(tup));
}
 
auto createDailyFileSinkTuple(toml::table &&sinkTable, bool const &truncate, toml::string &&baseFilename,
                              uint16_t const &maxFiles)
        -> std::tuple<toml::string const, int const, int const, bool const, uint16_t const>;
 
template<typename Mutex>
auto createDailyFileSinkPtr(toml::table &&sinkTable, bool const &truncate, toml::string &&baseFilename,
                            uint16_t const &maxFiles) -> std::shared_ptr<spdlog::sinks::daily_file_sink<Mutex>>
{
    auto tup = createDailyFileSinkTuple(std::move(sinkTable), truncate, std::move(baseFilename), maxFiles);
    return std::make_shared<spdlog::sinks::daily_file_sink<Mutex>>(std::get<0>(tup), std::get<1>(tup), std::get<2>(tup),
                                                                   std::get<3>(tup), std::get<4>(tup));
}
 
auto createNullSinkPtr() -> std::shared_ptr<spdlog::sinks::null_sink<spdlog::details::null_mutex>>;
 
template<typename Mutex>
auto createStdoutSinkPtr() -> std::shared_ptr<spdlog::sinks::stdout_sink<Mutex>>
{
    return std::make_shared<spdlog::sinks::stdout_sink<Mutex>>();
}
 
template<typename Mutex>
auto createStderrSinkPtr() -> std::shared_ptr<spdlog::sinks::stderr_sink<Mutex>>
{
    return std::make_shared<spdlog::sinks::stderr_sink<Mutex>>();
}
 
#ifdef _WIN32
template<typename Mutex>
auto createStdoutColorSinkPtr() -> std::shared_ptr<spdlog::sinks::wincolor_stdout_sink<Mutex>>
{
    return std::make_shared<spdlog::sinks::wincolor_stdout_sink<Mutex>>();
}
 
template<typename Mutex>
auto createStderrColorSinkPtr() -> std::shared_ptr<spdlog::sinks::wincolor_stderr_sink<Mutex>>
{
    return std::make_shared<spdlog::sinks::wincolor_stderr_sink<Mutex>>();
}
 
#else
template<typename Mutex>
auto createStdoutColorSinkPtr() -> std::shared_ptr<spdlog::sinks::ansicolor_stdout_sink<Mutex>>
{
    return std::make_shared<spdlog::sinks::ansicolor_stdout_sink<Mutex>>();
}
 
template<typename Mutex>
auto createStderrColorSinkPtr() -> std::shared_ptr<spdlog::sinks::ansicolor_stderr_sink<Mutex>>
{
    return std::make_shared<spdlog::sinks::ansicolor_stderr_sink<Mutex>>();
}
 
#endif
 
#ifdef __linux__
auto createSyslogSinkTuple(toml::table const &sinkTable)
        -> std::tuple<toml::string const, int const, int const, bool const>;
 
template<typename Mutex>
auto createSyslogSinkPtr(toml::table &&sinkTable) -> std::shared_ptr<spdlog::sinks::syslog_sink<Mutex>>
{
    auto tup = createSyslogSinkTuple(std::move(sinkTable));
    return std::make_shared<spdlog::sinks::syslog_sink<Mutex>>(std::get<0>(tup), std::get<1>(tup), std::get<2>(tup),
                                                               std::get<3>(tup));
}
 
#elif _WIN32
template<typename Mutex>
auto createMsvcSinkPtr() -> std::shared_ptr<spdlog::sinks::msvc_sink<Mutex>>
{
    return std::make_shared<spdlog::sinks::msvc_sink<Mutex>>();
}
#endif
 
auto genFromFileStr(toml::string &&typeStr, toml::table &&sinkTable, bool const &truncate) -> spdlog::sink_ptr;
 
auto genFromRotateStr(toml::string &&typeStr, toml::table &&sinkTable, toml::string &&baseFilename,
                      std::size_t const &maxFiles) -> spdlog::sink_ptr;
 
auto genFromDailyStr(toml::string &&typeStr, toml::table &&sinkTable, bool const &truncate,
                     toml::string &&baseFilename, uint16_t const &maxFiles) -> spdlog::sink_ptr;
 
auto genFromNullOrStdStr(toml::string &&typeStr) -> spdlog::sink_ptr;
 
#ifdef __linux__
auto genFromLinuxStr(toml::string &&typeStr, toml::table &&sinkTable) -> spdlog::sink_ptr;
 
#elif _WIN32
auto genFromWinStr(toml::string &&typeStr) -> spdlog::sink_ptr;
 
#endif
 
} // namespace KDSPDSetup::details