Fixing small glitch in a header file

[quassel.git] / src / common / signalproxy.h

diff --git a/src/common/signalproxy.h b/src/common/signalproxy.h
index b630fe4..3b8497c 100644 (file)
--- a/src/common/signalproxy.h
+++ b/src/common/signalproxy.h
@@ -41,9 +41,7 @@ class SignalProxy : public QObject {
   class IODevicePeer;
   class SignalProxyPeer;
 
-  class Relay;
   class SignalRelay;
-  class SyncRelay;
 
 public:
   enum ProxyMode {
@@ -87,6 +85,7 @@ public:
   bool attachSlot(const QByteArray& sigName, QObject *recv, const char *slot);
 
   void synchronize(SyncableObject *obj);
+  void stopSynchronize(SyncableObject *obj);
 
   //! Writes a QVariant to a device.
   /** The data item is prefixed with the resulting blocksize,
@@ -103,9 +102,9 @@ public:
 
   class ExtendedMetaObject;
   ExtendedMetaObject *extendedMetaObject(const QMetaObject *meta) const;
-  ExtendedMetaObject *createExtendedMetaObject(const QMetaObject *meta);
+  ExtendedMetaObject *createExtendedMetaObject(const QMetaObject *meta, bool checkConflicts = false);
   inline ExtendedMetaObject *extendedMetaObject(const QObject *obj) const { return extendedMetaObject(metaObject(obj)); }
-  inline ExtendedMetaObject *createExtendedMetaObject(const QObject *obj) { return createExtendedMetaObject(metaObject(obj)); }
+  inline ExtendedMetaObject *createExtendedMetaObject(const QObject *obj, bool checkConflicts = false) { return createExtendedMetaObject(metaObject(obj), checkConflicts); }
 
   bool isSecure() const { return _secure; }
   void dumpProxyStats();
@@ -114,16 +113,15 @@ public slots:
   void detachObject(QObject *obj);
   void detachSignals(QObject *sender);
   void detachSlots(QObject *receiver);
-  void stopSync(QObject *obj);
 
 protected:
   void customEvent(QEvent *event);
-  void syncCall(const SyncableObject *obj, ProxyMode modeType, const char *funcname, va_list ap);
+  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);
 
 private slots:
   void dataAvailable();
   void removePeerBySender();
-  void objectRenamed(const QString &newname, const QString &oldname);
   void objectRenamed(const QByteArray &classname, const QString &newname, const QString &oldname);
   void sendHeartBeat();
   void receiveHeartBeat(AbstractPeer *peer, const QVariantList &params);
@@ -184,8 +182,6 @@ private:
 
   // SignalRelay for all manually attached signals
   SignalRelay *_signalRelay;
-  // one SyncRelay per class
-  QHash<const QMetaObject *, SyncRelay *> _syncRelays;
 
   // RPC function -> (object, slot ID)
   typedef QPair<QObject*, int> MethodId;
@@ -214,51 +210,52 @@ class SignalProxy::ExtendedMetaObject {
   class MethodDescriptor {
   public:
     MethodDescriptor(const QMetaMethod &method);
-    MethodDescriptor() : _returnType(-1), _minArgCount(-1) {}
+    MethodDescriptor() : _returnType(-1), _minArgCount(-1), _receiverMode(SignalProxy::Client) {}
 
     inline const QByteArray &methodName() const { return _methodName; }
     inline const QList<int> &argTypes() const { return _argTypes; }
     inline int returnType() const { return _returnType; }
     inline int minArgCount() const { return _minArgCount; }
+    inline SignalProxy::ProxyMode receiverMode() const { return _receiverMode; }
 
   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.
   };
 
 public:
-  ExtendedMetaObject(const QMetaObject *meta);
+  ExtendedMetaObject(const QMetaObject *meta, bool checkConflicts);
 
   inline const QByteArray &methodName(int methodId) { return methodDescriptor(methodId).methodName(); }
   inline const QList<int> &argTypes(int methodId) { return methodDescriptor(methodId).argTypes(); }
   inline int returnType(int methodId) { return methodDescriptor(methodId).returnType(); }
   inline int minArgCount(int methodId) { return methodDescriptor(methodId).minArgCount(); }
+  inline SignalProxy::ProxyMode receiverMode(int methodId) { return methodDescriptor(methodId).receiverMode(); }
+
+  inline int methodId(const QByteArray &methodName) { return _methodIds.contains(methodName) ? _methodIds[methodName] : -1; }
 
   inline int updatedRemotelyId() { return _updatedRemotelyId; }
   
-  int methodId(const QByteArray &methodName);
-  const QHash<QByteArray, int> &syncMap();
+  inline const QHash<QByteArray, int> &slotMap() { return _methodIds; }
   const QHash<int, int> &receiveMap();
 
   const QMetaObject *metaObject() const { return _meta; }
 
   static QByteArray methodName(const QMetaMethod &method);
-  static bool methodsMatch(const QMetaMethod &signal, const QMetaMethod &slot);
   static QString methodBaseName(const QMetaMethod &method);
 
 private:
   const MethodDescriptor &methodDescriptor(int methodId);
 
   const QMetaObject *_meta;
-  QHash<int, MethodDescriptor> _methods;
-  QHash<QByteArray, int> _methodIds;
-
   int _updatedRemotelyId; // id of the updatedRemotely() signal - makes things faster
 
-  QHash<QByteArray, int> _syncMap;
-  QHash<int, int> _receiveMap;
+  QHash<int, MethodDescriptor> _methods;
+  QHash<QByteArray, int> _methodIds;
+  QHash<int, int> _receiveMap; // if slot x is called then hand over the result to slot y
 };