Struct LoaderContext 

pub struct LoaderContext<'a, 'b, O: Send + Sync, I: Info> { /* private fields */ }

Context for configuring the plugin loader.

LoaderContext provides a fluent interface for setting up the plugin loader with managers, functions, and requests. It ensures proper initialization order and provides convenient methods for loader configuration.

Type Parameters

• 'a - Lifetime for references within the loader
• 'b - Lifetime of the loader reference
• O - Output type for plugin functions (must implement Send + Sync)
• I - Plugin information type (must implement Info trait)

Fields

• loader - Mutable reference to the underlying loader

Example

use plux_rs::prelude::*;
use plux_custom_manager::CustomManager;

#[plux_rs::function]
fn my_function(_: ()) {
    // Function implementation
}
 
let mut loader = Loader::new();
loader.context(|mut ctx| {
    // Register a manager
    ctx.register_manager(CustomManager::new())?;

    // Register functions and requests
    ctx.register_function(my_function());
    ctx.register_request(Request::new("main".to_string(), vec![], None));

    Ok(())
});

Implementations

impl<'a, 'b, O: Send + Sync, I: Info> LoaderContext<'a, 'b, O, I>

pub fn register_manager<M>( &mut self, manager: M, ) -> Result<(), RegisterManagerError>

where M: Manager<'a, O, I> + 'static,

Registers a plugin manager with the loader.

This method registers a manager that can handle plugins of a specific format.

Parameters

• manager - The manager instance to register

Returns

Returns Result<(), RegisterManagerError> indicating success or failure.

Type Parameters

• M - Type of the manager (must implement Manager trait)

pub fn register_managers<M>( &mut self, managers: M, ) -> Result<(), RegisterManagerError>

where M: IntoIterator<Item = Box<dyn Manager<'a, O, I>>>,

Registers multiple plugin managers with the loader.

This method registers a collection of managers in sequence.

Parameters

• managers - Iterator of manager instances to register

Returns

Returns Result<(), RegisterManagerError> indicating success or failure.

pub fn register_request(&mut self, request: Request)

Registers a function request with the loader.

Function requests define the interface that plugins must implement.

Parameters

• request - The request to register

pub fn register_requests<IT>(&mut self, requests: IT)

where IT: IntoIterator<Item = Request>,

Registers multiple function requests with the loader.

This method registers a collection of requests.

Parameters

• requests - Iterator of requests to register

Type Parameters

• IT - Type of the iterator containing requests

pub fn register_function<F>(&mut self, function: F)

where F: Function<Output = O> + 'static,

Registers a function in the loader’s registry.

Functions registered here are available to all plugins.

Parameters

• function - The function to register

Type Parameters

• F - Type of the function (must implement Function trait)

pub fn register_functions<F, IT>(&mut self, functions: IT)

where F: Function<Output = O> + 'static, IT: IntoIterator<Item = F>,

Registers multiple functions in the loader’s registry.

This method registers a collection of functions.

Parameters

• functions - Iterator of functions to register

Type Parameters

• F - Type of the functions (must implement Function trait)
• IT - Type of the iterator containing functions