add 'context' property to loggingzeug. #71

source/examples/logging/main.cpp

@@ -6,11 +6,18 @@ using namespace loggingzeug;
 
 int main(int argc, char const *argv[])
 {
-    info() << "Info";
-    debug() << "Debug";
-    warning() << "Warning";
-    critical() << "Critical";
-    fatal() << "Fatal";
-
+
+    info() << "A normal info message.";
+    debug() << "A normal debug message.";
+    warning() << "A normal warning message.";
+    critical() << "A normal critical message.";
+    fatal() << "A normal fatal message." << std::endl;
+
+
+    info("A") << "Info message from context A";
+    warning("B") << "Warning from context B";
+    fatal("C") << "Fatal message from context C" << std::endl;
+
+
     return 0;
 }

source/loggingzeug/include/loggingzeug/ConsoleLogHandler.h

@@ -20,6 +20,7 @@ class LOGGINGZEUG_API ConsoleLogHandler : public AbstractLogHandler
     virtual void handle(const LogMessage & message) override;
 
 protected:
+    static std::string messagePrefix(const LogMessage & message);
     static std::string levelString(LogMessage::Level level);
 };
 

source/loggingzeug/include/loggingzeug/LogMessage.h

@@ -27,14 +27,16 @@ class LOGGINGZEUG_API LogMessage
 		Info
 	};
 
-	LogMessage(Level level, const std::string& message);
+	LogMessage(Level level, const std::string& message, const std::string& context);
 
 	Level level() const;
 	const std::string& message() const;
+	const std::string& context() const;
 
 protected:
 	Level m_level;
 	std::string m_message;
+	std::string m_context;
 };
 
 } // namespace loggingzeug

source/loggingzeug/include/loggingzeug/LogMessageBuilder.h

@@ -48,7 +48,7 @@ class LOGGINGZEUG_API LogMessageBuilder
     using FillManipulator = decltype(std::setfill('0'));
     using WidthManipulator = decltype(std::setw(0));
 public:
-    LogMessageBuilder(LogMessage::Level level, AbstractLogHandler * handler);
+    LogMessageBuilder(LogMessage::Level level, AbstractLogHandler * handler, const std::string & context);
     LogMessageBuilder(const LogMessageBuilder & builder);
 	virtual ~LogMessageBuilder();
 
@@ -88,6 +88,7 @@ class LOGGINGZEUG_API LogMessageBuilder
 protected:
 	LogMessage::Level m_level;
     AbstractLogHandler * m_handler;
+    std::string m_context;
     std::shared_ptr<std::stringstream> m_stream;
 };
 

source/loggingzeug/include/loggingzeug/baselogging.h

@@ -20,11 +20,11 @@ class LogMessageBuilder;
   * info() << "Message: " << 3.14;
   * \endcode
   */
-LOGGINGZEUG_API LogMessageBuilder info(LogMessage::Level level = LogMessage::Info);
-LOGGINGZEUG_API LogMessageBuilder debug();
-LOGGINGZEUG_API LogMessageBuilder warning();
-LOGGINGZEUG_API LogMessageBuilder critical();
-LOGGINGZEUG_API LogMessageBuilder fatal();
+LOGGINGZEUG_API LogMessageBuilder info(const std::string & context = "", LogMessage::Level level = LogMessage::Info);
+LOGGINGZEUG_API LogMessageBuilder debug(const std::string & context = "");
+LOGGINGZEUG_API LogMessageBuilder warning(const std::string & context = "");
+LOGGINGZEUG_API LogMessageBuilder critical(const std::string & context = "");
+LOGGINGZEUG_API LogMessageBuilder fatal(const std::string & context = "");
 
 LOGGINGZEUG_API void setLoggingHandler(AbstractLogHandler * handler);
 LOGGINGZEUG_API AbstractLogHandler * loggingHandler();
@@ -37,38 +37,38 @@ LOGGINGZEUG_API LogMessage::Level verbosityLevel();
  *
  *  Sample usage:
  *  \code{.cpp}
- *      info("This is a test: %; pi = %+0E10.5;", 42, 3.141592653589793); // output: "This is a test: 42 pi = +3.14159E+00"
- *      info("%; - %X; - %rf?_10.2;", "a string", 255, 2.71828182846); // output: "a string - 255 - ______2.72"
+ *      fInfo("This is a test: %; pi = %+0E10.5;", 42, 3.141592653589793); // output: "This is a test: 42 pi = +3.14159E+00"
+ *      fInfo("%; - %X; - %rf?_10.2;", "a string", 255, 2.71828182846); // output: "a string - 255 - ______2.72"
  *  \endcode
  *
  *   \see formatString
  */
 template <typename... Arguments>
-void info(const char* format, Arguments... arguments);
+void fInfo(const char* format, Arguments... arguments);
 
 /**
- *  \see info
+ *  \see fInfo
  */
 template <typename... Arguments>
-void debug(const char* format, Arguments... arguments);
+void fDebug(const char* format, Arguments... arguments);
 
 /**
- *  \see info
+ *  \see fInfo
  */
 template <typename... Arguments>
-void warning(const char* format, Arguments... arguments);
+void fWarning(const char* format, Arguments... arguments);
 
 /**
- *  \see info
+ *  \see fInfo
  */
 template <typename... Arguments>
-void critical(const char* format, Arguments... arguments);
+void fCritical(const char* format, Arguments... arguments);
 
 /**
- *  \see info
+ *  \see fInfo
  */
 template <typename... Arguments>
-void fatal(const char* format, Arguments... arguments);
+void fFatal(const char* format, Arguments... arguments);
 
 } // namespace loggingzeug
 

source/loggingzeug/include/loggingzeug/baselogging.hpp

@@ -9,35 +9,35 @@
 namespace loggingzeug
 {
 
-template <typename... Arguments> void info(const char* format, Arguments... arguments)
+template <typename... Arguments> void fInfo(const char* format, Arguments... arguments)
 {
     assert(format != nullptr);
 
     info() << formatString(format, arguments...);
 }
 
-template <typename... Arguments> void debug(const char* format, Arguments... arguments)
+template <typename... Arguments> void fDebug(const char* format, Arguments... arguments)
 {
     assert(format != nullptr);
 
     debug() << formatString(format, arguments...);
 }
 
-template <typename... Arguments> void warning(const char* format, Arguments... arguments)
+template <typename... Arguments> void fWarning(const char* format, Arguments... arguments)
 {
     assert(format != nullptr);
 
     warning() << formatString(format, arguments...);
 }
 
-template <typename... Arguments> void critical(const char* format, Arguments... arguments)
+template <typename... Arguments> void fCritical(const char* format, Arguments... arguments)
 {
     assert(format != nullptr);
 
     critical() << formatString(format, arguments...);
 }
 
-template <typename... Arguments> void fatal(const char* format, Arguments... arguments)
+template <typename... Arguments> void fFatal(const char* format, Arguments... arguments)
 {
     assert(format != nullptr);
 

source/loggingzeug/source/ConsoleLogHandler.cpp

@@ -5,24 +5,43 @@
 namespace loggingzeug
 {
 
-void ConsoleLogHandler::handle(const LogMessage& message)
+void ConsoleLogHandler::handle(const LogMessage & message)
 {
     if (LogMessage::Info > message.level())
-	    std::cerr << levelString(message.level()) << message.message() << std::endl;
+	    std::cerr << messagePrefix(message) << message.message() << std::endl;
     else
-        std::cout << levelString(message.level()) << message.message() << std::endl;
+        std::cout << messagePrefix(message) << message.message() << std::endl;
+}
+
+std::string ConsoleLogHandler::messagePrefix(const LogMessage & message)
+{
+	std::string prefix = levelString(message.level());
+
+
+	if (!message.context().empty())
+	{
+		if (!prefix.empty())
+			prefix = prefix + " ";
+
+		prefix = prefix + "[" + message.context() + "]";
+	}
+
+	if (prefix.empty())
+		return prefix;
+
+	return prefix + ": ";
 }
 
 std::string ConsoleLogHandler::levelString(LogMessage::Level level)
 {
 	switch (level)
 	{
 	case LogMessage::Fatal:
-		return "#fatal: ";
+		return "#fatal";
 	case LogMessage::Critical:
-		return "#critical: ";
+		return "#critical";
 	case LogMessage::Warning:
-		return "#warning: ";
+		return "#warning";
 	default:
 		return "";
 	}

source/loggingzeug/source/LogMessage.cpp

@@ -3,9 +3,10 @@
 namespace loggingzeug
 {
 
-LogMessage::LogMessage(Level level, const std::string& message)
+LogMessage::LogMessage(Level level, const std::string& message, const std::string& context)
 : m_level(level)
 , m_message(message)
+, m_context(context)
 {
 }
 
@@ -16,7 +17,12 @@ LogMessage::Level LogMessage::level() const
 
 const std::string& LogMessage::message() const
 {
-	return m_message;
+    return m_message;
+}
+
+const std::string& LogMessage::context() const
+{
+    return m_context;
 }
 
 } // namespace loggingzeug

source/loggingzeug/source/LogMessageBuilder.cpp

@@ -10,9 +10,10 @@
 namespace loggingzeug
 {
 
-LogMessageBuilder::LogMessageBuilder(LogMessage::Level level, AbstractLogHandler * handler)
+LogMessageBuilder::LogMessageBuilder(LogMessage::Level level, AbstractLogHandler * handler, const std::string & context)
 : m_level(level)
 , m_handler(handler)
+, m_context(context)
 , m_stream(new std::stringstream)
 {
     assert(handler != nullptr);
@@ -21,6 +22,7 @@ LogMessageBuilder::LogMessageBuilder(LogMessage::Level level, AbstractLogHandler
 LogMessageBuilder::LogMessageBuilder(const LogMessageBuilder & builder)
 : m_level(builder.m_level)
 , m_handler(builder.m_handler)
+, m_context(builder.m_context)
 , m_stream(builder.m_stream)
 {
 }
@@ -31,7 +33,7 @@ LogMessageBuilder::~LogMessageBuilder()
         return;
 
 	if (m_handler)
-        m_handler->handle(LogMessage(m_level, m_stream->str()));
+        m_handler->handle(LogMessage(m_level, m_stream->str(), m_context));
 }
 
 LogMessageBuilder & LogMessageBuilder::operator<<(const char * c)

source/loggingzeug/source/baselogging.cpp

@@ -15,29 +15,29 @@ namespace
 namespace loggingzeug
 {
 
-LogMessageBuilder info(LogMessage::Level level)
+LogMessageBuilder info(const std::string & context, LogMessage::Level level)
 {
-    return LogMessageBuilder(level, level <= l_verbosityLevel ? l_logHandler : nullptr);
+    return LogMessageBuilder(level, level <= l_verbosityLevel ? l_logHandler : nullptr, context);
 }
 
-LogMessageBuilder debug()
+LogMessageBuilder debug(const std::string & context)
 {
-    return info(LogMessage::Debug);
+    return info(context, LogMessage::Debug);
 }
 
-LogMessageBuilder warning()
+LogMessageBuilder warning(const std::string & context)
 {
-    return info(LogMessage::Warning);
+    return info(context, LogMessage::Warning);
 }
 
-LogMessageBuilder critical()
+LogMessageBuilder critical(const std::string & context)
 {
-    return info(LogMessage::Critical);
+    return info(context, LogMessage::Critical);
 }
 
-LogMessageBuilder fatal()
+LogMessageBuilder fatal(const std::string & context)
 {
-    return info(LogMessage::Fatal);
+    return info(context, LogMessage::Fatal);
 }
 
 AbstractLogHandler * loggingHandler()