Adding default logging schema data

- Includes support for the %t thread-id specifier.
- This doesn't actually do anything, at the moment.

include/logger/properties.h

@@ -23,4 +23,7 @@ namespace logging {
     const std::vector<properties> array;
     const std::string value;
   };
+  
+  extern properties const DEFAULT_APPENDER_SCHEMA;
+  extern properties const DEFAULT_LOGGER_SCHEMA;
 }

src/format.cxx

@@ -60,6 +60,8 @@ namespace logging {
       return [](logpacket const & lp){ return to_string(lp.level, true); };
     } else if (is('m')) {
       return [](logpacket const & lp){ return lp.message.str(); };
+    } else if (is('t')) {
+      return [](logpacket const & lp){ return "???"; };
     } else {
       std::string error_msg{"unknown format character: '"};
       throw unknown_format_specifier{error_msg + *next + "'"};

src/log_manager.cxx

@@ -31,15 +31,23 @@ using p_layout = std::shared_ptr<layout>;
 using p_logger = std::shared_ptr<logger_impl>;
 
 struct logging::manager_impl {
+  template <typename V> using cache = std::unordered_map<std::string, V>;
+  
+  manager_impl();
   p_logger get_logger(properties const & props);
   void configure_appenders(properties const & props);
   void configure_loggers(properties const & props);
 
   p_logger default_logger;
-  std::unordered_map<std::string, std::pair<p_appender, p_layout>> appenders;
-  std::unordered_map<std::string, p_logger> loggers;
+  cache<std::pair<p_appender, p_layout>> appenders;
+  cache<p_logger> loggers;
 };
 
+manager_impl::manager_impl() {
+  configure_appenders(DEFAULT_APPENDER_SCHEMA);
+  configure_loggers(DEFAULT_LOGGER_SCHEMA);
+}
+
 std::shared_ptr<logger_impl>
 manager_impl::get_logger(properties const & props) {
   auto out = std::make_shared<logger_impl>();
@@ -89,7 +97,7 @@ void manager_impl::configure_appenders(properties const & props) {
     auto pair = std::make_pair(load_appender(app.first, app.second),
                                load_layout(app.first, app.second));
     inject_log_level(app.second, *pair.first);
-    appenders.emplace(app.first, pair);
+    appenders[app.first] = pair;
   }
 }
 
@@ -98,7 +106,7 @@ void manager_impl::configure_loggers(properties const & props) {
   for (auto & log : props["loggers"].obj) {
     auto plog = get_logger(log.second["appenders"]);
     inject_log_level(log.second, *plog);
-    loggers.emplace(log.first, plog);
+    loggers[log.first] = plog;
   }
   if (loggers.count("root")) {
     default_logger = loggers["root"];

src/loggers/properties.cxx

@@ -23,9 +23,9 @@ namespace logging {
     properties _property(std::map<std::string, properties> const& m) {
       return properties{properties::OBJECT, m, {}, {}};
     }
-    properties _list(std::vector<properties> const& l) {
-      return properties{properties::ARRAY, {}, l, {}};
-    }
+//    properties _list(std::vector<properties> const& l) {
+//      return properties{properties::ARRAY, {}, l, {}};
+//    }
     properties _value(std::string const& s) {
       return properties{properties::STRING, {}, {}, s};
     }
@@ -43,43 +43,33 @@ namespace logging {
    *
    */
   
-  properties const STDOUT_DEFAULT_SCHEMA{
-    _property({
-      {"type", _value("Console")},
-      {"name", _value("Console")},
-      {"target", _value("SYSTEM_OUT")},
-      {
-        "data", _list({
-          _property({
-            {"type", _value("PatternLayout")},
-            {"pattern", _value("%d{%h:%M:%s.%_ms} [%t] %-5.5p %.36c - %m%n")}
-          })
-        })
-      }
-    })
-  };
+  extern properties const DEFAULT_APPENDER_SCHEMA;
+  extern properties const DEFAULT_LOGGER_SCHEMA;
   
-  properties const LOGGER_DEFAULT_SCHEMA {
-    _property({
-      {"type", _value("Root")},
-      {"level", _value("Error")},
-      {
-        "data", _list({
-          _property({
-            {"type", _value("AppenderRef")},
-            {"ref", _value("Console")}
-          })
-        })
-      }
-    })
-  };
+  static char const * const DEFAULT_PATTERN =
+    "%d{%h:%M:%s.%_ms} [%t] %-5.5p %.36c - %m%n";
+
+  properties const DEFAULT_APPENDER_SCHEMA{_property({
+    {"appenders", _property({
+      {"Console", _property({
+        {"target", _value("SYSTEM_OUT")},
+        {"PatternLayout", _property({
+          {"pattern", _value(DEFAULT_PATTERN)}
+        })}
+      })}
+    })}
+  })};
   
-  properties const DEFAULT_SCHEMA{
-    _property({
-      {"Appenders",_list({STDOUT_DEFAULT_SCHEMA})},
-      {"Loggers",_list({LOGGER_DEFAULT_SCHEMA})}
-    })
-  };
+  properties const DEFAULT_LOGGER_SCHEMA{_property({
+    {"loggers", _property({
+      {"root", _property({
+        {"level", _value("Error")},
+        {"appenders", _property({
+          {"ref", _value("Console")}
+        })}
+      })}
+    })}
+  })};
   
   properties::operator std::string const &() const {
     expects(type == STRING, invalid_property_type, "expected STRING");