- AbstractPeer() : _type(NotAPeer) {}
- AbstractPeer(PeerType type) : _type(type) {}
- virtual ~AbstractPeer() {}
- inline PeerType type() const { return _type; }
- virtual void dispatchSignal(const RequestType &requestType, const QVariantList ¶ms) = 0;
- private:
- PeerType _type;
- };
-
- class IODevicePeer : public AbstractPeer {
- public:
- IODevicePeer(QIODevice *device, bool compress) : AbstractPeer(AbstractPeer::IODevicePeer), _device(device), byteCount(0), usesCompression(compress), sentHeartBeats(0), lag(0) {}
- virtual void dispatchSignal(const RequestType &requestType, const QVariantList ¶ms);
- inline void dispatchPackedFunc(const QVariant &packedFunc) { SignalProxy::writeDataToDevice(_device, packedFunc, usesCompression); }
- QString address() const;
- inline bool isOpen() const { return _device->isOpen(); }
- inline void close() const { _device->close(); }
- inline bool readData(QVariant &item) { return SignalProxy::readDataFromDevice(_device, byteCount, item, usesCompression); }
- private:
- QIODevice *_device;
- quint32 byteCount;
- bool usesCompression;
- public:
- int sentHeartBeats;
- int lag;
- };
-
- class SignalProxyPeer : public AbstractPeer {
- public:
- SignalProxyPeer(SignalProxy *sender, SignalProxy *receiver) : AbstractPeer(AbstractPeer::SignalProxyPeer), sender(sender), receiver(receiver) {}
- virtual void dispatchSignal(const RequestType &requestType, const QVariantList ¶ms);
- private:
- SignalProxy *sender;
- SignalProxy *receiver;
- };
-
- // a Hash of the actual used communication object to it's corresponding peer
- // currently a communication object can either be an arbitrary QIODevice or another SignalProxy
- typedef QHash<QObject *, AbstractPeer *> PeerHash;
- PeerHash _peers;
-
- // containg a list of argtypes for fast access
- QHash<const QMetaObject *, ClassInfo*> _classInfo;
-
- // we use one SignalRelay per QObject
- QHash<QObject*, SignalRelay *> _relayHash;
-
- // RPC function -> (object, slot ID)
- typedef QPair<QObject*, int> MethodId;
- typedef QMultiHash<QByteArray, MethodId> SlotHash;
- SlotHash _attachedSlots;
-
- // slaves for sync
- typedef QHash<QString, SyncableObject *> ObjectId;
- QHash<QByteArray, ObjectId> _syncSlave;
-
-
- ProxyMode _proxyMode;
- QTimer _heartBeatTimer;
-
- friend class SignalRelay;
+
+
+public:
+ 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; }
+
+ 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 QString methodBaseName(const QMetaMethod &method);
+
+private:
+ const MethodDescriptor &methodDescriptor(int methodId);
+
+ const QMetaObject *_meta;
+ int _updatedRemotelyId; // id of the updatedRemotely() signal - makes things faster
+
+ 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
+};
+
+
+// ==================================================
+// AbstractPeer
+// ==================================================
+class SignalProxy::AbstractPeer : public QObject
+{
+ Q_OBJECT
+
+public:
+ AbstractPeer(QObject *parent = 0) : QObject(parent) {}
+
+ virtual QString description() const = 0;
+
+ virtual void setSignalProxy(SignalProxy *proxy) = 0;
+
+ virtual bool isOpen() const = 0;
+ virtual bool isSecure() const = 0;
+ virtual bool isLocal() const = 0;
+
+ virtual QString errorString() const { return QString(); }
+
+ virtual int lag() const = 0;
+
+public slots:
+ virtual void dispatch(const SyncMessage &msg) = 0;
+ virtual void dispatch(const RpcCall &msg) = 0;
+ virtual void dispatch(const InitRequest &msg) = 0;
+ virtual void dispatch(const InitData &msg) = 0;
+
+ virtual void close(const QString &reason = QString()) = 0;
+
+signals:
+ void disconnected();
+ void error(QAbstractSocket::SocketError);
+ void secureStateChanged(bool secure = true);
+ void lagUpdated(int msecs);
+};
+
+
+// ==================================================
+// Protocol Messages
+// ==================================================
+class SignalProxy::SyncMessage
+{
+public:
+ inline SyncMessage(const QByteArray &className, const QString &objectName, const QByteArray &slotName, const QVariantList ¶ms)
+ : _className(className), _objectName(objectName), _slotName(slotName), _params(params) {}
+
+ inline QByteArray className() const { return _className; }
+ inline QString objectName() const { return _objectName; }
+ inline QByteArray slotName() const { return _slotName; }
+
+ inline QVariantList params() const { return _params; }
+
+private:
+ QByteArray _className;
+ QString _objectName;
+ QByteArray _slotName;
+ QVariantList _params;
+};
+
+
+class SignalProxy::RpcCall
+{
+public:
+ inline RpcCall(const QByteArray &slotName, const QVariantList ¶ms)
+ : _slotName(slotName), _params(params) {}
+
+ inline QByteArray slotName() const { return _slotName; }
+ inline QVariantList params() const { return _params; }
+
+private:
+ QByteArray _slotName;
+ QVariantList _params;
+};
+
+
+class SignalProxy::InitRequest
+{
+public:
+ inline InitRequest(const QByteArray &className, const QString &objectName)
+ : _className(className), _objectName(objectName) {}
+
+ inline QByteArray className() const { return _className; }
+ inline QString objectName() const { return _objectName; }
+
+private:
+ QByteArray _className;
+ QString _objectName;
+};
+
+
+class SignalProxy::InitData
+{
+public:
+ inline InitData(const QByteArray &className, const QString &objectName, const QVariantMap &initData)
+ : _className(className), _objectName(objectName), _initData(initData) {}
+
+ inline QByteArray className() const { return _className; }
+ inline QString objectName() const { return _objectName; }
+
+ inline QVariantMap initData() const { return _initData; }
+
+private:
+ QByteArray _className;
+ QString _objectName;
+ QVariantMap _initData;