Add LpxClient/LpxServer stubs, add dispatcher to main

luprex/core/cpp/drivenengine.hpp

@@ -409,4 +409,7 @@ private:
     friend class Channel;
 };
 
+using UniqueDrivenEngine = std::unique_ptr<DrivenEngine>;
+using DrivenEngineMaker = UniqueDrivenEngine (*)();
+
 #endif // DRIVENENGINE_HPP

luprex/core/cpp/drivertests.cpp

@@ -0,0 +1,141 @@
+#include "drivertests.hpp"
+#include "drivenengine.hpp"
+#include <iostream>
+#include <iomanip>
+
+static void write_closed_message(Channel *ch, StreamBuffer *out) {
+    std::ostringstream oss;
+    oss << "Chan " << ch->chid() << " closed [" << ch->error() << "]\n";
+    out->write_bytes(oss.str());
+}
+
+static void dump_lines(StreamBuffer *in, StreamBuffer *out, int chid) {
+    while (true) {
+        std::string l = in->readline();
+        if (l == "") break;
+        std::ostringstream oss;
+        oss << "Chan " << chid << ": " << l;
+        out->write_bytes(oss.str());
+    }
+}
+
+// This test allows input on stdin or on port 8085.
+// You can type lines and see them echoed.
+class DriverListenTest : public DrivenEngine {
+public:
+    std::vector<UniqueChannel> channels_;
+    virtual void event_init() {
+        listen_port(8085);
+    }
+    
+    virtual void event_update() {
+        while (true) {
+            UniqueChannel ch = new_incoming_channel();
+            if (ch == nullptr) break;
+            ch->set_readline(true);
+            channels_.emplace_back(std::move(ch));
+        }
+
+        Channel *stdioch = get_stdio_channel();
+        dump_lines(stdioch->in(), stdioch->out(), 0);
+        std::vector<UniqueChannel> keep;
+        for (UniqueChannel &ch : channels_) {
+            dump_lines(ch->in(), stdioch->out(), ch->chid());
+            if (ch->closed()) {
+                write_closed_message(ch.get(), stdioch->out());
+            } else {
+                keep.emplace_back(std::move(ch));
+            }
+        }
+        channels_ = std::move(keep);
+    }
+};
+
+// This test connects to a public webserver and prints
+// the output from the server.
+class DriverWebServerTest : public DrivenEngine {
+public:
+    std::vector<UniqueChannel> channels_;
+    virtual void event_init() {
+        UniqueChannel ch = new_outgoing_channel("stanford.edu:80");
+        ch->out()->write_bytes("GET http://stanford.edu/index.html HTTP/1.1\n\n");
+        channels_.emplace_back(std::move(ch));
+    }
+    
+    virtual void event_update() {
+        Channel *stdioch = get_stdio_channel();
+        dump_lines(stdioch->in(), stdioch->out(), 0);
+        std::vector<UniqueChannel> keep;
+        for (UniqueChannel &ch : channels_) {
+            dump_lines(ch->in(), stdioch->out(), ch->chid());
+            if (ch->closed()) {
+                write_closed_message(ch.get(), stdioch->out());
+            } else {
+                keep.emplace_back(std::move(ch));
+            }
+        }
+        channels_ = std::move(keep);
+    }
+};
+
+// This test produces a DNS resolution failure.
+class DriverDNSFailTest : public DrivenEngine {
+public:
+    std::vector<UniqueChannel> channels_;
+    virtual void event_init() {
+        UniqueChannel ch = new_outgoing_channel("akjsdkajshdakjshd.alk:80");
+        ch->out()->write_bytes("GET http://stanford.edu/index.html HTTP/1.1\n\n");
+        channels_.emplace_back(std::move(ch));
+    }
+    
+    virtual void event_update() {
+        Channel *stdioch = get_stdio_channel();
+        dump_lines(stdioch->in(), stdioch->out(), 0);
+        std::vector<UniqueChannel> keep;
+        for (UniqueChannel &ch : channels_) {
+            dump_lines(ch->in(), stdioch->out(), ch->chid());
+            if (ch->closed()) {
+                write_closed_message(ch.get(), stdioch->out());
+            } else {
+                keep.emplace_back(std::move(ch));
+            }
+        }
+        channels_ = std::move(keep);
+    }
+};
+
+// This test just prints the time.
+class DriverPrintClockTest : public DrivenEngine {
+public:
+    int count;
+    virtual void event_init() {
+        count = 0;
+    }
+    
+    virtual void event_update() {
+        std::cerr << std::fixed << std::setprecision(2) << get_clock() << "   ";
+        count++;
+        if (count == 10) {
+            std::cerr << std::endl;
+            count = 0;
+        }
+    }
+};
+
+UniqueDrivenEngine make_DriverListenTest() {
+    return UniqueDrivenEngine(new DriverListenTest);
+}
+
+UniqueDrivenEngine make_DriverWebServerTest() {
+    return UniqueDrivenEngine(new DriverWebServerTest);
+}
+
+UniqueDrivenEngine make_DriverDNSFailTest() {
+    return UniqueDrivenEngine(new DriverDNSFailTest);
+}
+
+UniqueDrivenEngine make_DriverPrintClockTest() {
+    return UniqueDrivenEngine(new DriverPrintClockTest);
+}
+
+

luprex/core/cpp/drivertests.hpp

@@ -0,0 +1,12 @@
+#ifndef DRIVERTESTS_HPP
+#define DRIVERTESTS_HPP
+
+#include "drivenengine.hpp"
+
+UniqueDrivenEngine make_DriverListenTest();
+UniqueDrivenEngine make_DriverWebServerTest();
+UniqueDrivenEngine make_DriverDNSFailTest();
+UniqueDrivenEngine make_DriverPrintClockTest();
+
+#endif // DRIVERTESTS_HPP
+

luprex/core/cpp/lpxclient.cpp

@@ -0,0 +1,38 @@
+#include "lpxclient.hpp"
+
+#include "drivenengine.hpp"
+#include "world.hpp"
+#include "luaconsole.hpp"
+#include "invocation.hpp"
+#include <memory>
+
+class LpxClient : public DrivenEngine {
+public:
+    using StringVec = LuaConsole::StringVec;
+    std::unique_ptr<World> world_;
+    int64_t actor_id_;
+    InvocationQueue unack_;
+    Channel *channel_;
+    LuaConsole console_;
+    Gui gui_;
+    int64_t gui_place_;
+
+    void do_view_command(const StringVec &cmd);
+    void do_menu_command(const StringVec &cmd);
+    void do_choose_command(const StringVec &cmd);
+    void do_quit_command(const StringVec &cmd);
+    void do_lua(const std::string &exp);
+    void do_command(const StringVec &exp);
+
+public:
+    virtual void event_init() {
+    }
+
+    virtual void event_update() {
+    }
+};
+
+UniqueDrivenEngine make_LpxClient() {
+    return UniqueDrivenEngine(new LpxClient);
+}
+

luprex/core/cpp/lpxclient.hpp

@@ -0,0 +1,8 @@
+#ifndef LPXCLIENT_HPP
+#define LPXCLIENT_HPP
+
+#include "drivenengine.hpp"
+
+UniqueDrivenEngine make_LpxClient();
+
+#endif // LPXCLIENT_HPP

luprex/core/cpp/lpxserver.cpp

@@ -0,0 +1,30 @@
+#include "lpxserver.hpp"
+
+#include "world.hpp"
+#include "drivenengine.hpp"
+#include <memory>
+
+class ServerClient {
+public:
+    int64_t actor_id_;
+    Channel *channel_;
+    std::unique_ptr<World> sync_;
+};
+
+class LpxServer : public DrivenEngine {
+public:
+    std::unique_ptr<World> master_;
+    std::vector<std::unique_ptr<ServerClient>> clients_;
+
+public:
+    virtual void event_init() {
+    }
+
+    virtual void event_update() {
+    }
+};
+
+UniqueDrivenEngine make_LpxServer() {
+    return UniqueDrivenEngine(new LpxServer);
+}
+

luprex/core/cpp/lpxserver.hpp

@@ -0,0 +1,9 @@
+#ifndef LPXSERVER_HPP
+#define LPXSERVER_HPP
+
+#include "drivenengine.hpp"
+
+UniqueDrivenEngine make_LpxServer();
+
+#endif // LPXSERVER_HPP
+

luprex/core/cpp/main.cpp

@@ -1,131 +1,47 @@
 
 #include "textgame.hpp"
+#include "lpxclient.hpp"
+#include "lpxserver.hpp"
+#include "drivertests.hpp"
 #include "driver.hpp"
-#include "drivenengine.hpp"
 #include <iostream>
-#include <iomanip>
 
-void write_closed_message(Channel *ch, StreamBuffer *out) {
-    std::ostringstream oss;
-    oss << "Chan " << ch->chid() << " closed [" << ch->error() << "]\n";
-    out->write_bytes(oss.str());
+struct EngineMaker {
+    const char *name;
+    DrivenEngineMaker func;
+};
+
+static EngineMaker makers[] = {
+    { "textgame", make_TextGame },
+    { "lpxclient", make_LpxClient },
+    { "lpxserver", make_LpxServer },
+    { "driverlistentest", make_DriverListenTest },
+    { "driverwebservertest", make_DriverWebServerTest },
+    { "driverdnsfailtest", make_DriverDNSFailTest },
+    { "driverprintclocktest", make_DriverPrintClockTest },
+    { nullptr, nullptr },
+};
+
+static void usage() {
+    std::cerr << "Usage: main <mode>" << std::endl;
+    for (int i = 0; makers[i].name != nullptr; i++) {
+        std::cerr << "  <mode> can be: " << makers[i].name << std::endl;
+    }
+    exit(1);
 }
 
-void dump_lines(StreamBuffer *in, StreamBuffer *out, int chid) {
-    while (true) {
-        std::string l = in->readline();
-        if (l == "") break;
-        std::ostringstream oss;
-        oss << "Chan " << chid << ": " << l;
-        out->write_bytes(oss.str());
-    }
-}
-
-// This test allows input on stdin or on port 8085.
-// You can type lines and see them echoed.
-class TNTest1 : public DrivenEngine {
-public:
-    std::vector<UniqueChannel> channels_;
-    virtual void event_init() {
-        listen_port(8085);
-    }
-    
-    virtual void event_update() {
-        while (true) {
-            UniqueChannel ch = new_incoming_channel();
-            if (ch == nullptr) break;
-            ch->set_readline(true);
-            channels_.emplace_back(std::move(ch));
-        }
-
-        Channel *stdioch = get_stdio_channel();
-        dump_lines(stdioch->in(), stdioch->out(), 0);
-        std::vector<UniqueChannel> keep;
-        for (UniqueChannel &ch : channels_) {
-            dump_lines(ch->in(), stdioch->out(), ch->chid());
-            if (ch->closed()) {
-                write_closed_message(ch.get(), stdioch->out());
-            } else {
-                keep.emplace_back(std::move(ch));
-            }
-        }
-        channels_ = std::move(keep);
-    }
-};
-
-// This test connects to a public webserver and prints
-// the output from the server.
-class TNTest2 : public DrivenEngine {
-public:
-    std::vector<UniqueChannel> channels_;
-    virtual void event_init() {
-        UniqueChannel ch = new_outgoing_channel("stanford.edu:80");
-        ch->out()->write_bytes("GET http://stanford.edu/index.html HTTP/1.1\n\n");
-        channels_.emplace_back(std::move(ch));
-    }
-    
-    virtual void event_update() {
-        Channel *stdioch = get_stdio_channel();
-        dump_lines(stdioch->in(), stdioch->out(), 0);
-        std::vector<UniqueChannel> keep;
-        for (UniqueChannel &ch : channels_) {
-            dump_lines(ch->in(), stdioch->out(), ch->chid());
-            if (ch->closed()) {
-                write_closed_message(ch.get(), stdioch->out());
-            } else {
-                keep.emplace_back(std::move(ch));
-            }
-        }
-        channels_ = std::move(keep);
-    }
-};
-
-// This test produces a DNS resolution failure.
-class TNTest3 : public DrivenEngine {
-public:
-    std::vector<UniqueChannel> channels_;
-    virtual void event_init() {
-        UniqueChannel ch = new_outgoing_channel("akjsdkajshdakjshd.alk:80");
-        ch->out()->write_bytes("GET http://stanford.edu/index.html HTTP/1.1\n\n");
-        channels_.emplace_back(std::move(ch));
-    }
-    
-    virtual void event_update() {
-        Channel *stdioch = get_stdio_channel();
-        dump_lines(stdioch->in(), stdioch->out(), 0);
-        std::vector<UniqueChannel> keep;
-        for (UniqueChannel &ch : channels_) {
-            dump_lines(ch->in(), stdioch->out(), ch->chid());
-            if (ch->closed()) {
-                write_closed_message(ch.get(), stdioch->out());
-            } else {
-                keep.emplace_back(std::move(ch));
-            }
-        }
-        channels_ = std::move(keep);
-    }
-};
-
-// This test just prints the time.
-class TNTest4 : public DrivenEngine {
-public:
-    int count;
-    virtual void event_init() {
-        count = 0;
-    }
-    
-    virtual void event_update() {
-        std::cerr << std::fixed << std::setprecision(2) << get_clock() << "   ";
-        count++;
-        if (count == 10) {
-            std::cerr << std::endl;
-            count = 0;
-        }
-    }
-};
-
 int main(int argc, char **argv)
 {
-    TextGame tg;
-    driver_drive(&tg);
+    UniqueDrivenEngine engine;
+    if (argc != 2) usage();
+    std::string mode = argv[1];
+    for (int i = 0; makers[i].name != nullptr; i++) {
+        if (mode == makers[i].name) {
+            engine = makers[i].func();
+            break;
+        }
+    }
+    if (engine == nullptr) usage();
+    driver_drive(engine.get());
 }
+

luprex/core/cpp/textgame.cpp

@@ -15,8 +15,37 @@
 #include "textgame.hpp"
 #include "luaconsole.hpp"
 #include "print.hpp"
+#include <memory>
+
+
+class TextGame : public DrivenEngine {
+private:
+    using StringVec = LuaConsole::StringVec;
+    std::unique_ptr<World> world_;
+    LuaConsole console_;
+    Gui gui_;
+    int64_t gui_place_;
+    int64_t actor_id_;
+
+    void do_view_command(const StringVec &cmd);
+    void do_menu_command(const StringVec &cmd);
+    void do_choose_command(const StringVec &cmd);
+    void do_quit_command(const StringVec &cmd);
+    void do_snapshot_command(const StringVec &cmd);
+    void do_rollback_command(const StringVec &cmd);
+    void do_tick_command(const StringVec &cmd);
+    
+    void do_lua(const std::string &exp);
+    void do_command(const StringVec &exp);
+
+    void check_redirects();
+
+public:
+    virtual void event_init();
+    virtual void event_update();
+};
+
 
-// Add another error status.
 
 static lua_State *globalL = NULL;
 
@@ -222,3 +251,6 @@ void TextGame::event_update()
     }
 }
 
+UniqueDrivenEngine make_TextGame() {
+    return UniqueDrivenEngine(new TextGame);
+}

luprex/core/cpp/textgame.hpp

@@ -2,37 +2,8 @@
 #ifndef TEXTGAME_HPP
 #define TEXTGAME_HPP
 
-#include "luaconsole.hpp"
-#include "world.hpp"
 #include "drivenengine.hpp"
-#include <memory>
 
-class TextGame : public DrivenEngine {
-private:
-    using StringVec = LuaConsole::StringVec;
-    std::unique_ptr<World> world_;
-    LuaConsole console_;
-    Gui gui_;
-    int64_t gui_place_;
-    int64_t actor_id_;
-
-    void do_view_command(const StringVec &cmd);
-    void do_menu_command(const StringVec &cmd);
-    void do_choose_command(const StringVec &cmd);
-    void do_quit_command(const StringVec &cmd);
-    void do_snapshot_command(const StringVec &cmd);
-    void do_rollback_command(const StringVec &cmd);
-    void do_tick_command(const StringVec &cmd);
-    
-    void do_lua(const std::string &exp);
-    void do_command(const StringVec &exp);
-
-    void check_redirects();
-
-public:
-    virtual void event_init();
-    virtual void event_update();
-};
+UniqueDrivenEngine make_TextGame();
 
 #endif // TEXTGAME_HPP
-