QObject通用信号处理程序

Question

("信号处理程序"是指插槽,而不是POSIX信号的处理程序.)

我需要将来自QObject的一个(尚未知晓的)子类的实例的所有信号 "连接"(可能不QObject::connect直接使用)到另一个QObject的单个插槽.我需要这个以便通过网络发送信号(带参数)(对于支持信号的自己的RPC系统).

("还不知道"我的意思是我的代码应该尽可能通用.所以它不能包含connect我在RPC系统中使用的每个类中的每个信号的语句,但提供类似的东西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;
};

然后我可以连接一个名为QMetaMethod method(这是众所周知的是一个信号)一个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在问题评论中建议的柯南代码后,我找到了一个问题的解决方案:

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

对于具有一些槽的一类,此处例如两个时隙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: ;
        }
    }
}

如您所见,它将调用重定向到被调用者提供的对象指针上的"真实"方法.

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

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还包括index的返回值的占位符0,因此参数从index开始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中.其他类型的工作方式就像魅力.)