Struct PluginRegistry 

pub struct PluginRegistry {
    pub registry: Registry,
    pub handlers: HandlerRegistry,
    pub current_prefix: Option<String>,
    pub capabilities: CapabilityRegistry,
    pub const_coercers: Arc<RwLock<HashMap<&'static str, Box<dyn Fn(&Value) -> Option<Box<dyn Any + Sync + Send>> + Sync + Send>>>>,
    pub output_movers: Arc<RwLock<HashMap<TypeId, Box<dyn Fn(Box<dyn Any + Sync + Send>) -> EdgePayload + Sync + Send>>>>,
    pub type_compatibilities: BTreeSet<(TypeExpr, TypeExpr)>,
}

Container for descriptors + handlers. All nodes are installed via plugins.

Fields

registry: Registry

handlers: HandlerRegistry

current_prefix: Option<String>

capabilities: CapabilityRegistry

const_coercers: Arc<RwLock<HashMap<&'static str, Box<dyn Fn(&Value) -> Option<Box<dyn Any + Sync + Send>> + Sync + Send>>>>

output_movers: Arc<RwLock<HashMap<TypeId, Box<dyn Fn(Box<dyn Any + Sync + Send>) -> EdgePayload + Sync + Send>>>>

type_compatibilities: BTreeSet<(TypeExpr, TypeExpr)>

Implementations

impl PluginRegistry

pub fn new() -> PluginRegistry

pub fn merge<N>(&mut self) -> Result<(), &'static str>

where N: NodeInstall,

pub fn take_handlers(&mut self) -> HandlerRegistry

pub fn register_conversion<S, T>(&mut self, f: fn(&S) -> Option<T>)

where S: 'static + Send + Sync + Any, T: 'static + Send + Sync + Any,

Register an application-specific CPU-side conversion (available to all nodes).

pub fn register_const_coercer<T, F>(&mut self, coercer: F)

where T: Any + Send + Sync + 'static, F: Fn(&Value) -> Option<T> + Send + Sync + 'static,

Register a conversion for constant default values.

This is the preferred API for dynamic plugins so the host and plugin share a single coercer map stored in the host-owned PluginRegistry.

pub fn register_value_serializer<T, F>(&mut self, serializer: F)

where T: Any + Clone + Send + Sync + 'static, F: Fn(&T) -> Value + Send + Sync + 'static,

Register a serializer for outbound host-bridge values.

This enables host-bridge serialization for plugin-defined structured payload types by converting them into daedalus_data::model::Value.

pub fn register_output_mover<T, F>(&mut self, mover: F)

where T: Any + Send + Sync + 'static, F: Fn(T) -> EdgePayload + Send + Sync + 'static,

Register an output mover to emit a typed output payload by value.

pub fn register_type_compatibility(&mut self, from: TypeExpr, to: TypeExpr)

Register a type-compatibility edge to support dynamic port polling.

Dynamic plugins should use this API so compat data is stored in the host registry.

pub fn apply_type_compatibilities(&self)

Apply any registered compatibility edges to the host typing registry.

pub fn register_enum<T>( &mut self, variants: impl IntoIterator<Item = impl Into<String>>, )

where T: Any + Send + Sync + 'static + DeserializeOwned,

Register an enum type for UI/typing and enable constant binding for it.

This lets node function signatures take a strongly-typed enum (e.g. mode: ExecMode) while allowing JSON-authored graphs to provide the value as either:

• Value::Int(2) (index into the registered variant list)
• Value::String("cpu") (variant name)
• Value::Enum { name: "cpu", .. } (variant name)

The enum T must be DeserializeOwned so we can construct it from the variant name.

pub fn register_capability_typed<T, F>(&mut self, key: impl Into<String>, f: F)

where T: Send + Sync + 'static, F: Fn(&T, &T) -> Result<T, NodeError> + Send + Sync + 'static,

Register a typed capability entry keyed by a string. The provided function operates on typed references; downcasting is handled internally.

pub fn register_capability_typed3<T, F>(&mut self, key: impl Into<String>, f: F)

where T: Send + Sync + 'static, F: Fn(&T, &T, &T) -> Result<T, NodeError> + Send + Sync + 'static,

Register a typed capability entry that takes three operands of the same type.

Trait Implementations

impl Default for PluginRegistry

fn default() -> PluginRegistry

Returns the “default value” for a type.

impl RegistryPluginExt for PluginRegistry

fn install_plugin<P>(&mut self, plugin: &P) -> Result<(), &'static str>

where P: Plugin,