child_info.h

#pragma once
 
//
// Copyright (c) 2022 Ivan Baidakou (basiliscos) (the dot dmol at gmail dot com)
//
// Distributed under the MIT Software License
//
 
#include "rotor/forward.hpp"
#include "rotor/policy.h"
#include <variant>
 
#if defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4251)
#endif
 
namespace rotor::detail {
 
enum class shutdown_state_t { none, sent, confirmed };
 
namespace demand {
struct no {};
struct now {};
struct escalate_failure {};
} // namespace demand
 
using spawn_demand_t = std::variant<demand::no, demand::now, demand::escalate_failure, pt::time_duration>;
 
struct ROTOR_API child_info_t : boost::intrusive_ref_counter<child_info_t, boost::thread_unsafe_counter> {
    using clock_t = pt::microsec_clock;
 
    template <typename Factory>
    child_info_t(address_ptr_t address_, Factory &&factory_, restart_policy_t policy_ = restart_policy_t::normal_only,
                 const pt::time_duration &restart_period_ = pt::seconds{15}, size_t max_attempts_ = 0,
                 bool escalate_failure_ = false) noexcept
        : address{std::move(address_)}, factory{std::forward<Factory>(factory_)}, policy{policy_},
          restart_period{restart_period_}, max_attempts{max_attempts_}, escalate_failure{escalate_failure_} {}
 
    template <typename Factory, typename Actor>
    child_info_t(address_ptr_t address_, Factory &&factory_, Actor &&actor_) noexcept
        : child_info_t(std::move(address_), std::forward<Factory>(factory_)) {
        actor = std::forward<Actor>(actor_);
        if (actor) {
            spawn_attempt();
        }
    }
 
    void spawn_attempt() noexcept;
 
    spawn_demand_t next_spawn(bool abnormal_shutdown) noexcept;
 
    address_ptr_t address;
 
    factory_t factory;
 
    actor_ptr_t actor;
 
    restart_policy_t policy;
 
    pt::time_duration restart_period;
 
    shutdown_state_t shutdown = shutdown_state_t::none;
 
    size_t max_attempts;
 
    size_t attempts = 0;
 
    bool active = true;
 
    bool escalate_failure = false;
 
    request_id_t timer_id{0};
 
    pt::ptime last_instantiation;
 
    bool initialized = false;
 
    bool started = false;
};
 
using child_info_ptr_t = boost::intrusive_ptr<child_info_t>;
 
} // namespace rotor::detail
 
#if defined(_MSC_VER)
#pragma warning(pop)
#endif