Come integrare il loop principale di Boost.Asio nella struttura della GUI come Qt4 o GTK

Question

C'è un modo per integrare Boost.Asio con Qt4 (preferito) o ciclo principale GTK? GTK fornisce sondaggio (2) come API, quindi tecnicamente dovrebbe essere possibile. Qt fornisce il proprio livello di rete, tuttavia preferisco usare il codice esistente scritto per Boost.Asio. Voglio integrarli senza utilizzando un thread aggiuntivo.

C'è qualche riferimento su come farlo per Qt4 (preferito) o GTKmm?

Grazie.

Modifica

voglio clearify diverse cose per rendere la risposta più facile. Sia Qt e GTKmm forniscono "selezionare come" funzionalità:

• http://qt-project.org/doc/qt-5.0/qtcore/qsocketnotifier.html
• http://www.gtkmm.org/docs/glibmm-2.4/docs/reference/html/group__MainLoop.html

Quindi, la domanda è: come integrare esistenti "selettori/poller", come reattore per Boost. Asio io_service. Oggi, Boost.Asio può utilizzare select, kqueue, epoll,/dev/poll e iocp come servizio reattore/proattore. Voglio integrarlo al ciclo principale del framework GUI.

Eventuali suggerimenti e soluzioni (migliori) sono i benvenuti.

Answer 1

È una domanda piuttosto vecchia, ma per coloro che stanno leggendo ora mi piacerebbe condividere my code che è un'implementazione di QAbstractEventDispatcher per boost :: asio.

Tutto ciò che serve è aggiungere la seguente riga prima di creare QApplication (di solito è in main()).

QApplication::setEventDispatcher(new QAsioEventDispatcher(my_io_service)); 

Esso provocherà, che io_service è gestito insieme con l'applicazione qt in un thread senza ulteriore latenza e calo di prestazioni (come nella soluzione chiamata io_service :: poll() "di volta in volta").

Sfortunatamente, la mia soluzione è solo per sistemi posix, poiché usa asio :: posix :: stream_descriptor. Il supporto di Windows potrebbe richiedere un approccio completamente diverso o abbastanza simile - non lo so davvero.

Answer 2

Se ho capito bene la tua domanda, hai codice scritto per Boost.Asio. Vorresti usare quel codice all'interno di un'applicazione GUI.

Ciò che non è chiaro nella tua domanda è se vuoi avvolgere i livelli di rete Qt/Gtk attraverso asynio per far funzionare il tuo codice, se stai solo cercando una soluzione per avere insieme un ciclo di eventi gui e asynio.

Assumerò il secondo caso.

Sia Qt che Gtk hanno metodi per integrare eventi stranieri nel loro ciclo di eventi. Si veda ad esempio qtgtk dove il loop di eventi Qt è collegato a Gtk.

Nel caso specifico di Qt, se si desidera generare eventi per Qt, è possibile utilizzare la seguente classe: QAbstractEventDispatcher.

Dopo un rapido sguardo a spinta asio, penso che è necessario effettuare le seguenti operazioni:

• hanno un QTimer ricorrente con durata nulla che chiama io_service :: run() per tutto il tempo. In questo modo, boost :: asio chiamerà il gestore di completamento non appena viene completata l'operazione asincrona.
• nel vostro gestore di completamento, due opzioni:
  • se l'operazione di completamento è lunga, separata dalla GUI, fare il vostro business e assicurarsi di chiamare QAPP.processEvents() regolarmente per mantenere l'interfaccia grafica sensibile
  • se si vuole solo comunicare di nuovo con la GUI:
    1. definire un QEvent tipo personalizzato
    2. subscribe to this event
    3. Pubblica il tuo evento a Qt ciclo di eventi utilizzando QCoreApplication::postEvent().

Answer 3

Semplice: Costruire uno slot QT che chiama il io_service::poll_one() appartenente alla gui. Collegare lo slot al segnale tick di QT.

In profondità: Fortunatamente per te Boost.Asio è molto ben progettato. Esistono molte opzioni su come fornire un thread di esecuzione agli interni asincroni sottostanti. Le persone hanno già menzionato l'uso di io_service::run(), una chiamata bloccante con molti svantaggi.

È possibile accedere solo ai widget GUI da una singola discussione. I thread esterni generalmente hanno bisogno di inviare eventi alla GUI se vogliono fare la modifica di qualsiasi widget. Questo è molto simile a come funziona Asio.

L'approccio ingenuo è dedicare solo un thread (o un timer) a eseguire io_service::run() e il gestore di completamento Asio postare un segnale di GUI. Questo sarà lavoro.

Invece è possibile utilizzare la garanzia che i gestori di completamento vengano chiamati solo nella sequenza di esecuzione del chiamante io_service. Non fare in modo che il thread del GUI chiami io_service::run() mentre blocca e potrebbe bloccare la GUI. Utilizzare invece io_service::poll() o io_service::poll_one(). Ciò causerà la chiamata di tutti i gestori di completamento Asio in attesa dal thread GUI. Poiché i gestori sono in esecuzione nel thread GUI, sono liberi di modificare i widget.

Ora è necessario assicurarsi che l'io_service abbia la possibilità di funzionare regolarmente. Raccomando di avere un segnale gui ripetuto chiamare lo poll_one() un paio di volte. Credo che QT abbia un segnale di spunta che farebbe il trucco. Ovviamente potresti trasmettere il tuo segnale QT per un maggiore controllo.

Answer 4

Integrando genuinamente i loop principali è possibile. È solo un grande dolore (e devo ancora provarlo davvero).

L'esecuzione di io_service :: run() su una thread separata è probabilmente la strada da percorrere.