Clean up generator_t overrides to not repeat themselves.

src/loggers/pattern_layout.h

@@ -17,10 +17,8 @@ namespace logging {
   public:
     struct generator_t {
       virtual ~generator_t() = default;
-      virtual std::string str(logpacket const & lp) const = 0;
-      virtual void write(logpacket const & lp, std::ostream & os) const {
-        os << str(lp);
-      }
+      std::string str(logpacket const & lp) const;
+      virtual void write(logpacket const & lp, std::ostream & os) const = 0;
     };
   public:
     enum class token_id {

src/loggers/pattern_layout_date.cxx

@@ -34,25 +34,27 @@ static std::string fmt_time_with_milis(struct timeval round,
   return fmt_time(round, buf);
 }
 
-namespace {
-  struct time_gen : public logging::format::generator_t {
+namespace logging {
+  struct time_gen : public format::generator_t {
     enum resolution { seconds, milis };
+    
     time_gen(std::string const & pre, resolution res)
     : predef_format(pre), res(res) {}
-    std::string str(logging::logpacket const & lp) const override {
+    
+    void write(logpacket const & lp, std::ostream & os) const override {
       switch (res) {
         case seconds:
-          return fmt_time(lp.time, predef_format.c_str());
+          os << fmt_time(lp.time, predef_format.c_str());
+          break;
         case milis:
-          return fmt_time_with_milis(lp.time, predef_format);
+          os << fmt_time_with_milis(lp.time, predef_format);
+        break;
       }
     }
     std::string predef_format;
     resolution res;
   };
-}
 
-namespace logging {
   format::generator parse_date_format_string(char const * str) {
     char const * const end = strchr(str, '}');
     if (end == nullptr) {

src/loggers/pattern_layout_format.cxx

@@ -24,9 +24,6 @@
 
 namespace logging { namespace {
   struct log_handle_gen : public format::generator_t {
-    std::string str(logpacket const & lp) const override {
-      return lp.logger;
-    }
     void write(logpacket const & lp, std::ostream & os) const override {
       os << lp.logger;
     }
@@ -34,21 +31,21 @@ namespace logging { namespace {
   
   struct thread_name_gen : public detail::thread_info_helper,
                            public format::generator_t {
-    std::string str(logpacket const &) const override {
-      return thread_name();
+    void write(logpacket const & lp, std::ostream & os) const override {
+      os << thread_name();
     }
   };
 
   struct time_elapsed_gen : public detail::time_elapsed_helper,
                             public format::generator_t {
-    std::string str(logpacket const & lp) const override {
-      return elapsed(lp);
+    void write(logpacket const & lp, std::ostream & os) const override {
+      os << elapsed(lp);
     }
   };
 
   struct level_gen : public format::generator_t {
-    std::string str(logpacket const & lp) const override {
-      return to_string(lp.level, true);
+    void write(logpacket const & lp, std::ostream & os) const override {
+      os << to_string(lp.level, true);
     }
   };
   
@@ -65,8 +62,8 @@ namespace logging { namespace {
     class_info_gen(char const * token)
         : detail::calling_class_helper(components(token)) {}
 
-    std::string str(logpacket const & lp) const override {
-      return full_name(lp, "::");
+    void write(logpacket const & lp, std::ostream & os) const override {
+      os << full_name(lp, "::");
     }
   };
   
@@ -81,38 +78,49 @@ namespace logging { namespace {
     };
 
     location_info_gen(char wh) : where(format_codes[wh]) {}
-    static std::string str(logpacket const & lp, decltype(where) wh) {
+    
+    static void write(logpacket const & lp, std::ostream & os,
+                      decltype(where) wh) {
       switch (wh) {
         case file:
-          return lp.info.filename;
+          os << lp.info.filename;
+          break;
         case line:
-          return std::to_string(lp.info.line);
+          os << std::to_string(lp.info.line);
+          break;
         case method:
-          return lp.info.function;
+          os << lp.info.function;
+          break;
         case classname:
-          return class_info_gen(0).str(lp);
+          class_info_gen(0).write(lp, os);
+          break;
         case location:
-          return str(lp, classname) + "::" + str(lp, method) + " (" +
-              str(lp, file) + ", " + str(lp, line) + ")";
+          write(lp, os, classname);
+          os << "::";
+          write(lp, os, method);
+          os << " (";
+          write(lp, os, file);
+          os << ", ";
+          write(lp, os, line);
+          os << ")";
+        break;
       }
     }
     
-    std::string str(logpacket const & lp) const override {
-      return str(lp, where);
+    void write(logpacket const & lp, std::ostream & os) const override {
+      write(lp, os, where);
     }
   };
 
   struct message_gen : public format::generator_t {
-    std::string str(logpacket const & lp) const override {
-      return lp.message.str();
+    void write(logpacket const & lp, std::ostream & os) const override {
+      os << lp.message.str();
     }
   };
   
   struct literal_gen : public format::generator_t {
     literal_gen(std::string const & value) : value(value) {}
-    std::string str(logpacket const & lp) const override {
-      return value;
-    }
+
     void write(logpacket const & lp, std::ostream & os) const override {
       os << value;
     }
@@ -122,12 +130,10 @@ namespace logging { namespace {
   struct bounds_gen : public format::generator_t {
     bounds_gen(format::generator impl, bool is_left, int min, size_t max)
     : impl(impl), is_left(is_left), min(min), max(max) {}
-    std::string str(logpacket const & lp) const override {
-      return impl->str(lp);
-    }
+    
     void write(logpacket const & lp, std::ostream & os) const override {
       auto align = is_left ? std::left : std::right;
-      std::string str = this->str(lp);
+      std::string str = impl->str(lp);
       if (str.length() > max) {
         str.erase(str.begin()+max, str.end());
       }
@@ -141,6 +147,12 @@ namespace logging { namespace {
 } }
 
 namespace logging {
+  std::string format::generator_t::str(logpacket const & lp) const {
+    std::stringstream ss;
+    write(lp, ss);
+    return ss.str();
+  }
+  
 #define is( chr ) *next == chr
 #define is_string( str ) ! strncmp(next, str, strlen(str))
   format::generator date_token(char const * next);