Adds further ext deps as-is binaries copies from customers env.

external/tmsif/include/ddkit/utils/Logger.hpp

@@ -0,0 +1,166 @@
+#pragma once
+
+#include "ddkit/utils/container.hpp"
+#include "ddkit/utils/system.hpp"
+
+#include <sstream>
+#include <string>
+#include <queue>
+#include <memory>
+#include <functional>
+
+// platforms either define __FUNCSIG__ (MSVC), or __PRETTY_FUNCTION__ (gcc, clang)
+#ifdef _WIN32
+#define DDKIT_LOG_FUNCSIG __FUNCSIG__ 
+#else
+#define DDKIT_LOG_FUNCSIG __PRETTY_FUNCTION__ 
+#endif
+
+#define DDKIT_LOG_LOCATION (ddkit::utils::system::filename(std::string(__FILE__)) + ":" + __LINE__)
+#define DDKIT_LOG_LOCATION_STREAM ddkit::utils::system::filename(std::string(__FILE__)) << ":" << __LINE__ << ":" << DDKIT_LOG_FUNCSIG
+#define DDKIT_LOG_VAR_VALUE(val) #val << "==" << (val)
+
+// Only for trace, there would be anyway a macro needed for line
+#define DDKIT_LOG_TRACE ddkit::utils::log::trace() << "(" << DDKIT_LOG_LOCATION_STREAM << ") "
+
+namespace ddkit {
+namespace base {
+
+class IConfig;
+class Config;
+}
+
+namespace utils {
+namespace log {
+
+enum class Level {
+    None  = 0x0,  // 0b00000000
+    Fatal = 0x1,  // 0b00000001
+    Error = 0x3,  // 0b00000011
+    Warn  = 0x7,  // 0b00000111
+    Info  = 0xF,  // 0b00001111
+    // ?? = 0x1F, // 0b00011111 RESERVED
+    Debug = 0x3F, // 0b00111111
+    // ?? = 0x7F, // 0b01111111 RESERVED
+    Trace = 0xFF, // 0b11111111
+};
+
+class Sink;
+typedef std::shared_ptr<Sink> SinkPtr;
+
+class Logger {
+
+using SinkFactoryFunction = std::function<SinkPtr(const base::IConfig&)>;
+
+public:
+    static void loadConfig(const base::Config&);
+    static void registerSinkType(const std::string& id, const SinkFactoryFunction& factory);
+    static void installSink(const std::string& id, const base::IConfig&);
+    static void installSink(SinkPtr);
+    static void write(Level, const std::string&);
+    static void uninstallAllSinks();
+    static Level getHighestUsedLevel();
+private:
+    Logger();
+    Logger(const Logger&) = delete;
+    static Logger& instance();
+    static std::string getPrefix(Level);
+
+    // shared_ptr/SinkPtr is used to circumvent the issue of having a collection of pure virtual class
+    std::vector<SinkPtr> m_sinks;
+    std::map<std::string, SinkFactoryFunction> m_sinkTypes;
+
+    // stored for performance reasons, aids in aborting early in LineBuilder if the log level isnt used
+    Level mHighestLevel;
+};
+
+class Sink {
+
+public:
+    template<class Type> class Registrar;
+    Sink(const base::IConfig&);
+    virtual ~Sink(){}
+    virtual void write(Level level, const std::string& prefix, const std::string& line) = 0;
+
+    void setLevel(Level);
+    void setLevel(const std::string&);
+    Level getLevel() const;
+
+private:
+    Sink() = delete;
+
+protected:
+    Level m_level;
+};
+
+template<class Type> class Sink::Registrar {
+
+public:
+    Registrar() = delete;
+    // Registrar<FileSink>("file")
+    Registrar(const std::string& id){
+        Logger::registerSinkType(id, [](const base::IConfig& config){
+            return std::make_shared<Type>(config);
+        });
+    }
+
+    // Registrar<OStreamSink>("cerr", std::cerr)
+    template<class Param> Registrar(const std::string& id, Param& param){
+        auto pRef = std::ref(param);
+        Logger::registerSinkType(id, [pRef](const base::IConfig& config){
+            return std::make_shared<Type>(config, pRef.get());
+        });
+    }
+};
+
+/// @brief Stores a number of strings and writes them to log on destruction
+class LineBuilder {
+
+public:
+    LineBuilder(Level);
+    LineBuilder() = delete; 
+    LineBuilder(const LineBuilder&) = delete; 
+    LineBuilder(LineBuilder&&); 
+    ~LineBuilder();
+    LineBuilder& operator<<(const std::string&);
+    LineBuilder& operator<<(bool);
+
+    template<typename T> LineBuilder& operator<<(const T& value){
+        if(Logger::getHighestUsedLevel() < m_level) return *this; // early abort for performance gains
+
+        m_line << value << " ";
+        return *this;
+    }
+
+    template<typename T> LineBuilder& operator<<(const std::vector<T>& vec){
+        if(Logger::getHighestUsedLevel() < m_level) return *this; // early abort for performance gains
+
+        m_line << "[";
+        for(auto it = vec.begin(); it != vec.end(); it++){
+            *this << *it;
+            if(vec.end() - it != 1){ // all except for the last element
+                m_line << ", ";
+            }
+        }
+        *this << "] ";
+        return *this;
+    }
+
+private:
+    Level m_level;
+    std::ostringstream m_line;
+};
+
+LineBuilder fatal();
+LineBuilder error();
+LineBuilder warn();
+LineBuilder info();
+LineBuilder debug();
+LineBuilder trace();
+
+} // namespace log
+} // namespace utils
+
+namespace log = ddkit::utils::log;
+
+} // namespace ddkit