I segnali Qt possono restituire un valore?

Question

Boost.Signals consente various strategies di utilizzare i valori di ritorno degli slot per formare il valore di ritorno del segnale. Per esempio. aggiungendoli, formando uno vector di questi o restituendo l'ultimo.

La saggezza comune (espressa nella documentazione Qt [EDIT: così come alcune risposte a questa domanda ]) è che nulla del genere è possibile con i segnali Qt.

Tuttavia, quando ho eseguito il MOC sulla seguente definizione di classe:

class Object : public QObject { 
    Q_OBJECT 
public: 
    explicit Object(QObject * parent=0) 
     : QObject(parent) {} 

public Q_SLOTS: 
    void voidSlot(); 
    int intSlot(); 

Q_SIGNALS: 
    void voidSignal(); 
    int intSignal(); 
}; 

Non solo non Moc lamentarsi del segnale con il tipo di ritorno non-vuoto, sembra ad attuare attivamente in tale un modo tale da consentire un valore di ritorno di passare:

// SIGNAL 1 
int Object::intSignal() 
{ 
    int _t0; 
    void *_a[] = { const_cast<void*>(reinterpret_cast<const void*>(&_t0)) }; 
    QMetaObject::activate(this, &staticMetaObject, 1, _a); 
    return _t0; 
} 

Quindi: secondo la documentazione, questa cosa non è possibile. Allora cosa sta facendo moc qui?

Slots can have return values, così possiamo collegare uno slot con un valore di ritorno a un segnale con un valore di ritorno ora? Potrebbe essere possibile, dopotutto? Se è così, è utile?

MODIFICA: Non sto chiedendo soluzioni alternative, quindi non fornire nulla.

EDIT: Ovviamente non è utile in modalità Qt::QueuedConnection (né è la QPrintPreviewWidget API, però, e ancora esiste ed è utile). Ma che dire di Qt::DirectConnection e Qt::BlockingQueuedConnection (o Qt::AutoConnection, quando si risolve in Qt::DirectConnection).

Answer 1

OK. Quindi, ho fatto un po 'più di investigazione. Sembra che questo sia possibile. Sono stato in grado di emettere un segnale e ricevere il valore dallo slot a cui era collegato il segnale. Ma, il problema era che ha restituito solo l'ultimo valore restituito da molteplici slot collegati:

Ecco una definizione semplice classe (main.cpp):

#include <QObject> 
#include <QDebug> 

class TestClass : public QObject 
{ 
    Q_OBJECT 
public: 
    TestClass(); 

Q_SIGNALS: 
    QString testSignal(); 

public Q_SLOTS: 
    QString testSlot1() { 
     return QLatin1String("testSlot1"); 
    } 
    QString testSlot2() { 
     return QLatin1String("testSlot2"); 
    } 
}; 

TestClass::TestClass() { 
    connect(this, SIGNAL(testSignal()), this, SLOT(testSlot1())); 
    connect(this, SIGNAL(testSignal()), this, SLOT(testSlot2())); 

    QString a = emit testSignal(); 
    qDebug() << a; 
} 

int main() { 
    TestClass a; 
} 

#include "main.moc" 

Quando viene eseguito principali, si costruisce una delle classi di test . Il costruttore collega due slot al segnale testSignal e quindi emette il segnale. Cattura il valore di ritorno dagli slot invocati.

Sfortunatamente, si ottiene solo l'ultimo valore restituito. Se valuti il ​​codice sopra, riceverai: "testSlot2", l'ultimo valore restituito dagli slot connessi del segnale.

Ecco perché. I segnali Qt sono un'interfaccia sintattica per il pattern di segnalazione. Gli slot sono i destinatari di un segnale. In un rapporto segnale-scanalatura collegato diretta, si potrebbe pensare simile alla (pseudo-codice):

foreach slot in connectedSlotsForSignal(signal): 
    value = invoke slot with parameters from signal 
return value 

Ovviamente il moc fa un po 'più per aiutare in questo processo (controllo di tipo rudimentale, ecc), ma questo aiuta a dipingere l'immagine.

Answer 2

No, non possono.

Boost::signals sono molto diversi da quelli in Qt. I primi forniscono un meccanismo di callback avanzato, mentre i secondi implementano l'idioma di segnalazione. Nel contesto del multithreading, i segnali di Qt (cross-threaded) dipendono dalle code dei messaggi, quindi vengono chiamati in modo asincrono in un punto (sconosciuto al thread dell'emettitore) nel tempo.

Answer 3

Si può cercare di risolvere questo con i seguenti:

1. Tutte le tue slot collegati devono salvare i loro risultati in un luogo (contenitore) accessibili dalla segnalazione oggetto
2. L'ultimo slot connessa deve in qualche modo (selezionare max o ultimo valore) valori di processo raccolti ed espongono l'unico
3. l'oggetto luminescente può tentare di accedere a questo risultato

Proprio come idea.

Answer 4

La funzione qt_metacall di Qt restituisce un codice di stato intero. Per questo motivo, ritengo che ciò renda impossibile un effettivo valore di ritorno (a meno che non ci si diverta con il sistema meta oggetto ei file moc dopo la precompilazione).

Tuttavia, sono disponibili parametri di funzionamento normali. Dovrebbe essere possibile modificare il codice in modo tale da utilizzare i parametri "out" che fungono da "ritorno".

void ClassObj::method(return_type * return_) 
{ 
    ... 

    if(return_) *return_ = ...; 
} 

// somewhere else in the code... 

return_type ret; 
emit this->method(&ret); 

Answer 5

Si può ottenere un valore di ritorno dalla Qt signal con il seguente codice:

Il mio esempio mostra come usare un Qt signal di leggere il testo di una QLineEdit. Sto semplicemente estendendo ciò che @jordan ha proposto:

Dovrebbe essere possibile modificare il codice in modo tale da utilizzare i parametri "out" che fungono da "ritorno".

#include <QtCore> 
#include <QtGui> 

class SignalsRet : public QObject 
{ 
    Q_OBJECT 

public: 
    SignalsRet() 
    { 
     connect(this, SIGNAL(Get(QString*)), SLOT(GetCurrentThread(QString*)), Qt::DirectConnection); 
     connect(this, SIGNAL(GetFromAnotherThread(QString*)), SLOT(ReadObject(QString*)), Qt::BlockingQueuedConnection); 
     edit.setText("This is a test"); 
    } 

public slots: 
    QString call() 
    { 
     QString text; 
     emit Get(&text); 
     return text; 
    } 

signals: 
    void Get(QString *value); 
    void GetFromAnotherThread(QString *value); 

private slots: 
    void GetCurrentThread(QString *value) 
    { 
     QThread *thread = QThread::currentThread(); 
     QThread *mainthread = this->thread(); 
     if(thread == mainthread) //Signal called from the same thread that SignalsRet class was living 
      ReadObject(value); 
     else //Signal called from another thread 
      emit GetFromAnotherThread(value); 
    } 

    void ReadObject(QString *value) 
    { 
     QString text = edit.text(); 
     *value = text; 
    } 

private: 
    QLineEdit edit; 

}; 

Per utilizzare questo, basta chiedere call();.