helios::ecs::details::EventQueue Class Reference

Queue for managing multiple event types. More...

#include <event_queue.hpp>

Public Member Functions
	EventQueue ()=default
	EventQueue (const EventQueue &)=delete
	EventQueue (EventQueue &&) noexcept=default
	~EventQueue ()=default
EventQueue &	operator= (const EventQueue &)=delete
EventQueue &	operator= (EventQueue &&) noexcept=default
template<EventTrait T>
void	Register ()
	Registers an event type with the queue.
void	Clear () noexcept
	Clears all events from the queue and removes registrations.
void	ClearData () noexcept
	Clears all event data but preserves registrations.
template<EventTrait T>
void	Clear ()
	Clears events of a specific type.
void	ClearByTypeId (EventTypeId type_id)
	Clears events of a specific type by type ID (runtime).
void	Merge (EventQueue &other)
	Merges events from another EventQueue into this one.
template<EventTrait T>
void	Write (const T &event)
	Writes a single event to the queue.
template<std::ranges::sized_range R> requires EventTrait<std::ranges::range_value_t<R>>
void	WriteBulk (const R &events)
	Writes multiple events to the queue in bulk.
template<EventTrait T>
auto	Read () const -> std::span< const T >
	Reads all events of a specific type from the queue.
template<EventTrait T, typename OutIt > requires std::output_iterator<OutIt, T>
void	ReadInto (OutIt out) const
	Reads events of a specific type into a provided output iterator.
template<EventTrait T>
bool	IsRegistered () const
	Checks if an event type is registered.
template<EventTrait T>
bool	HasEvents () const
	Checks if events of a specific type exist in the queue.
bool	Empty () const noexcept
	Checks if the queue is empty.
size_t	TypeCount () const noexcept
	Gets the number of event types stored.
size_t	TotalSizeBytes () const noexcept
	Gets the total size of all stored events in bytes.

Detailed Description

Queue for managing multiple event types.

Uses an unordered_map to store EventStorage for each event type, allowing efficient type-based event management. Events can be written and read in batches for better performance.

Note

Not thread-safe.

Definition at line 27 of file event_queue.hpp.

Constructor & Destructor Documentation

EventQueue() [1/3]

helios::ecs::details::EventQueue::EventQueue ( )

default

EventQueue() [2/3]

helios::ecs::details::EventQueue::EventQueue ( const EventQueue &  )

delete

EventQueue() [3/3]

helios::ecs::details::EventQueue::EventQueue ( EventQueue &&  )

defaultnoexcept

~EventQueue()

helios::ecs::details::EventQueue::~EventQueue ( )

default

Member Function Documentation

Clear() [1/2]

template<EventTrait T>

void helios::ecs::details::EventQueue::Clear ( )

inline

Clears events of a specific type.

Warning

Triggers assertion if event type is not registered.

Template Parameters

T	Event type

Definition at line 164 of file event_queue.hpp.

                              {
  constexpr EventTypeId type_id = EventTypeIdOf<T>();
  HELIOS_ASSERT(IsRegistered<T>(), "Failed to clear events: Event type '{}' is not registered!", EventNameOf<T>());
  storages_.at(type_id).Clear();
}

Clear() [2/2]

void helios::ecs::details::EventQueue::Clear ( )

inlinenoexcept

Clears all events from the queue and removes registrations.

Definition at line 47 of file event_queue.hpp.

{ storages_.clear(); }

ClearByTypeId()

void helios::ecs::details::EventQueue::ClearByTypeId ( EventTypeId  type_id )

inline

Clears events of a specific type by type ID (runtime).

Warning

Triggers assertion if event type does not exist.

Parameters

type_id

Type identifier of events to clear

Definition at line 176 of file event_queue.hpp.

                                                         {
  if (const auto it = storages_.find(type_id); it != storages_.end()) {
    it->second.Clear();
  }
}

ClearData()

void helios::ecs::details::EventQueue::ClearData ( )

inlinenoexcept

Clears all event data but preserves registrations.

Use this when you want to clear events without losing type registrations.

Definition at line 170 of file event_queue.hpp.

                                           {
  for (auto& [_, storage] : storages_) {
    storage.Clear();
  }
}

Empty()

bool helios::ecs::details::EventQueue::Empty ( ) const

inlinenoexcept

Checks if the queue is empty.

Returns

True if no events are stored, false otherwise

Definition at line 135 of file event_queue.hpp.

                                            {
    return std::ranges::all_of(storages_, [](const auto& pair) { return pair.second.Empty(); });
  }

HasEvents()

template<EventTrait T>

bool helios::ecs::details::EventQueue::HasEvents ( ) const

inline

Checks if events of a specific type exist in the queue.

Template Parameters

T	Event type

Returns

True if events of type T exist, false otherwise

Definition at line 245 of file event_queue.hpp.

                                        {
  constexpr EventTypeId type_id = EventTypeIdOf<T>();
  const auto it = storages_.find(type_id);
  return it != storages_.end() && !it->second.Empty();
}

IsRegistered()

template<EventTrait T>

bool helios::ecs::details::EventQueue::IsRegistered ( ) const

inline

Checks if an event type is registered.

Template Parameters

T	Event type

Returns

True if the event type is registered, false otherwise

Definition at line 252 of file event_queue.hpp.

                                           {
  constexpr EventTypeId type_id = EventTypeIdOf<T>();
  return storages_.contains(type_id);
}

Merge()

void helios::ecs::details::EventQueue::Merge ( EventQueue &  other )

inline

Merges events from another EventQueue into this one.

Parameters

other

EventQueue to merge from

Definition at line 182 of file event_queue.hpp.

                                               {
  for (auto& [type_id, other_storage] : other.storages_) {
    if (other_storage.Empty()) {
      continue;
    }
 
    if (const auto it = storages_.find(type_id); it == storages_.end()) {
      // If we don't have this type registered, move the entire storage
      storages_.emplace(type_id, std::move(other_storage));
    } else {
      auto& this_storage = it->second;
      if (this_storage.Empty()) {
        // If our storage is empty, just move the other storage
        this_storage = std::move(other_storage);
      } else {
        // Append raw bytes from other storage to this storage
        this_storage.AppendRawBytes(other_storage.Data());
      }
    }
  }
}

operator=() [1/2]

EventQueue & helios::ecs::details::EventQueue::operator= ( const EventQueue &  )

delete

operator=() [2/2]

EventQueue & helios::ecs::details::EventQueue::operator= ( EventQueue &&  )

defaultnoexcept

Read()

template<EventTrait T>

auto helios::ecs::details::EventQueue::Read ( ) const -> std::span<const T>

inline

Reads all events of a specific type from the queue.

Warning

Span gets invalidated if storage is modified.

Template Parameters

T	Event type

Returns

Span containing all events of type T

Definition at line 222 of file event_queue.hpp.

                                                       {
  constexpr EventTypeId type_id = EventTypeIdOf<T>();
  const auto it = storages_.find(type_id);
  if (it == storages_.end()) {
    return {};
  }
 
  return it->second.ReadAll<T>();
}

ReadInto()

template<EventTrait T, typename OutIt >
requires std::output_iterator<OutIt, T>

void helios::ecs::details::EventQueue::ReadInto ( OutIt  out ) const

inline

Reads events of a specific type into a provided output iterator.

Warning

Triggers assertion if event type is not registered.

Template Parameters

T	Event type
OutIt	Output iterator type

Parameters

out	Output iterator to write events into

Definition at line 234 of file event_queue.hpp.

                                                {
  constexpr EventTypeId type_id = EventTypeIdOf<T>();
  const auto it = storages_.find(type_id);
  if (it == storages_.end()) {
    return;
  }
 
  it->second.ReadInto<T>(std::move(out));
}

Register()

template<EventTrait T>

void helios::ecs::details::EventQueue::Register ( )

inline

Registers an event type with the queue.

Template Parameters

T	Event type

Definition at line 156 of file event_queue.hpp.

                                 {
  constexpr EventTypeId type_id = EventTypeIdOf<T>();
  if (!storages_.contains(type_id)) {
    storages_.emplace(type_id, EventStorage::FromEvent<T>());
  }
}

TotalSizeBytes()

size_t helios::ecs::details::EventQueue::TotalSizeBytes ( ) const

inlinenoexcept

Gets the total size of all stored events in bytes.

Returns

Total size in bytes

Definition at line 257 of file event_queue.hpp.

                                                        {
  size_t total = 0;
  for (const auto& [_, storage] : storages_) {
    total += storage.SizeBytes();
  }
  return total;
}

TypeCount()

size_t helios::ecs::details::EventQueue::TypeCount ( ) const

inlinenoexcept

Gets the number of event types stored.

Returns

Number of distinct event types

Definition at line 143 of file event_queue.hpp.

{ return storages_.size(); }

Write()

template<EventTrait T>

void helios::ecs::details::EventQueue::Write ( const T &  event )

inline

Writes a single event to the queue.

Warning

Triggers assertion if event type is not registered.

Template Parameters

T	Event type

Parameters

event

Event to store

Definition at line 205 of file event_queue.hpp.

                                            {
  constexpr EventTypeId type_id = EventTypeIdOf<T>();
  HELIOS_ASSERT(IsRegistered<T>(), "Failed to write event: Event type '{}' is not registered!", EventNameOf<T>());
  storages_.at(type_id).Write(event);
}

WriteBulk()

template<std::ranges::sized_range R>
requires EventTrait<std::ranges::range_value_t<R>>

void helios::ecs::details::EventQueue::WriteBulk ( const R &  events )

inline

Writes multiple events to the queue in bulk.

Warning

Triggers assertion if event type is not registered.

Template Parameters

R	Range of events

Parameters

events

Range of events to store

Definition at line 213 of file event_queue.hpp.

                                                 {
  using EventType = std::ranges::range_value_t<R>;
  constexpr EventTypeId type_id = EventTypeIdOf<EventType>();
  HELIOS_ASSERT(IsRegistered<EventType>(), "Failed to write events bulk: Event type '{}' is not registered!",
                EventNameOf<EventType>());
  storages_.at(type_id).WriteBulk(events);
}