Refactor SignalProxy, network and protocol code

[quassel.git] / src / core / sessionthread.cpp

diff --git a/src/core/sessionthread.cpp b/src/core/sessionthread.cpp
index c29d1ff..49790df 100644 (file)
--- a/src/core/sessionthread.cpp
+++ b/src/core/sessionthread.cpp
@@ -1,5 +1,5 @@
 /***************************************************************************
- *   Copyright (C) 2005-09 by the Quassel Project                          *
+ *   Copyright (C) 2005-2012 by the Quassel Project                        *
  *   devel@quassel-irc.org                                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
@@ -15,104 +15,116 @@
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the                         *
  *   Free Software Foundation, Inc.,                                       *
- *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  ***************************************************************************/
 
-#include <QMutexLocker>
-
+#include "core.h"
+#include "coresession.h"
+#include "internalconnection.h"
+#include "remoteconnection.h"
 #include "sessionthread.h"
 #include "signalproxy.h"
-#include "coresession.h"
-#include "core.h"
 
 SessionThread::SessionThread(UserId uid, bool restoreState, QObject *parent)
-  : QThread(parent),
+    : QThread(parent),
     _session(0),
     _user(uid),
     _sessionInitialized(false),
     _restoreState(restoreState)
 {
-  connect(this, SIGNAL(initialized()), this, SLOT(setSessionInitialized()));
+    connect(this, SIGNAL(initialized()), this, SLOT(setSessionInitialized()));
 }
 
-SessionThread::~SessionThread() {
-  if(_session) {
-    _session->setParent(0);
-    _session->moveToThread(thread());
-    _session->deleteLater();
-    _session = 0;
-  }
-}
 
-CoreSession *SessionThread::session() {
-  return _session;
+SessionThread::~SessionThread()
+{
+    // shut down thread gracefully
+    quit();
+    wait();
 }
 
-UserId SessionThread::user() {
-  return _user;
-}
 
-bool SessionThread::isSessionInitialized() {
-  return _sessionInitialized;
+CoreSession *SessionThread::session()
+{
+    return _session;
 }
 
-void SessionThread::setSessionInitialized() {
-  _sessionInitialized = true;
-  foreach(QObject *peer, clientQueue) {
-    addClientToSession(peer);
-  }
-  clientQueue.clear();
+
+UserId SessionThread::user()
+{
+    return _user;
 }
 
-void SessionThread::addClient(QObject *peer) {
-  if(isSessionInitialized()) {
-    addClientToSession(peer);
-  } else {
-    clientQueue.append(peer);
-  }
+
+bool SessionThread::isSessionInitialized()
+{
+    return _sessionInitialized;
 }
 
-void SessionThread::addClientToSession(QObject *peer) {
-  QIODevice *socket = qobject_cast<QIODevice *>(peer);
-  if(socket) {
-    addRemoteClientToSession(socket);
-    return;
-  }
 
-  SignalProxy *proxy = qobject_cast<SignalProxy *>(peer);
-  if(proxy) {
-    addInternalClientToSession(proxy);
-    return;
-  }
+void SessionThread::setSessionInitialized()
+{
+    _sessionInitialized = true;
+    foreach(QObject *peer, clientQueue) {
+        addClientToSession(peer);
+    }
+    clientQueue.clear();
+}
+
 
-  qWarning() << "SessionThread::addClient() received neither QIODevice nor SignalProxy as peer!" << peer;
+// this and the following related methods are executed in the Core thread!
+void SessionThread::addClient(QObject *peer)
+{
+    if (isSessionInitialized()) {
+        addClientToSession(peer);
+    }
+    else {
+        clientQueue.append(peer);
+    }
 }
 
-void SessionThread::addRemoteClientToSession(QIODevice *socket) {
-  socket->setParent(0);
-  socket->moveToThread(session()->thread());
-  emit addRemoteClient(socket);
+
+void SessionThread::addClientToSession(QObject *peer)
+{
+    RemoteConnection *connection = qobject_cast<RemoteConnection *>(peer);
+    if (connection) {
+        addRemoteClientToSession(connection);
+        return;
+    }
+
+    InternalConnection *internal = qobject_cast<InternalConnection *>(peer);
+    if (internal) {
+        addInternalClientToSession(internal);
+        return;
+    }
+
+    qWarning() << "SessionThread::addClient() received invalid peer!" << peer;
 }
 
-void SessionThread::addInternalClientToSession(SignalProxy *proxy) {
-  emit addInternalClient(proxy);
+
+void SessionThread::addRemoteClientToSession(RemoteConnection *connection)
+{
+    connection->setParent(0);
+    connection->moveToThread(session()->thread());
+    emit addRemoteClient(connection);
 }
 
-void SessionThread::run() {
-  _session = new CoreSession(user(), _restoreState);
-  connect(this, SIGNAL(addRemoteClient(QIODevice *)), _session, SLOT(addClient(QIODevice *)));
-  connect(this, SIGNAL(addInternalClient(SignalProxy *)), _session, SLOT(addClient(SignalProxy *)));
-  connect(_session, SIGNAL(sessionState(const QVariant &)), Core::instance(), SIGNAL(sessionState(const QVariant &)));
-  emit initialized();
-  exec();
-  delete _session;
-  _session = 0;
+
+void SessionThread::addInternalClientToSession(InternalConnection *connection)
+{
+    connection->setParent(0);
+    connection->moveToThread(session()->thread());
+    emit addInternalClient(connection);
 }
 
-void SessionThread::stopSession() {
-  if(_session) {
-    connect(_session, SIGNAL(destroyed()), this, SLOT(quit()));
-    _session->deleteLater();
-    _session = 0;
-  }
+
+void SessionThread::run()
+{
+    _session = new CoreSession(user(), _restoreState);
+    connect(this, SIGNAL(addRemoteClient(RemoteConnection*)), _session, SLOT(addClient(RemoteConnection*)));
+    connect(this, SIGNAL(addInternalClient(InternalConnection*)), _session, SLOT(addClient(InternalConnection*)));
+    connect(_session, SIGNAL(sessionState(QVariant)), Core::instance(), SIGNAL(sessionState(QVariant)));
+    emit initialized();
+    exec();
+    delete _session;
 }