message_endpoint.h

Go to the documentation of this file.

 
#pragma once
 
#include <knp/core/messaging/message_envelope.h>
#include <knp/core/messaging/messaging.h>
#include <knp/core/subscription.h>
#include <knp/core/uid.h>
 
#include <any>
#include <chrono>
#include <functional>
#include <map>
#include <memory>
#include <numeric>
#include <string>
#include <utility>
#include <variant>
#include <vector>
 
#include <boost/mp11.hpp>
#include <boost/noncopyable.hpp>
 
 
namespace knp::core::messaging::impl
{
class MessageEndpointImpl;
}  // namespace knp::core::messaging::impl
 
 
namespace knp::core
{
class MessageEndpoint : private boost::noncopyable
{
public:
    using AllSubscriptions = boost::mp11::mp_transform<Subscription, messaging::AllMessages>;
 
    using SubscriptionVariant = boost::mp11::mp_rename<AllSubscriptions, std::variant>;
 
public:
    static UID get_receiver_uid(const SubscriptionVariant &subscription);
    static std::pair<size_t, UID> get_subscription_key(const SubscriptionVariant &subscription);
 
    template <typename Variant, typename Type>
    static constexpr size_t get_type_index = boost::mp11::mp_find<Variant, Type>::value;
 
public:
    MessageEndpoint(MessageEndpoint &&endpoint) noexcept;
 
    MessageEndpoint &operator=(MessageEndpoint &) = delete;
 
    virtual ~MessageEndpoint();
 
public:
    template <typename MessageType>
    Subscription<MessageType> &subscribe(const UID &receiver, const std::vector<UID> &senders);
 
    template <typename MessageType>
    bool unsubscribe(const UID &receiver);
 
    void remove_receiver(const UID &receiver);
 
    void send_message(const knp::core::messaging::MessageVariant &message);
 
    bool receive_message();
 
    size_t receive_all_messages(const std::chrono::milliseconds &sleep_duration = std::chrono::milliseconds(0));
 
    template <class MessageType>
    std::vector<MessageType> unload_messages(const knp::core::UID &receiver_uid);
 
public:
    using SubscriptionContainer = std::map<std::pair<size_t, UID>, SubscriptionVariant>;
 
    const SubscriptionContainer &get_endpoint_subscriptions() const { return subscriptions_; }
 
protected:
    std::shared_ptr<messaging::impl::MessageEndpointImpl> impl_;
 
protected:
    MessageEndpoint() = default;
 
private:
    SubscriptionContainer subscriptions_;
};
 
}  // namespace knp::core