Struct PooledScope 

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

A scope acquired from a pool that automatically returns when dropped.

This provides RAII-style management of pooled scopes, ensuring they’re always returned to the pool even if the code panics.

Implementations

impl<'a> PooledScope<'a>

pub fn container(&self) -> &Container

Get a reference to the underlying container.

Methods from Deref<Target = Container>

pub fn scope(&self) -> Self

Create a child scope that inherits from this container.

Child scopes can:

• Access all services from parent scopes
• Override parent services with local registrations
• Have their own transient/scoped services

Examples

use dependency_injector::Container;

#[derive(Clone)]
struct AppConfig { debug: bool }

#[derive(Clone)]
struct RequestId(String);

let root = Container::new();
root.singleton(AppConfig { debug: true });

let request = root.scope();
request.singleton(RequestId("req-123".into()));

// Request scope can access root config
assert!(request.contains::<AppConfig>());

pub fn create_scope(&self) -> Self

Alias for scope() - creates a child container.

pub fn singleton<T: Injectable>(&self, instance: T)

Register a singleton service (eager).

The instance is stored immediately and shared across all resolves.

Examples

use dependency_injector::Container;

#[derive(Clone)]
struct Database { url: String }

let container = Container::new();
container.singleton(Database { url: "postgres://localhost".into() });

pub fn lazy<T: Injectable, F>(&self, factory: F)

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

Register a lazy singleton service.

The factory is called once on first access, then the instance is cached.

Examples

use dependency_injector::Container;

#[derive(Clone)]
struct ExpensiveService { data: Vec<u8> }

let container = Container::new();
container.lazy(|| ExpensiveService {
    data: vec![0; 1024 * 1024], // Only allocated on first use
});

pub fn transient<T: Injectable, F>(&self, factory: F)

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

Register a transient service.

A new instance is created on every resolve.

Examples

use dependency_injector::Container;
use std::sync::atomic::{AtomicU64, Ordering};

static COUNTER: AtomicU64 = AtomicU64::new(0);

#[derive(Clone)]
struct RequestId(u64);

let container = Container::new();
container.transient(|| RequestId(COUNTER.fetch_add(1, Ordering::SeqCst)));

let id1 = container.get::<RequestId>().unwrap();
let id2 = container.get::<RequestId>().unwrap();
assert_ne!(id1.0, id2.0); // Different instances

pub fn register_factory<T: Injectable, F>(&self, factory: F)

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

Register using a factory (alias for lazy).

pub fn register<T: Injectable>(&self, instance: T)

Register an instance (alias for singleton).

pub fn register_boxed<T: Injectable>(&self, instance: Box<T>)

Register a boxed instance.

pub fn register_by_id( &self, type_id: TypeId, instance: Arc<dyn Any + Send + Sync>, )

Register by TypeId directly (advanced use).

pub fn get<T: Injectable>(&self) -> Result<Arc<T>>

Resolve a service by type.

Returns Arc<T> for zero-copy sharing. Walks the parent chain if not found in the current scope.

Performance

Uses thread-local caching for frequently accessed services (~8ns vs ~19ns). The cache is automatically populated on first access.

Examples

use dependency_injector::Container;

#[derive(Clone)]
struct MyService;

let container = Container::new();
container.singleton(MyService);

let service = container.get::<MyService>().unwrap();

pub fn clear_cache(&self)

Clear the thread-local hot cache.

Call this after modifying the container (registering/removing services) if you want subsequent resolutions to see the changes immediately.

Note: The cache is automatically invalidated when services are re-registered, but this method can be used for explicit control.

pub fn warm_cache<T: Injectable>(&self)

Pre-warm the thread-local cache with a specific service type.

This can be useful at the start of request handling to ensure hot services are already in the cache.

Example

use dependency_injector::Container;

#[derive(Clone)]
struct Database;

let container = Container::new();
container.singleton(Database);

// Pre-warm cache for hot services
container.warm_cache::<Database>();

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

Alias for get - resolve a service.

pub fn try_get<T: Injectable>(&self) -> Option<Arc<T>>

Try to resolve, returning None if not found.

Examples

use dependency_injector::Container;

#[derive(Clone)]
struct OptionalService;

let container = Container::new();
assert!(container.try_get::<OptionalService>().is_none());

pub fn try_resolve<T: Injectable>(&self) -> Option<Arc<T>>

Alias for try_get.

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

Check if a service is registered.

Checks both current scope and parent scopes.

pub fn has<T: Injectable>(&self) -> bool

Alias for contains.

pub fn len(&self) -> usize

Get the number of services in this scope (not including parents).

pub fn is_empty(&self) -> bool

Check if this scope is empty.

pub fn registered_types(&self) -> Vec<TypeId>

Get all registered TypeIds in this scope.

pub fn depth(&self) -> u32

Get the scope depth (0 = root).

pub fn lock(&self)

Lock the container to prevent further registrations.

Useful for ensuring no services are registered after app initialization.

pub fn is_locked(&self) -> bool

Check if the container is locked.

pub fn clear(&self)

Clear all services from this scope.

Does not affect parent scopes.

pub fn batch<F>(&self, f: F)

where F: FnOnce(BatchRegistrar<'_>),

Register multiple services in a single batch operation.

This is more efficient than individual registrations when registering many services at once, as it:

• Performs a single lock check at the start
• Minimizes per-call overhead

Examples

use dependency_injector::Container;

#[derive(Clone)]
struct Database { url: String }
#[derive(Clone)]
struct Cache { size: usize }
#[derive(Clone)]
struct Logger { level: String }

let container = Container::new();
container.batch(|batch| {
    batch.singleton(Database { url: "postgres://localhost".into() });
    batch.singleton(Cache { size: 1024 });
    batch.singleton(Logger { level: "info".into() });
});

assert!(container.contains::<Database>());
assert!(container.contains::<Cache>());
assert!(container.contains::<Logger>());

Note: For maximum performance with many services, prefer the builder API:

use dependency_injector::Container;

#[derive(Clone)]
struct A;
#[derive(Clone)]
struct B;

let container = Container::new();
container.register_batch()
    .singleton(A)
    .singleton(B)
    .done();

pub fn register_batch(&self) -> BatchBuilder<'_>

Start a fluent batch registration.

This is faster than the closure-based batch() for many services because it avoids closure overhead.

Example

use dependency_injector::Container;

#[derive(Clone)]
struct Database { url: String }
#[derive(Clone)]
struct Cache { size: usize }

let container = Container::new();
container.register_batch()
    .singleton(Database { url: "postgres://localhost".into() })
    .singleton(Cache { size: 1024 })
    .done();

assert!(container.contains::<Database>());
assert!(container.contains::<Cache>());

Trait Implementations

impl<'a> Deref for PooledScope<'a>

type Target = Container

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a> Drop for PooledScope<'a>

fn drop(&mut self)

Executes the destructor for this type.