session.hpp

Go to the documentation of this file.

/*------------------------------------------------------------------------------
    Copyright Butterfly Energy Systems 2014-2015, 2022.
    Distributed under the Boost Software License, Version 1.0.
    http://www.boost.org/LICENSE_1_0.txt
------------------------------------------------------------------------------*/
 
#ifndef CPPWAMP_SESSION_HPP
#define CPPWAMP_SESSION_HPP
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
#include <atomic>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "anyhandler.hpp"
#include "api.hpp"
#include "asiodefs.hpp"
#include "chits.hpp"
#include "config.hpp"
#include "connector.hpp"
#include "error.hpp"
#include "erroror.hpp"
#include "peerdata.hpp"
#include "registration.hpp"
#include "subscription.hpp"
#include "traits.hpp"
#include "wampdefs.hpp"
#include "internal/clientinterface.hpp"
 
namespace wamp
{
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
struct ThreadSafe
{
    constexpr ThreadSafe() = default;
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
CPPWAMP_INLINE_VARIABLE constexpr ThreadSafe threadSafe;
 
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API Session : public std::enable_shared_from_this<Session>
{
private:
    struct GenericOp { template <typename F> void operator()(F&&) {} };
 
public:
    using Ptr = std::shared_ptr<Session>;
 
    using State = SessionState;
 
    using EventSlot = AnyReusableHandler<void (Event)>;
 
    using CallSlot = AnyReusableHandler<Outcome (Invocation)>;
 
    using InterruptSlot = AnyReusableHandler<Outcome (Interruption)>;
 
    using LogHandler = AnyReusableHandler<void(std::string)>;
 
    using StateChangeHandler = AnyReusableHandler<void(SessionState)>;
 
    using ChallengeHandler = AnyReusableHandler<void(Challenge)>;
 
    template <typename T, typename C>
    using Deduced = decltype(
        boost::asio::async_initiate<C, void(T)>(std::declval<GenericOp&>(),
                                                std::declval<C&>()));
    static Ptr create(AnyIoExecutor exec, const Connector::Ptr& connector);
 
    static Ptr create(AnyIoExecutor exec, const ConnectorList& connectors);
 
    template <typename TExecutionContext>
    static CPPWAMP_ENABLED_TYPE(Ptr, isExecutionContext<TExecutionContext>())
    create(
        TExecutionContext& context, 
        const Connector::Ptr& connector 
        )
    {
        return create(context.get_executor(), connector);
    }
 
    template <typename TExecutionContext>
    static CPPWAMP_ENABLED_TYPE(Ptr, isExecutionContext<TExecutionContext>())
    create(
        TExecutionContext& context, 
        const ConnectorList& connectors  
    )
    {
        return create(context.get_executor(), connectors);
    }
 
    static const Object& roles();
 
    Session(const Session&) = delete;
    Session& operator=(const Session&) = delete;
 
    virtual ~Session();
 
 
    AnyIoExecutor userExecutor() const;
 
    CPPWAMP_DEPRECATED AnyIoExecutor userIosvc() const;
 
    IoStrand strand() const;
 
    SessionState state() const;
 
 
    void setWarningHandler(LogHandler handler);
 
    void setWarningHandler(ThreadSafe, LogHandler handler);
 
    void setTraceHandler(LogHandler handler);
 
    void setTraceHandler(ThreadSafe, LogHandler handler);
 
    void setStateChangeHandler(StateChangeHandler handler);
 
    void setStateChangeHandler(ThreadSafe, StateChangeHandler handler);
 
    void setChallengeHandler(ChallengeHandler handler);
 
    void setChallengeHandler(ThreadSafe, ChallengeHandler handler);
 
 
    template <typename C>
    CPPWAMP_NODISCARD Deduced<ErrorOr<std::size_t>, C>
    connect(C&& completion);
 
    template <typename C>
    CPPWAMP_NODISCARD Deduced<ErrorOr<std::size_t>, C>
    connect(ThreadSafe, C&& completion);
 
    template <typename C>
    CPPWAMP_NODISCARD Deduced<ErrorOr<SessionInfo>, C>
    join(Realm realm, C&& completion);
 
    template <typename C>
    CPPWAMP_NODISCARD Deduced<ErrorOr<SessionInfo>, C>
    join(ThreadSafe, Realm realm, C&& completion);
 
    void authenticate(Authentication auth);
 
    void authenticate(ThreadSafe, Authentication auth);
 
    template <typename C>
    CPPWAMP_NODISCARD Deduced<ErrorOr<Reason>, C>
    leave(C&& completion);
 
    template <typename C>
    CPPWAMP_NODISCARD Deduced<ErrorOr<Reason>, C>
    leave(ThreadSafe, C&& completion);
 
    template <typename C>
    CPPWAMP_NODISCARD Deduced<ErrorOr<Reason>, C>
    leave(Reason reason, C&& completion);
 
    template <typename C>
    CPPWAMP_NODISCARD Deduced<ErrorOr<Reason>, C>
    leave(ThreadSafe, Reason reason, C&& completion);
 
    void disconnect();
 
    void disconnect(ThreadSafe);
 
    void reset();
 
    void reset(ThreadSafe);
 
 
    template <typename C>
    CPPWAMP_NODISCARD Deduced<ErrorOr<Subscription>, C>
    subscribe(Topic topic, EventSlot eventSlot, C&& completion);
 
    template <typename C>
    CPPWAMP_NODISCARD Deduced<ErrorOr<Subscription>, C>
    subscribe(ThreadSafe, Topic topic, EventSlot eventSlot, C&& completion);
 
    void unsubscribe(Subscription sub);
 
    void unsubscribe(ThreadSafe, Subscription sub);
 
    template <typename C>
    CPPWAMP_NODISCARD Deduced<ErrorOr<bool>, C>
    unsubscribe(Subscription sub, C&& completion);
 
    template <typename C>
    CPPWAMP_NODISCARD Deduced<ErrorOr<bool>, C>
    unsubscribe(ThreadSafe, Subscription sub, C&& completion);
 
    void publish(Pub pub);
 
    void publish(ThreadSafe, Pub pub);
 
    template <typename C>
    CPPWAMP_NODISCARD Deduced<ErrorOr<PublicationId>, C>
    publish(Pub pub, C&& completion);
 
    template <typename C>
    CPPWAMP_NODISCARD Deduced<ErrorOr<PublicationId>, C>
    publish(ThreadSafe, Pub pub, C&& completion);
 
 
    template <typename C>
    CPPWAMP_NODISCARD Deduced<ErrorOr<Registration>, C>
    enroll(Procedure procedure, CallSlot callSlot, C&& completion);
 
    template <typename C>
    CPPWAMP_NODISCARD Deduced<ErrorOr<Registration>, C>
    enroll(ThreadSafe, Procedure procedure, CallSlot callSlot, C&& completion);
 
    template <typename C>
    CPPWAMP_NODISCARD Deduced<ErrorOr<Registration>, C>
    enroll(Procedure procedure, CallSlot callSlot, InterruptSlot interruptSlot,
           C&& completion);
 
    template <typename C>
    CPPWAMP_NODISCARD Deduced<ErrorOr<Registration>, C>
    enroll(ThreadSafe, Procedure procedure, CallSlot callSlot,
           InterruptSlot interruptSlot, C&& completion);
 
    void unregister(Registration reg);
 
    void unregister(ThreadSafe, Registration reg);
 
    template <typename C>
    CPPWAMP_NODISCARD Deduced<ErrorOr<bool>, C>
    unregister(Registration reg, C&& completion);
 
    template <typename C>
    CPPWAMP_NODISCARD Deduced<ErrorOr<bool>, C>
    unregister(ThreadSafe, Registration reg, C&& completion);
 
    template <typename C>
    CPPWAMP_NODISCARD Deduced<ErrorOr<Result>, C>
    call(Rpc rpc, C&& completion);
 
    template <typename C>
    CPPWAMP_NODISCARD Deduced<ErrorOr<Result>, C>
    call(ThreadSafe, Rpc rpc, C&& completion);
 
    template <typename C>
    CPPWAMP_NODISCARD Deduced<ErrorOr<Result>, C>
    call(Rpc rpc, CallChit& chit, C&& completion);
 
    template <typename C>
    CPPWAMP_NODISCARD Deduced<ErrorOr<Result>, C>
    call(ThreadSafe, Rpc rpc, CallChit& chit, C&& completion);
 
    void cancel(CallChit);
 
    void cancel(ThreadSafe, CallChit);
 
    void cancel(CallChit, CallCancelMode mode);
 
    void cancel(ThreadSafe, CallChit, CallCancelMode mode);
 
    void cancel(CallCancellation cancellation);
 
    void cancel(ThreadSafe, CallCancellation cancellation);
 
private:
    using ImplPtr = typename internal::ClientInterface::Ptr;
 
    template <typename T>
    using CompletionHandler = AnyCompletionHandler<void(ErrorOr<T>)>;
 
    template <typename T>
    using ReusableHandler = AnyReusableHandler<void(T)>;
 
    using OneShotCallHandler   = CompletionHandler<Result>;
    using MultiShotCallHandler = AnyReusableHandler<void(ErrorOr<Result>)>;
 
    // These initiator function objects are needed due to C++11 lacking
    // generic lambdas.
    template <typename O> class SafeOp;
    struct ConnectOp;
    struct JoinOp;
    struct LeaveOp;
    struct SubscribeOp;
    struct UnsubscribeOp;
    struct PublishOp;
    struct EnrollOp;
    struct EnrollIntrOp;
    struct UnregisterOp;
    struct CallOp;
 
    template <typename O, typename C, typename... As>
    Deduced<ErrorOr<typename O::ResultValue>, C>
    initiate(C&& token, As&&... args);
 
    template <typename O, typename C, typename... As>
    Deduced<ErrorOr<typename O::ResultValue>, C>
    safelyInitiate(C&& token, As&&... args);
 
    template <typename F>
    void dispatchViaStrand(F&& operation);
 
    template <typename TResultValue, typename F>
    bool checkState(State expectedState, F& handler);
 
    void asyncConnect(CompletionHandler<size_t>&& handler);
 
    CPPWAMP_HIDDEN explicit Session(AnyIoExecutor userExec,
                                    const ConnectorList& connectors);
 
    CPPWAMP_HIDDEN void warn(std::string message);
 
    CPPWAMP_HIDDEN void setState(SessionState state);
 
    CPPWAMP_HIDDEN void doConnect(
        size_t index, std::shared_ptr<CompletionHandler<size_t>> handler);
 
    CPPWAMP_INLINE void onConnectFailure(
        size_t index, std::error_code ec,
        std::shared_ptr<CompletionHandler<size_t>> handler);
 
    CPPWAMP_INLINE void onConnectSuccess(
        size_t index, ImplPtr impl,
            std::shared_ptr<CompletionHandler<size_t>> handler);
 
    AnyIoExecutor userExecutor_;
    ConnectorList connectors_;
    Connector::Ptr currentConnector_;
    ReusableHandler<std::string> warningHandler_;
    ReusableHandler<std::string> traceHandler_;
    ReusableHandler<State> stateChangeHandler_;
    ReusableHandler<Challenge> challengeHandler_;
    std::atomic<SessionState> state_;
    bool isTerminating_ = false;
    ImplPtr impl_;
 
    // TODO: Remove this once CoroSession is removed
    template <typename> friend class CoroSession;
};
 
 
//******************************************************************************
// Session template function implementations
//******************************************************************************
 
//------------------------------------------------------------------------------
template <typename O>
class Session::SafeOp
{
public:
    using ResultValue = typename O::ResultValue;
 
    template <typename... Ts>
    SafeOp(Session* self, Ts&&... args)
        : self_(self),
          operation_({self, std::forward<Ts>(args)...})
    {}
 
    template <typename F>
    void operator()(F&& handler)
    {
        struct Dispatched
        {
            Session::Ptr self;
            O operation;
            typename std::decay<F>::type handler;
 
            void operator()()
            {
                operation(std::move(handler));
            }
        };
 
        boost::asio::dispatch(self_->strand(),
                              Dispatched{self_->shared_from_this(),
                                         std::move(operation_),
                                         std::forward<F>(handler)});
    }
 
private:
    Session* self_;
    O operation_;
};
 
//------------------------------------------------------------------------------
struct Session::ConnectOp
{
    using ResultValue = size_t;
    Session* self;
    template <typename F> void operator()(F&& f)
    {
        self->asyncConnect(std::forward<F>(f));
    }
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename C>
#ifdef CPPWAMP_FOR_DOXYGEN
Deduced<ErrorOr<std::size_t>, C>
#else
Session::template Deduced<ErrorOr<std::size_t>, C>
#endif
Session::connect(
    C&& completion 
    )
{
    return initiate<ConnectOp>(std::forward<C>(completion));
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename C>
#ifdef CPPWAMP_FOR_DOXYGEN
Deduced<ErrorOr<std::size_t>, C>
#else
Session::template Deduced<ErrorOr<std::size_t>, C>
#endif
Session::connect(
    ThreadSafe,
    C&& completion 
    )
{
    return safelyInitiate<ConnectOp>(std::forward<C>(completion));
}
 
//------------------------------------------------------------------------------
struct Session::JoinOp
{
    using ResultValue = SessionInfo;
    Session* self;
    Realm realm;
    template <typename F> void operator()(F&& f)
    {
        CompletionHandler<ResultValue> handler(std::forward<F>(f));
        if (self->checkState<ResultValue>(State::closed, handler))
            self->impl_->join(std::move(realm), std::move(handler));
    }
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename C>
#ifdef CPPWAMP_FOR_DOXYGEN
Deduced<ErrorOr<SessionInfo>, C>
#else
Session::template Deduced<ErrorOr<SessionInfo>, C>
#endif
Session::join(
    Realm realm,   
    C&& completion 
    )
{
    return initiate<JoinOp>(std::forward<C>(completion), std::move(realm));
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename C>
#ifdef CPPWAMP_FOR_DOXYGEN
Deduced<ErrorOr<SessionInfo>, C>
#else
Session::template Deduced<ErrorOr<SessionInfo>, C>
#endif
Session::join(
    ThreadSafe,
    Realm realm,   
    C&& completion 
    )
{
    return safelyInitiate<JoinOp>(std::forward<C>(completion),
                                  std::move(realm));
}
 
//------------------------------------------------------------------------------
struct Session::LeaveOp
{
    using ResultValue = Reason;
    Session* self;
    Reason reason;
    template <typename F> void operator()(F&& f)
    {
        CompletionHandler<ResultValue> handler(std::forward<F>(f));
        if (self->checkState<ResultValue>(State::established, handler))
            self->impl_->leave(std::move(reason), std::move(handler));
    }
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename C>
#ifdef CPPWAMP_FOR_DOXYGEN
Deduced<ErrorOr<Reason>, C>
#else
Session::template Deduced<ErrorOr<Reason>, C>
#endif
Session::leave(
    C&& completion 
    )
{
    return leave(Reason("wamp.close.close_realm"), std::forward<C>(completion));
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename C>
#ifdef CPPWAMP_FOR_DOXYGEN
Deduced<ErrorOr<Reason>, C>
#else
Session::template Deduced<ErrorOr<Reason>, C>
#endif
Session::leave(
    ThreadSafe,
    C&& completion 
    )
{
    return leave(threadSafe, Reason("wamp.close.close_realm"),
                 std::forward<C>(completion));
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename C>
#ifdef CPPWAMP_FOR_DOXYGEN
Deduced<ErrorOr<Reason>, C>
#else
Session::template Deduced<ErrorOr<Reason>, C>
#endif
Session::leave(
    Reason reason, 
    C&& completion 
    )
{
    return initiate<LeaveOp>(std::forward<C>(completion), std::move(reason));
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename C>
#ifdef CPPWAMP_FOR_DOXYGEN
Deduced<ErrorOr<Reason>, C>
#else
Session::template Deduced<ErrorOr<Reason>, C>
#endif
Session::leave(
    ThreadSafe,
    Reason reason, 
    C&& completion 
    )
{
    return safelyInitiate<LeaveOp>(std::forward<C>(completion),
                                   std::move(reason));
}
 
//------------------------------------------------------------------------------
struct Session::SubscribeOp
{
    using ResultValue = Subscription;
    Session* self;
    Topic topic;
    EventSlot slot;
    template <typename F> void operator()(F&& f)
    {
        using std::move;
        CompletionHandler<ResultValue> handler(std::forward<F>(f));
        if (self->checkState<ResultValue>(State::established, handler))
            self->impl_->subscribe(move(topic), move(slot), move(handler));
    }
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename C>
#ifdef CPPWAMP_FOR_DOXYGEN
Deduced<ErrorOr<Subscription>, C>
#else
Session::template Deduced<ErrorOr<Subscription>, C>
#endif
Session::subscribe(
    Topic topic,         
    EventSlot eventSlot, 
    C&& completion       
    )
{
    return initiate<SubscribeOp>(std::forward<C>(completion), std::move(topic),
                                 std::move(eventSlot));
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename C>
#ifdef CPPWAMP_FOR_DOXYGEN
Deduced<ErrorOr<Subscription>, C>
#else
Session::template Deduced<ErrorOr<Subscription>, C>
#endif
Session::subscribe(
    ThreadSafe,
    Topic topic,         
    EventSlot eventSlot, 
    C&& completion       
    )
{
    return safelyInitiate<SubscribeOp>(std::forward<C>(completion),
                                       std::move(topic), std::move(eventSlot));
}
 
//------------------------------------------------------------------------------
struct Session::UnsubscribeOp
{
    using ResultValue = bool;
    Session* self;
    Subscription sub;
    template <typename F> void operator()(F&& f)
    {
        CompletionHandler<ResultValue> handler(std::forward<F>(f));
        if (self->checkState<ResultValue>(State::established, handler))
            self->impl_->unsubscribe(std::move(sub), std::move(handler));
    }
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename C>
#ifdef CPPWAMP_FOR_DOXYGEN
Deduced<ErrorOr<bool>, C>
#else
Session::template Deduced<ErrorOr<bool>, C>
#endif
Session::unsubscribe(
    Subscription sub, 
    C&& completion    
    )
{
    CPPWAMP_LOGIC_CHECK(bool(sub), "The subscription is empty");
    return initiate<UnsubscribeOp>(std::forward<C>(completion), sub);
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename C>
#ifdef CPPWAMP_FOR_DOXYGEN
Deduced<ErrorOr<bool>, C>
#else
Session::template Deduced<ErrorOr<bool>, C>
#endif
Session::unsubscribe(
    ThreadSafe,
    Subscription sub, 
    C&& completion    
    )
{
    CPPWAMP_LOGIC_CHECK(bool(sub), "The subscription is empty");
    return safelyInitiate<UnsubscribeOp>(std::forward<C>(completion), sub);
}
 
//------------------------------------------------------------------------------
struct Session::PublishOp
{
    using ResultValue = PublicationId;
    Session* self;
    Pub pub;
    template <typename F> void operator()(F&& f)
    {
        CompletionHandler<ResultValue> handler(std::forward<F>(f));
        if (self->checkState<ResultValue>(State::established, handler))
            self->impl_->publish(std::move(pub), std::move(handler));
    }
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename C>
#ifdef CPPWAMP_FOR_DOXYGEN
Deduced<ErrorOr<PublicationId>, C>
#else
Session::template Deduced<ErrorOr<PublicationId>, C>
#endif
Session::publish(
    Pub pub,       
    C&& completion 
)
{
    return initiate<PublishOp>(std::forward<C>(completion), std::move(pub));
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename C>
#ifdef CPPWAMP_FOR_DOXYGEN
Deduced<ErrorOr<PublicationId>, C>
#else
Session::template Deduced<ErrorOr<PublicationId>, C>
#endif
Session::publish(
    ThreadSafe,
    Pub pub,       
    C&& completion 
    )
{
    return safelyInitiate<PublishOp>(std::forward<C>(completion),
                                     std::move(pub));
}
 
//------------------------------------------------------------------------------
struct Session::EnrollOp
{
    using ResultValue = Registration;
    Session* self;
    Procedure procedure;
    CallSlot slot;
    template <typename F> void operator()(F&& f)
    {
        using std::move;
        CompletionHandler<ResultValue> handler(std::forward<F>(f));
        if (self->checkState<ResultValue>(State::established, handler))
            self->impl_->enroll(move(procedure), move(slot), nullptr,
                                move(handler));
    }
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename C>
#ifdef CPPWAMP_FOR_DOXYGEN
Deduced<ErrorOr<Registration>, C>
#else
Session::template Deduced<ErrorOr<Registration>, C>
#endif
Session::enroll(
    Procedure procedure, 
    CallSlot callSlot,   
    C&& completion       
)
{
    return initiate<EnrollOp>(
        std::forward<C>(completion), std::move(procedure), std::move(callSlot));
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename C>
#ifdef CPPWAMP_FOR_DOXYGEN
Deduced<ErrorOr<Registration>, C>
#else
Session::template Deduced<ErrorOr<Registration>, C>
#endif
Session::enroll(
    ThreadSafe,
    Procedure procedure, 
    CallSlot callSlot,   
    C&& completion       
    )
{
    return safelyInitiate<EnrollOp>(
        std::forward<C>(completion), std::move(procedure), std::move(callSlot));
}
 
//------------------------------------------------------------------------------
struct Session::EnrollIntrOp
{
    using ResultValue = Registration;
    Session* self;
    Procedure procedure;
    CallSlot callSlot;
    InterruptSlot interruptSlot;
    template <typename F> void operator()(F&& f)
    {
        CompletionHandler<ResultValue> handler(std::forward<F>(f));
        if (self->checkState<ResultValue>(State::established, handler))
        {
            self->impl_->enroll(std::move(procedure), std::move(callSlot),
                                std::move(interruptSlot), std::move(handler));
        }
    }
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename C>
#ifdef CPPWAMP_FOR_DOXYGEN
Deduced<ErrorOr<Registration>, C>
#else
Session::template Deduced<ErrorOr<Registration>, C>
#endif
Session::enroll(
    Procedure procedure, 
    CallSlot callSlot,   
    InterruptSlot
        interruptSlot,   
    C&& completion       
    )
{
    return initiate<EnrollIntrOp>(
        std::forward<C>(completion), std::move(procedure), std::move(callSlot),
                        std::move(interruptSlot));
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename C>
#ifdef CPPWAMP_FOR_DOXYGEN
Deduced<ErrorOr<Registration>, C>
#else
Session::template Deduced<ErrorOr<Registration>, C>
#endif
Session::enroll(
    ThreadSafe,
    Procedure procedure, 
    CallSlot callSlot,   
    InterruptSlot
        interruptSlot,   
    C&& completion       
    )
{
    return safelyInitiate<EnrollIntrOp>(
        std::forward<C>(completion), std::move(procedure), std::move(callSlot),
        std::move(interruptSlot));
}
 
//------------------------------------------------------------------------------
struct Session::UnregisterOp
{
    using ResultValue = bool;
    Session* self;
    Registration reg;
    template <typename F> void operator()(F&& f)
    {
        CompletionHandler<ResultValue> handler(std::forward<F>(f));
        if (self->checkState<ResultValue>(State::established, handler))
            self->impl_->unregister(std::move(reg), std::move(handler));
    }
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename C>
#ifdef CPPWAMP_FOR_DOXYGEN
Deduced<ErrorOr<bool>, C>
#else
Session::template Deduced<ErrorOr<bool>, C>
#endif
Session::unregister(
    Registration reg, 
    C&& completion    
    )
{
    CPPWAMP_LOGIC_CHECK(bool(reg), "The registration is empty");
    return initiate<UnregisterOp>(std::forward<C>(completion), reg);
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename C>
#ifdef CPPWAMP_FOR_DOXYGEN
Deduced<ErrorOr<bool>, C>
#else
Session::template Deduced<ErrorOr<bool>, C>
#endif
Session::unregister(
    ThreadSafe,
    Registration reg, 
    C&& completion    
    )
{
    CPPWAMP_LOGIC_CHECK(bool(reg), "The registration is empty");
    return safelyInitiate<UnregisterOp>(std::forward<C>(completion), reg);
}
 
//------------------------------------------------------------------------------
struct Session::CallOp
{
    using ResultValue = Result;
    Session* self;
    Rpc rpc;
    CallChit* chitPtr;
 
    template <typename F>
    void operator()(F&& f)
    {
        if (chitPtr)
            *chitPtr = {};
        auto chit = call(std::is_copy_constructible<ValueTypeOf<F>>{},
                         std::forward<F>(f));
        if (chitPtr)
            *chitPtr = chit;
    }
 
    template <typename F>
    CallChit call(std::true_type, F&& f)
    {
        using std::move;
        CallChit chit;
        if (rpc.progressiveResultsAreEnabled())
        {
            MultiShotCallHandler handler(std::forward<F>(f));
            if (self->checkState<Result>(State::established, handler))
                chit = self->impl_->ongoingCall(move(rpc), move(handler));
        }
        else
        {
            OneShotCallHandler handler(std::forward<F>(f));
            if (self->checkState<Result>(State::established, handler))
                chit = self->impl_->oneShotCall(move(rpc), move(handler));
        }
        return chit;
    }
 
    template <typename F>
    CallChit call(std::false_type, F&& f)
    {
        using std::move;
        CallChit chit;
        CPPWAMP_LOGIC_CHECK(!rpc.progressiveResultsAreEnabled(),
                            "Progressive results require copyable "
                            "multi-shot handler");
        CompletionHandler<Result> handler(std::forward<F>(f));
        if (self->checkState<ResultValue>(State::established, handler))
            chit = self->impl_->oneShotCall(move(rpc), move(handler));
        return chit;
    }
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename C>
#ifdef CPPWAMP_FOR_DOXYGEN
Deduced<ErrorOr<Result>, C>
#else
Session::template Deduced<ErrorOr<Result>, C>
#endif
Session::call(
    Rpc rpc,       
    C&& completion 
)
{
    return initiate<CallOp>(std::forward<C>(completion), std::move(rpc),
                            nullptr);
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename C>
#ifdef CPPWAMP_FOR_DOXYGEN
Deduced<ErrorOr<Result>, C>
#else
Session::template Deduced<ErrorOr<Result>, C>
#endif
Session::call(
    ThreadSafe,
    Rpc rpc,       
    C&& completion 
    )
{
    return safelyInitiate<CallOp>(std::forward<C>(completion), std::move(rpc),
                                  nullptr);
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename C>
#ifdef CPPWAMP_FOR_DOXYGEN
Deduced<ErrorOr<Result>, C>
#else
Session::template Deduced<ErrorOr<Result>, C>
#endif
Session::call(
    Rpc rpc,        
    CallChit& chit, 
    C&& completion  
    )
{
    return initiate<CallOp>(std::forward<C>(completion), std::move(rpc), &chit);
}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <typename C>
#ifdef CPPWAMP_FOR_DOXYGEN
Deduced<ErrorOr<Result>, C>
#else
Session::template Deduced<ErrorOr<Result>, C>
#endif
Session::call(
    ThreadSafe,
    Rpc rpc,        
    CallChit& chit, 
    C&& completion  
    )
{
    return safelyInitiate<CallOp>(std::forward<C>(completion), std::move(rpc),
                                  &chit);
}
 
//------------------------------------------------------------------------------
template <typename O, typename C, typename... As>
#ifdef CPPWAMP_FOR_DOXYGEN
Deduced<ErrorOr<typename O::ResultValue>, C>
#else
Session::template Deduced<ErrorOr<typename O::ResultValue>, C>
#endif
Session::initiate(C&& token, As&&... args)
{
    return boost::asio::async_initiate<
        C, void(ErrorOr<typename O::ResultValue>)>(
        O{this, std::forward<As>(args)...}, token);
}
 
//------------------------------------------------------------------------------
template <typename O, typename C, typename... As>
#ifdef CPPWAMP_FOR_DOXYGEN
Deduced<ErrorOr<typename O::ResultValue>, C>
#else
Session::template Deduced<ErrorOr<typename O::ResultValue>, C>
#endif
Session::safelyInitiate(C&& token, As&&... args)
{
 
    return initiate<SafeOp<O>>(std::forward<C>(token),
                               std::forward<As>(args)...);
}
 
//------------------------------------------------------------------------------
template <typename F>
void Session::dispatchViaStrand(F&& operation)
{
    boost::asio::dispatch(strand(), std::forward<F>(operation));
}
 
//------------------------------------------------------------------------------
template <typename TResultValue, typename F>
bool Session::checkState(State expectedState, F& handler)
{
    bool valid = state() == expectedState;
    if (!valid)
    {
        ErrorOr<TResultValue> e{makeUnexpectedError(SessionErrc::invalidState)};
        postVia(userExecutor_, std::move(handler), std::move(e));
    }
    return valid;
}
 
} // namespace wamp
 
#ifndef CPPWAMP_COMPILED_LIB
#include "internal/session.ipp"
#endif
 
#endif // CPPWAMP_SESSION_HPP