Abstract plugin interface that provides its own MessageLoop event thread. More...

#include <runnable_plugin_interface.h>

Inheritance diagram for vlink::RunablePluginInterface:

Collaboration diagram for vlink::RunablePluginInterface:

Public Member Functions
virtual void	on_init ()=0
	Called by the host after the plugin's event loop has started.
virtual void	on_deinit ()=0
	Called by the host before the plugin is unloaded.
Public Member Functions inherited from vlink::MessageLoop
	MessageLoop ()
	Constructs a `MessageLoop` with `kNormalType` queue.
	MessageLoop (Type type)
	Constructs a `MessageLoop` with the specified queue type.
virtual	~MessageLoop ()
	Destructor. Calls `quit(true)` and waits for the background thread (if any).
void	set_name (const std::string &name)
	Sets a human-readable name for this loop (visible in profiling tools).
const std::string &	get_name () const
	Returns the name set via `set_name()`.
Type	get_type () const
	Returns the queue type this loop was constructed with.
Strategy	get_strategy () const
	Returns the current idle dispatch strategy.
void	set_strategy (Strategy strategy)
	Changes the idle dispatch strategy.
void	register_begin_handler (Callback &&callback)
	Registers a callback invoked once when the loop thread starts.
void	register_end_handler (Callback &&callback)
	Registers a callback invoked once when the loop thread exits.
void	register_idle_handler (Callback &&callback)
	Registers a callback invoked each time the task queue becomes empty.
bool	run ()
	Runs the message loop on the calling thread (blocking).
bool	async_run ()
	Starts the message loop on a new background thread (non-blocking).
bool	spin ()
	Runs the loop continuously in a spin mode (blocking; no background thread).
bool	spin_once (bool block=true)
	Processes one batch of pending tasks and timers.
bool	quit (bool force=false)
	Requests the loop to exit cleanly.
bool	wait_for_idle (int ms=Timer::kInfinite, bool check=true)
	Waits until the task queue is drained.
bool	wait_for_quit (int ms=Timer::kInfinite, bool check=true)
	Waits until the loop has fully exited (after `quit()` was called).
bool	post_task (Callback &&callback)
	Posts a task to the queue for execution on the loop thread.
bool	post_task_with_priority (Callback &&callback, uint16_t priority)
	Posts a task with an explicit priority (requires `kPriorityType` loop).
template<typename CallbackT, typename = std::enable_if_t<!std::is_convertible_v<CallbackT, Schedule::RetCallback>>>
Schedule::Status	exec_task (const Schedule::Config &config, CallbackT &&callback)
	Posts a scheduled task and returns a `Schedule::Status` for chaining callbacks.
template<typename CallbackT, typename = std::enable_if_t<std::is_convertible_v<CallbackT, Schedule::RetCallback>>>
Schedule::RetStatus	exec_task (const Schedule::Config &config, CallbackT &&callback)
	Posts a scheduled task and returns a `Schedule::RetStatus` for chaining callbacks.
bool	wakeup ()
	Wakes the loop thread if it is sleeping (e.g., in `kBlockStrategy`).
void	reset_lockfree_capacity ()
	Resets the lock-free queue to its initial capacity.
bool	is_running () const
	Returns `true` if the loop is currently running (started and not quit).
bool	is_ready_to_quit () const
	Returns `true` if `quit()` has been called and the loop is winding down.
bool	is_busy () const
	Returns `true` if the loop is currently executing a task.
size_t	get_task_count () const
	Returns the number of tasks currently in the queue.
virtual size_t	get_max_task_count () const
	Returns the maximum queue depth.
virtual size_t	get_max_timer_count () const
	Returns the maximum number of timers that can be attached to this loop.
virtual uint32_t	get_max_elapsed_time () const
	Returns the maximum allowed task execution time in milliseconds.
virtual bool	is_in_same_thread () const
	Returns `true` if the calling thread is the same as the loop thread.
template<class FunctionT, class... ArgsT, typename ResultT = std::invoke_result_t<FunctionT, ArgsT...>>
std::future< ResultT >	invoke_task (FunctionT &&function, ArgsT &&... args)
	Dispatches a callable to the loop thread and returns a `std::future` for the result.
template<class FunctionT, class... ArgsT, typename ResultT = std::invoke_result_t<FunctionT, ArgsT...>>
std::future< ResultT >	invoke_task_with_priority (FunctionT &&function, uint16_t priority, ArgsT &&... args)
	Dispatches a callable with an explicit priority and returns a `std::future`.

Protected Member Functions
	RunablePluginInterface ()=default
	~RunablePluginInterface () override=default
Protected Member Functions inherited from vlink::MessageLoop
virtual void	on_begin ()
	Called from the loop thread just before the first task is processed.
virtual void	on_end ()
	Called from the loop thread just after the last task has been processed.
virtual void	on_idle ()
	Called from the loop thread each time the queue becomes empty.
virtual void	on_task_changed (Callback &&callback, uint32_t start_time)
	Called before each task is executed.
virtual void	on_task_timeout (Callback &&callback, uint32_t elapsed_time)
	Called when a task's execution time exceeds `get_max_elapsed_time()`.

Additional Inherited Members
Public Types inherited from vlink::MessageLoop
enum	Type : uint8_t { kNormalType = 0 , kLockfreeType = 1 , kPriorityType = 2 }
	Queue implementation type. More...
enum	Strategy : uint8_t { kOptimizationStrategy = 0 , kPopStrategy = 1 , kBlockStrategy = 2 }
	Idle strategy controlling CPU and latency trade-offs. More...
enum	Priority : uint16_t { kNoPriority = 0 , kLowestPriority = 1 , kTimerPriority = 50 , kNormalPriority = 100 , kHighestPriority = std::numeric_limits<uint16_t>::max() }
	Pre-defined task priority levels for `kPriorityType` loops. More...
using	Callback = std::function<void()>
	Callback type for tasks and event handlers.

Detailed Description

Abstract plugin interface that provides its own MessageLoop event thread.

The plugin owns a MessageLoop and implements on_init() / on_deinit() for lifecycle management. The host is responsible for calling async_run() after loading.

Constructor & Destructor Documentation

◆ RunablePluginInterface()

vlink::RunablePluginInterface::RunablePluginInterface ( )

protecteddefault

Here is the caller graph for this function:

◆ ~RunablePluginInterface()

vlink::RunablePluginInterface::~RunablePluginInterface ( )

overrideprotecteddefault

Member Function Documentation

◆ on_deinit()

virtual void vlink::RunablePluginInterface::on_deinit ( )

pure virtual

Called by the host before the plugin is unloaded.

Implement this method to release all resources, cancel timers, and unsubscribe. After this call, the host will stop the event loop and unload the plugin.

Here is the call graph for this function:

◆ on_init()

virtual void vlink::RunablePluginInterface::on_init ( )

pure virtual

Called by the host after the plugin's event loop has started.

Implement this method to create subscribers, timers, and other resources that require the loop to be running. This method is called on the caller's thread.

The documentation for this class was generated from the following file:

include/vlink/extension/runnable_plugin_interface.h

Public Member Functions

Protected Member Functions