subscription_point.h

#pragma once
 
//
// Copyright (c) 2019-2025 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 <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;
};

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 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