Dynamic (growable) event table implementation. More...

#include <driven_table.H>

Inheritance diagram for Dynamic_Event_Table< Signature >:

Collaboration diagram for Dynamic_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 the current table size (implements Event_Table virtual method)

	Dynamic_Event_Table (const size_t num_events=0)
	Construct a dynamic event table.

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

Dynamic_Event_Table &	operator= (const Dynamic_Event_Table &)=delete

	Dynamic_Event_Table (Dynamic_Event_Table &&) noexcept=default
	Move constructor.

Dynamic_Event_Table &	operator= (Dynamic_Event_Table &&) noexcept=default
	Move assignment.

	~Dynamic_Event_Table () override=default
	Default destructor.

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
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
DynArray< Event_Handler >	table
	Dynamic array of event handlers.

Additional Inherited Members

Detailed Description

template<typename Signature>
class Dynamic_Event_Table< Signature >

Dynamic (growable) event table implementation.

Uses a dynamic array that can grow as events are added. Suitable when the number of events is not known in advance or when events are added dynamically at runtime.

Template Parameters

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

Memory Management

Backed by DynArray (automatic memory management)
Moveable (events may contain non-copyable captures)
Automatically grows when events are appended beyond current size

Growth Strategy

When appending beyond current size, the underlying DynArray grows according to its own growth strategy (typically doubling capacity).

Complexity

Space: O(n) where n is current size
register_event (at end): O(1) amortized
register_event (at index): O(1)
unregister_event: O(1)
execute_event: O(1)

Example: Dynamic_Event_Table<void(int)> table; // starts empty

// Events can be added dynamically (lambdas, functions, etc.)

auto id1 = table.register_event([](int x) { std::cout << x << "\n"; });

auto id2 = table.register_event([](int x) { std::cout << x * 2 << "\n"; });

table.execute_event(id1, 42); // prints 42

table.execute_event(id2, 21); // prints 42

Dynamic_Event_Table
Dynamic (growable) event table implementation.
Definition driven_table.H:515

Dynamic_Event_Table::table
DynArray< Event_Handler > table
Dynamic array of event handlers.
Definition driven_table.H:520

Aleph::maps
DynList< T > maps(const C &c, Op op)
Classic map operation.
Definition ahFunctional.H:693