Add clean logs support + dependent MR

Description

Add some mechanisms to add log support to Vivy.

• A LogSink is an object that will collect all the logs and emit them to a file, stderr, or in a Qt widget
• A Logger is the object used to create log message and submit them to the sink
• A LogMessage is a message, a line of log. You should not create it yourself, but use the macros or defined methods. They are submitted on destruction, so don't try things like auto msg = VIVY_LOG_WARN(appLog); msg << "toto"; unless you know what you are doing. If you don't pay attention, you might get log messages in a different order than what you originally wanted.

Example

Here is a small demo:

// Custom sink
VIVY_DCL_LOG_SINK(logSink) // Declare a Sink
std::shared_ptr<Logger> scriptLog = VIVY_GET_LOGGER(mySink, SCRIPT); // Custom logger
VIVY_LOG_WARN(scriptLog) << "This is" << ' ' << "very usefull!"; // Use the custom logger

// With the vivyApp's sink
class Object {
    // Add a logger to the sink and add log methods to the object
    VIVY_APP_LOGGABLE_OBJECT(Object, logger)

public:
    // ...
};

TODO List

• Create and use the API
• The simple stderr dispatcher
• The VivyConsoleDispatcher -> a dock widget with the MainWindow, like the console with VSCode or Eclipse
• Create the LogDispatcherThread -> flush at regular intervals the LogSink

Also merge dependent MR with this one to uniformize the logging process

src/Lib/Log.hh

@@ -119,22 +119,28 @@ public:
 // Class used to check the messageQueue and send needFlush or something like
 // that messages. It needs to be moved to its own thread and connected with the
 // queue version of the QObject::connect method.
-template <class MutexType, class MessageQueueType> class LogSinkUpdater final {
-    MutexType *const messageQueueLock;
-    MessageQueueType *const messageQueue;
+template <class Mutex, class MessageQueue>
+requires MutexType<Mutex>
+class LogSinkUpdater final {
+    VIVY_UNMOVABLE_OBJECT(LogSinkUpdater)
 
-    using size_type = typename MessageQueueType::size_type;
+    Mutex *const messageQueueLock;
+    MessageQueue *const messageQueue;
+
+    using size_type = typename MessageQueue::size_type;
 
 public:
-    explicit LogSinkUpdater(MutexType *const lock, MessageQueueType *const queue) noexcept
+    explicit LogSinkUpdater(Mutex *const lock, MessageQueue *const queue)
         : messageQueueLock(lock)
         , messageQueue(queue)
     {
+        if (lock == nullptr || queue == nullptr)
+            throw std::logic_error("Can't pass null pointers for the queue and its lock");
     }
 
     bool isMessageAvailable() const noexcept
     {
-        std::lock_guard<MutexType> lockGuard(*messageQueueLock);
+        std::lock_guard<Mutex> lockGuard(*messageQueueLock);
         size_type size = messageQueue->size();
         return size != 0;
     }
@@ -142,9 +148,12 @@ public:
 
 // LogSinkUpdater controller, needed because templated Q_OBJECT are not
 // supported by Qt. This controller is specialized for a std implementation of
-// the message queue.
+// the message queue. For a Qt version use the following types:
+//      using MutexType        = QMutex;
+//      using MessageQueueType = QVector<QTuple<QStringView, LogMessage>>;
 class StlLogSinkUpdater final : public QThread {
     Q_OBJECT
+    VIVY_UNMOVABLE_OBJECT(StlLogSinkUpdater)
 
 public:
     using MutexType        = std::mutex;