helios::ecs::details::EventStorage Class Reference

Type-erased storage for events using a byte vector. More...

#include <event_storage.hpp>

Public Member Functions
	EventStorage (size_t event_size)
	Constructs an EventStorage.
	EventStorage (const EventStorage &)=delete
	EventStorage (EventStorage &&) noexcept=default
	~EventStorage ()=default
EventStorage &	operator= (const EventStorage &)=delete
EventStorage &	operator= (EventStorage &&) noexcept=default
void	Clear () noexcept
	Clears all stored events.
void	Reserve (size_t capacity_bytes)
	Reserves space for events.
template<EventTrait T>
void	Write (const T &event)
	Writes a single event to storage.
template<std::ranges::sized_range R> requires EventTrait<std::ranges::range_value_t<R>>
void	WriteBulk (const R &events)
	Writes multiple events to storage in bulk.
template<EventTrait T>
auto	ReadAll () const noexcept -> std::span< const T >
	Reads all events from storage.
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.
void	AppendRawBytes (std::span< const std::byte > data)
	Appends raw bytes from another EventStorage.
bool	Empty () const noexcept
	Checks if storage is empty.
size_t	SizeBytes () const noexcept
	Gets the size of stored data in bytes.
auto	Data () const noexcept -> std::span< const std::byte >
	Gets raw data (const).
size_t	EventSize () const noexcept
	Gets the size of each event in bytes.

Static Public Member Functions
template<EventTrait T>
static EventStorage	FromEvent ()
	Creates an EventStorage for a specific event type.

Detailed Description

Type-erased storage for events using a byte vector.

Stores events as raw bytes and provides methods to write/read events with proper type safety through. Events are stored sequentially with their size information for proper deserialization.

Note

Not thread-safe.

Definition at line 25 of file event_storage.hpp.

Constructor & Destructor Documentation

EventStorage() [1/3]

helios::ecs::details::EventStorage::EventStorage ( size_t  event_size )

inlineexplicit

Constructs an EventStorage.

Parameters

event_size

Size of each event in bytes

Definition at line 31 of file event_storage.hpp.

: event_size_(event_size) {};

EventStorage() [2/3]

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

delete

EventStorage() [3/3]

helios::ecs::details::EventStorage::EventStorage ( EventStorage &&  )

defaultnoexcept

~EventStorage()

helios::ecs::details::EventStorage::~EventStorage ( )

default

Member Function Documentation

AppendRawBytes()

void helios::ecs::details::EventStorage::AppendRawBytes ( std::span< const std::byte >  data )

inline

Appends raw bytes from another EventStorage.

Parameters

data	Pointer to raw byte data

Definition at line 197 of file event_storage.hpp.

                                                                    {
  if (data.empty()) [[unlikely]] {
    return;
  }
 
  const size_t old_size = data_.size();
  data_.resize(old_size + data.size());
  std::memcpy(data_.data() + old_size, data.data(), data.size());
}

Clear()

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

inlinenoexcept

Clears all stored events.

Definition at line 52 of file event_storage.hpp.

{ data_.clear(); }

Data()

auto helios::ecs::details::EventStorage::Data ( ) const -> std::span<const std::byte>

inlinenoexcept

Gets raw data (const).

Returns

Pointer to raw byte data

Definition at line 123 of file event_storage.hpp.

{ return {data_.data(), data_.size()}; }

Empty()

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

inlinenoexcept

Checks if storage is empty.

Returns

True if no events are stored, false otherwise

Definition at line 111 of file event_storage.hpp.

{ return data_.empty(); }

EventSize()

size_t helios::ecs::details::EventStorage::EventSize ( ) const

inlinenoexcept

Gets the size of each event in bytes.

Returns

Event size in bytes

Definition at line 129 of file event_storage.hpp.

{ return event_size_; }

FromEvent()

template<EventTrait T>

static EventStorage helios::ecs::details::EventStorage::FromEvent ( )

inlinestatic

Creates an EventStorage for a specific event type.

Template Parameters

T	Event type

Returns

EventStorage configured for the event type

Definition at line 42 of file event_storage.hpp.

                                                {
    return EventStorage(sizeof(T));
  }

operator=() [1/2]

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

delete

operator=() [2/2]

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

defaultnoexcept

ReadAll()

template<EventTrait T>

auto helios::ecs::details::EventStorage::ReadAll ( ) const -> std::span<const T>

inlinenoexcept

Reads all events from storage.

Warning

Triggers assertion if event size doesn't match storage event size. Span gets invalidated if storage is modified.

Template Parameters

T	Event type

Returns

Span containing all events

Definition at line 169 of file event_storage.hpp.

                                                                     {
  constexpr size_t event_size = sizeof(T);
  HELIOS_ASSERT(event_size == event_size_, "Failed to write event: Event size misatch, expected '{}', got '{}'!",
                event_size_, event_size);
 
  const auto* begin = std::bit_cast<const T*>(data_.data());
  const auto* end = std::bit_cast<const T*>(data_.data() + data_.size());
  return {begin, end};
}

ReadInto()

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

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

inline

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

Note

Thread-safe for read operations.

Warning

Triggers assertion if event size doesn't match storage event size.

Template Parameters

T	Event type
OutIt	Output iterator type

Parameters

out	Output iterator to write events into

Definition at line 181 of file event_storage.hpp.

                                                  {
  constexpr size_t event_size = sizeof(T);
  HELIOS_ASSERT(event_size == event_size_, "Failed to write event: Event size misatch, expected '{}', got '{}'!",
                event_size_, event_size);
 
  size_t offset = 0;
  while (offset < data_.size()) {
    // Read event data using memcpy (safe for trivially copyable types)
    T event;
    std::memcpy(&event, data_.data() + offset, event_size);
    *out++ = std::move(event);
 
    offset += event_size;
  }
}

Reserve()

void helios::ecs::details::EventStorage::Reserve ( size_t  capacity_bytes )

inline

Reserves space for events.

Parameters

capacity_bytes

Capacity to reserve in bytes

Definition at line 58 of file event_storage.hpp.

{ data_.reserve(capacity_bytes); }

SizeBytes()

size_t helios::ecs::details::EventStorage::SizeBytes ( ) const

inlinenoexcept

Gets the size of stored data in bytes.

Returns

Size in bytes

Definition at line 117 of file event_storage.hpp.

{ return data_.size(); }

Write()

template<EventTrait T>

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

inline

Writes a single event to storage.

Warning

Triggers assertion if event size doesn't match storage event size.

Template Parameters

T	Event type

Parameters

event

Event to store

Definition at line 137 of file event_storage.hpp.

                                              {
  constexpr size_t event_size = sizeof(T);
  HELIOS_ASSERT(event_size == event_size_, "Failed to write event: Event size misatch, expected '{}', got '{}'!",
                event_size_, event_size);
 
  const size_t old_size = data_.size();
  data_.resize(old_size + event_size);
  std::memcpy(data_.data() + old_size, &event, event_size);
}

WriteBulk()

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

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

inline

Writes multiple events to storage in bulk.

Warning

Triggers assertion if event size doesn't match storage event size.

Template Parameters

R	Range of events

Parameters

events

Range of events to store

Definition at line 149 of file event_storage.hpp.

                                                   {
  using EventType = std::ranges::range_value_t<R>;
  constexpr size_t event_size = sizeof(EventType);
  HELIOS_ASSERT(event_size == event_size_, "Failed to write events bulk: Event size misatch, expected '{}', got '{}'!",
                event_size_, event_size);
 
  const size_t old_size = data_.size();
  const size_t total_bytes = events.size() * event_size;
 
  data_.resize(old_size + total_bytes);
 
  size_t offset = old_size;
  for (const auto& event : events) {
    // Write event data using memcpy (safe for trivially copyable types)
    std::memcpy(data_.data() + offset, &event, event_size);
    offset += event_size;
  }
}