Struct IocContainer 

pub struct IocContainer { /* private fields */ }

Modern IoC container with proper dependency injection

Implementations

impl IocContainer

pub fn new() -> Self

Create a new IoC container

pub fn from_bindings(bindings: ServiceBindings) -> Self

Create IoC container from existing bindings

pub fn build(&mut self) -> Result<(), CoreError>

Build the container and prepare for service resolution

pub async fn initialize_async(&mut self) -> Result<(), CoreError>

Initialize all async services

pub async fn initialize_async_with_timeout( &mut self, timeout: Duration, ) -> Result<(), CoreError>

Initialize all async services with timeout

pub fn create_scope(&self) -> Result<ScopeId, CoreError>

Create a new service scope

pub fn create_child_scope( &self, parent_scope_id: &ScopeId, ) -> Result<ScopeId, CoreError>

Create a child scope from an existing scope

pub async fn dispose_scope(&self, scope_id: &ScopeId) -> Result<(), CoreError>

Dispose of a scope and all its services

pub async fn dispose_all(&mut self) -> Result<(), CoreError>

Dispose all scoped services and lifecycle managed services

pub fn lifecycle_manager(&self) -> &ServiceLifecycleManager

Get a reference to the lifecycle manager

pub fn lifecycle_manager_mut(&mut self) -> &mut ServiceLifecycleManager

Get a mutable reference to the lifecycle manager

pub fn resolve<T: Send + Sync + 'static>(&self) -> Result<Arc<T>, CoreError>

Resolve a service by type

pub fn resolve_scoped<T: Send + Sync + 'static>( &self, scope_id: &ScopeId, ) -> Result<Arc<T>, CoreError>

Resolve a scoped service by type

pub fn resolve_named<T: Send + Sync + 'static>( &self, name: &str, ) -> Result<Arc<T>, CoreError>

Resolve a named service

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

Try to resolve a service, returning None if not found

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

Try to resolve a named service, returning None if not found

pub fn resolve_injectable<T: Injectable>(&self) -> Result<Arc<T>, CoreError>

Resolve a service using the Injectable trait (auto-wiring)

pub fn resolve_trait<T: ?Sized + Send + Sync + 'static>( &self, ) -> Result<Arc<T>, CoreError>

Resolve a trait object by downcasting from a concrete implementation

pub fn bind_token<Token, Impl>(&mut self) -> Result<&mut Self, CoreError>

where Token: ServiceToken, Impl: Send + Sync + Default + 'static,

Bind a service token to a concrete implementation with transient lifetime

This creates a mapping from a service token to a concrete implementation, enabling semantic dependency resolution through tokens.

Example

use elif_core::container::{IocContainer, ServiceToken};

// Define service trait and token
trait EmailService: Send + Sync {}
struct EmailToken;
impl ServiceToken for EmailToken {
    type Service = dyn EmailService;
}

// Implementation
#[derive(Default)]
struct SmtpService;
impl EmailService for SmtpService {}

// Bind token to implementation
let mut container = IocContainer::new();
container.bind_token::<EmailToken, SmtpService>()?;

pub fn bind_token_singleton<Token, Impl>( &mut self, ) -> Result<&mut Self, CoreError>

where Token: ServiceToken, Impl: Send + Sync + Default + 'static,

Bind a service token to a concrete implementation as a singleton

pub fn bind_token_scoped<Token, Impl>(&mut self) -> Result<&mut Self, CoreError>

where Token: ServiceToken, Impl: Send + Sync + Default + 'static,

Bind a service token to a concrete implementation as a scoped service

pub fn bind_token_with_lifetime<Token, Impl>( &mut self, lifetime: ServiceScope, ) -> Result<&mut Self, CoreError>

where Token: ServiceToken, Impl: Send + Sync + Default + 'static,

Bind a service token to a concrete implementation with a specific lifetime

pub fn bind_token_named<Token, Impl>( &mut self, name: impl Into<String>, ) -> Result<&mut Self, CoreError>

where Token: ServiceToken, Impl: Send + Sync + Default + 'static,

Bind a named service token to a concrete implementation

pub fn resolve_by_token<Token>(&self) -> Result<Arc<Token::Service>, CoreError>

where Token: ServiceToken, Token::Service: 'static,

Resolve a service by its token type

This enables semantic dependency resolution where services are identified by tokens rather than concrete types, enabling true dependency inversion.

Example

use std::sync::Arc;
use elif_core::container::{IocContainer, ServiceToken};

// Define service trait and token
trait EmailService: Send + Sync {
    fn send(&self, to: &str, subject: &str, body: &str) -> Result<(), String>;
}
struct EmailToken;
impl ServiceToken for EmailToken {
    type Service = dyn EmailService;
}

// Implementation
#[derive(Default)]
struct SmtpService;
impl EmailService for SmtpService {
    fn send(&self, _to: &str, _subject: &str, _body: &str) -> Result<(), String> {
        Ok(()) // Mock implementation
    }
}

// Setup and resolve
let mut container = IocContainer::new();
container.bind_token::<EmailToken, SmtpService>()?;
container.build()?;
 
// Note: Trait object resolution is not yet fully implemented
// This will be available in a future version:
// let service: Arc<dyn EmailService> = container.resolve_by_token::<EmailToken>()?;
// service.send("user@example.com", "Welcome", "Hello world!")?;

pub fn resolve_by_token_named<Token>( &self, name: &str, ) -> Result<Arc<Token::Service>, CoreError>

where Token: ServiceToken, Token::Service: 'static,

Resolve a named service by its token type

pub fn try_resolve_by_token<Token>(&self) -> Option<Arc<Token::Service>>

where Token: ServiceToken, Token::Service: 'static,

Try to resolve a service by its token type, returning None if not found

pub fn try_resolve_by_token_named<Token>( &self, name: &str, ) -> Option<Arc<Token::Service>>

where Token: ServiceToken, Token::Service: 'static,

Try to resolve a named service by its token type, returning None if not found

pub fn resolve_by_token_scoped<Token>( &self, scope_id: &ScopeId, ) -> Result<Arc<Token::Service>, CoreError>

where Token: ServiceToken, Token::Service: 'static,

Resolve a scoped service by its token type

This resolves services within a specific scope, maintaining the lifecycle and cleanup patterns expected by the existing scope management system.

pub fn resolve_by_token_named_scoped<Token>( &self, name: &str, scope_id: &ScopeId, ) -> Result<Arc<Token::Service>, CoreError>

where Token: ServiceToken, Token::Service: 'static,

Resolve a named scoped service by its token type

pub fn try_resolve_by_token_scoped<Token>( &self, scope_id: &ScopeId, ) -> Option<Arc<Token::Service>>

where Token: ServiceToken, Token::Service: 'static,

Try to resolve a scoped service by its token type, returning None if not found

pub fn try_resolve_by_token_named_scoped<Token>( &self, name: &str, scope_id: &ScopeId, ) -> Option<Arc<Token::Service>>

where Token: ServiceToken, Token::Service: 'static,

Try to resolve a named scoped service by its token type, returning None if not found

pub fn contains_token<Token: ServiceToken>(&self) -> bool

Check if a token is registered

pub fn contains_token_named<Token: ServiceToken>(&self, name: &str) -> bool

Check if a named token is registered

pub fn token_stats(&self) -> TokenRegistryStats

Get token registry statistics

pub fn contains<T: 'static>(&self) -> bool

Check if a service is registered

pub fn contains_named<T: 'static>(&self, name: &str) -> bool

Check if a named service is registered

pub fn service_count(&self) -> usize

Get the number of registered services

pub fn registered_services(&self) -> Vec<ServiceId>

Get all registered service IDs

pub fn is_built(&self) -> bool

Check if the container is built and ready

pub fn validate(&self) -> Result<(), CoreError>

Validate the container configuration

pub fn resolve_all<T: Send + Sync + 'static>( &self, ) -> Result<Vec<Arc<T>>, CoreError>

Resolve all implementations of an interface as a vector

pub fn resolve_all_named<T: Send + Sync + 'static>( &self, ) -> Result<HashMap<String, Arc<T>>, CoreError>

Resolve all implementations of an interface as a HashMap with their names

pub fn resolve_default<T: Send + Sync + 'static>( &self, ) -> Result<Arc<T>, CoreError>

Get default implementation for a type (marked with is_default in BindingConfig)

pub fn get_service_info<T: 'static>(&self) -> Option<String>

Get service information for debugging

pub fn get_registered_services(&self) -> Vec<String>

Get all registered service IDs for debugging

pub fn validate_all_services(&self) -> Result<(), Vec<CoreError>>

Validate that all registered services can be resolved

pub fn get_statistics(&self) -> ServiceStatistics

Get service statistics

Trait Implementations

impl Debug for IocContainer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for IocContainer

fn default() -> Self

Returns the “default value” for a type.

impl DependencyResolver for IocContainer

fn resolve<T: Send + Sync + 'static>(&self) -> Result<Arc<T>, CoreError>

Resolve a service by type

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

Resolve a named service

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

Try to resolve a service, returning None if not found

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

Try to resolve a named service, returning None if not found

impl ServiceBinder for IocContainer

fn add_service_descriptor( &mut self, descriptor: ServiceDescriptor, ) -> Result<&mut Self, CoreError>

Add a pre-built service descriptor

fn bind<TInterface: ?Sized + 'static, TImpl: Send + Sync + Default + 'static>( &mut self, ) -> &mut Self

Bind an interface to an implementation

fn bind_singleton<TInterface: ?Sized + 'static, TImpl: Send + Sync + Default + 'static>( &mut self, ) -> &mut Self

Bind an interface to an implementation with singleton lifetime

fn bind_transient<TInterface: ?Sized + 'static, TImpl: Send + Sync + Default + 'static>( &mut self, ) -> &mut Self

Bind an interface to an implementation with transient lifetime

fn bind_factory<TInterface: ?Sized + 'static, F, T>( &mut self, factory: F, ) -> &mut Self

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

Bind a service using a factory function

fn bind_instance<TInterface: ?Sized + 'static, TImpl: Send + Sync + Clone + 'static>( &mut self, instance: TImpl, ) -> &mut Self

Bind a pre-created instance

fn bind_named<TInterface: ?Sized + 'static, TImpl: Send + Sync + Default + 'static>( &mut self, name: &str, ) -> &mut Self

Bind a named service

fn bind_injectable<T: Injectable>(&mut self) -> &mut Self

Bind an Injectable service with auto-wiring

fn bind_injectable_singleton<T: Injectable>(&mut self) -> &mut Self

Bind an Injectable service as singleton with auto-wiring

fn bind_with<TInterface: ?Sized + 'static, TImpl: Send + Sync + Default + 'static>( &mut self, ) -> AdvancedBindingBuilder<TInterface>

Advanced bind with fluent configuration - returns builder for chaining

fn with_implementation<TInterface: ?Sized + 'static, TImpl: Send + Sync + Default + 'static>( &mut self, config: BindingConfig, ) -> &mut Self

Complete advanced binding with implementation

fn bind_lazy<TInterface: ?Sized + 'static, F, T>( &mut self, factory: F, ) -> &mut Self

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

Bind a lazy service using factory that gets called only when needed

fn bind_parameterized_factory<TInterface: ?Sized + 'static, P, F, T>( &mut self, factory: F, ) -> &mut Self

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

Bind with parameterized factory

fn bind_collection<TInterface: ?Sized + 'static, F>( &mut self, configure: F, ) -> &mut Self

where F: FnOnce(&mut CollectionBindingBuilder<TInterface>),

Bind a collection of services using a closure-based configuration