Polymorphic codecs and transports

New features:
- Session is now a move-only type that can be instantiated on the stack.
- Deprecated Session::create.
- Added ConnectionWish and ConnectionWishList which should now be
  used in place of the old Connection and ConnectionList classes.
- Passing ConnectionWish and ConnectionWishList via
  Session::connect is now preferred over passing the legacy
  Connector instances via Session::create.
- TcpHost and UdsPath now have withFormat methods which generate a
  ConnectionWish that can be passed to Session.
- The authenticate, publish, yield, and cancel methods of Session
  not taking a completion handler now return an ErrorOrDone. The
  thread-safe overloads for those now return a
  `std::future<ErrorOrDone>`.
- AnyCompletionExecutor is now used by session to contain the user
  executor.
- Added Session::ongoingCall for progressive call results, which
  automatically applies rpc.withProgessiveResults(true).
- Renamed Session::reset to Session::terminate, leaving the former
  as a deprecated alias.
- Renamed Session::userExecutor to Session::fallbackExecutor,
  leaving the former as a deprecated alias.
- Session::fallbackExecutor type relaxed to AnyCompletionExecutor.
- Handlers registered via Session's setWarningHandler,
  setTraceHandler, and setStateChangeHandler will no longer be
  fired after Session::terminate is called and before
  Session::connect is called.
- Added wamp::spawn and wamp::YieldContext in <cppwamp/spawn.hpp>, which
  are aliases to their Boost.Asio counterparts.
- Added wamp::spawnCompletionHandler and
  wamp::CompletionYieldContext to support spawning coroutines via
  Event::executor and Invocation::executor.
- When CPPWAMP_USE_COMPLETION_YIELD_CONTEXT is defined,
  wamp::BasicYieldContext<wamp::AnyCompletionExecutor> will be passed to
  coroutines spawned via Event/Invocation unpackers. The relaxes the
  requirement that the Session::userExecutor() originate from
  boost::asio::io_context.
- When CPPWAMP_USE_COMPLETION_YIELD_CONTEXT and
  ASIO_DISABLE_BOOST_COROUTINE are defined, the coroutine
  Event/Invocation unpackers will use the new Boost.Context-based
  coroutines introduced in Boost 1.80.0.
- Instead of throwing an exception, Session now emits a
  TransportErrc::badTxLength error via the completion handler or return
  value when the payload exceeds the transport's limit.
- Challenge::authenticate, Invocation::yield and Interruption::yield
  now have thread-safe and non-thread-safe overloads.
- Added SessionErrc error codes corresponding to new predefined error
  URIs that have appeared in the WAMP spec.
- Added Session::setLogHandler which takes a handler of type
  'void (LogEntry)' and unifies all log event handling.
- Added Session::setLogLevel for use with Session::setLogHandler.
- Renamed AsioContext to IoContext, leaving the former as a deprecated
  alias.
- Deprecated AsioErrorCode.
- Deprecated ProtocolErrc and ProtocolCategory in favor of
  SessionErrc::protocolViolation.
- Deprecated Session::setWarningHandler and Session::setTraceHandler in
  favor of Session::setLogHandler.

Implementation improvements:
- Adding more codecs or transports in the future will no longer
  result in a combinatorial explosion of explicit template instantions
  due to the number of transport/codec combinations.
- Codecs are now specializations of SinkEncoder and SourceDecoder.
- Simplified codec tags to only provide their numeric ID.
- Added AnyCodec polymorphic wrapper for codecs.
- Added Transporting interface class which replaces the old Transport
  type requirement.
- internal::Client is now non-templated and is retained by Session
  during the latter's lifetime.
- Session::connect logic has been moved to internal::Client.
- Renamed internal::AsioTransport to internal::RawsockTransport and
  simplified its previously convoluted design.
- internal::RawsockConnector and internal::RawsockTransport now use
  policy classes instead of polymorphism to alter their behavior for
  tests.
- Tidying of transport tests.
- internal::Peer composition instead of inheritance.
- Avoid unnecessary boost::asio::post in intermediate handlers.

Beaking Changes:
- Session::call can no longer be used for progessive call results, use
  Session::ongoingCall instead.
- The Session destructor now automatically invokes Session::disconnect
  instead of Session::terminate, to better emulate the cancellation
  behavior of Asio sockets being destroyed.
- Event::executor and Invocation::executor can no longer be directly
  used by Boost.Coroutine-based boost::asio::spawn to spawn coroutines.
- The undecorated Challenge::authenticate, Invocation::yield and
  Interruption::yield are no longer thread-safe.

Author: ecorm

CMakeLists.txt

@@ -38,7 +38,7 @@ cmake_minimum_required (VERSION 3.12)
 include_guard()
 
 project(CppWAMP
-        VERSION 0.10.0
+        VERSION 0.11.0
         LANGUAGES CXX)
 
 include(ProcessorCount)

README.md

@@ -71,21 +71,13 @@ This library has been tested with:
 Roadmap
 -------
 
-### v0.11
-
-- Polymorphic codecs and transports to prevent combinatorial explosion of
-  explicit template instantiations when new codecs/transports are added.
-
 ### v1.0
 
+- Embedded router functionality
 - Remove all deprecated types and functions.
 - Aim for API stability until v2.0.
 
-### v1.1
-
-- Embedded router functionality
-
-### v1.2 (maybe)
+### v1.1 (maybe)
 
 - Websocket support via Boost.Beast
 
@@ -119,37 +111,39 @@ documentation._
 ### Establishing a WAMP session
 ```c++
 wamp::AsioContext ioctx;
-boost::asio::spawn(ioctx, [&](boost::asio::yield_context yield)
-{
-    // Specify a TCP transport and JSON serialization
-    auto tcp = wamp::connector<wamp::Json>(
-        ioctx, wamp::TcpHost("localhost", 8001));
-    auto session = wamp::CoroSession<>::create(ioctx, tcp);
-    session->connect(yield);
-    auto sessionInfo = session->join(wamp::Realm("myrealm"), yield);
-    std::cout << "Client joined. Session ID = "
-              << sessionInfo.id() << "\n";
-    // etc.
-    });
+wamp::Session session(ioctx);
+wamp::spawn(
+    ioctx,
+    [&](wamp::YieldContext yield)
+    {
+        auto tcp = wamp::TcpHost("localhost", 8001).withFormat(wamp::json);
+        session.connect(tcp, yield).value();
+        auto sessionInfo = session.join(wamp::Realm("myrealm"), yield).value();
+        std::cout << "Client joined. Session ID = "
+                  << sessionInfo.id() << "\n";
+        // etc.
+        });
 ioctx.run();
 ```
 
 ### Registering a remote procedure
 ```c++
-boost::asio::spawn(ioctx, [&](boost::asio::yield_context yield)
-{
-    :::
-    session->enroll(wamp::Procedure("add"),
-                    wamp::basicRpc<int, int, int>(
-                        [](int n, int m) -> int {return n+m;}),
-                    yield);
-    :::
-});
+wamp::spawn(
+    ioctx,
+    [&](wamp::YieldContext yield)
+    {
+        :::
+        session.enroll(wamp::Procedure("add"),
+                       wamp::simpleRpc<int, int, int>(
+                           [](int n, int m) -> int {return n+m;}),
+                       yield).value();
+        :::
+    });
 ```
 
 ### Calling a remote procedure
 ```c++
-auto result = session->call(wamp::Rpc("add").withArgs(2, 2), yield);
+auto result = session.call(wamp::Rpc("add").withArgs(2, 2), yield).value();
 std::cout << "2 + 2 is " << result[0].to<int>() << "\n";
 ```
 
@@ -160,20 +154,22 @@ void sensorSampled(float value)
     std::cout << "Sensor sampled, value = " << value << "\n";
 }
 
-boost::asio::spawn(ioctx, [&](boost::asio::yield_context yield)
-{
-    :::
-    session->subscribe(wamp::Topic("sensorSampled"),
-                       wamp::basicEvent<float>(&sensorSampled),
-                       yield);
-    :::
-});
+wamp::spawn(
+    ioctx,
+    [&](wamp::YieldContext yield)
+    {
+        :::
+        session.subscribe(wamp::Topic("sensorSampled"),
+                          wamp::simpleEvent<float>(&sensorSampled),
+                          yield).value();
+        :::
+    });
 ```
 
 ### Publishing an event
 ```c++
 float value = std::rand() % 10;
-session->publish(wamp::Pub("sensorSampled").withArgs(value));
+session.publish(wamp::Pub("sensorSampled").withArgs(value));
 ```
 
 
@@ -185,25 +181,24 @@ Usage Examples Using Asynchronous Callbacks
 class App : public std::enable_shared_from_this<App>
 { 
 public:
-    void start(wamp::AnyExecutor executor)
-    {
-        // Specify a TCP transport and JSON serialization
-        auto tcp = wamp::connector<wamp::Json>(
-            executor, wamp::TcpHost("localhost", 8001));
-
-        session_ = wamp::Session::create(executor, tcp);
+    App(wamp::AnyIoExecutor exec)
+        : session_(std::move(exec))
+    {}
 
+    void start(wamp::ConnectionWish where)
+    {
         // `self` is used to ensure the App instance still exists
         // when the callback is invoked.
         auto self = shared_from_this();
 
         // Perform the connection, then chain to the next operation.
-        session_->connect(
-            [this, self](wamp::AsyncResult<size_t> result)
+        session_.connect(
+            where,
+            [this, self](wamp::ErrorOr<size_t> result)
             {
                 // 'result' contains the index of the connector used to
                 // establish the connection, or an error
-                result.get(); // Throws if result contains an error
+                result.value(); // Throws if result contains an error
                 onConnect();
             });
     }
@@ -212,11 +207,11 @@ private:
     void onConnect()
     {
         auto self = shared_from_this();
-        session_->join(
+        session_.join(
             wamp::Realm("myrealm"),
-            [this, self](wamp::AsyncResult<wamp::SessionInfo> info)
+            [this, self](wamp::ErrorOr<wamp::SessionInfo> info)
             {
-                onJoin(info.get());
+                onJoin(info.value());
             });
     }
 
@@ -227,14 +222,14 @@ private:
         // etc...
     }
 
-    wamp::Session::Ptr session_;
+    wamp::Session session_;
 };
 
 int main()
 {
     wamp::AsioContext ioctx;
-    App app;
-    app.start(ioctx.get_executor());
+    App app(ioctx.get_executor());
+    app.start(wamp::TcpHost("localhost", 8001).withFormat(wamp::json);
     ioctx.run();
 }
 
@@ -245,22 +240,23 @@ int main()
 class App : public std::shared_from_this<App>
 { 
 public:
-    void start(wamp::AnyExecutor executor) {/* As above */}
+    App(wamp::AnyIoExecutor exec); // As above
+    void start(wamp::ConnectionWish where); // As above
 
 private:
     static int add(int n, int m) {return n + m;}
 
-    void onConnect() {/* As above */}
+    void onConnect(); // As above
 
     void onJoin(wamp::SessionInfo)
     {
         auto self = shared_from_this();
-        session_->enroll(
+        session_.enroll(
             wamp::Procedure("add"),
-            wamp::basicRpc<int, int, int>(&App::add),
-            [this, self](AsyncResult<Registration> reg)
+            wamp::simpleRpc<int, int, int>(&App::add),
+            [this, self](wamp::ErrorOr<Registration> reg)
             {
-                onRegistered(reg.get());
+                onRegistered(reg.value());
             });
     }
 
@@ -269,7 +265,7 @@ private:
         // etc
     }
 
-    wamp::Session::Ptr session_;
+    wamp::Session session_;
 };
 
 ```
@@ -279,19 +275,20 @@ private:
 class App : public std::shared_from_this<App>
 { 
 public:
-    void start(wamp::AnyExecutor executor) {/* As above */}
+    App(wamp::AnyIoExecutor exec); // As above
+    void start(wamp::ConnectionWish where); // As above
 
 private:
-    void onConnect() {/* As above */}
+    void onConnect(); // As above
 
     void onJoin(wamp::SessionInfo info)
     {
         auto self = shared_from_this();
-        session_->call(
+        session_.call(
             wamp::Rpc("add").withArgs(2, 2),
-            [this, self](wamp::AsyncResult<wamp::Result> sum)
+            [this, self](wamp::ErrorOr<wamp::Result> sum)
             {
-                onAdd(sum.get());
+                onAdd(sum.value());
             });
     }
 
@@ -300,7 +297,7 @@ private:
         std::cout << "2 + 2 is " << result[0].to<int>() << "\n";
     }
 
-    wamp::Session::Ptr session_;
+    wamp::Session session_;
 };
 ```
 
@@ -309,25 +306,26 @@ private:
 class App : public std::shared_from_this<App>
 { 
 public:
-    void start(wamp::AnyExecutor executor) {/* As above */}
+    App(wamp::AnyIoExecutor exec); // As above
+    void start(wamp::ConnectionWish where); // As above
 
 private:
     static void sensorSampled(float value)
     {
         std::cout << "Sensor sampled, value = " << value << "\n";
     }
 
-    void onConnect() {/* As above */}
+    void onConnect(); // As above
 
     void onJoin(wamp::SessionInfo info)
     {
         auto self = shared_from_this();
-        session_->subscribe(
+        session_.subscribe(
             wamp::Topic("sensorSampled"),
-            wamp::basicEvent<float>(&App::sensorSampled),
-            [this, self](wamp::AsyncResult<wamp::Subscription> sub)
+            wamp::simpleEvent<float>(&App::sensorSampled),
+            [this, self](wamp::ErrorOr<wamp::Subscription> sub)
             {
-                onSubscribed(sub.get());
+                onSubscribed(sub.value());
             });
     }
 
@@ -336,14 +334,14 @@ private:
         std::cout << "Subscribed, subscription ID = " << sub.id() << "\n";
     }
 
-    wamp::Session::Ptr session_;
+    wamp::Session session_;
 };
 ```
 
 ### Publishing an event
 ```c++
 float value = std::rand() % 10;
-session_->publish(wamp::Pub("sensorSampled").withArgs(value));
+session_.publish(wamp::Pub("sensorSampled").withArgs(value));
 ```
 
 

cmake/CppWAMPDependencies.cmake

@@ -16,6 +16,12 @@ set(CPPWAMP_VENDORIZED_BOOST_VERSION 1.79.0)
 set(CPPWAMP_VENDORIZED_BOOST_SHA256
     "475d589d51a7f8b3ba2ba4eda022b170e562ca3b760ee922c146b6c65856ef39")
 
+# Stackful coroutines have a bug in Boost 1.80.0
+# https://github.com/chriskohlhoff/asio/issues/1110
+#set(CPPWAMP_VENDORIZED_BOOST_VERSION 1.80.0)
+#set(CPPWAMP_VENDORIZED_BOOST_SHA256
+#    "1e19565d82e43bc59209a168f5ac899d3ba471d55c7610c677d4ccf2c9c500c0")
+
 string(REPLACE "." "_" CPPWAMP_BOOST_FILE_STEM "boost_${CPPWAMP_VENDORIZED_BOOST_VERSION}")
 string(CONCAT CPPWAMP_BOOST_URL
     "https://boostorg.jfrog.io/artifactory/main/release/"