Add whatever I was working on for the last month

4 files changed, 212 insertions, 0 deletions

diff --git a/deps/include/spdlog/cfg/argv.h b/deps/include/spdlog/cfg/argv.h
new file mode 100644
index 0000000..5eaebf3
--- /dev/null
+++ b/deps/include/spdlog/cfg/argv.h
@@ -0,0 +1,40 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+

+#pragma once

+#include <spdlog/cfg/helpers.h>

+#include <spdlog/details/registry.h>

+

+//

+// Init log levels using each argv entry that starts with "SPDLOG_LEVEL="

+//

+// set all loggers to debug level:

+// example.exe "SPDLOG_LEVEL=debug"

+

+// set logger1 to trace level

+// example.exe "SPDLOG_LEVEL=logger1=trace"

+

+// turn off all logging except for logger1 and logger2:

+// example.exe "SPDLOG_LEVEL=off,logger1=debug,logger2=info"

+

+namespace spdlog {

+namespace cfg {

+

+// search for SPDLOG_LEVEL= in the args and use it to init the levels

+inline void load_argv_levels(int argc, const char **argv) {

+    const std::string spdlog_level_prefix = "SPDLOG_LEVEL=";

+    for (int i = 1; i < argc; i++) {

+        std::string arg = argv[i];

+        if (arg.find(spdlog_level_prefix) == 0) {

+            auto levels_string = arg.substr(spdlog_level_prefix.size());

+            helpers::load_levels(levels_string);

+        }

+    }

+}

+

+inline void load_argv_levels(int argc, char **argv) {

+    load_argv_levels(argc, const_cast<const char **>(argv));

+}

+

+}  // namespace cfg

+}  // namespace spdlog

diff --git a/deps/include/spdlog/cfg/env.h b/deps/include/spdlog/cfg/env.h
new file mode 100644
index 0000000..11fa620
--- /dev/null
+++ b/deps/include/spdlog/cfg/env.h
@@ -0,0 +1,36 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+

+#pragma once

+#include <spdlog/cfg/helpers.h>

+#include <spdlog/details/os.h>

+#include <spdlog/details/registry.h>

+

+//

+// Init levels and patterns from env variables SPDLOG_LEVEL

+// Inspired from Rust's "env_logger" crate (https://crates.io/crates/env_logger).

+// Note - fallback to "info" level on unrecognized levels

+//

+// Examples:

+//

+// set global level to debug:

+// export SPDLOG_LEVEL=debug

+//

+// turn off all logging except for logger1:

+// export SPDLOG_LEVEL="*=off,logger1=debug"

+//

+

+// turn off all logging except for logger1 and logger2:

+// export SPDLOG_LEVEL="off,logger1=debug,logger2=info"

+

+namespace spdlog {

+namespace cfg {

+inline void load_env_levels() {

+    auto env_val = details::os::getenv("SPDLOG_LEVEL");

+    if (!env_val.empty()) {

+        helpers::load_levels(env_val);

+    }

+}

+

+}  // namespace cfg

+}  // namespace spdlog

diff --git a/deps/include/spdlog/cfg/helpers-inl.h b/deps/include/spdlog/cfg/helpers-inl.h
new file mode 100644
index 0000000..d2c31e0
--- /dev/null
+++ b/deps/include/spdlog/cfg/helpers-inl.h
@@ -0,0 +1,107 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+

+#pragma once

+

+#ifndef SPDLOG_HEADER_ONLY

+    #include <spdlog/cfg/helpers.h>

+#endif

+

+#include <spdlog/details/os.h>

+#include <spdlog/details/registry.h>

+#include <spdlog/spdlog.h>

+

+#include <algorithm>

+#include <sstream>

+#include <string>

+#include <utility>

+

+namespace spdlog {

+namespace cfg {

+namespace helpers {

+

+// inplace convert to lowercase

+inline std::string &to_lower_(std::string &str) {

+    std::transform(str.begin(), str.end(), str.begin(), [](char ch) {

+        return static_cast<char>((ch >= 'A' && ch <= 'Z') ? ch + ('a' - 'A') : ch);

+    });

+    return str;

+}

+

+// inplace trim spaces

+inline std::string &trim_(std::string &str) {

+    const char *spaces = " \n\r\t";

+    str.erase(str.find_last_not_of(spaces) + 1);

+    str.erase(0, str.find_first_not_of(spaces));

+    return str;

+}

+

+// return (name,value) trimmed pair from given "name=value" string.

+// return empty string on missing parts

+// "key=val" => ("key", "val")

+// " key  =  val " => ("key", "val")

+// "key=" => ("key", "")

+// "val" => ("", "val")

+

+inline std::pair<std::string, std::string> extract_kv_(char sep, const std::string &str) {

+    auto n = str.find(sep);

+    std::string k, v;

+    if (n == std::string::npos) {

+        v = str;

+    } else {

+        k = str.substr(0, n);

+        v = str.substr(n + 1);

+    }

+    return std::make_pair(trim_(k), trim_(v));

+}

+

+// return vector of key/value pairs from sequence of "K1=V1,K2=V2,.."

+// "a=AAA,b=BBB,c=CCC,.." => {("a","AAA"),("b","BBB"),("c", "CCC"),...}

+inline std::unordered_map<std::string, std::string> extract_key_vals_(const std::string &str) {

+    std::string token;

+    std::istringstream token_stream(str);

+    std::unordered_map<std::string, std::string> rv{};

+    while (std::getline(token_stream, token, ',')) {

+        if (token.empty()) {

+            continue;

+        }

+        auto kv = extract_kv_('=', token);

+        rv[kv.first] = kv.second;

+    }

+    return rv;

+}

+

+SPDLOG_INLINE void load_levels(const std::string &input) {

+    if (input.empty() || input.size() > 512) {

+        return;

+    }

+

+    auto key_vals = extract_key_vals_(input);

+    std::unordered_map<std::string, level::level_enum> levels;

+    level::level_enum global_level = level::info;

+    bool global_level_found = false;

+

+    for (auto &name_level : key_vals) {

+        auto &logger_name = name_level.first;

+        auto level_name = to_lower_(name_level.second);

+        auto level = level::from_str(level_name);

+        // ignore unrecognized level names

+        if (level == level::off && level_name != "off") {

+            continue;

+        }

+        if (logger_name.empty())  // no logger name indicate global level

+        {

+            global_level_found = true;

+            global_level = level;

+        } else {

+            levels[logger_name] = level;

+        }

+    }

+

+    details::registry::instance().set_levels(std::move(levels),

+                                             global_level_found ? &global_level : nullptr);

+}

+

+}  // namespace helpers

+}  // namespace cfg

+}  // namespace spdlog

diff --git a/deps/include/spdlog/cfg/helpers.h b/deps/include/spdlog/cfg/helpers.h
new file mode 100644
index 0000000..507f9f0
--- /dev/null
+++ b/deps/include/spdlog/cfg/helpers.h
@@ -0,0 +1,29 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.

+// Distributed under the MIT License (http://opensource.org/licenses/MIT)

+

+#pragma once

+

+#include <spdlog/common.h>

+#include <unordered_map>

+

+namespace spdlog {

+namespace cfg {

+namespace helpers {

+//

+// Init levels from given string

+//

+// Examples:

+//

+// set global level to debug: "debug"

+// turn off all logging except for logger1: "off,logger1=debug"

+// turn off all logging except for logger1 and logger2: "off,logger1=debug,logger2=info"

+//

+SPDLOG_API void load_levels(const std::string &txt);

+}  // namespace helpers

+

+}  // namespace cfg

+}  // namespace spdlog

+

+#ifdef SPDLOG_HEADER_ONLY

+    #include "helpers-inl.h"

+#endif  // SPDLOG_HEADER_ONLY