Move local/remote client and local server files.

Took 32 minutes


Took 8 seconds

libcockatrice_network/libcockatrice/server/local/CMakeLists.txt

@@ -0,0 +1,31 @@
+set(CMAKE_AUTOMOC ON)
+set(CMAKE_AUTOUIC ON)
+set(CMAKE_AUTORCC ON)
+
+set(HEADERS
+    local_client.h
+)
+
+set(SOURCES
+    local_client.cpp
+)
+
+if (Qt6_FOUND)
+    qt6_wrap_cpp(MOC_SOURCES ${HEADERS})
+elseif (Qt5_FOUND)
+    qt5_wrap_cpp(MOC_SOURCES ${HEADERS})
+endif ()
+
+add_library(
+    libcockatrice_network_client_local STATIC
+    ${MOC_SOURCES}
+    ${SOURCES}
+)
+
+# add_dependencies(libcockatrice_server libcockatrice_protocol_wrapper)
+
+target_include_directories(libcockatrice_network_client_local PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+
+target_link_libraries(
+    libcockatrice_network_client_local PUBLIC ${COCKATRICE_QT_MODULES}
+)

libcockatrice_network/libcockatrice/server/local/local_server.cpp

@@ -0,0 +1,51 @@
+#include "../../../cockatrice/src/server/local_server.h"
+
+#include "local_server_interface.h"
+
+#include <libcockatrice/server/server_room.h>
+
+LocalServer::LocalServer(QObject *parent) : Server(parent)
+{
+    setDatabaseInterface(new LocalServer_DatabaseInterface(this));
+    addRoom(new Server_Room(0, 0, QString(), QString(), QString(), QString(), false, QString(), QStringList(), this));
+}
+
+LocalServer::~LocalServer()
+{
+    // LocalServer is single threaded so it doesn't need locks on this
+    for (auto *client : clients) {
+        client->prepareDestroy();
+    }
+
+    prepareDestroy();
+}
+
+LocalServerInterface *LocalServer::newConnection()
+{
+    LocalServerInterface *lsi = new LocalServerInterface(this, getDatabaseInterface());
+    addClient(lsi);
+    return lsi;
+}
+
+LocalServer_DatabaseInterface::LocalServer_DatabaseInterface(LocalServer *_localServer)
+    : Server_DatabaseInterface(_localServer), localServer(_localServer)
+{
+}
+
+ServerInfo_User LocalServer_DatabaseInterface::getUserData(const QString &name, bool /*withId*/)
+{
+    ServerInfo_User result;
+    result.set_name(name.toStdString());
+    return result;
+}
+
+AuthenticationResult LocalServer_DatabaseInterface::checkUserPassword(Server_ProtocolHandler * /* handler */,
+                                                                      const QString & /* user */,
+                                                                      const QString & /* password */,
+                                                                      const QString & /* clientId */,
+                                                                      QString & /* reasonStr */,
+                                                                      int & /* banSecondsLeft */,
+                                                                      bool /* passwordNeedsHash */)
+{
+    return UnknownUser;
+}

libcockatrice_network/libcockatrice/server/local/local_server.h

@@ -0,0 +1,58 @@
+/**
+ * @file local_server.h
+ * @ingroup Server
+ * @brief TODO: Document this.
+ */
+
+#ifndef LOCALSERVER_H
+#define LOCALSERVER_H
+
+#include <libcockatrice/server/server.h>
+#include <libcockatrice/server/server_database_interface.h>
+
+class LocalServerInterface;
+
+class LocalServer : public Server
+{
+    Q_OBJECT
+public:
+    explicit LocalServer(QObject *parent = nullptr);
+    ~LocalServer() override;
+
+    LocalServerInterface *newConnection();
+};
+
+class LocalServer_DatabaseInterface : public Server_DatabaseInterface
+{
+    Q_OBJECT
+private:
+    LocalServer *localServer;
+
+protected:
+    ServerInfo_User getUserData(const QString &name, bool withId = false) override;
+
+public:
+    explicit LocalServer_DatabaseInterface(LocalServer *_localServer);
+    ~LocalServer_DatabaseInterface() override = default;
+    AuthenticationResult checkUserPassword(Server_ProtocolHandler *handler,
+                                           const QString &user,
+                                           const QString &password,
+                                           const QString &clientId,
+                                           QString &reasonStr,
+                                           int &secondsLeft,
+                                           bool passwordNeedsHash) override;
+    int getNextGameId() override
+    {
+        return localServer->getNextLocalGameId();
+    }
+    int getNextReplayId() override
+    {
+        return -1;
+    }
+    int getActiveUserCount(QString /* connectionType */) override
+    {
+        return 0;
+    }
+};
+
+#endif

libcockatrice_network/libcockatrice/server/local/local_server_interface.cpp

@@ -0,0 +1,24 @@
+#include "../../../cockatrice/src/server/local_server_interface.h"
+
+#include "local_server.h"
+
+#include <QDebug>
+
+LocalServerInterface::LocalServerInterface(LocalServer *_server, Server_DatabaseInterface *_databaseInterface)
+    : Server_ProtocolHandler(_server, _databaseInterface, _server)
+{
+}
+
+LocalServerInterface::~LocalServerInterface()
+{
+}
+
+void LocalServerInterface::transmitProtocolItem(const ServerMessage &item)
+{
+    emit itemToClient(item);
+}
+
+void LocalServerInterface::itemFromClient(const CommandContainer &item)
+{
+    processCommandContainer(item);
+}

libcockatrice_network/libcockatrice/server/local/local_server_interface.h

@@ -0,0 +1,36 @@
+/**
+ * @file local_server_interface.h
+ * @ingroup Server
+ * @brief TODO: Document this.
+ */
+
+#ifndef LOCALSERVERINTERFACE_H
+#define LOCALSERVERINTERFACE_H
+
+#include <libcockatrice/server/server_protocolhandler.h>
+
+class LocalServer;
+
+class LocalServerInterface : public Server_ProtocolHandler
+{
+    Q_OBJECT
+public:
+    LocalServerInterface(LocalServer *_server, Server_DatabaseInterface *_databaseInterface);
+    ~LocalServerInterface() override;
+
+    QString getAddress() const override
+    {
+        return QString();
+    }
+    QString getConnectionType() const override
+    {
+        return "local";
+    };
+    void transmitProtocolItem(const ServerMessage &item) override;
+signals:
+    void itemToClient(const ServerMessage &item);
+public slots:
+    void itemFromClient(const CommandContainer &item);
+};
+
+#endif