Actor.h

Go to the documentation of this file.

 
#ifndef QB_ACTOR_H
#define QB_ACTOR_H
#include <map>
#include <tuple>
#include <utility>
#include <vector>
// include from qb
#include <qb/system/container/unordered_map.h>
#include <qb/utility/nocopy.h>
#include <qb/utility/type_traits.h>
#include "Event.h"
#include "ICallback.h"
#include "Pipe.h"
 
#ifdef __GNUG__
#include <cstdlib>
#include <cxxabi.h>
#include <memory>
#endif
 
namespace qb {
 
class VirtualCore;
class ActorProxy;
class Service;

class Actor : nocopy {
    friend class VirtualCore;
    friend class ActorProxy;
    friend class Service;
 
    const char   *name = "unnamed";
    ActorId       _id;
    mutable bool  _alive  = true;
    std::uint32_t id_type = 0u;

    template <typename _Type>
    bool require_type() const noexcept;

    explicit Actor(ActorId id) noexcept;
 
protected:
    template <typename Tag>
    static ServiceId registerIndex() noexcept;


    Actor() noexcept;

    virtual ~Actor() noexcept = default;

    virtual bool
    onInit() {
        return true;
    };
 
public:
    void kill() const noexcept;

 
public:

    void on(KillEvent const &event) noexcept;

    void on(SignalEvent const &event) noexcept;

    void on(UnregisterCallbackEvent const &event) noexcept;

    void on(PingEvent const &event) noexcept;

 
public:
    class EventBuilder {
        friend class Actor;
        Pipe dest_pipe;

        explicit EventBuilder(Pipe const &pipe) noexcept;
 
    public:
        EventBuilder()                                 = delete;
        EventBuilder(EventBuilder const &rhs) noexcept = default;

        template <typename _Event, typename... _Args>
        EventBuilder &push(_Args &&...args) noexcept;
    };


    [[nodiscard]] ActorId
    id() const noexcept {
        return _id;
    }

    [[nodiscard]] CoreId getIndex() const noexcept;

    [[nodiscard]] std::string_view getName() const noexcept;

    [[nodiscard]] const CoreIdSet &getCoreSet() const noexcept;

    [[nodiscard]] uint64_t time() const noexcept;

    template <typename T>
    [[nodiscard]] static ActorId getServiceId(CoreId index) noexcept;

    template <typename _ServiceActor>
    [[nodiscard]] _ServiceActor *getService() const noexcept;
 
    // void setCoreLowLatency(bool state) const noexcept;

    [[nodiscard]] bool is_alive() const noexcept;



    template <typename _Actor>
    void registerCallback(_Actor &actor) const noexcept;

    template <typename _Actor>
    void unregisterCallback(_Actor &actor) const noexcept;

    void unregisterCallback() const noexcept;

    template <typename _Event, typename _Actor>
    void registerEvent(_Actor &actor) const noexcept;

    template <typename _Event, typename _Actor>
    void unregisterEvent(_Actor &actor) const noexcept;

    template <typename _Event>
    void unregisterEvent() const noexcept;

    [[nodiscard]] EventBuilder to(ActorId dest) const noexcept;

    template <typename _Event, typename... _Args>
    _Event &push(ActorId const &dest, _Args &&...args) const noexcept;

    template <typename _Event, typename... _Args>
    void send(ActorId const &dest, _Args &&...args) const noexcept;

    template <typename _Event, typename... _Args>
    [[nodiscard]] _Event build_event(qb::ActorId const source,
                                     _Args &&...args) const noexcept;

    template <typename _Type>
    [[nodiscard]] inline bool
    is(uint32_t const id) const noexcept {
        return id == type_id<_Type>();
    }

    template <typename _Type>
    [[nodiscard]] inline bool
    is(RequireEvent const &event) const noexcept {
        return event.type == type_id<_Type>();
    }

    template <typename... _Actors>
    bool require() const noexcept;

    template <typename _Event, typename... _Args>
    void broadcast(_Args &&...args) const noexcept;

    void reply(Event &event) const noexcept;

    void forward(ActorId dest, Event &event) const noexcept;
 
    // OpenApi : used for module
    void send(Event const &event) const noexcept;
    void push(Event const &event) const noexcept;
    bool try_send(Event const &event) const noexcept;

    [[nodiscard]] Pipe getPipe(ActorId dest) const noexcept;

    template <typename _Actor, typename... _Args>
    _Actor *addRefActor(_Args &&...args) const;

};

class Service : public Actor {
public:
    explicit Service(ServiceId sid);
};

template <typename Tag>
class ServiceActor : public Service {
    friend class Main;
    friend class CoreInitializer;
    friend class VirtualCore;
    static const ServiceId ServiceIndex;
 
public:
    ServiceActor()
        : Service(ServiceIndex) {}
};

class IActorFactory {
public:
    virtual ~IActorFactory()                     = default;
    virtual Actor             *create()          = 0;
    [[nodiscard]] virtual bool isService() const = 0;
};

class ActorProxy {
protected:
    ActorProxy() = default;
    template <typename _Type>
    static void
    setType(Actor &actor) {
        actor.id_type = ActorProxy::getType<_Type>();
    }
    template <typename _Type>
    static void
    setName(Actor &actor) {
        actor.name = ActorProxy::getName<_Type>();
    }
 
public:
    template <typename _Type>
    static auto
    getType() {
        return type_id<_Type>();
    }
    template <typename _Type>
    static const char *
    getName() {
#ifdef __GNUC__
        static std::unique_ptr<char, void (*)(void *)> res{
            abi::__cxa_demangle(typeid(_Type).name(), nullptr, nullptr, nullptr),
            std::free};
 
        return res.get();
#else
        return typeid(_Type).name();
#endif
    }
};
 
// ======= Utility: detect std::reference_wrapper<T> =========
 
template <template <typename...> class Template, typename T>
struct is_specialization_of : std::false_type {};
 
template <template <typename...> class Template, typename... Args>
struct is_specialization_of<Template, Template<Args...>> : std::true_type {};

template <typename T>
struct actor_factory_param {
    using no_ref = std::remove_reference_t<T>;

    static constexpr bool is_ref_wrapper =
        is_specialization_of<std::reference_wrapper, std::decay_t<no_ref>>::value;

    using type = std::conditional_t<
        is_ref_wrapper,
        no_ref, // Keep ref_wrapper untouched
 
        std::conditional_t<
            std::is_array_v<T> && std::is_same_v<std::remove_extent_t<T>, const char>,
            std::string,  // string literals → std::string
 
            std::decay_t<T> // fallback
            >
        >;
};

template <typename T>
inline auto actor_factory_forward(T&& val) {
    using Target = typename actor_factory_param<T>::type;
 
    if constexpr (std::is_same_v<Target, std::string>) {
        return std::string(std::forward<T>(val)); // copy literal
    } else {
        return std::forward<T>(val); // forward all others
    }
}

template <typename _Actor, typename... _Args>
class TActorFactory : public IActorFactory, public ActorProxy {
    using Tuple = std::tuple<typename actor_factory_param<_Args>::type...>;
 
    ActorId _id;
    Tuple _parameters;
 
public:
    explicit TActorFactory(ActorId const id, _Args&&... args)
        : _id(id)
        , _parameters(actor_factory_forward<_Args>(std::forward<_Args>(args))...) {}
 
    Actor* create() final {
        return create_impl(std::index_sequence_for<_Args...>{});
    }
 
    [[nodiscard]] bool isService() const final {
        return std::is_base_of_v<Service, _Actor>;
    }
 
private:
    template <std::size_t... Is>
    Actor* create_impl(std::index_sequence<Is...>) {
        auto actor = new _Actor(std::get<Is>(_parameters)...);
        ActorProxy::setType<_Actor>(*actor);
        ActorProxy::setName<_Actor>(*actor);
        return actor;
    }
};

using actor = Actor;

template <typename Tag>
using service_actor = ServiceActor<Tag>;
 
#ifdef QB_LOGGER
qb::io::log::stream &operator<<(qb::io::log::stream &os, qb::Actor const &actor);
#endif

std::ostream &operator<<(std::ostream &os, qb::Actor const &actor);
 
} // namespace qb
 
#endif // QB_ACTOR_H