Struct PluginRegistry 

pub struct PluginRegistry { /* private fields */ }

Registry for managing plugins

The PluginRegistry provides centralized management of all registered plugins with thread-safe operations, efficient discovery through indexing, and comprehensive lifecycle management.

Features

• Thread-safe plugin registration and unregistration
• Category-based plugin organization
• Type compatibility indexing for automatic plugin selection
• Metadata caching for fast discovery
• Search functionality by name and description
• Validation and lifecycle management

Examples

use sklears_core::plugin::{PluginRegistry, Plugin, PluginMetadata, PluginCategory};
use sklears_core::error::Result;
use std::any::TypeId;

// Create a registry
let registry = PluginRegistry::new();

// List available plugins
let plugins = registry.list_plugins()?;
println!("Available plugins: {:?}", plugins);

// Search for plugins by category
let algorithms = registry.get_plugins_by_category(&PluginCategory::Algorithm)?;
println!("Algorithm plugins: {:?}", algorithms);

// Find plugins compatible with a specific type
let compatible = registry.get_compatible_plugins(TypeId::of::<f64>())?;
println!("f64-compatible plugins: {:?}", compatible);

Implementations

impl PluginRegistry

pub fn new() -> Self

Create a new plugin registry

Initializes an empty registry with all necessary internal data structures for efficient plugin management and discovery.

Examples

use sklears_core::plugin::PluginRegistry;

let registry = PluginRegistry::new();
assert_eq!(registry.list_plugins().unwrap().len(), 0);

pub fn register(&self, id: &str, plugin: Box<dyn Plugin>) -> Result<()>

Register a plugin in the registry

This method registers a new plugin with the given ID, validates its metadata, and updates all internal indices for efficient discovery.

Arguments

• id - Unique identifier for the plugin
• plugin - The plugin instance to register

Returns

Ok(()) on successful registration, or an error if validation fails or the plugin cannot be registered.

Examples

use sklears_core::plugin::{PluginRegistry, Plugin};

let registry = PluginRegistry::new();
// registry.register("my_plugin", Box::new(my_plugin_instance))?;

pub fn unregister(&self, id: &str) -> Result<()>

Unregister a plugin from the registry

This method removes a plugin from the registry, cleans up its resources, and updates all internal indices.

Arguments

• id - The ID of the plugin to unregister

Returns

Ok(()) on successful unregistration, or an error if the operation fails.

Examples

use sklears_core::plugin::PluginRegistry;

let registry = PluginRegistry::new();
// First register a plugin...
// registry.register("my_plugin", Box::new(my_plugin_instance))?;

// Then unregister it
registry.unregister("my_plugin")?;

pub fn get_plugin(&self, id: &str) -> Result<Arc<RwLock<Box<dyn Plugin>>>>

Get a reference to a plugin by ID

Note: This is a simplified implementation. In practice, you’d want to return a proper reference or handle that manages plugin lifetime.

Arguments

• id - The ID of the plugin to retrieve

Returns

An error in this simplified implementation, as proper plugin access requires careful lifetime management.

pub fn list_plugins(&self) -> Result<Vec<String>>

List all registered plugin IDs

Returns a vector of all plugin IDs currently registered in the system.

Returns

A vector of plugin IDs, or an error if the registry cannot be accessed.

Examples

use sklears_core::plugin::PluginRegistry;

let registry = PluginRegistry::new();
let plugins = registry.list_plugins().unwrap();
assert!(plugins.is_empty()); // No plugins registered yet

pub fn get_plugins_by_category( &self, category: &PluginCategory, ) -> Result<Vec<String>>

Get all plugins in a specific category

Returns all plugin IDs that belong to the specified category.

Arguments

• category - The category to search for

Returns

A vector of plugin IDs in the category, or an error if the index cannot be accessed.

Examples

use sklears_core::plugin::{PluginRegistry, PluginCategory};

let registry = PluginRegistry::new();
let algorithms = registry.get_plugins_by_category(&PluginCategory::Algorithm).unwrap();
assert!(algorithms.is_empty()); // No plugins registered yet

pub fn get_compatible_plugins(&self, type_id: TypeId) -> Result<Vec<String>>

Get plugins compatible with a specific data type

Returns all plugin IDs that declare compatibility with the given TypeId.

Arguments

• type_id - The TypeId to check compatibility for

Returns

A vector of compatible plugin IDs, or an error if the index cannot be accessed.

Examples

use sklears_core::plugin::PluginRegistry;
use std::any::TypeId;

let registry = PluginRegistry::new();
let compatible = registry.get_compatible_plugins(TypeId::of::<f64>()).unwrap();
assert!(compatible.is_empty()); // No plugins registered yet

pub fn get_metadata(&self, id: &str) -> Result<PluginMetadata>

Get metadata for a specific plugin

Returns the cached metadata for the plugin with the given ID.

Arguments

• id - The ID of the plugin

Returns

The plugin’s metadata, or an error if the plugin is not found.

Examples

use sklears_core::plugin::PluginRegistry;

let registry = PluginRegistry::new();
// First register a plugin...
// registry.register("my_plugin", Box::new(my_plugin_instance))?;

// Then get its metadata
let metadata = registry.get_metadata("my_plugin")?;
println!("Plugin: {} v{}", metadata.name, metadata.version);

pub fn search_plugins(&self, query: &str) -> Result<Vec<String>>

Search plugins by name or description

Performs a case-insensitive search through plugin names and descriptions for the given query string.

Arguments

• query - The search query string

Returns

A vector of plugin IDs that match the search query, or an error if the search cannot be performed.

Examples

use sklears_core::plugin::PluginRegistry;

let registry = PluginRegistry::new();
// Register some plugins first...

// Search for plugins
let matches = registry.search_plugins("regression")?;
println!("Found regression plugins: {:?}", matches);

pub fn get_statistics(&self) -> Result<HashMap<String, usize>>

Get registry statistics

Returns information about the current state of the registry.

Returns

A HashMap with statistics about the registry.

pub fn is_registered(&self, id: &str) -> bool

Check if a plugin is registered

Arguments

• id - The plugin ID to check

Returns

true if the plugin is registered, false otherwise.

pub fn plugin_count(&self) -> usize

Get the number of registered plugins

Returns

The number of currently registered plugins.

Trait Implementations

impl Clone for PluginRegistry

fn clone(&self) -> Self

Clone the registry (creates a new registry with the same structure but empty)

Note: This doesn’t clone the actual plugins, just the registry structure. This is because plugins contain trait objects that can’t be easily cloned.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PluginRegistry

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for PluginRegistry

fn default() -> Self

Returns the “default value” for a type.

impl ExperimentalApi for PluginRegistry

const INTRODUCED_IN: &'static str = "0.1.0"

API version this type was introduced in

const STABILIZATION_TARGET: Option<&'static str>

Expected version when this API will be stabilized

const KNOWN_LIMITATIONS: &'static [&'static str]

Known limitations or issues with this API