message.h

#pragma once
 
//
// Copyright (c) 2019-2024 Ivan Baidakou (basiliscos) (the dot dmol at gmail dot com)
//
// Distributed under the MIT Software License
//
 
#include "arc.hpp"
#include "address.hpp"
#include <typeindex>
#include <deque>
 
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4251)
#endif
 
namespace rotor {
 
struct message_base_t;
 
struct ROTOR_API message_visitor_t {
    virtual ~message_visitor_t() = default;
 
    virtual bool try_visit(const message_base_t &message, void *context) const = 0;
};
 
struct message_base_t : public arc_base_t<message_base_t> {
    virtual ~message_base_t() = default;
 
    const void *type_index;
 
    address_ptr_t address;
 
    address_ptr_t next_route;
 
    inline message_base_t(const void *type_index_, const address_ptr_t &addr)
        : type_index(type_index_), address{addr} {}
};
 
namespace message_support {
ROTOR_API const void *register_type(const std::type_index &type_index) noexcept;
}
 
template <typename T> struct message_t : public message_base_t {
 
    using payload_t = T;
 
    struct ROTOR_API visitor_t {
        virtual ~visitor_t() = default;
 
        virtual void on(const message_t &, void *) {}
    };
 
    template <typename... Args>
    message_t(const address_ptr_t &addr, Args &&...args)
        : message_base_t{message_type, addr}, payload{std::forward<Args>(args)...} {}
 
    T payload;
 
    static const void *message_type;
};
 
template <typename T> const void *message_t<T>::message_type = message_support::register_type(typeid(message_t<T>));
 
using message_ptr_t = intrusive_ptr_t<message_base_t>;
 
using messages_queue_t = std::deque<message_ptr_t>;
 
template <typename M, typename... Args> auto make_message(const address_ptr_t &addr, Args &&...args) -> message_ptr_t {
    assert(addr);
    return message_ptr_t{new message_t<M>(addr, std::forward<Args>(args)...)};
}
 
template <typename M, typename... Args>
auto make_routed_message(const address_ptr_t &addr, const address_ptr_t &route_addr, Args &&...args) -> message_ptr_t {
    assert(addr);
    auto message = message_ptr_t{new message_t<M>(addr, std::forward<Args>(args)...)};
    message->next_route = route_addr;
    return message;
}
 
} // namespace rotor
 
#if defined(_MSC_VER)
#pragma warning(pop)
#endif