Fixed-size event table implementation. More...

#include <driven_table.H>

Inheritance diagram for Static_Event_Table< Signature >:

Collaboration diagram for Static_Event_Table< Signature >:

Public Types
using	Event_Handler = typename Event_Table< Signature >::Event_Handler

Public Types inherited from Event_Table< Signature >
using	Event_Handler = std::function< Signature >

Public Member Functions
size_t	size () const override
	Get table size (implements Event_Table virtual method)

	Static_Event_Table (const size_t num_events=0)
	Construct a static event table with a fixed size.

	Static_Event_Table (const Static_Event_Table &)=delete
	Copying disabled (events may contain non-copyable captures)

Static_Event_Table &	operator= (const Static_Event_Table &)=delete

	Static_Event_Table (Static_Event_Table &&other) noexcept
	Move constructor - transfers ownership of the array.

Static_Event_Table &	operator= (Static_Event_Table &&other) noexcept
	Move assignment - transfers ownership of the array.

	~Static_Event_Table () override=default
	Destructor - automatically frees the underlying array.

Public Member Functions inherited from Event_Table< Signature >
virtual	~Event_Table ()=default
	Virtual destructor for proper cleanup in derived classes.

template<typename Callable >
void	register_event (const size_t index, Callable &&fct)
	Register an event at a specific index.

template<typename Callable >
size_t	register_event (Callable &&fct)
	Append a new event and return its auto-assigned index.

void	unregister_event (const size_t index)
	Unregister an event at the given index.

bool	is_registered (const size_t index) const
	Check if an event is registered at the given index.

template<typename F >
bool	check (const size_t, F) const
	Legacy check method (for backward compatibility).

template<typename... Args>
auto	execute_event (const size_t index, Args &&... args) const
	Execute the event at the given index with type-safe arguments.

Private Member Functions
void	verify_index (const size_t i) const
	Verify index is within valid range.

const Event_Handler *	read_table (const size_t i) const override
	Read event at index (implements Event_Table virtual method)

void	write_table (const size_t i, Event_Handler &&event_fct) override
	Write event at index (implements Event_Table virtual method)

void	clear_slot (size_t i) override
	Clear event at index (implements Event_Table virtual method)

Private Attributes
std::unique_ptr< Event_Handler[]>	table
	Array of event handlers.

size_t	size_table
	Fixed size of the table.

Additional Inherited Members

Detailed Description

template<typename Signature>
class Static_Event_Table< Signature >

Fixed-size event table implementation.

Uses a fixed-size array of event handlers. The size is determined at construction and cannot be changed afterward. Suitable when the number of possible events is known in advance.

Warning: The auto-append overload register_event(fct) (without an explicit index) is not supported on static tables and will always throw range_error. Use register_event(index, fct) instead.

Template Parameters

Signature Function signature for events (e.g., void(int), int(double, bool))