cmake: avoid de-duplication of user's CXXFLAGS

[quassel.git] / src / common / internalpeer.cpp

diff --git a/src/common/internalpeer.cpp b/src/common/internalpeer.cpp
index 4180b76..de2743b 100644 (file)
--- a/src/common/internalpeer.cpp
+++ b/src/common/internalpeer.cpp
@@ -1,5 +1,5 @@
 /***************************************************************************
- *   Copyright (C) 2005-2018 by the Quassel Project                        *
+ *   Copyright (C) 2005-2022 by the Quassel Project                        *
  *   devel@quassel-irc.org                                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
@@ -20,12 +20,15 @@
 
 #include "internalpeer.h"
 
+#include "util.h"
+
 using namespace Protocol;
 
-InternalPeer::InternalPeer(QObject *parent)
+InternalPeer::InternalPeer(QObject* parent)
     : Peer(nullptr, parent)
 {
     static bool registered = []() {
+        qRegisterMetaType<QPointer<InternalPeer>>();
         qRegisterMetaType<Protocol::SyncMessage>();
         qRegisterMetaType<Protocol::RpcCall>();
         qRegisterMetaType<Protocol::InitRequest>();
@@ -37,7 +40,6 @@ InternalPeer::InternalPeer(QObject *parent)
     setFeatures(Quassel::Features{});
 }
 
-
 InternalPeer::~InternalPeer()
 {
     if (_isOpen) {
@@ -45,64 +47,53 @@ InternalPeer::~InternalPeer()
     }
 }
 
-
 QString InternalPeer::description() const
 {
     return tr("internal connection");
 }
 
-
 QString InternalPeer::address() const
 {
     return tr("internal connection");
 }
 
-
 quint16 InternalPeer::port() const
 {
     return 0;
 }
 
-
 bool InternalPeer::isOpen() const
 {
-    return true;
+    return _isOpen;
 }
 
-
 bool InternalPeer::isSecure() const
 {
     return true;
 }
 
-
 bool InternalPeer::isLocal() const
 {
     return true;
 }
 
-
-void InternalPeer::close(const QString &reason)
+void InternalPeer::close(const QString& reason)
 {
-    // FIXME
-    Q_UNUSED(reason)
-    qWarning() << "closing not implemented!";
+    Q_UNUSED(reason);
+    _isOpen = false;
 }
 
-
 int InternalPeer::lag() const
 {
     return 0;
 }
 
-
-::SignalProxy *InternalPeer::signalProxy() const
+::SignalProxy* InternalPeer::signalProxy() const
 {
     return _proxy;
 }
 
-
-void InternalPeer::setSignalProxy(::SignalProxy *proxy)
+void InternalPeer::setSignalProxy(::SignalProxy* proxy)
 {
     if (!proxy && _proxy) {
         _proxy = nullptr;
@@ -115,26 +106,37 @@ void InternalPeer::setSignalProxy(::SignalProxy *proxy)
 
     if (proxy && !_proxy) {
         _proxy = proxy;
+        _isOpen = true;
         return;
     }
 
     qWarning() << Q_FUNC_INFO << "Changing the SignalProxy is not supported!";
 }
 
-
-void InternalPeer::setPeer(InternalPeer *peer)
+void InternalPeer::setPeer(InternalPeer* peer)
 {
-    connect(peer, SIGNAL(dispatchMessage(Protocol::SyncMessage)), SLOT(handleMessage(Protocol::SyncMessage)));
-    connect(peer, SIGNAL(dispatchMessage(Protocol::RpcCall))    , SLOT(handleMessage(Protocol::RpcCall)));
-    connect(peer, SIGNAL(dispatchMessage(Protocol::InitRequest)), SLOT(handleMessage(Protocol::InitRequest)));
-    connect(peer, SIGNAL(dispatchMessage(Protocol::InitData))   , SLOT(handleMessage(Protocol::InitData)));
+    connect(peer,
+            selectOverload<const Protocol::SyncMessage&>(&InternalPeer::dispatchMessage),
+            this,
+            selectOverload<const Protocol::SyncMessage&>(&InternalPeer::handleMessage));
+    connect(peer,
+            selectOverload<const Protocol::RpcCall&>(&InternalPeer::dispatchMessage),
+            this,
+            selectOverload<const Protocol::RpcCall&>(&InternalPeer::handleMessage));
+    connect(peer,
+            selectOverload<const Protocol::InitRequest&>(&InternalPeer::dispatchMessage),
+            this,
+            selectOverload<const Protocol::InitRequest&>(&InternalPeer::handleMessage));
+    connect(peer,
+            selectOverload<const Protocol::InitData&>(&InternalPeer::dispatchMessage),
+            this,
+            selectOverload<const Protocol::InitData&>(&InternalPeer::handleMessage));
 
-    connect(peer, SIGNAL(disconnected()), SLOT(peerDisconnected()));
+    connect(peer, &Peer::disconnected, this, &InternalPeer::peerDisconnected);
 
     _isOpen = true;
 }
 
-
 void InternalPeer::peerDisconnected()
 {
     disconnect(sender(), nullptr, this, nullptr);
@@ -144,59 +146,50 @@ void InternalPeer::peerDisconnected()
     }
 }
 
-
-void InternalPeer::dispatch(const SyncMessage &msg)
+void InternalPeer::dispatch(const SyncMessage& msg)
 {
     emit dispatchMessage(msg);
 }
 
-
-void InternalPeer::dispatch(const RpcCall &msg)
+void InternalPeer::dispatch(const RpcCall& msg)
 {
     emit dispatchMessage(msg);
 }
 
-
-void InternalPeer::dispatch(const InitRequest &msg)
+void InternalPeer::dispatch(const InitRequest& msg)
 {
     emit dispatchMessage(msg);
 }
 
-
-void InternalPeer::dispatch(const InitData &msg)
+void InternalPeer::dispatch(const InitData& msg)
 {
     emit dispatchMessage(msg);
 }
 
-
-void InternalPeer::handleMessage(const Protocol::SyncMessage &msg)
+void InternalPeer::handleMessage(const Protocol::SyncMessage& msg)
 {
     handle(msg);
 }
 
-
-void InternalPeer::handleMessage(const Protocol::RpcCall &msg)
+void InternalPeer::handleMessage(const Protocol::RpcCall& msg)
 {
     handle(msg);
 }
 
-
-void InternalPeer::handleMessage(const Protocol::InitRequest &msg)
+void InternalPeer::handleMessage(const Protocol::InitRequest& msg)
 {
     handle(msg);
 }
 
-
-void InternalPeer::handleMessage(const Protocol::InitData &msg)
+void InternalPeer::handleMessage(const Protocol::InitData& msg)
 {
     handle(msg);
 }
 
-
 template<class T>
-void InternalPeer::handle(const T &msg)
+void InternalPeer::handle(const T& msg)
 {
-    static auto setSourcePeer = [](Peer *peer) {
+    static auto setSourcePeer = [](Peer* peer) {
         auto p = SignalProxy::current();
         if (p) {
             p->setSourcePeer(peer);