Asynchronous Callbacks

The previous tutorials have used stackful routines to demonstrate CppWAMP. Traditional "callback" handler functions can also be used with wamp::Session.

For asynchronous operations that can fail, Session expects a handler taking an wamp::ErrorOr<T> as a parameter. ErrorOr<T> makes it difficult for handlers to ignore error conditions when accessing the result of an asynchronous operation via its value method.

The following example shows how to establish a connection using callback handler functions:

#include <cppwamp/session.hpp>
#include <cppwamp/json.hpp>
#include <cppwamp/tcp.hpp>
using namespace wamp;
 
int main()
{
    AsioContext ioctx;
    auto tcp = connector<Json>(ioctx, TcpHost("localhost", 8001));
 
    auto session = Session::create(ioctx, tcp);
 
    // Asynchronously connect to the router, using a lambda function for
    // the handler
    session->connect( [](ErrorOr<size_t> result)
    {
        // Obtain the result of the connect operation, which is the index of
        // the connector used to establish the transport connection.
        // ErrorOr::get throws an error::Failure exception if the
        // operation failed.
        auto index = result.value();
    });
 
    ioctx.run();
    return 0;
}

Instead of letting wamp::ErrorOr::get throw an exception upon failure, wamp::ErrorOr::operator bool() and wamp::ErrorOr::errorCode can be used to check the error status of an asynchronous operation:

using namespace wamp;
session->connect( [](ErrorOr<size_t> index)
{
    if (index)
    {
        std::cout << "Connected via transport #" << (index.value()+1) << "\n";
        // Continue as normal...
    }
    else
    {
        std::cerr << "Failure connecting: " << index.error() << "\n";
    }
});

The following example shows how to call member functions within asynchronous handlers, and how to chain one asynchronous operation after another:

using namespace wamp;
 
class App
{
public:
    explicit App(wamp::Connector::Ptr connector)
        : session_(wamp::Session::create(connector))
    {}
 
    void start()
    {
        session_->connect( [this](wamp::AsyncHandler<size_t> index)
        {
            index.value(); // throws if connection failed
            this->join();
        });
    }
 
private:
    void join()
    {
        session_->join(Realm("somerealm"),
            [this](wamp::AsyncHandler<wamp::SessionInfo> info)
            {
                sessionInfo_ = info.value(); // throws if join failed
                // Continue with other asynchronous operations...
            }
        );
    }
 
    wamp::Session::Ptr session_;
    wamp::SessionInfo sessionInfo_;
};

With this asynchronous style of programming, it is not immediately obvious how the program control flows. Couroutines are therefore useful in implementing asynchronous logic in a more synchronous, sequential manner.

For complete examples using the asynchronous API see:

• examples/asynctimeclient/main.cpp
• examples/asynctimeservice/main.cpp.

---

Next: User Type Conversions