Question

（“信号处理程序”是指插槽，而不是POSIX信号的处理程序。）

我需要从QObject的一个（尚未知道的）子类的实例“连接”（可能不是直接使用QObject::connect）所有信号另一个QObject的单个插槽。我需要这个以便通过网络发送信号（带参数）（对于支持信号的自己的RPC系统）。

（“尚未知道”我的意思是我的代码应尽可能通用。因此，对于我在RPC系统中使用的每个类中的每个信号，它都不能包含connect语句，但提供RPC::connectAllSignals(QObject*);之类的东西，然后在运行时扫描所有信号并连接它们。）

我想要实现的是：处理所有信号并将它们串行化（信号名称+参数）。我已经可以序列化参数，但我不知道如何获取信号名称。在谷歌搜索之后，似乎不可能像sender()那样使用类似QObject实例的东西。所以我需要做一些更复杂的事情。

我目前用于将参数传递给远程端目标函数的类型系统仅限于某些类型。（那是因为我需要qt_metacall，除了参数类型为void*并且背后有“正确的类型”。我的RPC系统在内部只使用几种类型的QVariants并将它们转换为void*使用自定义方法的正确类型。我听说QVariant::constData使用它的时间太晚了，它可能不适合;所以如果没有缺点，我会坚持我的类型转换。）

应将所有信号映射到的目标槽应类似于：

void handleSignal(QByteArray signalName, QVariantList arguments);

最好是C ++ 03支持该解决方案，所以我只想使用可变参数模板，如果它是大缺点而不使用它们。在这种情况下，C ++ 11可以，所以我也很高兴使用C ++ 11获得答案。

现在我的可能的解决方案来解决我正在考虑的问题：

我可以使用QMetaObject扫描对象的所有信号，然后为每个信号创建一个QSignalMapper（或类似的传递所有参数的东西）。这很容易，我不需要这方面的帮助。如前所述，我已经限制了一些类型的参数，我也可以对参数计数有限制。

这听起来像是一个肮脏的黑客，但我可以使用某种自定义的，基于模板的信号映射器（在本例中为三个参数）：

template<class T1, class T2, class T3>
class MySignalMapper : public QObject
{
    Q_OBJECT
public:
    void setSignalName(QByteArray signalName)
    {
        this->signalName = signalName;
    }
signals:
    void mapped(QByteArray signalName, QVariantList arguments);
public slots:
    void map(T1 arg1, T2 arg2, T3 arg3)
    {
        QVariantList args;
        // QVariant myTypeConverter<T>(T) already implemented:
        args << myTypeConverter(arg1);
        args << myTypeConverter(arg2);
        args << myTypeConverter(arg3);
        emit mapped(signalName, args);
    }
private:
    QByteArray signalName;
};

然后我可以像这样连接一个名为method的QMetaMethod（已知是一个信号），这个QObject称为obj（可能是使用某种类型的脚本生成所有支持的类型和争论很重要......是的...... 它变脏了！）：

    // ...
}
else if(type1 == "int" && type2 == "char" && type3 == "bool")
{
    MySignalMapper<int,char,bool> *sm = new MySignalMapper<int,char,bool>(this);
    QByteArray signalName = method.signature();
    signalName = signalName.left(signalName.indexOf('(')); // remove parameters
    sm->setMember(signalName);

    // prepend "2", like Qt's SIGNAL() macro does:
    QByteArray signalName = QByteArray("2") + method.signature();

    // connect the mapper:
    connect(obj, signalName.constData(),
            sm, SLOT(map(int,char,bool)));
    connect(sm, SIGNAL(mapped(int,char,bool)),
            this, SLOT(handleSignal(const char*,QVariantList)));
}
else if(type1 == ...)
{
    // ...

由于可能正常工作，它确实是一个肮脏的解决方案。我需要很多宏来覆盖最多N个参数的所有类型组合（其中N大约是3到5，还不知道），或者生成代码的简单脚本所有情况。问题是这将是很多的案例，因为我支持每个参数大约70种不同类型（10种基本类型+嵌套列表和深度为2的映射每个他们的类型）。因此，对于N的参数计数限制，有N ^ 70个案例要涵盖！

这个目标是否存在完全不同的方法，我忽视了这一点？

更新

我自己解决了这个问题（见答案）。如果您对完整源代码感兴趣，请参阅我刚刚发布的RPC系统bitbucket上的我的存储库：bitbucket.org/leemes/qtsimplerpc

Answer 1

在查看问题评论中HostileFork建议的Conan代码后，我找到了我的问题的解决方案：

我通过使用自定义的qt_static_metacall输出文件（通过将生成的文件移动到我的源中并随后从我的.pro文件中删除类'标题）为帮助程序QObject编写了自定义moc。我需要小心，但它似乎远不如我在问题中建议的解决方案那么脏。

对于包含一些广告位的类，例如两个广告位exampleA(int)和exampleB(bool)，其定义如下：

void ClassName::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        Q_ASSERT(staticMetaObject.cast(_o));
        ClassName *_t = static_cast<ClassName *>(_o);
        switch (_id) {
        case 0: _t->exampleA((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 1: _t->exampleB((*reinterpret_cast< bool(*)>(_a[1]))); break;
        default: ;
        }
    }
}

如您所见，它将调用重定向到被调用者提供的对象指针上的“real”方法。

我创建了一个没有任何参数的插槽的类，它将用作我们想要检查的信号的目标。

class GenericSignalMapper : public QObject
{
    Q_OBJECT
public:
    explicit GenericSignalMapper(QMetaMethod mappedMethod, QObject *parent = 0);
signals:
    void mapped(QObject *sender, QMetaMethod signal, QVariantList arguments);
public slots:
    void map();
private:
    void internalSignalHandler(void **arguments);
    QMetaMethod method;
};

插槽map()永远不会被实际调用，因为我们通过将自己的方法放在qt_static_metacall中来介入此调用过程（请注意，ID为0的元方法是我在下面解释的另一个信号）下一节，因此修改后的方法是case 1）：

void GenericSignalMapper::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        Q_ASSERT(staticMetaObject.cast(_o));
        GenericSignalMapper *_t = static_cast<GenericSignalMapper *>(_o);
        switch (_id) {
        case 0: _t->mapped((*reinterpret_cast< QObject*(*)>(_a[1])),(*reinterpret_cast< QMetaMethod(*)>(_a[2])),(*reinterpret_cast< QVariantList(*)>(_a[3]))); break;
        case 1: _t->internalSignalHandler(_a); break;
        default: ;
        }
    }
}

我们所做的是：我们只是将未解释的参数数组传递给我们自己的处理程序，因为我们不能具体说明它的类型（甚至计数）。我将此处理程序定义如下：

void GenericSignalMapper::internalSignalHandler(void **_a)
{
    QVariantList args;
    int i = 0;
    foreach(QByteArray typeName, method.parameterTypes())
    {
        int type = QMetaType::type(typeName.constData());

        QVariant arg(type, _a[++i]); // preincrement: start with 1
                                     // (_a[0] is return value)
        args << arg;
    }
    emit mapped(sender(), method, args);
}

最后，其他一些类可以连接到mapped信号，它将提供发送者对象，信号为QMetaMethod（我们可以从中读取名称），参数为QVariants。

这不是一个完整的解决方案，但最后一步很简单：对于要检查的类的每个信号，我们创建一个GenericSignalMapper，提供信号的元方法。我们将map连接到对象并映射到最终接收器，然后能够处理（并区分）源对象发出的所有信号。

~~我仍然无法将void*参数转换为QVariants。~~已修复。 _a还包含索引0的返回值的占位符，因此参数从索引1开始。

实施例

在此示例中，“最后一步”（为每个信号创建和连接映射器）是手动完成的。

要检查的课程：

class Test : public QObject
{
    Q_OBJECT
public:
    explicit Test(QObject *parent = 0);

    void emitTestSignal() {
        emit test(1, 'x');
    }

signals:
    void test(int, char);
};

通过映射器接收所有信号的最终处理程序类：

class CommonHandler : public QObject
{
    Q_OBJECT
public:
    explicit CommonHandler(QObject *parent = 0);

signals:

public slots:
    void handleSignal(QObject *sender, QMetaMethod signal, QVariantList arguments)
    {
        qDebug() << "Signal emitted:";
        qDebug() << "  sender:" << sender;
        qDebug() << "  signal:" << signal.signature();
        qDebug() << "  arguments:" << arguments;
    }
};

我们创建对象并连接它们的代码：

CommonHandler handler;

// In my scenario, it is easy to get the meta objects since I loop over them.
// Here, 4 is the index of SIGNAL(test(int,char))
QMetaMethod signal = Test::staticMetaObject.method(4);

Test test1;
test1.setObjectName("test1");
Test test2;
test2.setObjectName("test2");

GenericSignalMapper mapper1(signal);
QObject::connect(&test1, SIGNAL(test(int,char)), &mapper1, SLOT(map()));
QObject::connect(&mapper1, SIGNAL(mapped(QObject*,QMetaMethod,QVariantList)), &handler, SLOT(handleSignal(QObject*,QMetaMethod,QVariantList)));

GenericSignalMapper mapper2(signal);
QObject::connect(&test2, SIGNAL(test(int,char)), &mapper2, SLOT(map()));
QObject::connect(&mapper2, SIGNAL(mapped(QObject*,QMetaMethod,QVariantList)), &handler, SLOT(handleSignal(QObject*,QMetaMethod,QVariantList)));

test1.emitTestSignal();
test2.emitTestSignal();

输出：

Signal emitted: 
  sender: Test(0xbf955d70, name = "test1") 
  signal: test(int,char) 
  arguments: (QVariant(int, 1) ,  QVariant(char, ) )  
Signal emitted: 
  sender: Test(0xbf955d68, name = "test2") 
  signal: test(int,char) 
  arguments: (QVariant(int, 1) ,  QVariant(char, ) )

（char参数无法正确打印，但正确存储在QVariant中。其他类型的工作方式类似于魅力。）

Answer 2

你可以对每个参数进行泛型调度，关于SLOT / SIGNAL它们只是字符串，因此伪造它们不是问题。这是关于制作一个模板函数，它将每个参数传递到调度并合并所有结果。如果你使用c ++ 11，这甚至可以有无限数量的参数。

Answer 3

我出于同样的原因寻找通用信号处理程序，即通过RPC转发信号调用。在QtDevDays presentation中有一个非常有趣和详细的QObject-QMetaObject魔法描述。特别是，他们还描述了检查通用信号以调试脚本语言或与脚本语言接口的愿望 - 所以这是一个完美的阅读。

长话短说：您的解决方案是修改moc代码中的qt_static_metacall。（现在在Qt5？）同样的事情可以通过子类化基于QObject的类并覆盖qt_metacall来实现，例如：

class QRpcService : public QRpcServiceBase
{
public:
    explicit QRpcService(QTcpServer* server, QObject *parent = 0);
    virtual ~QRpcService();

    virtual int qt_metacall(QMetaObject::Call, int, void**);
private:
    static int s_id_handleRegisteredObjectSignal;
};

magic capture-all-slot只是在基类（此处为void handleRegisteredObjectSignal()）中定义的虚拟方法，它不需要任何操作，也不执行任何操作。我在构造函数中查询其meta-method-id并将其存储为static int以避免每次都搜索它。

在这个自定义元调用处理程序中，您可以拦截对magic-capture-all插槽的调用，并检查发送方对象和信号。这提供了将void**参数转换为QVariant列表所需的所有类型信息

int QRpcService::qt_metacall(QMetaObject::Call c, int id, void **a)
{
    // only handle calls to handleRegisteredObjectSignal
    // let parent qt_metacall do the rest
    if (id != QRpcService::s_id_handleRegisteredObjectSignal)
        return QRpcServiceBase::qt_metacall(c, id, a);

    // inspect sender and signal
    QObject* o = sender();
    QMetaMethod signal = o->metaObject()->method(senderSignalIndex());
    QString signal_name(signal.name());

    // convert signal args to QVariantList
    QVariantList args;
    for (int i = 0; i < signal.parameterCount(); ++i)
        args << QVariant(signal.parameterType(i), a[i+1]);

    // ...
    // do whatever you want with the signal name and arguments
    // (inspect, send via RPC, push to scripting environment, etc.)
    // ...

    return -1;
}

我刚刚处理了此方法中的所有内容，但您也可以重新发出在另一个信号中收集的所有信息，并在运行时附加到该信息中。

如果有人感兴趣，我还使用我的解决方案here设置了一个存储库。

QObject通用信号处理程序

3 个答案:

实施例