Refactor connection factories to shared base class

There was a lot of duplicate code, and having a common base class makes it
easier to extend (in future changesets) to support connections made outside
of QtRO.

Change-Id: Ie2a436132df2f4c7a2503a67b4f8fc2b9e18ef4e
Reviewed-by: Michael Brasser <michael.brasser@live.com>

1 files changed, 49 insertions, 67 deletions

diff --git a/src/remoteobjects/qconnectionfactories.cpp b/src/remoteobjects/qconnectionfactories.cpp
index 583f800..3c3059a 100644
--- a/src/remoteobjects/qconnectionfactories.cpp
+++ b/src/remoteobjects/qconnectionfactories.cpp
@@ -89,33 +89,25 @@ inline bool fromDataStream(QDataStream &in, QRemoteObjectPacketTypeEnum &type, Q
     return true;
 }
 
-ClientIoDevice::ClientIoDevice(QObject *parent)
+/*!
+    All communication between nodes happens through some form of QIODevice with
+    an associated QDataStream to handle marshalling of Qt types. IoDeviceBase
+    is an abstract base class that provides a consistent interface to QtRO, yet
+    can be extended to support different types of QIODevice.
+ */
+IoDeviceBase::IoDeviceBase(QObject *parent)
     : QObject(parent), m_isClosing(false), m_curReadSize(0)
 {
     m_dataStream.setVersion(dataStreamVersion);
 }
 
-ClientIoDevice::~ClientIoDevice()
+IoDeviceBase::~IoDeviceBase()
 {
-    if (!m_isClosing)
-        close();
 }
 
-void ClientIoDevice::close()
+bool IoDeviceBase::read(QRemoteObjectPacketTypeEnum &type, QString &name)
 {
-    m_isClosing = true;
-    doClose();
-}
-
-void ClientIoDevice::disconnectFromServer()
-{
-    doDisconnectFromServer();
-    emit shouldReconnect(this);
-}
-
-bool ClientIoDevice::read(QRemoteObjectPacketTypeEnum &type, QString &name)
-{
-    qCDebug(QT_REMOTEOBJECT_IO) << "ClientIODevice::read()" << m_curReadSize << bytesAvailable();
+    qCDebug(QT_REMOTEOBJECT_IO) << deviceType() << "read()" << m_curReadSize << bytesAvailable();
 
     if (m_curReadSize == 0) {
         if (bytesAvailable() < static_cast<int>(sizeof(quint32)))
@@ -124,7 +116,7 @@ bool ClientIoDevice::read(QRemoteObjectPacketTypeEnum &type, QString &name)
         m_dataStream >> m_curReadSize;
     }
 
-    qCDebug(QT_REMOTEOBJECT_IO) << "ClientIODevice::read()-looking for map" << m_curReadSize << bytesAvailable();
+    qCDebug(QT_REMOTEOBJECT_IO) << deviceType() << "read()-looking for map" << m_curReadSize << bytesAvailable();
 
     if (bytesAvailable() < m_curReadSize)
         return false;
@@ -133,98 +125,88 @@ bool ClientIoDevice::read(QRemoteObjectPacketTypeEnum &type, QString &name)
     return fromDataStream(m_dataStream, type, name);
 }
 
-void ClientIoDevice::write(const QByteArray &data)
+void IoDeviceBase::write(const QByteArray &data)
 {
-    connection()->write(data);
+    if (connection()->isOpen() && !m_isClosing)
+        connection()->write(data);
 }
 
-void ClientIoDevice::write(const QByteArray &data, qint64 size)
+void IoDeviceBase::write(const QByteArray &data, qint64 size)
 {
-    connection()->write(data.data(), size);
+    if (connection()->isOpen() && !m_isClosing)
+        connection()->write(data.data(), size);
+}
+
+void IoDeviceBase::close()
+{
+    m_isClosing = true;
+    doClose();
 }
 
-qint64 ClientIoDevice::bytesAvailable() const
+qint64 IoDeviceBase::bytesAvailable() const
 {
     return connection()->bytesAvailable();
 }
 
-QUrl ClientIoDevice::url() const
+void IoDeviceBase::initializeDataStream()
 {
-    return m_url;
+    m_dataStream.setDevice(connection());
+    m_dataStream.resetStatus();
 }
 
-void ClientIoDevice::addSource(const QString &name)
+void IoDeviceBase::addSource(const QString &name)
 {
     m_remoteObjects.insert(name);
 }
 
-void ClientIoDevice::removeSource(const QString &name)
+void IoDeviceBase::removeSource(const QString &name)
 {
     m_remoteObjects.remove(name);
 }
 
-QSet<QString> ClientIoDevice::remoteObjects() const
+QSet<QString> IoDeviceBase::remoteObjects() const
 {
     return m_remoteObjects;
 }
 
-ServerIoDevice::ServerIoDevice(QObject *parent)
-    : QObject(parent), m_isClosing(false), m_curReadSize(0)
-{
-    m_dataStream.setVersion(dataStreamVersion);
-}
-
-ServerIoDevice::~ServerIoDevice()
+ClientIoDevice::ClientIoDevice(QObject *parent) : IoDeviceBase(parent)
 {
 }
 
-bool ServerIoDevice::read(QRemoteObjectPacketTypeEnum &type, QString &name)
+ClientIoDevice::~ClientIoDevice()
 {
-    qCDebug(QT_REMOTEOBJECT_IO) << "ServerIODevice::read()" << m_curReadSize << bytesAvailable();
-
-    if (m_curReadSize == 0) {
-        if (bytesAvailable() < static_cast<int>(sizeof(quint32)))
-            return false;
-
-        m_dataStream >> m_curReadSize;
-    }
-
-    qCDebug(QT_REMOTEOBJECT_IO) << "ServerIODevice::read()-looking for map" << m_curReadSize << bytesAvailable();
-
-    if (bytesAvailable() < m_curReadSize)
-        return false;
-
-    m_curReadSize = 0;
-    return fromDataStream(m_dataStream, type, name);
+    if (!m_isClosing)
+        close();
 }
 
-void ServerIoDevice::close()
+void ClientIoDevice::disconnectFromServer()
 {
-    m_isClosing = true;
-    doClose();
+    doDisconnectFromServer();
+    emit shouldReconnect(this);
 }
 
-void ServerIoDevice::write(const QByteArray &data)
+QUrl ClientIoDevice::url() const
 {
-    if (connection()->isOpen() && !m_isClosing)
-        connection()->write(data);
+    return m_url;
 }
 
-void ServerIoDevice::write(const QByteArray &data, qint64 size)
+QString ClientIoDevice::deviceType() const
 {
-    if (connection()->isOpen() && !m_isClosing)
-        connection()->write(data.data(), size);
+    return QStringLiteral("ClientIoDevice");
 }
 
-qint64 ServerIoDevice::bytesAvailable()
+/*!
+    The Qt servers create QIODevice derived classes from handleConnection. The
+    problem is that they behave differently, so this class adds some
+    consistency.
+ */
+ServerIoDevice::ServerIoDevice(QObject *parent) : IoDeviceBase(parent)
 {
-    return connection()->bytesAvailable();
 }
 
-void ServerIoDevice::initializeDataStream()
+QString ServerIoDevice::deviceType() const
 {
-    m_dataStream.setDevice(connection());
-    m_dataStream.resetStatus();
+    return QStringLiteral("ServerIoDevice");
 }
 
 QConnectionAbstractServer::QConnectionAbstractServer(QObject *parent)