Struct FunctionRegistry

pub struct FunctionRegistry { /* private fields */ }

Registry for managing function handlers.

The function registry maintains a collection of named function handlers that can be called during expression evaluation. It supports both standalone functions and methods called on values.

This registry is a thread-safe singleton that ensures one-time initialization with all built-in functions registered.

Implementations

impl FunctionRegistry

pub fn get_instance() -> &'static RwLock<Self>

Get the global singleton instance of the function registry.

This method uses OnceLock to ensure thread-safe one-time initialization of the function registry with all built-in functions registered. Uses RwLock to allow multiple concurrent readers while ensuring exclusive access during writes.

Returns

Returns a reference to the RwLock-protected singleton function registry.

Example

use aimx::function_registry::FunctionRegistry;

let registry = FunctionRegistry::get_instance();
// Typically you'd use read_lock() or write_lock() instead of accessing directly

pub fn read_lock() -> Result<RwLockReadGuard<'static, Self>>

Get a read lock on the function registry for function calls.

This is a convenience method that returns a read guard, allowing multiple concurrent function calls without blocking each other.

Returns

Returns a Result containing the read guard or an error if the lock is poisoned.

Example

use aimx::function_registry::FunctionRegistry;

let registry = FunctionRegistry::read_lock().unwrap();
// Use registry for function calls

pub fn write_lock() -> Result<RwLockWriteGuard<'static, Self>>

Get a write lock on the function registry for registration.

This is a convenience method that returns a write guard, providing exclusive access for registering new functions.

Returns

Returns a Result containing the write guard or an error if the lock is poisoned.

Example

use aimx::{function_registry::FunctionRegistry, define_direct_function};

let mut registry = FunctionRegistry::write_lock().unwrap();
define_direct_function!(
    custom_func,
    args: [f64],
    |x: f64| x * 2.0
)(&mut *registry);
// Drop the lock to allow other threads to access the registry

pub fn register<F>(&mut self, name: String, handler: F)

where F: FunctionHandler + 'static,

Register a function handler with the given name.

Arguments

• name - The name to register the function under
• handler - The function handler implementation

Example

use aimx::function_registry::{FunctionRegistry, FunctionHandler};
use aimx::{ContextLike, Value, Literal};
use anyhow::Result;

struct CustomHandler;
 
impl FunctionHandler for CustomHandler {
    fn call(&self, context: &mut dyn ContextLike, args: &[Value]) -> Result<Value> {
        Ok(Value::from(42.0))
    }
}
 
// In practice, you would typically register functions through the write_lock() method
// This example shows the trait implementation for documentation purposes

pub fn function_call( &self, context: &mut dyn ContextLike, name: &str, arg: Value, ) -> Result<Value>

Call a standalone function with the given name and argument.

This method handles flattening array arguments into individual arguments before passing them to the function handler.

Arguments

• context - The evaluation context for closures
• name - The name of the function to call
• arg - The argument(s) to pass to the function (can be Empty, Literal, or Array)

Returns

Returns a Result<Value> containing the function result or an error if the function is not found or execution fails.

Example

// Call a function with a single argument
let result = registry.function_call(&mut context, "abs", Value::from(-5.0));

// Call a function with multiple arguments as an array
let args = Value::Array(vec![
    Box::new(Value::from(2.0)),
    Box::new(Value::from(3.0))
]);
let result = registry.function_call(&mut context, "pow", args);

pub fn method_call( &self, context: &mut dyn ContextLike, name: &str, value: Value, arg: Value, ) -> Result<Value>

Call a method on a value with the given name and argument.

This method passes the target value as the first argument to the function handler, followed by any additional arguments.

Arguments

• context - The evaluation context for closures
• name - The name of the method to call
• value - The value on which to call the method
• arg - The argument(s) to pass to the method (can be Empty, Literal, or Array)

Returns

Returns a Result<Value> containing the method result or an error if the method is not found or execution fails.

Example

// Call a method on an array value
let array_value = Value::Array(vec![
    Box::new(Value::from(1.0)),
    Box::new(Value::from(2.0)),
    Box::new(Value::from(3.0))
]);
let result = registry.method_call(&mut context, "sum", array_value, Value::Array(vec![]));