Event.h

Go to the documentation of this file.

 
#ifndef QB_EVENT_H
#define QB_EVENT_H
#include <bitset>
#include <qb/system/allocator/pipe.h>
#include <utility>
// include from qb
#include "ActorId.h"
#include "ICallback.h"
 
namespace qb {

template <typename T>
struct type {
    constexpr static void
    id() {}
};

template <typename T>
constexpr TypeId
type_id() {
    return static_cast<TypeId>(reinterpret_cast<std::size_t>(&type<T>::id));
}

class QB_LOCKFREE_CACHELINE_ALIGNMENT Event {
    friend class SharedCoreCommunication;
    friend class VirtualCore;
    friend class Actor;
    friend class Pipe;
    friend struct EventQOS0;
    friend struct ServiceEvent;
 
public:
    using id_handler_type = ActorId;
 
#ifdef NDEBUG
    using id_type = EventId;
    template <typename T>
    [[nodiscard]] constexpr static id_type
    type_to_id() {
        return static_cast<id_type>(reinterpret_cast<std::size_t>(&qb::type<T>::id));
    }
#else
    using id_type = const char *;
    template <typename T>
    [[nodiscard]] constexpr static id_type
    type_to_id() {
        return typeid(T).name();
    }
#endif
 
private:
    union Header {
        uint32_t : 16, : 8, alive : 1, qos : 2, factor : 5;
        uint8_t prot[4] = {'q', 'b', '\0',
                           4 | ((QB_LOCKFREE_EVENT_BUCKET_BYTES / 16) << 3)};
    } state;
    uint16_t bucket_size;
    id_type  id;
    // for users
    id_handler_type dest;
    id_handler_type source;
 
    //    Event &operator=(Event const &) = default;
 
public:
    Event() = default;

    [[nodiscard]] inline bool
    is_alive() const noexcept {
        return state.alive;
    }

    [[nodiscard]] inline id_type
    getID() const noexcept {
        return id;
    }

    [[nodiscard]] inline uint8_t
    getQOS() const noexcept {
        return state.qos;
    }

    [[nodiscard]] inline id_handler_type
    getDestination() const noexcept {
        return dest;
    }

    [[nodiscard]] inline id_handler_type
    getSource() const noexcept {
        return source;
    }

    [[nodiscard]] inline std::size_t
    getSize() const noexcept {
        return static_cast<std::size_t>(bucket_size) * QB_LOCKFREE_EVENT_BUCKET_BYTES;
    }
};

using EventQOS2 = Event;

using EventQOS1 = Event;

struct EventQOS0 : public Event {
    EventQOS0() {
        state.qos = 0;
    }
};

struct ServiceEvent : public Event {
    id_handler_type forward;
    id_type         service_event_id;

    inline void
    received() noexcept {
        std::swap(dest, forward);
        std::swap(id, service_event_id);
        live(true);
    }

    inline void
    live(bool flag) noexcept {
        state.alive = flag;
    }
};

struct KillEvent : public Event {};

struct UnregisterCallbackEvent : public Event {};

struct SignalEvent : public Event {
    int signum;
};

enum class ActorStatus : uint32_t { 
    Alive, 
    Dead 
};

struct PingEvent : public Event {
    const uint32_t type;
 
    explicit PingEvent(uint32_t const actor_type) noexcept
        : type(actor_type) {}
};

struct RequireEvent : public Event {
    const uint32_t    type;
    const ActorStatus status;
 
    explicit RequireEvent(uint32_t const    actor_type,
                          ActorStatus const actor_status) noexcept
        : type(actor_type)
        , status(actor_status) {}
};

template <typename... _Args>
struct WithData : public Event {
    std::tuple<_Args...> data;
 
    explicit WithData(_Args &&...args)
        : data(std::forward<_Args>(args)...) {}
};

template <typename... _Args>
class WithoutData : public Event {};

template <typename... _Args>
struct AskData : public WithoutData<_Args...> {};

template <typename... _Args>
struct FillEvent : public WithData<_Args...> {
    using base_t = WithData<_Args...>;
    FillEvent()  = default;
    explicit FillEvent(_Args &&...args)
        : base_t(std::forward<_Args>(args)...) {}
};

using VirtualPipe   = allocator::pipe<EventBucket>;

using event         = Event;

using service_event = ServiceEvent;
 
} // namespace qb
 
#endif // QB_EVENT_H