Merge branch 'refactor/msgcollect' into develop

src/app/app_module.cpp

@@ -220,13 +220,15 @@ bool AppModule::fromVariant(Property* prop, const Settings::Variant& variant) co
 
 void AppModule::emitMessage(MessageType msgType, std::string_view text)
 {
-    const QString qtext = to_QString(text);
+    const std::string stext{text};
+    const Messenger::Message* msg = nullptr;
     {
         [[maybe_unused]] std::lock_guard<std::mutex> lock(m_mutexMessageLog);
-        m_messageLog.push_back({ msgType, qtext });
+        m_messageLog.push_back({ msgType, stext });
+        msg = &m_messageLog.back();
     }
 
-    this->signalMessage.send(msgType, qtext);
+    this->signalMessage.send(*msg);
 }
 
 void AppModule::clearMessageLog()

src/app/app_module.h

@@ -44,12 +44,6 @@ class AppModule :
 {
     MAYO_DECLARE_TEXT_ID_FUNCTIONS(Mayo::AppModule)
 public:
-    // Loggable message
-    struct Message {
-        MessageType type;
-        QString text;
-    };
-
     // Query singleton instance
     static AppModule* get();
 
@@ -87,7 +81,7 @@ class AppModule :
     // Logging
     void clearMessageLog();
     Span<const Message> messageLog() const { return m_messageLog; }
-    Signal<MessageType, QString> signalMessage;
+    Signal<const Messenger::Message&> signalMessage;
     Signal<> signalMessageLogCleared;
 
     // Recent files
@@ -135,7 +129,7 @@ class AppModule :
     Settings* m_settings = nullptr;
     IO::System m_ioSystem;
     AppModuleProperties m_props;
-    std::vector<Message> m_messageLog;
+    std::vector<Messenger::Message> m_messageLog;
     std::mutex m_mutexMessageLog;
     std::locale m_stdLocale;
     QLocale m_qtLocale;

src/app/mainwindow.cpp

@@ -11,6 +11,7 @@
 #include "../base/global.h"
 #include "../gui/gui_application.h"
 #include "../gui/gui_document.h"
+#include "../qtcommon/qstring_conv.h"
 #include "../qtcommon/qtcore_utils.h"
 #include "app_context.h"
 #include "app_module.h"
@@ -272,20 +273,21 @@ void MainWindow::onGuiDocumentErased(GuiDocument* /*guiDoc*/)
     this->updateControlsActivation();
 }
 
-void MainWindow::onMessage(MessageType msgType, const QString& text)
+void MainWindow::onMessage(const Messenger::Message& msg)
 {
-    switch (msgType) {
+    const auto qtext = to_QString(msg.text);
+    switch (msg.type) {
     case MessageType::Trace:
-        qDebug() << text;
+        qDebug() << qtext;
         break;
     case MessageType::Info:
-        WidgetMessageIndicator::showInfo(text, this);
+        WidgetMessageIndicator::showInfo(qtext, this);
         break;
     case MessageType::Warning:
-        QtWidgetsUtils::asyncMsgBoxWarning(this, tr("Warning"), text);
+        QtWidgetsUtils::asyncMsgBoxWarning(this, tr("Warning"), qtext);
         break;
     case MessageType::Error:
-        QtWidgetsUtils::asyncMsgBoxCritical(this, tr("Error"), text);
+        QtWidgetsUtils::asyncMsgBoxCritical(this, tr("Error"), qtext);
         break;
     }
 }

src/app/mainwindow.h

@@ -50,7 +50,7 @@ class MainWindow : public QMainWindow {
     void onGuiDocumentAdded(GuiDocument* guiDoc);
     void onGuiDocumentErased(GuiDocument* guiDoc);
 
-    void onMessage(MessageType msgType, const QString& text);
+    void onMessage(const Messenger::Message& msg);
 
     void updateControlsActivation();
     void updateCurrentPage();

src/base/messenger.cpp

@@ -6,6 +6,7 @@
 
 #include "messenger.h"
 
+#include <cassert>
 #include <string>
 
 namespace Mayo {
@@ -117,4 +118,71 @@ void MessengerByCallback::emitMessage(MessageType msgType, std::string_view text
         m_fnCallback(msgType, text);
 }
 
+unsigned MessageCollecter::toFlag(MessageType msgType)
+{
+    auto msgFlag = static_cast<unsigned>(msgType);
+    assert(msgFlag < (8 * sizeof(unsigned) - 1));
+    return 1 << msgFlag;
+}
+
+void MessageCollecter::only(MessageType msgType)
+{
+    m_ignoredTypes = ~(toFlag(msgType));
+}
+
+void MessageCollecter::ignore(MessageType msgType)
+{
+    m_ignoredTypes |= toFlag(msgType);
+}
+
+bool MessageCollecter::isIgnored(MessageType msgType) const
+{
+    return (m_ignoredTypes & toFlag(msgType)) != 0;
+}
+
+void MessageCollecter::emitMessage(MessageType msgType, std::string_view text)
+{
+    if (!this->isIgnored((msgType))) {
+        const std::string stext{text};
+        const Message msg{ msgType, std::move(stext) };
+        m_vecMessage.push_back(std::move(msg));
+    }
+}
+
+Span<const Messenger::Message> MessageCollecter::messages() const
+{
+    return m_vecMessage;
+}
+
+std::string MessageCollecter::asString(std::string_view separator, MessageType msgType) const
+{
+    std::string str;
+    for (const auto& msg : m_vecMessage) {
+        if (msg.type == msgType) {
+            str += msg.text;
+            if (&msg != &m_vecMessage.back())
+                str += separator;
+        }
+    }
+
+    return str;
+}
+
+std::string MessageCollecter::asString(std::string_view separator) const
+{
+    std::string str;
+    for (const auto& msg : m_vecMessage) {
+        str += msg.text;
+        if (&msg != &m_vecMessage.back())
+            str += separator;
+    }
+
+    return str;
+}
+
+void MessageCollecter::clear()
+{
+    m_vecMessage.clear();
+}
+
 } // namespace Mayo

src/base/messenger.h

@@ -6,9 +6,12 @@
 
 #pragma once
 
+#include "span.h"
+
 #include <functional>
 #include <sstream>
 #include <string_view>
+#include <vector>
 
 namespace Mayo {
 
@@ -52,6 +55,11 @@ class MessageStream {
 // messages will be further processed
 class Messenger {
 public:
+    struct Message {
+        MessageType type;
+        std::string text;
+    };
+
     // Dispatch the message 'text' to all observers
     virtual void emitMessage(MessageType msgType, std::string_view text) = 0;
 
@@ -80,4 +88,26 @@ class MessengerByCallback : public Messenger {
     std::function<void(MessageType, std::string_view)> m_fnCallback;
 };
 
+// Collects emitted messages into a array
+class MessageCollecter : public Messenger {
+public:
+    void only(MessageType msgType);
+    void ignore(MessageType msgType);
+    bool isIgnored(MessageType msgType) const;
+
+    void emitMessage(MessageType msgType, std::string_view text) override;
+
+    Span<const Messenger::Message> messages() const;
+    std::string asString(std::string_view separator, MessageType msgType) const;
+    std::string asString(std::string_view separator) const;
+
+    void clear();
+
+private:
+    static unsigned toFlag(MessageType msgType);
+
+    unsigned m_ignoredTypes = 0;
+    std::vector<Messenger::Message> m_vecMessage;
+};
+
 } // namespace Mayo

src/cli/cli_export.cpp

@@ -53,23 +53,6 @@ struct Helper : public QObject {
     int lastPrintProgressLineCount = 0;
 };
 
-// Collects emitted error messages into a single string object
-class ErrorMessageCollect : public Messenger {
-public:
-    void emitMessage(MessageType msgType, std::string_view text) override
-    {
-        if (msgType == MessageType::Error) {
-            m_message += text;
-            m_message += " ";
-        }
-    }
-
-    const std::string& message() const { return m_message; }
-
-private:
-    std::string m_message;
-};
-
 void printTaskProgress(Helper* helper, TaskId taskId)
 {
     std::string strMessage = helper->taskMgr.title(taskId);
@@ -119,7 +102,8 @@ bool importInDocument(DocumentPtr doc, const CliExportArgs& args, Helper* helper
             break; // Interrupt
     }
 
-    ErrorMessageCollect errorCollect;
+    MessageCollecter errorCollect;
+    errorCollect.only(MessageType::Error);
     const bool okImport = appModule->ioSystem()->importInDocument()
         .targetDocument(doc)
         .withFilepaths(args.filesToOpen)
@@ -132,7 +116,7 @@ bool importInDocument(DocumentPtr doc, const CliExportArgs& args, Helper* helper
         .withMessenger(&errorCollect)
         .withTaskProgress(progress)
         .execute();
-    helper->taskMgr.setTitle(progress->taskId(), okImport ? CliExport::textIdTr("Imported") : errorCollect.message());
+    helper->taskMgr.setTitle(progress->taskId(), okImport ? CliExport::textIdTr("Imported") : errorCollect.asString(" "));
     helper->mapTaskStatus.at(progress->taskId())->success = okImport;
     helper->mapTaskStatus.at(progress->taskId())->finished = true;
     return okImport;
@@ -141,7 +125,8 @@ bool importInDocument(DocumentPtr doc, const CliExportArgs& args, Helper* helper
 void exportDocument(const DocumentPtr& doc, const FilePath& filepath, Helper* helper, TaskProgress* progress)
 {
     auto appModule = AppModule::get();
-    ErrorMessageCollect errorCollect;
+    MessageCollecter errorCollect;
+    errorCollect.only(MessageType::Error);
     const IO::Format format = appModule->ioSystem()->probeFormat(filepath);
     const ApplicationItem appItems[] = { doc };
     const bool okExport = appModule->ioSystem()->exportApplicationItems()
@@ -156,7 +141,7 @@ void exportDocument(const DocumentPtr& doc, const FilePath& filepath, Helper* he
     const std::string msg =
             okExport ?
                 fmt::format(CliExport::textIdTr("Exported {}"), strFilename) :
-                errorCollect.message();
+                errorCollect.asString(" ");
     helper->taskMgr.setTitle(progress->taskId(), msg);
     helper->mapTaskStatus.at(progress->taskId())->success = okExport;
     helper->mapTaskStatus.at(progress->taskId())->finished = true;

tests/test_base.cpp

@@ -25,6 +25,7 @@
 #include "../src/base/libtree.h"
 #include "../src/base/occ_handle.h"
 #include "../src/base/mesh_utils.h"
+#include "../src/base/messenger.h"
 #include "../src/base/meta_enum.h"
 #include "../src/base/property_builtins.h"
 #include "../src/base/property_enumeration.h"
@@ -80,6 +81,7 @@ Q_DECLARE_METATYPE(Mayo::UnitSystem::TranslateResult)
 Q_DECLARE_METATYPE(Mayo::IO::Format)
 Q_DECLARE_METATYPE(std::vector<gp_Pnt2d>)
 Q_DECLARE_METATYPE(Mayo::MeshUtils::Orientation)
+Q_DECLARE_METATYPE(Mayo::MessageType)
 Q_DECLARE_METATYPE(std::string)
 Q_DECLARE_METATYPE(Mayo::PropertyValueConversion::Variant)
 
@@ -315,6 +317,56 @@ void TestBase::FilePath_test()
     }
 }
 
+void TestBase::MessageCollecter_ignoreSingleMessageType_test()
+{
+    QFETCH(MessageType, msgTypeToIgnore);
+
+    MessageCollecter msgCollect;
+    msgCollect.ignore(msgTypeToIgnore);
+    QVERIFY(msgCollect.isIgnored(msgTypeToIgnore));
+    for (auto msgType : MetaEnum::values<MessageType>()) {
+        if (msgType != msgTypeToIgnore)
+            QVERIFY(!msgCollect.isIgnored(msgType));
+    }
+
+    for (const auto& [value, name] : MetaEnum::entries<MessageType>())
+        msgCollect.emitMessage(value, std::string{name} + " message");
+
+    QCOMPARE(msgCollect.messages().size(), MetaEnum::count<MessageType>() - 1);
+    for (const auto& msg : msgCollect.messages())
+        QVERIFY(msg.type != msgTypeToIgnore);
+}
+
+void TestBase::MessageCollecter_ignoreSingleMessageType_test_data()
+{
+    QTest::addColumn<MessageType>("msgTypeToIgnore");
+    for (const auto& [value, name] : MetaEnum::entries<MessageType>())
+        QTest::newRow(std::string{name}.c_str()) << value;
+}
+
+void TestBase::MessageCollecter_only_test()
+{
+    QFETCH(MessageType, msgTypeSingle);
+
+    MessageCollecter msgCollect;
+    msgCollect.only(msgTypeSingle);
+    for (const auto& [value, name] : MetaEnum::entries<MessageType>())
+        msgCollect.emitMessage(value, std::string{name} + " message");
+
+    QCOMPARE(msgCollect.messages().size(), 1);
+    QCOMPARE(msgCollect.messages().front().type, msgTypeSingle);
+    QCOMPARE(msgCollect.asString(" "), msgCollect.messages().front().text);
+    QCOMPARE(msgCollect.asString(" ", msgTypeSingle), msgCollect.messages().front().text);
+    QVERIFY(msgCollect.asString(" ").back() != ' ');
+}
+
+void TestBase::MessageCollecter_only_test_data()
+{
+    QTest::addColumn<MessageType>("msgTypeSingle");
+    for (const auto& [value, name] : MetaEnum::entries<MessageType>())
+        QTest::newRow(std::string{name}.c_str()) << value;
+}
+
 void TestBase::OccHandle_test()
 {
     {

tests/test_base.h

@@ -26,6 +26,11 @@ private slots:
 
     void FilePath_test();
 
+    void MessageCollecter_ignoreSingleMessageType_test();
+    void MessageCollecter_ignoreSingleMessageType_test_data();
+    void MessageCollecter_only_test();
+    void MessageCollecter_only_test_data();
+
     void OccHandle_test();
 
     void PropertyValueConversionVariant_toInt_test();