Struct ResolverContext 

pub struct ResolverContext<'a> { /* private fields */ }

Context passed to factory functions for resolving dependencies.

ResolverContext wraps a resolver (ServiceProvider or Scope) and provides the interface that factory functions use to access other services. This allows factory functions to be independent of the specific resolver type.

Examples

use ferrous_di::{ServiceCollection, Resolver};
use std::sync::Arc;

struct Database { url: String }
struct UserService { db: Arc<Database> }

let mut services = ServiceCollection::new();
services.add_singleton(Database { 
    url: "postgres://localhost".to_string() 
});
services.add_transient_factory::<UserService, _>(|resolver| {
    // resolver is a ResolverContext that provides access to other services
    UserService {
        db: resolver.get_required::<Database>(),
    }
});

Trait Implementations

impl<'a> Resolver for ResolverContext<'a>

fn register_disposer<T>(&self, service: Arc<T>)

where T: Dispose + 'static,

Registers a service for synchronous disposal.

fn register_async_disposer<T>(&self, service: Arc<T>)

where T: AsyncDispose + 'static,

Registers a service for asynchronous disposal.

fn get<T: 'static + Send + Sync>(&self) -> DiResult<Arc<T>>

Resolves a concrete service type.

fn get_trait<T: ?Sized + 'static + Send + Sync>(&self) -> DiResult<Arc<T>>

where Arc<T>: 'static,

Resolves a single trait implementation.

fn get_all_trait<T: ?Sized + 'static + Send + Sync>( &self, ) -> DiResult<Vec<Arc<T>>>

where Arc<T>: 'static,

Resolves all registered implementations of a trait.

fn get_required<T: 'static + Send + Sync>(&self) -> Arc<T>

Resolves a concrete service type, panicking on failure.

fn get_required_trait<T: ?Sized + 'static + Send + Sync>(&self) -> Arc<T>

where Arc<T>: 'static,

Resolves a trait implementation, panicking on failure.

fn get_named<T: 'static + Send + Sync>( &self, name: &'static str, ) -> DiResult<Arc<T>>

Resolves a named concrete service type.

fn get_named_required<T: 'static + Send + Sync>( &self, name: &'static str, ) -> Arc<T>

Resolves a named concrete service type, panicking on failure.

fn get_named_trait<T: ?Sized + 'static + Send + Sync>( &self, name: &'static str, ) -> DiResult<Arc<T>>

where Arc<T>: 'static,

Resolves a named trait implementation.

fn get_named_trait_required<T: ?Sized + 'static + Send + Sync>( &self, name: &'static str, ) -> Arc<T>

where Arc<T>: 'static,

Resolves a named trait implementation, panicking on failure.

impl<'a> ResolverCore for ResolverContext<'a>

fn resolve_any(&self, key: &Key) -> DiResult<Arc<dyn Any + Send + Sync>>

Resolves a single service using thread-local stack for circular dependency detection.

fn resolve_many(&self, key: &Key) -> DiResult<Vec<Arc<dyn Any + Send + Sync>>>

Resolves all multi-bound services for a trait using circular dependency detection.

fn push_sync_disposer(&self, f: Box<dyn FnOnce() + Send>)

Registers a synchronous disposal hook.

fn push_async_disposer( &self, f: Box<dyn FnOnce() -> Pin<Box<dyn Future<Output = ()> + Send>> + Send>, )

Registers an asynchronous disposal hook.

fn resolve_any_internal( &self, key: &Key, ) -> DiResult<Arc<dyn Any + Send + Sync>>

Legacy internal resolve method for compatibility.

fn resolve_many_internal( &self, key: &Key, ) -> DiResult<Vec<Arc<dyn Any + Send + Sync>>>

Legacy internal resolve many method for compatibility.