/***************************************************************************
- * Copyright (C) 2005-2016 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 *
#pragma once
+#include "common-export.h"
+
#include <QEvent>
#include <QSet>
class Peer;
class SyncableObject;
-class SignalProxy : public QObject
+class COMMON_EXPORT SignalProxy : public QObject
{
Q_OBJECT
SignalProxy(QObject *parent);
SignalProxy(ProxyMode mode, QObject *parent);
- virtual ~SignalProxy();
+ ~SignalProxy() override;
void setProxyMode(ProxyMode mode);
inline ProxyMode proxyMode() const { return _proxyMode; }
void dumpProxyStats();
void dumpSyncMap(SyncableObject *object);
- static SignalProxy *current() {
- return _current;
- }
+ static SignalProxy *current();
/**@{*/
/**
}
//A better version, but only implemented on Qt5 if Initializer Lists exist
-#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
#ifdef Q_COMPILER_INITIALIZER_LISTS
void restrictTargetPeers(std::initializer_list<Peer*> peers, std::function<void()> closure) {
restrictTargetPeers(QSet<Peer*>(peers), std::move(closure));
}
-#endif
#endif
/**}@*/
void detachSlots(QObject *receiver);
protected:
- void customEvent(QEvent *event);
+ void customEvent(QEvent *event) override;
void sync_call__(const SyncableObject *obj, ProxyMode modeType, const char *funcname, va_list ap);
void renameObject(const SyncableObject *obj, const QString &newname, const QString &oldname);
template<class T>
void handle(Peer *, T) { Q_ASSERT(0); }
- bool invokeSlot(QObject *receiver, int methodId, const QVariantList ¶ms, QVariant &returnValue, Peer *peer = 0);
- bool invokeSlot(QObject *receiver, int methodId, const QVariantList ¶ms = QVariantList(), Peer *peer = 0);
+ bool invokeSlot(QObject *receiver, int methodId, const QVariantList ¶ms, QVariant &returnValue, Peer *peer = nullptr);
+ bool invokeSlot(QObject *receiver, int methodId, const QVariantList ¶ms = QVariantList(), Peer *peer = nullptr);
void requestInit(SyncableObject *obj);
QVariantMap initData(SyncableObject *obj) const;
SignalRelay *_signalRelay;
// RPC function -> (object, slot ID)
- typedef QPair<QObject *, int> MethodId;
- typedef QMultiHash<QByteArray, MethodId> SlotHash;
+ using MethodId = QPair<QObject *, int>;
+ using SlotHash = QMultiHash<QByteArray, MethodId>;
SlotHash _attachedSlots;
// slaves for sync
- typedef QHash<QString, SyncableObject *> ObjectId;
+ using ObjectId = QHash<QString, SyncableObject *>;
QHash<QByteArray, ObjectId> _syncSlave;
ProxyMode _proxyMode;
Peer *_sourcePeer = nullptr;
Peer *_targetPeer = nullptr;
- thread_local static SignalProxy *_current;
-
friend class SignalRelay;
friend class SyncableObject;
friend class Peer;
{
public:
MethodDescriptor(const QMetaMethod &method);
- MethodDescriptor() : _returnType(-1), _minArgCount(-1), _receiverMode(SignalProxy::Client) {}
+ MethodDescriptor() = default;
inline const QByteArray &methodName() const { return _methodName; }
inline const QList<int> &argTypes() const { return _argTypes; }
private:
QByteArray _methodName;
QList<int> _argTypes;
- int _returnType;
- int _minArgCount;
- SignalProxy::ProxyMode _receiverMode; // Only acceptable as a Sync Call if the receiving SignalProxy is in this mode.
+ int _returnType{-1};
+ int _minArgCount{-1};
+ SignalProxy::ProxyMode _receiverMode{SignalProxy::Client}; // Only acceptable as a Sync Call if the receiving SignalProxy is in this mode.
};