messages.hpp

#pragma once
 
//
// Copyright (c) 2019-2022 Ivan Baidakou (basiliscos) (the dot dmol at gmail dot com)
//
// Distributed under the MIT Software License
//
 
#include "address.hpp"
#include "message.h"
#include "state.h"
#include "request.hpp"
#include "subscription_point.h"
#include "forward.hpp"
#include "extended_error.h"
 
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4251)
#endif
 
namespace rotor {
 
namespace payload {
 
struct initialize_confirmation_t {};
 
struct initialize_actor_t {
    using response_t = initialize_confirmation_t;
};
 
struct start_actor_t {};
 
struct create_actor_t {
    actor_ptr_t actor;
 
    pt::time_duration timeout;
};
 
struct spawn_actor_t {
 
    address_ptr_t spawner_address;
};
 
struct shutdown_trigger_t {
    address_ptr_t actor_address;
 
    extended_error_ptr_t reason;
 
    template <typename Address, typename Reason>
    shutdown_trigger_t(Address &&address_, Reason &&reason_) noexcept
        : actor_address(std::forward<Address>(address_)), reason(std::forward<Reason>(reason_)) {}
};
 
struct shutdown_confirmation_t {};
 
struct shutdown_request_t {
    using response_t = shutdown_confirmation_t;
 
    template <typename Reason>
    explicit shutdown_request_t(Reason &&reason_) noexcept : reason(std::forward<Reason>(reason_)) {}
 
    extended_error_ptr_t reason;
};
 
struct handler_call_t {
    message_ptr_t orig_message;
 
    handler_ptr_t handler;
};
 
struct external_subscription_t {
    subscription_point_t point;
};
 
struct subscription_confirmation_t {
    subscription_point_t point;
};
 
struct external_unsubscription_t {
    subscription_point_t point;
};
 
struct commit_unsubscription_t {
    subscription_point_t point;
};
 
struct unsubscription_confirmation_t {
    subscription_point_t point;
};
 
struct registration_response_t {};
 
struct registration_request_t {
    using response_t = registration_response_t;
 
    std::string service_name;
 
    address_ptr_t service_addr;
};
 
struct deregistration_notify_t {
    address_ptr_t service_addr;
};
 
struct deregistration_service_t {
    std::string service_name;
};
 
struct discovery_reply_t {
    address_ptr_t service_addr;
};
 
struct discovery_request_t {
    using response_t = discovery_reply_t;
 
    std::string service_name;
};
 
struct discovery_future_t {
    address_ptr_t service_addr;
};
 
struct discovery_promise_t {
    using response_t = discovery_future_t;
    std::string service_name;
};
 
struct link_response_t {};
 
struct link_request_t {
    using response_t = link_response_t;
 
    bool operational_only;
};
 
struct unlink_notify_t {
    address_ptr_t client_addr;
};
 
struct unlink_request_t {
    using response_t = unlink_notify_t;
 
    address_ptr_t server_addr;
};
 
} // namespace payload
 
namespace message {
 
// subscription-related
using unsubscription_t = message_t<payload::unsubscription_confirmation_t>;
using unsubscription_external_t = message_t<payload::external_unsubscription_t>;
using subscription_t = message_t<payload::subscription_confirmation_t>;
 
using external_subscription_t = message_t<payload::external_subscription_t>;
using commit_unsubscription_t = message_t<payload::commit_unsubscription_t>;
 
using handler_call_t = message_t<payload::handler_call_t>;
 
// lifetime-related
using init_request_t = request_traits_t<payload::initialize_actor_t>::request::message_t;
using init_response_t = request_traits_t<payload::initialize_actor_t>::response::message_t;
 
using start_trigger_t = message_t<payload::start_actor_t>;
 
using shutdown_trigger_t = message_t<payload::shutdown_trigger_t>;
using shutdown_request_t = request_traits_t<payload::shutdown_request_t>::request::message_t;
using shutdown_response_t = request_traits_t<payload::shutdown_request_t>::response::message_t;
 
using create_actor_t = message_t<payload::create_actor_t>;
 
using spawn_actor_t = message_t<payload::spawn_actor_t>;
 
// registry-related
using registration_request_t = request_traits_t<payload::registration_request_t>::request::message_t;
using registration_response_t = request_traits_t<payload::registration_request_t>::response::message_t;
using deregistration_notify_t = message_t<payload::deregistration_notify_t>;
using deregistration_service_t = message_t<payload::deregistration_service_t>;
 
using discovery_request_t = request_traits_t<payload::discovery_request_t>::request::message_t;
using discovery_response_t = request_traits_t<payload::discovery_request_t>::response::message_t;
using discovery_promise_t = request_traits_t<payload::discovery_promise_t>::request::message_t;
using discovery_future_t = request_traits_t<payload::discovery_promise_t>::response::message_t;
using discovery_cancel_t = request_traits_t<payload::discovery_promise_t>::cancel::message_t;
 
// link-related
using link_request_t = request_traits_t<payload::link_request_t>::request::message_t;
using link_response_t = request_traits_t<payload::link_request_t>::response::message_t;
using unlink_notify_t = message_t<payload::unlink_notify_t>;
using unlink_request_t = request_traits_t<payload::unlink_request_t>::request::message_t;
using unlink_response_t = request_traits_t<payload::unlink_request_t>::response::message_t;
 
} // namespace message
 
} // namespace rotor
 
#if defined(_MSC_VER)
#pragma warning(pop)
#endif