LaunchAPPLServer: move SerialConnectionProvider to its own module

LaunchAPPL/Server/CMakeLists.txt

@@ -13,6 +13,9 @@ add_application(LaunchAPPLServer
     ToolLauncher.cc
     StatusDisplay.h
     StatusDisplay.cc
+    ConnectionProvider.h
+    SerialConnectionProvider.h
+    SerialConnectionProvider.cc
 )
 
 target_link_libraries(LaunchAPPLServer LaunchAPPLCommon)

LaunchAPPL/Server/ConnectionProvider.h

@@ -0,0 +1,20 @@
+#pragma once
+
+class StreamListener;
+class Stream;
+
+class ConnectionProvider
+{
+protected:
+    StreamListener *listener;
+public:
+    void setListener(StreamListener *l) { listener = l; }
+
+    virtual ~ConnectionProvider() {}
+    virtual Stream* getStream() = 0;
+    virtual void idle() {}
+    virtual void suspend() {}
+    virtual void resume() {}
+
+    virtual void* segmentToUnload() { return nullptr; }
+};

LaunchAPPL/Server/LaunchAPPLServer.cc

@@ -31,17 +31,17 @@
 #include <SegLoad.h>
 #include <Gestalt.h>
 
-#include "MacSerialStream.h"
 #include "AppLauncher.h"
 #include "StatusDisplay.h"
 
-#include <ReliableStream.h>
 #include <ServerProtocol.h>
 #include <Processes.h>
 #include <string.h>
 #include <memory>
 
-#include <UnreliableStream.h>
+#include "ConnectionProvider.h"
+#include "SerialConnectionProvider.h"
+#include <Stream.h>
 
 enum
 {
@@ -232,61 +232,6 @@ void DoMenuCommand(long menuCommand)
 
 std::unique_ptr<StatusDisplay> statusDisplay;
 
-class ConnectionProvider
-{
-protected:
-    StreamListener *listener;
-public:
-    void setListener(StreamListener *l) { listener = l; }
-
-    virtual ~ConnectionProvider() {}
-    virtual Stream* getStream() = 0;
-    virtual void idle() {}
-    virtual void suspend() {}
-    virtual void resume() {}
-};
-
-class SerialConnectionProvider : public ConnectionProvider
-{
-    struct Streams
-    {
-        MacSerialStream serialStream;
-        ReliableStream reliableStream;
-
-        Streams()
-            : serialStream(gPrefs.port, gPrefs.baud)
-            , reliableStream(&serialStream)
-        {
-        }
-    };
-    std::unique_ptr<Streams> streams = std::make_unique<Streams>();
-public:
-    virtual Stream* getStream()
-    {
-        return streams ? &streams->reliableStream : nullptr;
-    }
-
-    virtual void idle()
-    {
-        if(streams)
-        {
-            streams->reliableStream.setListener(listener);
-            streams->serialStream.idle();
-            statusDisplay->SetErrorCount(streams->reliableStream.getFailedReceiveCount()
-                                        + streams->reliableStream.getFailedSendCount());
-        }
-    }
-    virtual void suspend()
-    {
-        streams.reset();
-    }
-    virtual void resume()
-    {
-        if(!streams)
-            streams = std::make_unique<Streams>();
-    }
-};
-
 std::unique_ptr<ConnectionProvider> connection;
 
 class LaunchServer : public StreamListener
@@ -411,7 +356,8 @@ public:
         if(state == State::launch)
         {
             connection->suspend();
-            UnloadSeg((void*) &MacSerialStream::unloadSegDummy);
+            if(void *seg = connection->segmentToUnload())
+                UnloadSeg(seg);
             gPrefs.inSubLaunch = true;
             WritePrefs();
 
@@ -513,7 +459,7 @@ LaunchServer server;
 
 void ConnectionChanged()
 {
-    connection = std::make_unique<SerialConnectionProvider>();
+    connection = std::make_unique<SerialConnectionProvider>(gPrefs.port, gPrefs.baud, statusDisplay.get());
     connection->setListener(&server);
     server.onReset();
 }

LaunchAPPL/Server/LaunchAPPLServer.segmap

@@ -1,6 +1,7 @@
 SEGMENT Serial
     */libLaunchAPPLCommon.a:ReliableStream.*
     */MacSerialStream.*
+    */SerialConnectionProvider.*
 
 SEGMENT Launcher
     */AppLauncher.*

LaunchAPPL/Server/SerialConnectionProvider.cc

@@ -0,0 +1,64 @@
+#include "SerialConnectionProvider.h"
+#include "MacSerialStream.h"
+#include <ReliableStream.h>
+#include "StatusDisplay.h"
+
+struct SerialConnectionProvider::Streams
+{
+    MacSerialStream serialStream;
+    ReliableStream reliableStream;
+
+    Streams(int port, int baud)
+        : serialStream(port, baud)
+        , reliableStream(&serialStream)
+    {
+    }
+};
+
+SerialConnectionProvider::SerialConnectionProvider(int port, int baud, StatusDisplay *statusDisplay)
+        : port(port), baud(baud), statusDisplay(statusDisplay)
+{
+    resume();
+}
+
+SerialConnectionProvider::~SerialConnectionProvider()
+{
+
+}
+
+Stream* SerialConnectionProvider::getStream()
+{
+    return streams ? &streams->reliableStream : nullptr;
+}
+
+void SerialConnectionProvider::idle()
+{
+    if(streams)
+    {
+        streams->reliableStream.setListener(listener);
+        streams->serialStream.idle();
+        if(statusDisplay)
+            statusDisplay->SetErrorCount(streams->reliableStream.getFailedReceiveCount()
+                                        + streams->reliableStream.getFailedSendCount());
+    }
+}
+
+void SerialConnectionProvider::suspend()
+{
+    streams.reset();
+}
+
+void SerialConnectionProvider::resume()
+{
+    if(!streams)
+        streams = std::make_unique<Streams>(port, baud);
+}
+
+void SerialConnectionProvider::unloadSegDummy()
+{
+}
+
+void *SerialConnectionProvider::segmentToUnload()
+{
+    return (void*) &unloadSegDummy;
+}

LaunchAPPL/Server/SerialConnectionProvider.h

@@ -0,0 +1,27 @@
+#pragma once
+#include "ConnectionProvider.h"
+#include <memory>
+
+class StatusDisplay;
+
+class SerialConnectionProvider : public ConnectionProvider
+{
+    int port, baud;
+    StatusDisplay *statusDisplay;
+    struct Streams;
+    
+    std::unique_ptr<Streams> streams;
+
+    static void unloadSegDummy();
+public:
+    SerialConnectionProvider(int port, int baud, StatusDisplay *statusDisplay);
+    virtual ~SerialConnectionProvider();
+
+    virtual Stream* getStream();
+
+    virtual void idle();
+    virtual void suspend();
+    virtual void resume();
+
+    virtual void* segmentToUnload();
+};