Call a method immediately after another one finished - c++

Question

I have the following pseudocode as part of a C++ project:
class BasicSender
{
public:
virtual void confirmation(int id) = 0;
int sendMessage(string x)
{
Message x = createMessageFromString(x);
if(! canSendMessage(m))
{
MessageStore::storeMessageForLater(this, m); // just store it
}
// *** HERE ***
return m.messageId;
}
};
void threadFunction()
{
while(1)
{
while(MessageStore::hasMessagesToBeSent())
{
StoredMessage m = MessageStore.getNextUnsentMessage();
if(m.basicSender.sendStoredMessage(m.message))
{
m.confirmation(m.message.messageId);
}
}
}
}
and the usage of it:
class ConcreteSender : public BasicSender
{
virtual void confirmation(int id)
{
cout << "Yippe " << id << " is sent";
}
};
int main() {
ConcreteSender a;
int ID = a.sendMessage("test");
... other stuff
}
And what I try to achieve:
is it even remotely possible to call the confirmation for succesfully delivered messages method right after sendMessage finished (ie: it returned to the caller and the caller (in main) has the ID value). If I put the method call at the place *** HERE *** the virtual method will get called before sendMessage finished and the user will be confused that the received a confirmation for a message ID he had no clue about. Yes, I have methods which can check if a message was sent or not, and yes, I can create a thread which from time to time pulls the MessageStore to see if the message was delivered or not. But I am more specifically interested if it is possible to somehow chain in the two function calls, in case of success: confirmation called right after sendMessage returns. If yes, how? (Please note, I cannot modify the signature of the functions, third party library :( )

Answer 1

If you want the ID of the new message in the scope of main, but you want it to indicate the ID of a message that has actually been sent, then you can use a promise/future pair. The ID will be available in main as soon as sendMessage returns, but attempting to read its value will block the main thread until the worker thread has finished actually sending that message.
This will involve changing Message to contain a promise, and changing sendMessage to return a future that references that promise.
class Message
{
public:
/*...*/
std::promise<int> messageIdOnceSent;
private:
/* ...*/
int messageId;
};
class BasicSender
{
public:
virtual void confirmation(int id) = 0;
std::future<int> sendMessage(string x)
{
Message x = createMessageFromString(x);
if(! canSendMessage(m))
{
MessageStore::storeMessageForLater(this, m); // just store it
}
// !!
return std::future<int>(x.messageIdOnceSent);
}
};
void threadFunction()
{
while(1)
{
while(MessageStore::hasMessagesToBeSent())
{
StoredMessage m = MessageStore.getNextUnsentMessage();
if(m.basicSender.sendStoredMessage(m.message))
{
m.confirmation(m.message.messageId);
// !!
m.message.messageIdOnceSent.set_value(m.message.messageId);
}
}
}
}
int main() {
ConcreteSender a;
std::future<int> ID = a.sendMessage("test");
// !!
std::cout << ID.get() << '\n'; // blocks until message has actually been sent
}
This is the closest solution I can get if you really want the ID "immediately after" sendMessage returns but not before the message has actually been sent.
Generally you don't want to block your main thread, but if your main function is more complex (and, presumably, it is) then this may be what you are looking for.