Struct Container 

pub struct Container { /* private fields */ }

Type-indexed dependency container.

Implementations

impl Container

pub fn new() -> Self

Creates an empty container.

pub fn request_scope(&self) -> RequestScope<'_>

Creates a request scope for request-lifetime providers.

pub fn register_singleton<T>(&mut self, value: T) -> Result<()>

where T: Send + Sync + 'static,

Registers a concrete singleton value.

pub fn override_singleton<T>(&mut self, value: T) -> Result<()>

where T: Send + Sync + 'static,

Replaces a singleton provider, intended for explicit test overrides.

pub fn register_factory<T, F>( &mut self, lifetime: ProviderLifetime, factory: F, ) -> Result<()>

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

Registers a provider factory.

pub fn register_singleton_factory<T, F>(&mut self, factory: F) -> Result<()>

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

Registers a singleton provider factory.

pub fn register_transient<T, F>(&mut self, factory: F) -> Result<()>

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

Registers a transient provider factory.

pub fn register_request<T, F>(&mut self, factory: F) -> Result<()>

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

Registers a request-lifetime provider factory.

pub fn register_request_scoped<T, F>(&mut self, factory: F) -> Result<()>

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

Registers a request-lifetime provider factory that resolves dependencies through the active request scope.

pub fn inject<T>(&self) -> Result<Inject<T>>

where T: Send + Sync + 'static,

Resolves a typed dependency reference.

pub fn optional<T>(&self) -> Result<Optional<T>>

where T: Send + Sync + 'static,

Resolves an optional typed dependency reference.

Missing providers become Optional::new(None), while registered providers that fail to construct still return their original error.

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

where T: Send + Sync + 'static,

Resolves a shared typed dependency.

pub fn eagerly_resolve_singletons(&self) -> Result<()>

Eagerly constructs every registered singleton provider and caches it.

Singletons are otherwise constructed lazily on first resolution, which uses a blocking Condvar wait when two callers race to construct the same provider. Calling this at startup pre-constructs each singleton so later resolutions (including from async request handlers) hit the cached value and never reach that wait, avoiding an async-runtime worker stalling on first use. Transient and request-lifetime providers are skipped.

A singleton whose factory errors or panics will do so here, failing startup fast instead of on first request.

Trait Implementations

impl Default for Container

fn default() -> Container

Returns the “default value” for a type.