actor.hpp

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2022 Ivan Baidakou
 
#pragma once
 
#include "context.hpp"
#include "definitions.hpp"
#include "messages.hpp"
#include <cassert>
 
namespace rotor_light {
 
struct SupervisorBase;
struct QueueBase;
 
struct ActorBase {
  using GenericMethod = void (ActorBase::*)(Message &);
 
  template <typename T> struct handler_traits {};
 
  template <typename A, typename M> struct handler_traits<void (A::*)(M &)> {
    using FinalMessage = M;
 
    using Backend = A;
  };
 
  struct Handler;
 
  using MethodEntry = void (*)(Message &, ActorBase &, Handler &);
 
  struct Handler {
    GenericMethod method;
 
    MessageTypeId message_id;
 
    MethodEntry entry;
  };
 
  static constexpr size_t min_handlers_amount = 1;
 
  ActorBase(const ActorBase &) = delete;
  ActorBase(ActorBase &&) = delete;
 
  virtual void initialize();
 
  virtual uint8_t bind(ActorId initial_value, SupervisorBase *supervisor,
                       Context &context);
 
  inline ActorId get_id() const { return id; }
 
  inline State get_state() const { return state; }
 
  inline FailPolicy get_fail_policy() const { return fail_policy; }
 
  inline void set_fail_policy(FailPolicy value) { fail_policy = value; }
 
  void stop();
 
  template <typename Ctx>
  EventId add_event(Duration delta, Callback callback, void *data);
 
  void cancel_event(EventId event_id);
 
  template <typename Ctx, typename MessageType, typename... Args>
  bool send(size_t queue_index, Args... args);
 
  template <typename Method> void subscribe(Method method) {
    assert(state == State::off);
    assert(backend_idx < (int)backends_count);
    auto ptr = backends_ptr + ++backend_idx * sizeof(Handler);
    make_handler(method, *reinterpret_cast<Handler *>(ptr));
  }
 
protected:
  ActorBase(char *backends, size_t backends_count);
 
  virtual void advance_init();
 
  virtual void advance_start();
 
  virtual void advance_stop();
 
  ActorId id;
 
  ActorId mask;
 
  State state = State::off;
 
  SupervisorBase *supervisor;
 
  FailPolicy fail_policy;
 
private:
  void on_state_change(message::ChangeState &);
 
  template <typename Method>
  void make_handler(Method &method, Handler &handler) {
    using traits = handler_traits<Method>;
    using FinalMessage = typename traits::FinalMessage;
    using Backend = typename traits::Backend;
 
    handler.message_id = FinalMessage::type_id;
    handler.entry = [](Message &message, ActorBase &actor, Handler &handler) {
      auto &final_message = static_cast<FinalMessage &>(message);
      auto &backend = static_cast<Backend &>(actor);
      (backend.*reinterpret_cast<Method &>(handler.method))(final_message);
    };
    handler.method = reinterpret_cast<GenericMethod &>(method);
  }
 
  char *backends_ptr;
  size_t backends_count;
  int backend_idx;
 
  friend struct SupervisorBase;
};
 
template <size_t HandlersCount> struct Actor : ActorBase {
  static_assert(HandlersCount >= Actor::min_handlers_amount,
                "no enough handlers");
  Actor() : ActorBase(reinterpret_cast<char *>(&backends), HandlersCount) {}
 
  ActorBase::Handler backends[HandlersCount];
};
 
} // namespace rotor_light