X-Git-Url: https://git.quassel-irc.org/?a=blobdiff_plain;f=src%2Fcommon%2Fsignalproxy.h;h=f3ea4c526861a33fd4496e92a949ed5f3d898724;hb=6718d7a1ccd42d7aae75e57d6974e0b1e0384044;hp=a1f9e714b4e66d1d2b8b1c0c2a9e5701f7d214c8;hpb=fd25e92f19d6afd4eb02844bcbf20ba132868303;p=quassel.git

diff --git a/src/common/signalproxy.h b/src/common/signalproxy.h
index a1f9e714..f3ea4c52 100644
--- a/src/common/signalproxy.h
+++ b/src/common/signalproxy.h
@@ -1,5 +1,5 @@
 /***************************************************************************
- *   Copyright (C) 2005-2013 by the Quassel Project                        *
+ *   Copyright (C) 2005-2018 by the Quassel Project                        *
  *   devel@quassel-irc.org                                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
@@ -18,24 +18,18 @@
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  ***************************************************************************/
 
-#ifndef SIGNALPROXY_H
-#define SIGNALPROXY_H
+#pragma once
 
-#include <QAbstractSocket>
 #include <QEvent>
-#include <QList>
-#include <QHash>
-#include <QVariant>
-#include <QVariantMap>
-#include <QPair>
 #include <QSet>
-#include <QString>
-#include <QByteArray>
-#include <QTimer>
+
+#include <functional>
+#include <initializer_list>
 
 #include "protocol.h"
 
-class QMetaObject;
+struct QMetaObject;
+class QIODevice;
 
 class Peer;
 class SyncableObject;
@@ -85,7 +79,48 @@ public:
     bool isSecure() const { return _secure; }
     void dumpProxyStats();
     void dumpSyncMap(SyncableObject *object);
-    inline int peerCount() const { return _peers.size(); }
+
+    static SignalProxy *current() {
+        return _current;
+    }
+
+    /**@{*/
+    /**
+     * This method allows to send a signal only to a limited set of peers
+     * @param peers A list of peers that should receive it
+     * @param closure Code you want to execute within of that restricted environment
+     */
+    void restrictTargetPeers(QSet<Peer*> peers, std::function<void()> closure);
+    void restrictTargetPeers(Peer *peer, std::function<void()> closure) {
+        QSet<Peer*> set;
+        set.insert(peer);
+        restrictTargetPeers(set, std::move(closure));
+    }
+
+    //A better version, but only implemented on Qt5 if Initializer Lists exist
+#ifdef Q_COMPILER_INITIALIZER_LISTS
+    void restrictTargetPeers(std::initializer_list<Peer*> peers, std::function<void()> closure) {
+        restrictTargetPeers(QSet<Peer*>(peers), std::move(closure));
+    }
+#endif
+    /**}@*/
+
+    inline int peerCount() const { return _peerMap.size(); }
+    QVariantList peerData();
+
+    Peer *peerById(int peerId);
+
+    /**
+     * @return If handling a signal, the Peer from which the current signal originates
+     */
+    Peer *sourcePeer();
+    void setSourcePeer(Peer *sourcePeer);
+
+    /**
+     * @return If sending a signal, the Peer to which the current signal is directed
+     */
+    Peer *targetPeer();
+    void setTargetPeer(Peer *targetPeer);
 
 public slots:
     void detachObject(QObject *obj);
@@ -125,8 +160,14 @@ private:
     void removePeer(Peer *peer);
     void removeAllPeers();
 
+    int nextPeerId() {
+        return _lastPeerId++;
+    }
+
     template<class T>
     void dispatch(const T &protoMessage);
+    template<class T>
+    void dispatch(Peer *peer, const T &protoMessage);
 
     void handle(Peer *peer, const Protocol::SyncMessage &syncMessage);
     void handle(Peer *peer, const Protocol::RpcCall &rpcCall);
@@ -134,10 +175,10 @@ private:
     void handle(Peer *peer, const Protocol::InitData &initData);
 
     template<class T>
-    void handle(Peer *peer, T) { Q_ASSERT(0); }
+    void handle(Peer *, T) { Q_ASSERT(0); }
 
-    bool invokeSlot(QObject *receiver, int methodId, const QVariantList &params, QVariant &returnValue);
-    bool invokeSlot(QObject *receiver, int methodId, const QVariantList &params = QVariantList());
+    bool invokeSlot(QObject *receiver, int methodId, const QVariantList &params, QVariant &returnValue, Peer *peer = 0);
+    bool invokeSlot(QObject *receiver, int methodId, const QVariantList &params = QVariantList(), Peer *peer = 0);
 
     void requestInit(SyncableObject *obj);
     QVariantMap initData(SyncableObject *obj) const;
@@ -145,7 +186,7 @@ private:
 
     static void disconnectDevice(QIODevice *dev, const QString &reason = QString());
 
-    QSet<Peer *> _peers;
+    QHash<int, Peer*> _peerMap;
 
     // containg a list of argtypes for fast access
     QHash<const QMetaObject *, ExtendedMetaObject *> _extendedMetaObjects;
@@ -168,6 +209,16 @@ private:
 
     bool _secure; // determines if all connections are in a secured state (using ssl or internal connections)
 
+    int _lastPeerId = 0;
+
+    QSet<Peer *> _restrictedTargets;
+    bool _restrictMessageTarget = false;
+
+    Peer *_sourcePeer = nullptr;
+    Peer *_targetPeer = nullptr;
+
+    thread_local static SignalProxy *_current;
+
     friend class SignalRelay;
     friend class SyncableObject;
     friend class Peer;
@@ -231,5 +282,3 @@ private:
     QHash<QByteArray, int> _methodIds;
     QHash<int, int> _receiveMap; // if slot x is called then hand over the result to slot y
 };
-
-#endif