subscription_point.h

#pragma once
 
//
// Copyright (c) 2019-2021 Ivan Baidakou (basiliscos) (the dot dmol at gmail dot com)
//
// Distributed under the MIT Software License
//
 
#include "rotor/forward.hpp"
#include "rotor/address.hpp"
#include <vector>
#include <list>
 
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4251)
#endif
 
namespace rotor {
 
struct actor_base_t;
 
namespace tags {
 
ROTOR_API extern const void *io;
 
}
 
enum class owner_tag_t {
    ANONYMOUS,
    PLUGIN,
    SUPERVISOR,
    FOREIGN,
};
 
struct ROTOR_API subscription_point_t {
    handler_ptr_t handler;
 
    address_ptr_t address;
 
    const actor_base_t *owner_ptr;
 
    owner_tag_t owner_tag;
 
    subscription_point_t(const handler_ptr_t &handler_, const address_ptr_t &address_) noexcept
        : handler{handler_}, address{address_}, owner_ptr{nullptr}, owner_tag{owner_tag_t::ANONYMOUS} {}
 
    subscription_point_t(const handler_ptr_t &handler_, const address_ptr_t &address_, const actor_base_t *owner_ptr_,
                         owner_tag_t owner_tag_) noexcept
        : handler{handler_}, address{address_}, owner_ptr{owner_ptr_}, owner_tag{owner_tag_} {}
 
    subscription_point_t(const subscription_point_t &) = default;
 
    subscription_point_t(subscription_point_t &&) = default;
 
    bool operator==(const subscription_point_t &other) const noexcept;
};
 
struct ROTOR_API subscription_info_t : public arc_base_t<subscription_info_t>, subscription_point_t {
    enum state_t { SUBSCRIBING, ESTABLISHED, UNSUBSCRIBING };
 
    subscription_info_t(const subscription_point_t &point, bool internal_address_, bool internal_handler_,
                        state_t state_) noexcept
        : subscription_point_t{point}, internal_address{internal_address_}, internal_handler{internal_handler_},
          state{state_} {}
 
    inline bool operator==(const subscription_point_t &point) const noexcept {
        return (subscription_point_t &)(*this) == point;
    }
 
    inline void tag_io() noexcept { tag(tags::io); }
 
    template <typename T> auto &access() noexcept;
 
    template <typename T, typename... Args> auto access(Args... args) noexcept;
 
  private:
    void tag(const void *t) noexcept;
 
    bool internal_address;
 
    bool internal_handler;
 
    state_t state;
};
 
using subscription_info_ptr_t = intrusive_ptr_t<subscription_info_t>;
 
struct ROTOR_API subscription_container_t : public std::list<subscription_info_ptr_t> {
    iterator find(const subscription_point_t &point) noexcept;
};
 
} // namespace rotor
 
#if defined(_MSC_VER)
#pragma warning(pop)
#endif