KDSPDSetup::setup Namespace Reference

This namespace contains the functions directly called by KDSPDSetup::setupFrom, along with helpers called by those functions. The file which contains the definitions for members of KDSPDSetup::setup, setup.h, is included in the implementation file kdspdsetup.cpp The functions defined in this namespace make use of the members of namespace KDSPDSetup::details, defined in details.h. More...

Functions
void	handleMultipleFileSink (toml::string &&typeStr, toml::table &&sinkTable, spdlog::sink_ptr &sinkPtr, bool const &truncate)
	Helper function for setting up sinks that use multiple files. The function extracts values for base_filename and max_files from the given table, which are needed by the constructors of these types of sinks. Based on the type specified in typeStr, either KDSPDSetup::details::genFromRotateStr or KDSPDSetup::details::genFromDailyStr are invoked with these values. This function is called by KDSPDSetup::setup::handleTruncatableSink when typeStr specifies a rotating or daily file sink. More...
void	handleTruncatableSink (toml::string &&typeStr, toml::table &&sinkTable, spdlog::sink_ptr &sinkPtr)
	Helper function for setting up file-based sinks that require a truncate argument in their constructor. Further narrows down the type after determining value of truncate and calls either KDSPDSetup::details::genFromFileStr or KDSPDSetup::setup::handleMultipleFileSink. This function is invoked by KDSPDSetup::setup::setupSink. More...
void	setupSink (toml::table &&sinkTable)
	Given a table representation of a sink, creates an spdlog::sink_ptr, and evaluates the type of sink specified in the table. Based on the type, calls additional functions to parse type-specific fields and construct the sink with the correct constructor. Adds the resultant sink to KDSPDSetup::details::SPDMaps::mSinkMap, which is used to obtain sink pointers by name when constructing loggers. More...
void	setupSinks (toml::value const &data)
	Using data read from a toml file, extract vector of tables representing every sink specified. Call KDSPDSetup::setup::setupSink on each table in the vector to create an spdlog sink for each. These sinks are put into KDSPDSetup::details::SPDMaps::mSinkMap, which is later indexed when constructing loggers to obtain the named sink pointers. More...
void	setupPatterns (toml::value const &data)
	Using data read from a toml file, search for the key global_pattern. If it exists, use its string value as the global pattern for spdlog by passing it to spdlog::set_pattern. Search again for a table called pattern. If found, extract vector of tables representing every pattern specified. For each table in the vector, add the name and pattern format string specified to KDSPDSetup::details::SPDMaps::mPatternMap. This map is used when constructing loggers that will use non-global patterns to format messages, allowing indexing of format strings by name. More...
void	setupThreadPools (toml::value const &data)
	Using data read from a toml file, search for a table global_thread_pool, and initialize it with the specified queue size and thread count fields by calling spdlog::init_thread_pool. Search again for a table thread_pool. If found, extract vector of tables representing every threadpool specified. For each table in the vector, add the name, queue size, and thread count specified to KDSPDSetup::details::SPDMaps::mThreadPoolMap. This map is used to index threadpool information by name when constructing asynchronous loggers. More...
void	registerAsynchronousLogger (toml::table const &loggerTable, toml::string const &name, std::vector< spdlog::sink_ptr > const &sinkList, toml::string const &pattern)
	Creates an std::shared_ptr<spdlog::async_logger> initialized with name, the sink pointers in sinklist, a thread pool pointer, and an overflow policy. The thread pool pointer is constructed with values obtained by indexing KDSPDSetup::details::SPDMaps::mThreadPoolMap by the specified thread_pool name in loggerTable. If not specified, the thread pool is set to spdlog::thread_pool(). The overflow policy is searched for in loggerTable, and defaults to "block" if not found. The function also sets a formatting pattern if pattern is nonempty before registering the logger by calling spdlog::register_logger. More...
void	registerSynchronousLogger (toml::table const &loggerTable, toml::string const &name, std::vector< spdlog::sink_ptr > const &sinkList, toml::string const &pattern)
	Creates an std::shared_ptr<spdlog::logger> initialized with name and the sink pointers in sinklist, sets the logger's pattern if nonempty and level if specified in loggerTable, and registers the logger by calling spdlog::register_logger on the shared_ptr. More...
void	setupLogger (toml::table const &loggerTable)
	Given a table representation of a logger whose name is not already registered with spdlog, evaluates whether the logger's specified type is asynchronous or not, and calls either KDSPDSetup::setup::registerAsynchronousLogger or KDSPDSetup::setup::registerSynchronousLogger accordingly. These functions are called with loggerTable, the specified name, a list of sink pointers, and the specified pattern, if found. The list of sink pointers is obtained by indexing KDSPDSetup::details::SPDMaps::mSinkMap with names specified in a list in the loggerTable. More...
void	setupLoggers (toml::value const &data)
	Using data read from a toml file, extract vector of tables representing every logger specified. Call KDSPDSetup::setup::setupLogger on each table in the vector to create and register an spdlog logger for each. The loggers should then be available through spdlog::get. More...

Detailed Description

This namespace contains the functions directly called by KDSPDSetup::setupFrom, along with helpers called by those functions. The file which contains the definitions for members of KDSPDSetup::setup, setup.h, is included in the implementation file kdspdsetup.cpp The functions defined in this namespace make use of the members of namespace KDSPDSetup::details, defined in details.h.

Function Documentation

handleMultipleFileSink()

void KDSPDSetup::setup::handleMultipleFileSink	(	toml::string &&	typeStr,
		toml::table &&	sinkTable,
		spdlog::sink_ptr &	sinkPtr,
		bool const &	truncate
	)

Helper function for setting up sinks that use multiple files. The function extracts values for base_filename and max_files from the given table, which are needed by the constructors of these types of sinks. Based on the type specified in typeStr, either KDSPDSetup::details::genFromRotateStr or KDSPDSetup::details::genFromDailyStr are invoked with these values. This function is called by KDSPDSetup::setup::handleTruncatableSink when typeStr specifies a rotating or daily file sink.

Parameters

typeStr	String of the sink's type, which is checked against string vectors in KDSPDSetup::details
sinkTable	toml11 table representation for a particular sink specified in a configuration file.
sinkPtr	An uninitialized sink pointer, which will be passed to functions that construct a sink. This pointer is eventually put into KDSPDSetup::details::SPDMaps::mSinkMap at the bottom of KDSPDSetup::setup::setupSink.
truncate	The value for truncate obtained in caller KDSPDSetup::setup::handleTruncatableSink.

Definition at line 18 of file setup.cpp.

{
    auto baseFilename = sinkTable.at("base_filename").as_string();
    auto maxFiles = (sinkTable.contains("max_files")) ? static_cast<uint16_t>(sinkTable.at("max_files").as_integer()) : uint16_t{ 0 };
 
    if (details::inTypelist(typeStr, details::rotateStrs)) {
        sinkPtr = details::genFromRotateStr(std::move(typeStr), std::move(sinkTable), std::move(baseFilename), maxFiles);
    }
 
    else if (details::inTypelist(typeStr, details::dailyStrs)) {
        sinkPtr = details::genFromDailyStr(std::move(typeStr), std::move(sinkTable), truncate, std::move(baseFilename), maxFiles);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

handleTruncatableSink()

void KDSPDSetup::setup::handleTruncatableSink	(	toml::string &&	typeStr,
		toml::table &&	sinkTable,
		spdlog::sink_ptr &	sinkPtr
	)

Helper function for setting up file-based sinks that require a truncate argument in their constructor. Further narrows down the type after determining value of truncate and calls either KDSPDSetup::details::genFromFileStr or KDSPDSetup::setup::handleMultipleFileSink. This function is invoked by KDSPDSetup::setup::setupSink.

Parameters

typeStr	String of the sink's type, which is checked against string vectors in KDSPDSetup::details
sinkTable	toml11 table representation for a particular sink specified in a configuration file.
sinkPtr	An uninitialized sink pointer, which will be passed to functions that construct a sink. This pointer is eventually put into KDSPDSetup::details::SPDMaps::mSinkMap at the bottom of KDSPDSetup::setup::setupSink.

Definition at line 32 of file setup.cpp.

{
    auto const truncate = (sinkTable.contains("truncate")) ? sinkTable.at("truncate").as_boolean() : false;
 
    if (details::inTypelist(typeStr, details::fileStrs)) {
        sinkPtr = details::genFromFileStr(std::move(typeStr), std::move(sinkTable), truncate);
    } else if (details::inTypelist(typeStr, details::rotateStrs) || details::inTypelist(typeStr, details::dailyStrs)) {
        handleMultipleFileSink(std::move(typeStr), std::move(sinkTable), sinkPtr, truncate);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

registerAsynchronousLogger()

void KDSPDSetup::setup::registerAsynchronousLogger	(	toml::table const &	loggerTable,
		toml::string const &	name,
		std::vector< spdlog::sink_ptr > const &	sinkList,
		toml::string const &	pattern
	)

Creates an std::shared_ptr<spdlog::async_logger> initialized with name, the sink pointers in sinklist, a thread pool pointer, and an overflow policy. The thread pool pointer is constructed with values obtained by indexing KDSPDSetup::details::SPDMaps::mThreadPoolMap by the specified thread_pool name in loggerTable. If not specified, the thread pool is set to spdlog::thread_pool(). The overflow policy is searched for in loggerTable, and defaults to "block" if not found. The function also sets a formatting pattern if pattern is nonempty before registering the logger by calling spdlog::register_logger.

Parameters

loggerTable	toml11 table representation for a particular logger specified in a configuration file.
name	A string with the name of the logger. This name is used to construct the logger and access it with spdlog::get.
sinkList	A vector of spdlog::sink_ptr objects to use as the sinks for the logger.
pattern	The format string for messages the logger will output. If empty, the logger uses the global pattern set up earlier in KDSPDSetup::setup::setupPatterns, or spdlog's default pattern if the global pattern was not created.

Definition at line 150 of file setup.cpp.

{
    auto const threadPool = (loggerTable.contains("thread_pool")) ? loggerTable.at("thread_pool").as_string() : "";
 
    static std::shared_ptr<spdlog::details::thread_pool> threadPoolPtr;
 
    if (threadPool != "") {
        if (!details::SPDMaps::threadPoolMap().contains(threadPool))
            throw std::out_of_range("KDSPDSetup: threadpool "s + threadPool.str + " not found"s);
 
        auto const threadPoolPair = details::SPDMaps::threadPoolMap().at(threadPool);
        auto const queueSize = threadPoolPair.first;
        auto const numThreads = threadPoolPair.second;
        threadPoolPtr = std::make_shared<spdlog::details::thread_pool>(queueSize, numThreads);
    } else {
        threadPoolPtr = spdlog::thread_pool();
    }
 
    auto const overflowPolicy =
            (loggerTable.contains("overflow_policy")) ? loggerTable.at("overflow_policy").as_string() : "block";
 
    if (!details::overflowMap.contains(overflowPolicy))
        throw std::out_of_range("KDSPDSetup: overflow policy "s + overflowPolicy.str + " not found"s);
 
    auto logger = std::make_shared<spdlog::async_logger>(name, sinkList.begin(), sinkList.end(), std::move(threadPoolPtr),
                                                         details::overflowMap.at(overflowPolicy));
 
    if (pattern != "") {
        logger->set_pattern(pattern);
    }
 
    spdlog::register_logger(logger);
}

Here is the call graph for this function:

Here is the caller graph for this function:

registerSynchronousLogger()

void KDSPDSetup::setup::registerSynchronousLogger	(	toml::table const &	loggerTable,
		toml::string const &	name,
		std::vector< spdlog::sink_ptr > const &	sinkList,
		toml::string const &	pattern
	)

Creates an std::shared_ptr<spdlog::logger> initialized with name and the sink pointers in sinklist, sets the logger's pattern if nonempty and level if specified in loggerTable, and registers the logger by calling spdlog::register_logger on the shared_ptr.

Parameters

loggerTable	toml11 table representation for a particular logger specified in a configuration file.
name	A string with the name of the logger. This name is used to construct the logger and access it with spdlog::get.
sinkList	A vector of spdlog::sink_ptr objects to use as the sinks for the logger.
pattern	The format string for messages the logger will output. If empty, the logger uses the global pattern set up earlier in KDSPDSetup::setup::setupPatterns, or spdlog's default pattern if the global pattern was not created.

Definition at line 185 of file setup.cpp.

{
    auto logger = std::make_shared<spdlog::logger>(name, sinkList.cbegin(), sinkList.cend());
    if (pattern != "") {
        logger->set_pattern(static_cast<std::string>(pattern));
    }
 
    if (loggerTable.contains("level")) {
        auto const level = loggerTable.at("level").as_string();
 
        if (!details::levelMap.contains(level))
            throw std::out_of_range("KDSPDSetup: level "s + level.str + " not found"s);
 
        logger->set_level(details::levelMap.at(level));
    }
 
    spdlog::register_logger(logger);
}

Here is the caller graph for this function:

setupLogger()

void KDSPDSetup::setup::setupLogger

(

toml::table const &

loggerTable

)

Given a table representation of a logger whose name is not already registered with spdlog, evaluates whether the logger's specified type is asynchronous or not, and calls either KDSPDSetup::setup::registerAsynchronousLogger or KDSPDSetup::setup::registerSynchronousLogger accordingly. These functions are called with loggerTable, the specified name, a list of sink pointers, and the specified pattern, if found. The list of sink pointers is obtained by indexing KDSPDSetup::details::SPDMaps::mSinkMap with names specified in a list in the loggerTable.

Parameters

loggerTable

toml11 table representation for a particular logger specified in a configuration file. Passed in by KDSPDSetup::setup::setupLoggers.

Definition at line 205 of file setup.cpp.

{
    auto const name = loggerTable.at("name").as_string();
    if (spdlog::get(name) != nullptr) {
        return;
    }
 
    auto const sinks = loggerTable.at("sinks").as_array();
 
    auto sinkList = std::vector<spdlog::sink_ptr>{};
    for (auto &&sink : sinks) {
        if (details::SPDMaps::sinkMap().contains(sink.as_string())) {
            sinkList.emplace_back(details::SPDMaps::sinkMap().at(sink.as_string()));
        } else {
            // ignore sink instead of throwing, but notify that this happens
            std::cerr << "KDSPDSetup: setting up logger " << name
                      << " - skipped sink " << sink.as_string().str << " as it was not found";
        }
    }
 
    std::string pattern = "";
 
    if (loggerTable.contains("pattern")) {
        if (!details::SPDMaps::patternMap().contains(loggerTable.at("pattern").as_string()))
            throw std::out_of_range("KDSPDSetup: pattern "s + loggerTable.at("pattern").as_string().str + " not found"s);
 
        pattern = details::SPDMaps::patternMap().at(loggerTable.at("pattern").as_string());
    }
 
    auto const type = (loggerTable.contains("type")) ? loggerTable.at("type").as_string() : "";
 
    if (type == "async") {
        registerAsynchronousLogger(loggerTable, name, sinkList, pattern);
    } else {
        registerSynchronousLogger(loggerTable, name, sinkList, pattern);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

setupLoggers()

void KDSPDSetup::setup::setupLoggers

(

toml::value const &

data

)

Using data read from a toml file, extract vector of tables representing every logger specified. Call KDSPDSetup::setup::setupLogger on each table in the vector to create and register an spdlog logger for each. The loggers should then be available through spdlog::get.

Parameters

data	toml11 representation of the configuration file.

Definition at line 243 of file setup.cpp.

{
    auto const loggers = toml::find<std::vector<toml::table>>(data, "logger");
    for (auto &&loggerTable : loggers) {
        setupLogger(loggerTable);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

setupPatterns()

void KDSPDSetup::setup::setupPatterns

(

toml::value const &

data

)

Using data read from a toml file, search for the key global_pattern. If it exists, use its string value as the global pattern for spdlog by passing it to spdlog::set_pattern. Search again for a table called pattern. If found, extract vector of tables representing every pattern specified. For each table in the vector, add the name and pattern format string specified to KDSPDSetup::details::SPDMaps::mPatternMap. This map is used when constructing loggers that will use non-global patterns to format messages, allowing indexing of format strings by name.

Parameters

data	toml11 representation of the configuration file.

Definition at line 108 of file setup.cpp.

{
    if (data.contains("global_pattern")) {
        auto const globalPattern = toml::find<toml::string>(data, "global_pattern");
        spdlog::set_pattern(globalPattern);
    }
 
    if (data.contains("pattern")) {
        auto const patterns = toml::find<std::vector<toml::table>>(data, "pattern");
 
        for (auto &&patternTable : patterns) {
            auto const name = patternTable.at("name").as_string();
            auto const value = patternTable.at("value").as_string();
 
            details::SPDMaps::emplacePatternMap(std::make_pair(name, value));
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

setupSink()

void KDSPDSetup::setup::setupSink

(

toml::table &&

sinkTable

)

Given a table representation of a sink, creates an spdlog::sink_ptr, and evaluates the type of sink specified in the table. Based on the type, calls additional functions to parse type-specific fields and construct the sink with the correct constructor. Adds the resultant sink to KDSPDSetup::details::SPDMaps::mSinkMap, which is used to obtain sink pointers by name when constructing loggers.

Parameters

sinkTable

toml11 table representation for a particular sink specified in a configuration file. Passed in by KDSPDSetup::setup::setupSinks.

Definition at line 43 of file setup.cpp.

{
    spdlog::sink_ptr sinkPtr;
 
    auto const name = sinkTable.at("name").as_string();
    auto typeStr = sinkTable.at("type").as_string();
 
    bool ok = false;
    for (auto &typeList : { details::fileStrs, details::rotateStrs, details::dailyStrs, details::nullStrs, details::stdStrs, details::linuxStrs, details::winStrs }) {
        if (details::inTypelist(typeStr, typeList)) {
            ok = true;
            break;
        }
    }
 
    if (!ok)
        throw std::out_of_range("KDSPDSetup: sink type "s + typeStr.str + " is not valid"s);
 
    toml::string level = "";
    if (sinkTable.contains("level")) {
        level = sinkTable.at("level").as_string();
    }
 
    if (details::inTypelist(typeStr, details::fileStrs) || details::inTypelist(typeStr, details::rotateStrs) ||
        details::inTypelist(typeStr, details::dailyStrs)) {
        handleTruncatableSink(std::move(typeStr), std::move(sinkTable), sinkPtr);
    }
 
    else if (details::inTypelist(typeStr, details::nullStrs) || details::inTypelist(typeStr, details::stdStrs)) {
        sinkPtr = details::genFromNullOrStdStr(std::move(typeStr));
    }
 
    else if (details::inTypelist(typeStr, details::linuxStrs)) {
#ifdef __linux__
        sinkPtr = details::genFromLinuxStr(std::move(typeStr), std::move(sinkTable));
#else
        return;
#endif
    } else if (details::inTypelist(typeStr, details::winStrs)) {
#ifdef _WIN32
        sinkPtr = details::genFromWinStr(std::move(typeStr));
#else
        return;
#endif
    }
 
    if (level != "") {
        if (!details::levelMap.contains(level))
            throw std::out_of_range("KDSPDSetup: level "s + level.str + " not found"s);
 
        sinkPtr->set_level(details::levelMap.at(level));
    }
 
    details::SPDMaps::emplaceSinkMap(std::make_pair(name, sinkPtr));
}

Here is the call graph for this function:

Here is the caller graph for this function:

setupSinks()

void KDSPDSetup::setup::setupSinks

(

toml::value const &

data

)

Using data read from a toml file, extract vector of tables representing every sink specified. Call KDSPDSetup::setup::setupSink on each table in the vector to create an spdlog sink for each. These sinks are put into KDSPDSetup::details::SPDMaps::mSinkMap, which is later indexed when constructing loggers to obtain the named sink pointers.

Parameters

data	toml11 representation of the configuration file.

Definition at line 99 of file setup.cpp.

{
    auto sinks = toml::find<std::vector<toml::table>>(data, "sink");
 
    for (auto &&sinkTable : sinks) {
        setupSink(std::move(sinkTable));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

setupThreadPools()

void KDSPDSetup::setup::setupThreadPools

(

toml::value const &

data

)

Using data read from a toml file, search for a table global_thread_pool, and initialize it with the specified queue size and thread count fields by calling spdlog::init_thread_pool. Search again for a table thread_pool. If found, extract vector of tables representing every threadpool specified. For each table in the vector, add the name, queue size, and thread count specified to KDSPDSetup::details::SPDMaps::mThreadPoolMap. This map is used to index threadpool information by name when constructing asynchronous loggers.

Parameters

data	toml11 representation of the configuration file.

Definition at line 127 of file setup.cpp.

{
    if (data.contains("global_thread_pool")) {
        auto const globalThreadPool = toml::find(data, "global_thread_pool");
 
        auto const queueSize = toml::find<std::size_t>(globalThreadPool, "queue_size");
        auto const numThreads = toml::find<std::size_t>(globalThreadPool, "num_threads");
        spdlog::init_thread_pool(queueSize, numThreads);
    }
 
    if (data.contains("thread_pool")) {
        auto const threadPools = toml::find<std::vector<toml::table>>(data, "thread_pool");
 
        for (auto &&poolTable : threadPools) {
            auto const name = poolTable.at("name").as_string();
            auto const queueSize = static_cast<std::size_t>(poolTable.at("queue_size").as_integer());
            auto const numThreads = static_cast<std::size_t>(poolTable.at("num_threads").as_integer());
 
            details::SPDMaps::emplaceThreadPoolMap(std::make_pair(name, std::make_pair(queueSize, numThreads)));
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function: