Added an example program showing how to setup a logger hook

examples/CMakeLists.txt

@@ -50,6 +50,7 @@ add_example(krr_regression_ex)
 add_example(learning_to_track_ex)
 add_example(least_squares_ex)
 add_example(linear_manifold_regularizer_ex)
+add_example(logger_custom_output_ex)
 add_example(logger_ex)
 add_example(logger_ex_2)
 add_example(matrix_ex)

examples/logger_custom_output_ex.cpp

+// The contents of this file are in the public domain. See LICENSE_FOR_EXAMPLE_PROGRAMS.txt
+
+/*
+
+    This is an example showing how to control where the dlib::logger sends its messages.
+    This is done by creating a "hook" class that is called whenever any of the loggers want
+    to log a message.  The hook class then outputs the messages using any method you like.
+
+
+    Prior to reading this example, you should understand the basics of the dlib::logger.
+    So you should have already read the logger_ex.cpp and logger_ex_2.cpp example programs.
+
+*/
+
+
+#include <dlib/logger.h>
+
+using namespace dlib;
+using namespace std;
+
+class my_hook
+{
+public:
+    my_hook(
+    ) 
+    {
+        fout.open("my_log_file.txt");
+    }
+
+    void log (
+        const string& logger_name,
+        const log_level& ll,
+        const uint64 thread_id,
+        const char* message_to_log
+    )
+    {
+        // Log all messages from any logger to our log file.
+        fout << ll << " ["<<thread_id<<"] " << logger_name << ": " << message_to_log << endl;
+
+        // But only log messages that are of LINFO priority or higher to the console.
+        if (ll >= LINFO)
+            cout << ll << " ["<<thread_id<<"] " << logger_name << ": " << message_to_log << endl;
+    }
+
+private:
+    ofstream fout;
+};
+
+int main()
+{
+    my_hook hook;
+    // This tells all dlib loggers to send their logging events to the hook object.  That
+    // is, any time a logger generates a message it will call hook.log() with the message
+    // contents.  Additionally, hook.log() will also only be called from one thread at a
+    // time so it is safe to use this kind of hook in a multi-threaded program with many
+    // loggers in many threads.
+    set_all_logging_output_hooks(hook);
+    // It should also be noted that the hook object must not be destructed while the
+    // loggers are still in use.  So it is a good idea to declare the hook object 
+    // somewhere where it will live the entire lifetime of the program, as we do here.
+
+
+    logger dlog("main");
+    // Tell the dlog logger to emit a message for all logging events rather than its
+    // default behavior of only logging LERROR or above. 
+    dlog.set_level(LALL);
+
+    // All these message go to my_log_file.txt, but only the last two go to the console.
+    dlog << LDEBUG << "This is a debugging message.";
+    dlog << LINFO  << "This is an informational message.";
+    dlog << LERROR << "An error message!";
+}
+