peerdata.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_PEERDATA_HPP
#define CPPWAMP_PEERDATA_HPP
 
#include <cassert>
#include <chrono>
#include <initializer_list>
#include <memory>
#include <set>
#include <string>
#include <vector>
#include "api.hpp"
#include "asiodefs.hpp"
#include "config.hpp"
#include "options.hpp"
#include "payload.hpp"
#include "variant.hpp"
#include "wampdefs.hpp"
#include "./internal/passkey.hpp"
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
namespace wamp
{
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API Abort : public Options<Abort, internal::AbortMessage>
{
public:
    Abort(String uri = "");
 
    const String& uri() const;
 
private:
    using Base = Options<Abort, internal::AbortMessage>;
 
public:
    // Internal use only
    Abort(internal::PassKey, internal::AbortMessage&& msg);
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API Realm : public Options<Realm, internal::HelloMessage>
{
public:
    Realm(String uri);
 
    const String& uri() const;
 
    Realm& captureAbort(Abort& abort);
 
    Realm& withAuthMethods(std::vector<String> methods);
 
    Realm& withAuthId(String authId);
 
private:
    using Base = Options<Realm, internal::HelloMessage>;
 
    Abort* abort_ = nullptr;
 
public:
    Abort* abort(internal::PassKey); // Internal use only
};
 
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API SessionInfo : public Options<SessionInfo,
                                               internal::WelcomeMessage>
{
public:
    using RoleSet = std::set<String>;
 
    using FeatureSet = std::set<String>;
 
    using FeatureMap = std::map<String, FeatureSet>;
 
    SessionInfo();
 
    SessionId id() const;
 
    const String& realm() const;
 
    String agentString() const;
 
    Object roles() const;
 
    bool supportsRoles(const RoleSet& roles) const;
 
    bool supportsFeatures(const FeatureMap& features) const;
 
    Variant authId() const;
 
    Variant authRole() const;
 
    Variant authMethod() const;
 
    Variant authProvider() const;
 
private:
    using Base = Options<SessionInfo, internal::WelcomeMessage>;
 
    String realm_;
 
public:
    // Internal use only
    SessionInfo(internal::PassKey, String&& realm,
                internal::WelcomeMessage&& msg);
};
 
CPPWAMP_API std::ostream& operator<<(std::ostream& out,
                                     const SessionInfo& info);
 
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API Reason : public Options<Reason, internal::GoodbyeMessage>
{
public:
    Reason(String uri = "");
 
    const String& uri() const;
 
private:
    using Base = Options<Reason, internal::GoodbyeMessage>;
 
public:
    // Internal use only
    Reason(internal::PassKey, internal::GoodbyeMessage&& msg);
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API Authentication : public Options<Authentication,
                                                  internal::AuthenticateMessage>
{
public:
    Authentication();
 
    Authentication(String signature);
 
    const String& signature() const;
 
    Authentication& withNonce(std::string nonce);
 
    Authentication& withChannelBinding(std::string type, std::string data);
 
private:
    using Base = Options<Authentication, internal::AuthenticateMessage>;
};
 
 
namespace internal { class Challengee; } // Forward declaration
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API Challenge : public Options<Challenge,
                                             internal::ChallengeMessage>
{
public:
    Challenge();
 
    bool challengeeHasExpired() const;
 
    const String& method() const;
 
    Variant challenge() const;
 
    Variant salt() const;
 
    Variant keyLength() const;
 
    Variant iterations() const;
 
    Variant kdf() const;
 
    Variant memory() const;
 
    void authenticate(Authentication auth);
 
public:
    // Internal use only
    using ChallengeePtr = std::weak_ptr<internal::Challengee>;
    Challenge(internal::PassKey, ChallengeePtr challengee,
              internal::ChallengeMessage&& msg);
 
private:
    using Base = Options<Challenge, internal::ChallengeMessage>;
 
    ChallengeePtr challengee_;
};
 
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API Error : public Payload<Error, internal::ErrorMessage>
{
public:
    Error();
 
    Error(String reason);
 
    explicit Error(const error::BadType& e);
 
    virtual ~Error();
 
    explicit operator bool() const;
 
    const String& reason() const;
 
private:
    using Base = Payload<Error, internal::ErrorMessage>;
 
public:
    // Internal use only
    Error(internal::PassKey, internal::ErrorMessage&& msg);
 
    internal::ErrorMessage& errorMessage(internal::PassKey,
                                         internal::WampMsgType reqType,
                                         RequestId reqId);
};
 
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API Topic : public Options<Topic, internal::SubscribeMessage>
{
public:
    Topic(String uri);
 
    Topic& usingPrefixMatch();
 
    Topic& usingWildcardMatch();
 
    const String& uri() const;
 
private:
    using Base = Options<Topic, internal::SubscribeMessage>;
};
 
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API Pub : public Payload<Pub, internal::PublishMessage>
{
public:
    Pub(String topic);
 
    const String& topic();
 
    Pub& withExcludedSessions(Array sessionIds);
 
    Pub& withExcludedAuthIds(Array authIds);
 
    Pub& withExcludedAuthRoles(Array authRoles);
 
    Pub& withEligibleSessions(Array sessionIds);
 
    Pub& withEligibleAuthIds(Array authIds);
 
    Pub& withEligibleAuthRoles(Array authRoles);
 
    Pub& withExcludeMe(bool excluded = true);
 
    Pub& withDiscloseMe(bool disclosed = true);
 
private:
    using Base = Payload<Pub, internal::PublishMessage>;
};
 
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API Event : public Payload<Event, internal::EventMessage>
{
public:
    Event();
 
    bool empty() const;
 
    SubscriptionId subId() const;
 
    PublicationId pubId() const;
 
    AnyIoExecutor executor() const;
 
    Variant publisher() const;
 
    Variant trustLevel() const;
 
    Variant topic() const;
 
private:
    using Base = Payload<Event, internal::EventMessage>;
 
    AnyIoExecutor executor_;
 
public:
    // Internal use only
    Event(internal::PassKey, AnyIoExecutor executor,
          internal::EventMessage&& msg);
};
 
CPPWAMP_API std::ostream& operator<<(std::ostream& out, const Event& event);
 
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API Procedure : public Options<Procedure,
                                             internal::RegisterMessage>
{
public:
    Procedure(String uri);
 
    const String& uri() const;
 
    Procedure& usingPrefixMatch();
 
    Procedure& usingWildcardMatch();
 
    Procedure& withDiscloseCaller(bool disclosed = true);
 
private:
    using Base = Options<Procedure, internal::RegisterMessage>;
};
 
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API Rpc : public Payload<Rpc, internal::CallMessage>
{
public:
    using CallerTimeoutDuration = std::chrono::steady_clock::duration;
 
    static constexpr CallCancelMode defaultCancelMode() noexcept
    {
        return CallCancelMode::kill;
    }
 
    Rpc(String uri);
 
    const String& procedure() const;
 
    Rpc& captureError(Error& error);
 
    Rpc& withProgressiveResults(bool enabled = true);
 
    bool progressiveResultsAreEnabled() const;
 
    Rpc& withDealerTimeout(UInt milliseconds);
 
    template <typename R, typename P>
    Rpc& withDealerTimeout(std::chrono::duration<R, P> timeout)
    {
        using namespace std::chrono;
        auto ms = duration_cast<milliseconds>(timeout).count();
        return withDealerTimeout(static_cast<Int>(ms));
    }
 
    Rpc& withCallerTimeout(UInt milliseconds);
 
    template <typename R, typename P>
    Rpc& withCallerTimeout(std::chrono::duration<R, P> timeout)
    {
        using namespace std::chrono;
        setCallerTimeout(duration_cast<CallerTimeoutDuration>(timeout));
        return *this;
    }
 
    CallerTimeoutDuration callerTimeout() const;
 
 
    Rpc& withDiscloseMe(bool disclosed = true);
 
    Rpc& withCancelMode(CallCancelMode mode);
 
    CallCancelMode cancelMode() const;
 
private:
    using Base = Payload<Rpc, internal::CallMessage>;
 
    void setCallerTimeout(CallerTimeoutDuration duration);
 
    Error* error_ = nullptr;
    CallerTimeoutDuration callerTimeout_ = {};
    CallCancelMode cancelMode_ = defaultCancelMode();
    bool progressiveResultsEnabled_ = false;
 
public:
    Error* error(internal::PassKey); // Internal use only
};
 
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API Result : public Payload<Result, internal::ResultMessage>
{
public:
    Result();
 
    Result(std::initializer_list<Variant> list);
 
    RequestId requestId() const;
 
    Result& withProgress(bool progressive = true);
 
    bool isProgressive() const;
 
private:
    using Base = Payload<Result, internal::ResultMessage>;
    Result(RequestId reqId, Object&& details);
 
public:
    // Internal use only
    Result(internal::PassKey, internal::ResultMessage&& msg);
 
    internal::YieldMessage& yieldMessage(internal::PassKey, RequestId reqId)
    {
        message().setRequestId(reqId);
        return message().transformToYield();
    }
};
 
CPPWAMP_API std::ostream& operator<<(std::ostream& out, const Result& result);
 
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
struct Deferment
{
    constexpr Deferment() noexcept = default;
};
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
constexpr CPPWAMP_INLINE_VARIABLE Deferment deferment;
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API Outcome
{
public:
    enum class Type
    {
        deferred, 
        result,   
        error     
    };
 
    CPPWAMP_DEPRECATED static Outcome deferred();
 
    Outcome();
 
    Outcome(Result result);
 
    Outcome(std::initializer_list<Variant> args);
 
    Outcome(Error error);
 
    Outcome(Deferment);
 
    Outcome(const Outcome& other);
 
    Outcome(Outcome&& other);
 
    ~Outcome();
 
    Type type() const;
 
    const Result& asResult() const &;
 
    Result&& asResult() &&;
 
    const Error& asError() const &;
 
    Error&& asError() &&;
 
    Outcome& operator=(const Outcome& other);
 
    Outcome& operator=(Outcome&& other);
 
private:
    CPPWAMP_HIDDEN explicit Outcome(std::nullptr_t);
    CPPWAMP_HIDDEN void copyFrom(const Outcome& other);
    CPPWAMP_HIDDEN void moveFrom(Outcome&& other);
    CPPWAMP_HIDDEN void destruct();
 
    Type type_;
 
    union CPPWAMP_HIDDEN Value
    {
        Value() {}
        ~Value() {}
 
        Result result;
        Error error;
    } value_;
};
 
 
namespace internal { class Callee; } // Forward declaration
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API Invocation : public Payload<Invocation,
                                              internal::InvocationMessage>
{
public:
    Invocation();
 
    bool empty() const;
 
    bool calleeHasExpired() const;
 
    RequestId requestId() const;
 
    AnyIoExecutor executor() const;
 
    void yield(Result result = Result()) const;
 
    void yield(Error error) const;
 
    bool isProgressive() const;
 
    Variant caller() const;
 
    Variant trustLevel() const;
 
    Variant procedure() const;
 
public:
    // Internal use only
    using CalleePtr = std::weak_ptr<internal::Callee>;
    Invocation(internal::PassKey, CalleePtr callee, AnyIoExecutor executor,
               internal::InvocationMessage&& msg);
 
private:
    using Base = Payload<Invocation, internal::InvocationMessage>;
 
    CalleePtr callee_;
    AnyIoExecutor executor_ = nullptr;
 
    template <typename, typename...> friend class CoroInvocationUnpacker;
};
 
CPPWAMP_API std::ostream& operator<<(std::ostream& out, const Invocation& inv);
 
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API CallCancellation
    : public Options<CallCancellation, internal::CancelMessage>
{
public:
    CallCancellation(RequestId reqId,
                     CallCancelMode cancelMode = Rpc::defaultCancelMode());
 
    RequestId requestId() const;
 
    CallCancelMode mode() const;
 
private:
    using Base = Options<CallCancellation, internal::CancelMessage>;
 
    RequestId requestId_;
    CallCancelMode mode_;
};
 
using Cancellation CPPWAMP_DEPRECATED = CallCancellation;
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
class CPPWAMP_API Interruption : public Options<Interruption,
                                                internal::InterruptMessage>
{
public:
    Interruption();
 
    bool empty() const;
 
    bool calleeHasExpired() const;
 
    RequestId requestId() const;
 
    AnyIoExecutor executor() const;
 
    void yield(Result result = Result()) const;
 
    void yield(Error error) const;
 
public:
    // Internal use only
    using CalleePtr = std::weak_ptr<internal::Callee>;
    Interruption(internal::PassKey, CalleePtr callee, AnyIoExecutor executor,
                 internal::InterruptMessage&& msg);
 
private:
    using Base = Options<Interruption, internal::InterruptMessage>;
 
    CalleePtr callee_;
    AnyIoExecutor executor_ = nullptr;
};
 
CPPWAMP_API std::ostream& operator<<(std::ostream& out,
                                     const Interruption& cncltn);
 
} // namespace wamp
 
#ifndef CPPWAMP_COMPILED_LIB
#include "./internal/peerdata.ipp"
#endif
 
#endif // CPPWAMP_PEERDATA_HPP