Qt：如何等待多個信號？

Question

我正在開發一個使用PySide和Qt的GUI測試庫。到目前爲止，當測試用例需要等待只發生一種情況時（例如信號或超時），它的工作情況非常好，但是我的問題是在繼續進行數據驗證之前需要等待多個條件發生。

測試運行器在其自己的線程中工作，以免干擾主線程太多。等待信號/超時與事件循環發生，這是一個很好地工作（簡化的例子）的部分：

# Create a simple event loop and fail timer (to prevent infinite waiting) 
loop = QtCore.QEventLoop() 
failtimer = QtCore.QTimer() 
failtimer.setInterval(MAX_DELAY) 
failtimer.setSingleShot(True) 
failtimer.timeout.connect(loop.quit) 

# Connect waitable signal to event loop 
condition.connect(loop.quit) # condition is for example QLineEdit.textChanged() signal 

# Perform test action 
testwidget.doStuff.emit() # Function not called directly, but via signals 

# Wait for condition, or fail timeout, to happen 
loop.exec_() 

# Verify data 
assert expectedvalue == testwidget.readValue() 

等候必須是同步的，所以事件循環是要走的路，但它不適用於多個信號。等待多個條件當然是可能的，但不等待多個條件/信號全部發生。那麼有關如何繼續這個的建議？

我在考慮一個幫助類，它計數接收到的信號數量，然後在達到所需計數後發出一個ready（）信號。但這真的是最好的方式嗎？助手還必須檢查每個發件人，以便只記錄特定信號的一個「實例」。

Answer 1

我會親自將所有必要的信號連接到它們相應的信號處理程序，也就是說。插槽。

它們都會標記它們的排放是「完成」的，並且可以檢查整體條件是否「完成」，並且在每個信號處理程序設置其自己的「完成」之後，可能會有一個全局「完成「檢查，如果滿足，他們會發出」全球完成「信號。

然後，您也可以最初連接到「全局完成」信號，並且當相應的信號處理程序被觸發時，您將知道該操作完成，除非條件在此期間發生變化。

理論設計後，你會是這樣的（僞代碼）

connect_signal1_to_slot1(); 
connect_signal2_to_slot2(); 
... 
connect_global_done_signal_to_global_done_slot(); 

slotX: mark_conditionX_done(); if global_done: emit global_done_signal(); 
global_done_slot: do_foo(); 

你也許也只有兩個信號和槽，即簡化：一個用於本地完成的操作，「標誌「基於通過的參數完成的本地信號，然後將會有」全局完成「信號和時隙。

不同之處在於語義，無論是使用帶有一個信號和槽的參數還是多個沒有參數的信號和槽，但原則上都是相同的理論。

Answer 2

我最終實現了一個相當直接的幫助類。它有一組等待信號和另一組接收信號。每個等待信號連接到一個插槽。該插槽將sender()添加到就緒，並且一旦設置的大小匹配，發出一個ready信號。

如果有人有興趣，這裏是我落得這樣做：

from PySide.QtCore import QObject, Signal, Slot 

class QMultiWait(QObject): 
    ready = Signal() 

    def __init__(self, parent=None): 
     super(QMultiWait, self).__init__(parent) 
     self._waitable = set() 
     self._waitready = set() 

    def addWaitableSignal(self, signal): 
     if signal not in self._waitable: 
      self._waitable.add(signal) 
      signal.connect(self._checkSignal) 

    @Slot() 
    def _checkSignal(self): 
     sender = self.sender() 
     self._waitready.add(sender) 
     if len(self._waitready) == len(self._waitable): 
      self.ready.emit() 

    def clear(self): 
     for signal in self._waitable: 
      signal.disconnect(self._checkSignal) 

的clear功能幾乎沒有必要，但允許被重用的類的實例。

Answer 3

一個非常簡單的方法來做到這一點，在C++中，將是：

1. 有一套，你期望得到信號（對象，信號指標）對。

2. 在等待開始之前複製設置。

3. 在插槽中，從複製列表中刪除（sender（），senderSignalIndex（））元素。如果列表爲空，則表明您已完成。

這個方案的好處是便攜性：這種方法在兩個PySide 和 C++工程。

在C++中，通常調用connect()時將方法參數封裝在一個SIGNAL或SLOT宏中。這些宏會預先設置一個方法代碼：'0'，'1'或'2'來表示它是一個可調用的方法，信號還是時隙。調用registerSignal時會跳過此方法代碼，因爲它需要原始方法名稱。

由於indexOfMethod所調用的registerSignal需要歸一化簽名，所以connect方法將其歸一化。

class SignalMerge : public QObject { 
    Q_OBJECT 
#if QT_VERSION>=QT_VERSION_CHECK(5,0,0) 
    typedef QMetaObject::Connection Connection; 
#else 
    typedef bool Connection; 
#endif 
    typedef QPair<QObject*, int> ObjectMethod; 
    QSet<ObjectMethod> m_signals, m_pendingSignals; 

    void registerSignal(QObject * obj, const char * method) { 
     int index = obj->metaObject()->indexOfMethod(method); 
     if (index < 0) return; 
     m_signals.insert(ObjectMethod(obj, index)); 
    } 
    Q_SLOT void merge() { 
     if (m_pendingSignals.isEmpty()) m_pendingSignals = m_signals; 
     m_pendingSignals.remove(ObjectMethod(sender(), senderSignalIndex())); 
     if (m_pendingSignals.isEmpty()) emit merged(); 
    } 
public: 

    void clear() { 
     foreach (ObjectMethod om, m_signals) { 
      QMetaObject::disconnect(om.first, om.second, this, staticMetaObject.indexOfSlot("merge()")); 
     } 
     m_signals.clear(); 
     m_pendingSignals.clear(); 
    } 
    Q_SIGNAL void merged(); 
    Connection connect(QObject *sender, const char *signal, Qt::ConnectionType type = Qt::AutoConnection) { 
     Connection conn = QObject::connect(sender, signal, this, SLOT(merge()), type); 
     if (conn) registerSignal(sender, QMetaObject::normalizedSignature(signal+1)); 
     return conn; 
    } 
};