add

+/**************************************************************************
+* file:              dmplogger.cpp
+
+* Author:            wanzhongping
+* Date:              2021-03-03 10:29:10
+* Email:             zhongpingw@chinadci.com
+* copyright:         广州城市信息研究所有限公司
+***************************************************************************/
+
+#include "dmplogger.h"
+#include <iostream>
+#include <fstream>
+#include <boost/core/ref.hpp>
+#include <boost/bind/bind.hpp>
+#include <boost/log/common.hpp>
+#include <boost/log/expressions.hpp>
+#include <boost/log/attributes/timer.hpp>
+#include <boost/log/attributes/named_scope.hpp>
+#include <boost/log/sources/logger.hpp>
+#include <boost/log/support/date_time.hpp>
+#include <boost/log/utility/setup/file.hpp>
+#include <boost/log/utility/setup/common_attributes.hpp>
+#include <boost/log/utility/setup/from_stream.hpp>
+#include <boost/log/utility/setup/filter_parser.hpp>
+#include <boost/log/utility/setup/formatter_parser.hpp>
+#include <boost/format.hpp>
+
+namespace logging = boost::log;
+namespace src = boost::log::sources;
+namespace expr = boost::log::expressions;
+namespace sinks = boost::log::sinks;
+namespace keywords = boost::log::keywords;
+namespace attrs = boost::log::attributes;
+
+static src::severity_logger< SeverityLevel > slg;
+static std::string sConfigName = "log.config";
+
+//! Formatting operator for severity levels
+std::ostream& operator<< (std::ostream& strm, SeverityLevel level)
+{
+    static const char* const str[] =
+    {
+        "debug",
+        "info",
+        "warning",
+        "error",
+        "critical"
+    };
+    if (static_cast< std::size_t >(level) < (sizeof(str) / sizeof(*str)))
+        strm << str[level];
+    else
+        strm << static_cast< int >(level);
+    return strm;
+}
+
+//! Parsing operator for severity levels
+std::istream& operator>> (std::istream& strm, SeverityLevel& level)
+{
+    if (strm.good())
+    {
+        std::string str;
+        strm >> str;
+        if (str == "debug")
+            level = debug_level;
+        else if (str == "info")
+            level = info_level;
+        else if (str == "warning")
+            level = warn_level;
+        else if (str == "error")
+            level = error_level;
+        else if (str == "critical")
+            level = critical_level;
+        else
+            strm.setstate(std::ios_base::failbit);
+    }
+
+    return strm;
+}
+
+//! Our custom formatter for the scope list
+struct scope_list_formatter
+{
+    typedef void result_type;
+    typedef attrs::named_scope::value_type scope_stack;
+
+    explicit scope_list_formatter(logging::attribute_name const& name) :
+        name_(name)
+    {
+    }
+    void operator()(logging::record_view const& rec, logging::formatting_ostream& strm) const
+    {
+        // We need to acquire the attribute value from the log record
+        logging::visit< scope_stack >
+        (
+            name_,
+            rec.attribute_values(),
+            boost::bind(&scope_list_formatter::format, boost::placeholders::_1, boost::ref(strm))
+        );
+    }
+
+private:
+    //! This is where our custom formatting takes place
+    static void format(scope_stack const& scopes, logging::formatting_ostream& strm)
+    {
+        scope_stack::const_iterator it = scopes.begin(), end = scopes.end();
+        for (; it != end; ++it)
+        {
+            strm << it->scope_name << " (" << it->file_name << ":" << it->line << ")";
+        }
+    }
+
+private:
+    logging::attribute_name name_;
+};
+
+class my_scopes_formatter_factory : public logging::formatter_factory< char >
+{
+public:
+    /*!
+     * This function creates a formatter for the MyScopes attribute.
+     * It effectively associates the attribute with the scope_list_formatter class
+     */
+    formatter_type create_formatter(logging::attribute_name const& attr_name, args_map const& args)
+    {
+        return formatter_type(scope_list_formatter(attr_name));
+    }
+};
+
+
+
+DmpLogger::DmpLogger()
+{
+    Init();
+}
+
+DmpLogger::~DmpLogger()
+{
+}
+
+void DmpLogger::Init()
+{
+    // First thing - register the custom formatter for MyScopes
+    logging::register_formatter_factory("Scope", boost::make_shared< my_scopes_formatter_factory >());
+
+    // Also register filter and formatter factories for our custom severity level enum. Since our operator<< and operator>> implement
+    // all required behavior, simple factories provided by Boost.Log will do.
+    logging::register_simple_filter_factory< SeverityLevel >("Severity");
+    logging::register_simple_formatter_factory< SeverityLevel, char >("Severity");
+
+
+    // Open the setting file
+    std::ifstream settings(sConfigName);
+    boost::format fmt = boost::format("Could not open %s file!") % sConfigName;
+    
+    if (!settings.is_open())
+        // throw std::runtime_error("Could not open log.config file!");
+        throw std::runtime_error(fmt.str());
+    
+    logging::init_from_stream(settings);
+
+    // Also let's add some commonly used attributes, like timestamp and record counter.
+    logging::add_common_attributes();
+    logging::core::get()->add_thread_attribute("Scope", attrs::named_scope());
+
+    slg.add_attribute("Uptime", attrs::timer());
+}
+
+void DmpLogger::Debug(const std::string &msg)
+{
+	BOOST_LOG_SEV(slg, debug_level) << msg;
+}
+
+void DmpLogger::Info(const std::string &msg)
+{
+	BOOST_LOG_SEV(slg, info_level) << msg;
+}
+
+void DmpLogger::Warn(const std::string &msg)
+{
+	BOOST_LOG_SEV(slg, warn_level) << msg;
+}
+
+void DmpLogger::Error(const std::string &msg)
+{
+	BOOST_LOG_SEV(slg, error_level) << msg;
+}
+
+void DmpLogger::Critical(const std::string &msg)
+{
+	BOOST_LOG_SEV(slg, critical_level) << msg;
+}
+
+void DmpLogger::SetLevel(SeverityLevel level)
+{
+    logging::core::get()->set_filter(expr::attr< SeverityLevel >("Severity") >= level);
+}
+
+DmpLogger *DmpLogger::Instance()
+{
+    static DmpLogger logger;
+    return &logger;
+}