Move the routines which render log messages out of logger.cc; this breaks the

dependency which required logger.cc to have access to the entire rest of the
system. Although we still need to forward declare all the log messages.

build.py

@@ -83,6 +83,7 @@ cxxlibrary(
         "./lib/layout.cc",
         "./lib/ldbs.cc",
         "./lib/logger.cc",
+        "./lib/logrenderer.cc",
         "./lib/proto.cc",
         "./lib/readerwriter.cc",
         "./lib/sector.cc",

lib/logger.cc

@@ -7,23 +7,44 @@
 
 static bool indented = false;
 
-static std::function<void(std::shared_ptr<const AnyLogMessage>)> loggerImpl =
-    [](auto message)
+static std::function<void(const AnyLogMessage&)> loggerImpl =
+    [](const auto& message)
 {
-    std::cout << Logger::toString(*message) << std::flush;
+    std::cout << Logger::toString(message) << std::flush;
 };
 
-void log(std::shared_ptr<const AnyLogMessage> message)
+void log(const char* m)
+{
+    log(std::string(m));
+}
+
+void log(const AnyLogMessage& message)
 {
     loggerImpl(message);
 }
 
-void Logger::setLogger(
-    std::function<void(std::shared_ptr<const AnyLogMessage>)> cb)
+void Logger::setLogger(std::function<void(const AnyLogMessage&)> cb)
 {
     loggerImpl = cb;
 }
 
+void renderLogMessage(
+    LogRenderer& r, std::shared_ptr<const ErrorLogMessage> msg)
+{
+    r.newline().add("Error:").add(msg->message).newline();
+}
+
+void renderLogMessage(
+    LogRenderer& r, std::shared_ptr<const EmergencyStopMessage> msg)
+{
+    r.newline().add("Stop!").newline();
+}
+
+void renderLogMessage(LogRenderer& r, std::shared_ptr<const std::string> msg)
+{
+    r.newline().add(*msg).newline();
+}
+
 std::string Logger::toString(const AnyLogMessage& message)
 {
     std::stringstream stream;
@@ -35,131 +56,13 @@ std::string Logger::toString(const AnyLogMessage& message)
         indented = false;
     };
 
+    auto r = LogRenderer::create();
     std::visit(
-        overloaded{
-            /* Fallback --- do nothing */
-            [&](const auto& m)
-            {
-            },
-
-            /* Start measuring the rotational speed */
-            [&](const BeginSpeedOperationLogMessage& m)
-            {
-                indent();
-                stream << "Measuring rotational speed...\n";
-            },
-
-            /* Finish measuring the rotational speed */
-            [&](const EndSpeedOperationLogMessage& m)
-            {
-                indent();
-                stream << fmt::format(
-                    "Rotational period is {:.1f}ms ({:.1f}rpm)\n",
-                    m.rotationalPeriod / 1e6,
-                    60e9 / m.rotationalPeriod);
-            },
-
-            /* Indicates that we're starting a write operation. */
-            [&](const BeginWriteOperationLogMessage& m)
-            {
-                stream << fmt::format("{:2}.{}: ", m.track, m.head);
-                indented = true;
-            },
-
-            /* Indicates that we're starting a read operation. */
-            [&](const BeginReadOperationLogMessage& m)
-            {
-                stream << fmt::format("{:2}.{}: ", m.track, m.head);
-                indented = true;
-            },
-
-            /* We've just read a track (we might reread it if there are errors)
-             */
-            [&](const TrackReadLogMessage& m)
-            {
-                const auto& track = *m.track;
-
-                std::set<std::shared_ptr<const Sector>> rawSectors;
-                std::set<std::shared_ptr<const Record>> rawRecords;
-                for (const auto& trackDataFlux : track.trackDatas)
-                {
-                    rawSectors.insert(trackDataFlux->sectors.begin(),
-                        trackDataFlux->sectors.end());
-                    rawRecords.insert(trackDataFlux->records.begin(),
-                        trackDataFlux->records.end());
-                }
-
-                nanoseconds_t clock = 0;
-                for (const auto& sector : rawSectors)
-                    clock += sector->clock;
-                if (!rawSectors.empty())
-                    clock /= rawSectors.size();
-
-                indent();
-                stream << fmt::format("{} raw records, {} raw sectors",
-                    rawRecords.size(),
-                    rawSectors.size());
-                if (clock != 0)
-                {
-                    stream << fmt::format("; {:.2f}us clock ({:.0f}kHz)",
-                        clock / 1000.0,
-                        1000000.0 / clock);
-                }
-
-                stream << '\n';
-
-                indent();
-                stream << "sectors:";
-
-                std::vector<std::shared_ptr<const Sector>> sectors(
-                    track.sectors.begin(), track.sectors.end());
-                std::sort(
-                    sectors.begin(), sectors.end(), sectorPointerSortPredicate);
-
-                for (const auto& sector : sectors)
-                    stream << fmt::format(" {}.{}.{}{}",
-                        sector->logicalTrack,
-                        sector->logicalSide,
-                        sector->logicalSector,
-                        Sector::statusToChar(sector->status));
-
-                stream << '\n';
-
-                int size = 0;
-                std::set<std::pair<int, int>> track_ids;
-                for (const auto& sector : m.track->sectors)
-                {
-                    track_ids.insert(std::make_pair(
-                        sector->logicalTrack, sector->logicalSide));
-                    size += sector->data.size();
-                }
-
-                indent();
-                stream << fmt::format("{} bytes decoded\n", size);
-            },
-
-            /* Large-scale operation start. */
-            [&](const BeginOperationLogMessage& m)
-            {
-            },
-
-            /* Large-scale operation end. */
-            [&](const EndOperationLogMessage& m)
-            {
-            },
-
-            /* Large-scale operation progress. */
-            [&](const OperationProgressLogMessage& m)
-            {
-            },
-
-            /* Generic text message */
-            [&](const std::string& s)
-            {
-                indent();
-                stream << s << '\n';
-            },
+        [&](const auto& arg)
+        {
+            renderLogMessage(*r, arg);
         },
         message);
+
     return stream.str();
 }

lib/logger.h

@@ -2,12 +2,40 @@
 #define LOGGER_H
 
 #include "fmt/format.h"
+#include <type_traits>
 
 class DiskFlux;
 class TrackDataFlux;
 class TrackFlux;
 class Sector;
 
+class LogRenderer
+{
+public:
+    static std::unique_ptr<LogRenderer> create();
+
+public:
+    virtual LogRenderer& add(std::string m) = 0;
+    virtual LogRenderer& newsection() = 0;
+    virtual LogRenderer& newline() = 0;
+
+    virtual void renderTo(std::ostream& stream) = 0;
+};
+
+struct ErrorLogMessage;
+struct EmergencyStopMessage;
+struct BeginSpeedOperationLogMessage;
+struct EndSpeedOperationLogMessage;
+struct TrackReadLogMessage;
+struct DiskReadLogMessage;
+struct BeginReadOperationLogMessage;
+struct EndReadOperationLogMessage;
+struct BeginWriteOperationLogMessage;
+struct EndWriteOperationLogMessage;
+struct BeginOperationLogMessage;
+struct EndOperationLogMessage;
+struct OperationProgressLogMessage;
+
 struct ErrorLogMessage
 {
     std::string message;
@@ -17,88 +45,58 @@ struct EmergencyStopMessage
 {
 };
 
-struct BeginSpeedOperationLogMessage
-{
-};
+extern void renderLogMessage(
+    LogRenderer& r, std::shared_ptr<const ErrorLogMessage> m);
+extern void renderLogMessage(
+    LogRenderer& r, std::shared_ptr<const EmergencyStopMessage> m);
+extern void renderLogMessage(
+    LogRenderer& r, std::shared_ptr<const TrackReadLogMessage> m);
+extern void renderLogMessage(
+    LogRenderer& r, std::shared_ptr<const DiskReadLogMessage> m);
+extern void renderLogMessage(
+    LogRenderer& r, std::shared_ptr<const BeginSpeedOperationLogMessage> m);
+extern void renderLogMessage(
+    LogRenderer& r, std::shared_ptr<const EndSpeedOperationLogMessage> m);
+extern void renderLogMessage(
+    LogRenderer& r, std::shared_ptr<const BeginReadOperationLogMessage> m);
+extern void renderLogMessage(
+    LogRenderer& r, std::shared_ptr<const EndReadOperationLogMessage> m);
+extern void renderLogMessage(
+    LogRenderer& r, std::shared_ptr<const BeginWriteOperationLogMessage> m);
+extern void renderLogMessage(
+    LogRenderer& r, std::shared_ptr<const EndWriteOperationLogMessage> m);
+extern void renderLogMessage(
+    LogRenderer& r, std::shared_ptr<const BeginOperationLogMessage> m);
+extern void renderLogMessage(
+    LogRenderer& r, std::shared_ptr<const EndOperationLogMessage> m);
+extern void renderLogMessage(
+    LogRenderer& r, std::shared_ptr<const OperationProgressLogMessage> m);
 
-struct EndSpeedOperationLogMessage
-{
-    nanoseconds_t rotationalPeriod;
-};
-
-struct TrackReadLogMessage
-{
-    std::shared_ptr<const TrackFlux> track;
-};
-
-struct DiskReadLogMessage
-{
-    std::shared_ptr<const DiskFlux> disk;
-};
-
-struct BeginReadOperationLogMessage
-{
-    unsigned track;
-    unsigned head;
-};
-
-struct EndReadOperationLogMessage
-{
-    std::shared_ptr<const TrackDataFlux> trackDataFlux;
-    std::set<std::shared_ptr<const Sector>> sectors;
-};
-
-struct BeginWriteOperationLogMessage
-{
-    unsigned track;
-    unsigned head;
-};
-
-struct EndWriteOperationLogMessage
-{
-};
-
-struct BeginOperationLogMessage
-{
-    std::string message;
-};
-
-struct EndOperationLogMessage
-{
-    std::string message;
-};
-
-struct OperationProgressLogMessage
-{
-    unsigned progress;
-};
-
-class TrackFlux;
-
-typedef std::variant<std::string,
-    ErrorLogMessage,
-    EmergencyStopMessage,
-    TrackReadLogMessage,
-    DiskReadLogMessage,
-    BeginSpeedOperationLogMessage,
-    EndSpeedOperationLogMessage,
-    BeginReadOperationLogMessage,
-    EndReadOperationLogMessage,
-    BeginWriteOperationLogMessage,
-    EndWriteOperationLogMessage,
-    BeginOperationLogMessage,
-    EndOperationLogMessage,
-    OperationProgressLogMessage>
+typedef std::variant<std::shared_ptr<const std::string>,
+    std::shared_ptr<const ErrorLogMessage>,
+    std::shared_ptr<const EmergencyStopMessage>,
+    std::shared_ptr<const TrackReadLogMessage>,
+    std::shared_ptr<const DiskReadLogMessage>,
+    std::shared_ptr<const BeginSpeedOperationLogMessage>,
+    std::shared_ptr<const EndSpeedOperationLogMessage>,
+    std::shared_ptr<const BeginReadOperationLogMessage>,
+    std::shared_ptr<const EndReadOperationLogMessage>,
+    std::shared_ptr<const BeginWriteOperationLogMessage>,
+    std::shared_ptr<const EndWriteOperationLogMessage>,
+    std::shared_ptr<const BeginOperationLogMessage>,
+    std::shared_ptr<const EndOperationLogMessage>,
+    std::shared_ptr<const OperationProgressLogMessage>>
     AnyLogMessage;
 
+extern void log(const char* ptr);
+extern void log(const AnyLogMessage& message);
+
 template <class T>
 inline void log(const T& message)
 {
-    log(std::make_shared<const AnyLogMessage>(message));
+    log(AnyLogMessage(std::make_shared<T>(message)));
 }
 
-extern void log(std::shared_ptr<const AnyLogMessage> message);
-
 template <typename... Args>
 inline void log(fmt::string_view fstr, const Args&... args)
 {
@@ -107,8 +105,7 @@ inline void log(fmt::string_view fstr, const Args&... args)
 
 namespace Logger
 {
-    extern void setLogger(
-        std::function<void(std::shared_ptr<const AnyLogMessage>)> cb);
+    extern void setLogger(std::function<void(const AnyLogMessage&)> cb);
 
     extern std::string toString(const AnyLogMessage&);
 }

lib/logrenderer.cc

@@ -0,0 +1,64 @@
+#include "lib/core/globals.h"
+#include "lib/core/bytes.h"
+#include "lib/fluxmap.h"
+#include "lib/sector.h"
+#include "lib/flux.h"
+#include "lib/logger.h"
+
+namespace
+{
+    class LogRendererImpl : public LogRenderer
+    {
+    public:
+        LogRenderer& add(std::string m) override
+        {
+            if (_atNewline && _indented)
+            {
+                _stream << "    ";
+                _lineLen = 4;
+                _indented = true;
+            }
+
+            if ((m.size() + _lineLen) > 80)
+            {
+                _stream << "\n    ";
+                _lineLen = 4;
+                _indented = true;
+            }
+
+            _stream << m;
+            return *this;
+        }
+
+        LogRenderer& newsection() override
+        {
+            newline();
+            _indented = false;
+            return *this;
+        }
+
+        LogRenderer& newline() override
+        {
+            if (!_atNewline)
+            {
+                _stream << '\n';
+                _atNewline = true;
+            }
+            _lineLen = 0;
+            return *this;
+        }
+
+        void renderTo(std::ostream& stream) override {}
+
+    private:
+        bool _atNewline = false;
+        bool _indented = false;
+        int _lineLen = 0;
+        std::stringstream _stream;
+    };
+}
+
+std::unique_ptr<LogRenderer> LogRenderer::create()
+{
+    return std::make_unique<LogRendererImpl>();
+}

lib/readerwriter.cc

@@ -33,6 +33,134 @@ enum BadSectorsState
     HAS_BAD_SECTORS
 };
 
+/* Log renderers. */
+
+/* Start measuring the rotational speed */
+void renderLogMessage(
+    LogRenderer& r, std::shared_ptr<const BeginSpeedOperationLogMessage> m)
+{
+    r.newline().add("Measuring rotational speed...").newline();
+}
+
+/* Finish measuring the rotational speed */
+void renderLogMessage(
+    LogRenderer& r, std::shared_ptr<const EndSpeedOperationLogMessage> m)
+{
+    r.newline()
+        .add(fmt::format("Rotational period is {:.1f}ms ({:.1f}rpm)",
+            m->rotationalPeriod / 1e6,
+            60e9 / m->rotationalPeriod))
+        .newline();
+}
+
+/* Indicates that we're starting a write operation. */
+void renderLogMessage(
+    LogRenderer& r, std::shared_ptr<const BeginWriteOperationLogMessage> m)
+{
+    r.newsection().add(fmt::format("{:2}.{}: ", m->track, m->head));
+}
+
+/* Indicates that we're finishing a write operation. */
+void renderLogMessage(
+    LogRenderer& r, std::shared_ptr<const EndWriteOperationLogMessage> m)
+{
+}
+
+/* Indicates that we're starting a read operation. */
+void renderLogMessage(
+    LogRenderer& r, std::shared_ptr<const BeginReadOperationLogMessage> m)
+{
+    r.newsection().add(fmt::format("{:2}.{}: ", m->track, m->head));
+}
+
+/* Indicates that we're finishing a read operation. */
+void renderLogMessage(
+    LogRenderer& r, std::shared_ptr<const EndReadOperationLogMessage> m)
+{
+}
+
+/* We've just read a track (we might reread it if there are errors)
+ */
+void renderLogMessage(
+    LogRenderer& r, std::shared_ptr<const TrackReadLogMessage> m)
+{
+    const auto& track = *m->track;
+
+    std::set<std::shared_ptr<const Sector>> rawSectors;
+    std::set<std::shared_ptr<const Record>> rawRecords;
+    for (const auto& trackDataFlux : track.trackDatas)
+    {
+        rawSectors.insert(
+            trackDataFlux->sectors.begin(), trackDataFlux->sectors.end());
+        rawRecords.insert(
+            trackDataFlux->records.begin(), trackDataFlux->records.end());
+    }
+
+    nanoseconds_t clock = 0;
+    for (const auto& sector : rawSectors)
+        clock += sector->clock;
+    if (!rawSectors.empty())
+        clock /= rawSectors.size();
+
+    r.add(fmt::format("{} raw records, {} raw sectors",
+        rawRecords.size(),
+        rawSectors.size()));
+    if (clock != 0)
+    {
+        r.add(fmt::format(
+            "; {:.2f}us clock ({:.0f}kHz)", clock / 1000.0, 1000000.0 / clock));
+    }
+
+    r.newline().add("sectors:");
+
+    std::vector<std::shared_ptr<const Sector>> sectors(
+        track.sectors.begin(), track.sectors.end());
+    std::sort(sectors.begin(), sectors.end(), sectorPointerSortPredicate);
+
+    for (const auto& sector : sectors)
+        r.add(fmt::format(" {}.{}.{}{}",
+            sector->logicalTrack,
+            sector->logicalSide,
+            sector->logicalSector,
+            Sector::statusToChar(sector->status)));
+
+    int size = 0;
+    std::set<std::pair<int, int>> track_ids;
+    for (const auto& sector : m->track->sectors)
+    {
+        track_ids.insert(
+            std::make_pair(sector->logicalTrack, sector->logicalSide));
+        size += sector->data.size();
+    }
+
+    r.newline().add(fmt::format("{} bytes decoded\n", size));
+}
+
+/* We've just read a disk.
+ */
+void renderLogMessage(
+    LogRenderer& r, std::shared_ptr<const DiskReadLogMessage> m)
+{
+}
+
+/* Large-scale operation start. */
+void renderLogMessage(
+    LogRenderer& r, std::shared_ptr<const BeginOperationLogMessage> m)
+{
+}
+
+/* Large-scale operation end. */
+void renderLogMessage(
+    LogRenderer& r, std::shared_ptr<const EndOperationLogMessage> m)
+{
+}
+
+/* Large-scale operation progress. */
+void renderLogMessage(
+    LogRenderer& r, std::shared_ptr<const OperationProgressLogMessage> m)
+{
+}
+
 /* In order to allow rereads in file-based flux sources, we need to persist the
  * FluxSourceIterator (as that's where the state for which read to return is
  * held). This class handles that. */

lib/readerwriter.h

@@ -13,6 +13,64 @@ class ImageReader;
 class ImageWriter;
 class TrackInfo;
 class TrackFlux;
+class TrackDataFlux;
+class Sector;
+
+struct BeginSpeedOperationLogMessage
+{
+};
+
+struct EndSpeedOperationLogMessage
+{
+    nanoseconds_t rotationalPeriod;
+};
+
+struct TrackReadLogMessage
+{
+    std::shared_ptr<const TrackFlux> track;
+};
+
+struct DiskReadLogMessage
+{
+    std::shared_ptr<const DiskFlux> disk;
+};
+
+struct BeginReadOperationLogMessage
+{
+    unsigned track;
+    unsigned head;
+};
+
+struct EndReadOperationLogMessage
+{
+    std::shared_ptr<const TrackDataFlux> trackDataFlux;
+    std::set<std::shared_ptr<const Sector>> sectors;
+};
+
+struct BeginWriteOperationLogMessage
+{
+    unsigned track;
+    unsigned head;
+};
+
+struct EndWriteOperationLogMessage
+{
+};
+
+struct BeginOperationLogMessage
+{
+    std::string message;
+};
+
+struct EndOperationLogMessage
+{
+    std::string message;
+};
+
+struct OperationProgressLogMessage
+{
+    unsigned progress;
+};
 
 extern void measureDiskRotation();
 

lib/vfs/amigaffs.cc

@@ -420,7 +420,7 @@ private:
 
 static void onAdfWarning(char* message)
 {
-    log(message);
+    log((const char*)message);
 }
 
 static void onAdfError(char* message)

src/gui/mainwindow.cc

@@ -33,7 +33,7 @@ public:
     MainWindowImpl(): MainWindowGen(nullptr)
     {
         Logger::setLogger(
-            [&](std::shared_ptr<const AnyLogMessage> message)
+            [&](const AnyLogMessage& message)
             {
                 if (isWorkerThread())
                 {
@@ -201,9 +201,9 @@ public:
         ShowConfig();
     }
 
-    void OnLogMessage(std::shared_ptr<const AnyLogMessage> message)
+    void OnLogMessage(const AnyLogMessage& message)
     {
-        _logWindow->GetTextControl()->AppendText(Logger::toString(*message));
+        _logWindow->GetTextControl()->AppendText(Logger::toString(message));
 
         std::visit(
             overloaded{
@@ -213,7 +213,7 @@ public:
                 },
 
                 /* We terminated due to the stop button. */
-                [&](const EmergencyStopMessage& m)
+                [&](std::shared_ptr<const EmergencyStopMessage> m)
                 {
                     _statusBar->SetLeftLabel("Emergency stop!");
                     _statusBar->HideProgressBar();
@@ -221,76 +221,76 @@ public:
                 },
 
                 /* A fatal error. */
-                [&](const ErrorLogMessage& m)
+                [&](std::shared_ptr<const ErrorLogMessage> m)
                 {
-                    _statusBar->SetLeftLabel(m.message);
-                    wxMessageBox(m.message, "Error", wxOK | wxICON_ERROR);
+                    _statusBar->SetLeftLabel(m->message);
+                    wxMessageBox(m->message, "Error", wxOK | wxICON_ERROR);
                     _statusBar->HideProgressBar();
                     _statusBar->SetRightLabel("");
                 },
 
                 /* Indicates that we're starting a write operation. */
-                [&](const BeginWriteOperationLogMessage& m)
+                [&](std::shared_ptr<const BeginWriteOperationLogMessage> m)
                 {
                     _statusBar->SetRightLabel(
-                        fmt::format("W {}.{}", m.track, m.head));
+                        fmt::format("W {}.{}", m->track, m->head));
                     _imagerPanel->SetVisualiserMode(
-                        m.track, m.head, VISMODE_WRITING);
+                        m->track, m->head, VISMODE_WRITING);
                 },
 
-                [&](const EndWriteOperationLogMessage& m)
+                [&](std::shared_ptr<const EndWriteOperationLogMessage> m)
                 {
                     _statusBar->SetRightLabel("");
                     _imagerPanel->SetVisualiserMode(0, 0, VISMODE_NOTHING);
                 },
 
                 /* Indicates that we're starting a read operation. */
-                [&](const BeginReadOperationLogMessage& m)
+                [&](std::shared_ptr<const BeginReadOperationLogMessage> m)
                 {
                     _statusBar->SetRightLabel(
-                        fmt::format("R {}.{}", m.track, m.head));
+                        fmt::format("R {}.{}", m->track, m->head));
                     _imagerPanel->SetVisualiserMode(
-                        m.track, m.head, VISMODE_READING);
+                        m->track, m->head, VISMODE_READING);
                 },
 
-                [&](const EndReadOperationLogMessage& m)
+                [&](std::shared_ptr<const EndReadOperationLogMessage> m)
                 {
                     _statusBar->SetRightLabel("");
                     _imagerPanel->SetVisualiserMode(0, 0, VISMODE_NOTHING);
                 },
 
-                [&](const TrackReadLogMessage& m)
+                [&](std::shared_ptr<const TrackReadLogMessage> m)
                 {
-                    _imagerPanel->SetVisualiserTrackData(m.track);
+                    _imagerPanel->SetVisualiserTrackData(m->track);
                 },
 
-                [&](const DiskReadLogMessage& m)
+                [&](std::shared_ptr<const DiskReadLogMessage> m)
                 {
-                    _imagerPanel->SetDisk(m.disk);
+                    _imagerPanel->SetDisk(m->disk);
                 },
 
                 /* Large-scale operation start. */
-                [&](const BeginOperationLogMessage& m)
+                [&](std::shared_ptr<const BeginOperationLogMessage> m)
                 {
-                    _statusBar->SetLeftLabel(m.message);
+                    _statusBar->SetLeftLabel(m->message);
                     _statusBar->ShowProgressBar();
                 },
 
                 /* Large-scale operation end. */
-                [&](const EndOperationLogMessage& m)
+                [&](std::shared_ptr<const EndOperationLogMessage> m)
                 {
-                    _statusBar->SetLeftLabel(m.message);
+                    _statusBar->SetLeftLabel(m->message);
                     _statusBar->HideProgressBar();
                 },
 
                 /* Large-scale operation progress. */
-                [&](const OperationProgressLogMessage& m)
+                [&](std::shared_ptr<const OperationProgressLogMessage> m)
                 {
-                    _statusBar->SetProgress(m.progress);
+                    _statusBar->SetProgress(m->progress);
                 },
 
             },
-            *message);
+            message);
     }
 
     void SetPage(int page) override