Struct Registry 

pub struct Registry<S> { /* private fields */ }

Type-erased provider registry used for service discovery and DI-style lookup. Registration happens during bootstrap and runtime access is read-only via typed resolves. We keep the underlying maps behind RwLock<HashMap<..>> so registration stays simple while lookup only holds a short-lived read lock long enough to clone the stored Arc.

Implementations

impl<S: 'static> Registry<S>

pub fn new() -> Self

Create the service with an empty registry. You can register later.

pub fn insert<C>(&self, item: Arc<C>) -> &Self

where C: Provider<S> + 'static,

Register a provider into the registry.

This accepts Arc<T> where T: Provider. The service is stored as a type-erased Arc<dyn Provider> but continues to point to the same underlying allocation (no new allocation is created).

If another service with the same concrete type is already registered, the new registration is skipped and a warning is logged.

Returns &Self to allow fluent chaining:

registry
    .insert(dns.clone())
    .insert(ipc.clone());

pub fn with_typed<T, R>(&self, f: impl FnOnce(&T) -> R) -> Option<R>

where T: Provider<S> + 'static,

Execute a closure with a concrete typed reference &T if the service is registered.

pub fn resolve<T>(&self) -> Option<Arc<T>>

where T: Provider<S> + 'static,

Resolve a concrete service as an owned Arc<T> handle.

This is the DI-style, high-level API: it returns a typed Arc<T> that points to the same underlying allocation as the internally registered provider (no new Arc allocation). The returned Arc is obtained by downcasting from a type-indexed map (TypeId).

Returns None if the type is not registered.

pub fn providers(&self) -> Vec<Arc<dyn Provider<S>>>

Return a snapshot of registered providers.

pub fn list_names(&self) -> Vec<&'static str>

Return the list of provider display names (for diagnostics only).

pub fn lifecycle_names(&self) -> Result<Vec<&'static str>>

Return provider display names in lifecycle order.

This is useful for diagnostics and startup logging before running boot_all().

pub fn run_all(&self, state: S, join_set: &mut JoinSet<Result<()>>) -> usize

where S: Clone + Send + 'static,

Spawn all runnable providers into the given JoinSet.

Returns the number of tasks spawned.

pub fn validate_all(&self, state: &S) -> Result<()>

Run validate hook for all registered providers.

pub async fn boot_all(&self, state: &S) -> Result<()>

pub async fn shutdown_all(&self, state: &S) -> Result<()>

pub async fn reload_one(&self, name: &str, state: &S) -> Result<()>

impl<S> Registry<S>

where S: ReloadState + 'static,

pub async fn reload_all(&self, state: &S) -> Result<()>

Trait Implementations

impl<S: 'static> Default for Registry<S>

fn default() -> Self

Returns the “default value” for a type.