ich habe mal eine Frage zur Nutzung des Promise-Future-Mechanismus.
Folgende Ausgangslage: ich nutze eine C-Schnittstelle für Profibus-Kommunikation.
Diese gibt Signale beim Initialisieren und beim Beenden durch asynchrone Aufrufe kund.
Da der restliche Ablauf sonst synchron ist, wollte ich für den init und das deinint nicht extra groß mit Threading, MessageQueue usw. anfangen.
Daher leite ich die Signale mit den futures durch.

Aktuell ist es so, dass es ein globales Promise-Objekt gibt. Ich setze hier immer erst ein neues, dann starte ich den API-Call, dann hole ich das Future und von dem das Ergebnis, welches im Callback gesetzt wird.

/* start the Device */
g_async_pnio_result = std::promise<void*>();
if (PNIOD_start_sync(g_devHndl) != PNIO_OK)
	return 14;

//wait for async signals
auto param = g_async_pnio_result.get_future().get();
g_async_pnio_result = std::promise<void*>();
PNIOD_connect_async_rsp((PNIOD_CBF_ASYNC_CONNECT_IND_PARAMS_TYPE*)param);

param = g_async_pnio_result.get_future().get();
g_async_pnio_result = std::promise<void*>();
PNIOD_ownership_async_rsp((PNIOD_CBF_ASYNC_OWNERSHIP_IND_PARAMS_TYPE*)param);

param = g_async_pnio_result.get_future().get();
g_async_pnio_result = std::promise<void*>();
prmEndIndFunc((PNIOD_CBF_ASYNC_PRM_END_IND_PARAMS_TYPE*)param);
PNIOD_prm_end_async_rsp((PNIOD_CBF_ASYNC_PRM_END_IND_PARAMS_TYPE*)param);

param = g_async_pnio_result.get_future().get();
PNIOD_indata_async_rsp((PNIOD_CBF_ASYNC_INDATA_IND_PARAMS_TYPE*)param);

Das ganze wiederhole ich dann einfach. Meine Frage: vom prinzipiellen Ablauf ist das Nutzen der Promise-Future-Objekte so in Ordnung, oder?
Man darf sie ja nur 1x benutzen, daher erzeuge ich immer ein neues Objekt.

Das future hole ich mir mit get_future und greife dann direkt auf das Ergebnis zu. Es kann also sein, dass
set_value im Callback schon gerufen wurde, bevor der get_future-Call kommt.
Ist das in Ordnung, oder muss das future vorher aus dem Promise geholt worden sein?