Struct HandlerRegistry 

pub struct HandlerRegistry { /* private fields */ }

Zero-overhead handler registry with O(1) average-case lookup.

The registry uses FxHash (2x faster than SipHash for small keys) for efficient handler dispatch. It provides type-safe handler registration and JSON-based dispatch.

Performance

• Lookup: O(1) average-case using FxHash
• Dispatch: <1μs target (hot path)
• Memory: ~256 bytes per registered handler

Examples

use pforge_runtime::{Handler, HandlerRegistry, Result};
use serde::{Deserialize, Serialize};
use schemars::JsonSchema;

#[derive(Debug, Deserialize, JsonSchema)]
struct Input { value: i32 }

#[derive(Debug, Serialize, JsonSchema)]
struct Output { result: i32 }

struct DoubleHandler;

#[async_trait::async_trait]
impl Handler for DoubleHandler {
    type Input = Input;
    type Output = Output;
    type Error = pforge_runtime::Error;

    async fn handle(&self, input: Self::Input) -> Result<Self::Output> {
        Ok(Output { result: input.value * 2 })
    }
}

let mut registry = HandlerRegistry::new();
registry.register("double", DoubleHandler);

// Dispatch with JSON
let input = serde_json::json!({"value": 21});
let result_bytes = registry.dispatch("double", &serde_json::to_vec(&input)?).await?;
let result: serde_json::Value = serde_json::from_slice(&result_bytes)?;
assert_eq!(result["result"], 42);

Implementations

impl HandlerRegistry

pub fn new() -> Self

Create new empty registry

pub fn register<H>(&mut self, name: impl Into<String>, handler: H)

where H: Handler, H::Input: 'static, H::Output: 'static,

Register a handler with a name

pub fn has_handler(&self, name: &str) -> bool

Check if handler exists

pub async fn dispatch(&self, tool: &str, params: &[u8]) -> Result<Vec<u8>>

Dispatch to a handler by name

pub fn len(&self) -> usize

Get number of registered handlers

pub fn is_empty(&self) -> bool

Check if registry is empty

pub fn get_input_schema(&self, tool: &str) -> Option<RootSchema>

Get input schema for a tool

pub fn get_output_schema(&self, tool: &str) -> Option<RootSchema>

Get output schema for a tool

Trait Implementations

impl Default for HandlerRegistry

fn default() -> Self

Returns the “default value” for a type.