- SlotHash::const_iterator slot = _attachedSlots.constFind(funcName);
- while(slot != _attachedSlots.constEnd() && slot.key() == funcName) {
- receiver = (*slot).first;
- methodId = (*slot).second;
- numParams = argTypes(receiver, methodId).count();
- QGenericArgument args[9];
- for(int i = 0; i < numParams; i++)
- args[i] = QGenericArgument(params[i].typeName(), params[i].constData());
- if(!QMetaObject::invokeMethod(receiver, methodName(receiver, methodId),
- args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8])) {
- qWarning("SignalProxy::receivePeerSignal: invokeMethod for \"%s\" failed ", methodName(receiver, methodId).constData());
+void SignalProxy::updateSecureState()
+{
+ bool wasSecure = _secure;
+
+ _secure = !_peers.isEmpty();
+ foreach (const Peer *peer, _peers) {
+ _secure &= peer->isSecure();
+ }
+
+ if (wasSecure != _secure)
+ emit secureStateChanged(_secure);
+}
+
+
+// ==================================================
+// ExtendedMetaObject
+// ==================================================
+SignalProxy::ExtendedMetaObject::ExtendedMetaObject(const QMetaObject *meta, bool checkConflicts)
+ : _meta(meta),
+ _updatedRemotelyId(_meta->indexOfSignal("updatedRemotely()"))
+{
+ for (int i = 0; i < _meta->methodCount(); i++) {
+ if (_meta->method(i).methodType() != QMetaMethod::Slot)
+ continue;
+
+ if (QByteArray(_meta->method(i).signature()).contains('*'))
+ continue; // skip methods with ptr params
+
+ QByteArray method = methodName(_meta->method(i));
+ if (method.startsWith("init"))
+ continue; // skip initializers
+
+ if (_methodIds.contains(method)) {
+ /* funny... moc creates for methods containing default parameters multiple metaMethod with separate methodIds.
+ we don't care... we just need the full fledged version
+ */
+ const QMetaMethod ¤t = _meta->method(_methodIds[method]);
+ const QMetaMethod &candidate = _meta->method(i);
+ if (current.parameterTypes().count() > candidate.parameterTypes().count()) {
+ int minCount = candidate.parameterTypes().count();
+ QList<QByteArray> commonParams = current.parameterTypes().mid(0, minCount);
+ if (commonParams == candidate.parameterTypes())
+ continue; // we already got the full featured version
+ }
+ else {
+ int minCount = current.parameterTypes().count();
+ QList<QByteArray> commonParams = candidate.parameterTypes().mid(0, minCount);
+ if (commonParams == current.parameterTypes()) {
+ _methodIds[method] = i; // use the new one
+ continue;
+ }
+ }
+ if (checkConflicts) {
+ qWarning() << "class" << meta->className() << "contains overloaded methods which is currently not supported!";
+ qWarning() << " - " << _meta->method(i).signature() << "conflicts with" << _meta->method(_methodIds[method]).signature();
+ }
+ continue;
+ }
+ _methodIds[method] = i;
+ }
+}
+
+
+const SignalProxy::ExtendedMetaObject::MethodDescriptor &SignalProxy::ExtendedMetaObject::methodDescriptor(int methodId)
+{
+ if (!_methods.contains(methodId)) {
+ _methods[methodId] = MethodDescriptor(_meta->method(methodId));
+ }
+ return _methods[methodId];
+}
+
+
+const QHash<int, int> &SignalProxy::ExtendedMetaObject::receiveMap()
+{
+ if (_receiveMap.isEmpty()) {
+ QHash<int, int> receiveMap;
+
+ QMetaMethod requestSlot;
+ QByteArray returnTypeName;
+ QByteArray signature;
+ QByteArray methodName;
+ QByteArray params;
+ int paramsPos;
+ int receiverId;
+ const int methodCount = _meta->methodCount();
+ for (int i = 0; i < methodCount; i++) {
+ requestSlot = _meta->method(i);
+ if (requestSlot.methodType() != QMetaMethod::Slot)
+ continue;
+
+ returnTypeName = requestSlot.typeName();
+ if (QMetaType::Void == (QMetaType::Type)returnType(i))
+ continue;
+
+ signature = QByteArray(requestSlot.signature());
+ if (!signature.startsWith("request"))
+ continue;
+
+ paramsPos = signature.indexOf('(');
+ if (paramsPos == -1)
+ continue;
+
+ methodName = signature.left(paramsPos);
+ params = signature.mid(paramsPos);
+
+ methodName = methodName.replace("request", "receive");
+ params = params.left(params.count() - 1) + ", " + returnTypeName + ")";
+
+ signature = QMetaObject::normalizedSignature(methodName + params);
+ receiverId = _meta->indexOfSlot(signature);
+
+ if (receiverId == -1) {
+ signature = QMetaObject::normalizedSignature(methodName + "(" + returnTypeName + ")");
+ receiverId = _meta->indexOfSlot(signature);
+ }
+
+ if (receiverId != -1) {
+ receiveMap[i] = receiverId;
+ }
+ }
+ _receiveMap = receiveMap;