Struct InjectionContext 

pub struct InjectionContext { /* private fields */ }

Available on crate feature di and non-WebAssembly only.

The main injection context for dependency resolution.

InjectionContext manages both request-scoped and singleton-scoped dependencies, as well as dependency overrides for testing.

Override Support

The context supports dependency overrides, which take precedence over normal dependency resolution. This is particularly useful for testing:

use reinhardt_di::{InjectionContext, SingletonScope};
use std::sync::Arc;


let singleton = Arc::new(SingletonScope::new());
let ctx = InjectionContext::builder(singleton).build();

// Set override for testing
ctx.dependency(create_database).override_with(Database::mock());

Implementations

impl InjectionContext

pub fn builder( singleton_scope: impl Into<Arc<SingletonScope>>, ) -> InjectionContextBuilder

Create a new InjectionContextBuilder.

This is the recommended way to construct an InjectionContext.

Examples

use reinhardt_di::{InjectionContext, SingletonScope};

let singleton_scope = SingletonScope::new();
let ctx = InjectionContext::builder(singleton_scope).build();

pub fn get_http_request(&self) -> Option<&Request>

Available on crate feature params only.

Gets the HTTP request from the context.

Returns None if no request was set (e.g., when testing without HTTP context). Returns a reference to the request.

Examples

use reinhardt_di::{InjectionContext, SingletonScope, Request, ParamContext};

let singleton_scope = SingletonScope::new();
let request = Request::builder()
    .method(hyper::Method::GET)
    .uri("/")
    .build()
    .unwrap();
let param_context = ParamContext::new();

let ctx = InjectionContext::builder(singleton_scope)
    .with_request(request)
    .with_param_context(param_context)
    .build();

assert!(ctx.get_http_request().is_some());

pub fn get_param_context(&self) -> Option<&ParamContext>

Available on crate feature params only.

Gets the parameter context from the context.

Returns None if no parameter context was set. Returns a reference to the parameter context.

Examples

use reinhardt_di::{InjectionContext, SingletonScope, Request, ParamContext};

let singleton_scope = SingletonScope::new();
let request = Request::builder()
    .method(hyper::Method::GET)
    .uri("/")
    .build()
    .unwrap();
let param_context = ParamContext::new();

let ctx = InjectionContext::builder(singleton_scope)
    .with_request(request)
    .with_param_context(param_context)
    .build();

assert!(ctx.get_param_context().is_some());

pub fn set_http_request( &mut self, request: Request, param_context: ParamContext, )

Available on crate feature params only.

Sets the HTTP request and parameter context.

This can be used to add HTTP context to an existing InjectionContext. The request and parameter context will be wrapped in Arc internally.

Examples

use reinhardt_di::{InjectionContext, SingletonScope, Request, ParamContext};

let singleton_scope = SingletonScope::new();
let mut ctx = InjectionContext::builder(singleton_scope).build();

let request = Request::builder()
    .method(hyper::Method::GET)
    .uri("/")
    .build()
    .unwrap();
let param_context = ParamContext::new();

ctx.set_http_request(request, param_context);

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

where T: Any + Send + Sync,

Retrieves a request-scoped value from the context.

Request-scoped values are cached only for the duration of a single request.

Examples

use reinhardt_di::{InjectionContext, SingletonScope};
use std::sync::Arc;

let singleton_scope = Arc::new(SingletonScope::new());
let ctx = InjectionContext::builder(singleton_scope).build();

ctx.set_request(42i32);
let value = ctx.get_request::<i32>().unwrap();
assert_eq!(*value, 42);

pub fn set_request<T>(&self, value: T)

where T: Any + Send + Sync,

Stores a value in the request scope.

The value is cached for the duration of the current request only.

Examples

use reinhardt_di::{InjectionContext, SingletonScope};
use std::sync::Arc;

let singleton_scope = Arc::new(SingletonScope::new());
let ctx = InjectionContext::builder(singleton_scope).build();

ctx.set_request("request-data".to_string());
assert!(ctx.get_request::<String>().is_some());

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

where T: Any + Send + Sync,

Retrieves a singleton value from the context.

Singleton values persist across all requests and are shared application-wide.

Examples

use reinhardt_di::{InjectionContext, SingletonScope};
use std::sync::Arc;

let singleton_scope = Arc::new(SingletonScope::new());
singleton_scope.set(100u64);

let ctx = InjectionContext::builder(singleton_scope).build();
let value = ctx.get_singleton::<u64>().unwrap();
assert_eq!(*value, 100);

pub fn set_singleton<T>(&self, value: T)

where T: Any + Send + Sync,

Stores a value in the singleton scope.

The value persists across all requests and is shared application-wide.

Examples

use reinhardt_di::{InjectionContext, SingletonScope};
use std::sync::Arc;

let singleton_scope = Arc::new(SingletonScope::new());
let ctx = InjectionContext::builder(singleton_scope).build();

ctx.set_singleton("global-config".to_string());
assert!(ctx.get_singleton::<String>().is_some());

pub fn singleton_scope(&self) -> &Arc<SingletonScope>

Returns a reference to the singleton scope.

This is useful for advanced scenarios where direct access to the singleton scope is needed.

pub fn fork_for_request(&self, request: Request) -> InjectionContext

Creates a per-request fork of this context with an HTTP request.

The forked context shares the same singleton scope but has a fresh request scope. When the params feature is enabled, the HTTP request and its path parameters are made available for parameter extraction.

The HTTP request is stored in both the dedicated request field (for get_http_request()) and the request_scope (for get_request::<HttpRequest>()), ensuring that Injectable types such as ServerFnRequest can retrieve it via either accessor.

pub fn fork(&self) -> InjectionContext

Creates a per-request fork of this context without an HTTP request.

The forked context shares the same singleton scope but has a fresh request scope. Unlike fork_for_request, this method does not store an HTTP request, so path parameter extraction is not available.

This is intended for non-HTTP protocols (gRPC, GraphQL) where request-scoped isolation is needed but HTTP request data is not available.

pub fn overrides(&self) -> &OverrideRegistry

Returns a reference to the override registry.

The override registry stores function-level overrides that take precedence over normal dependency resolution.

pub fn dependency<O>(&self, func: fn() -> O) -> FunctionHandle<'_, O>

where O: Clone + Send + Sync + 'static,

Creates a handle for the given injectable function.

This method provides a fluent API for setting and managing dependency overrides. The function pointer is used as a unique key to identify which injectable function should be overridden.

Note

This method is designed to work with functions annotated with #[injectable]. The #[injectable] macro generates a 0-argument function regardless of the original function’s parameter count, as all #[inject] parameters are resolved internally by the DI system.

Type Parameters

• O - The output type of the function (the dependency type)

Arguments

• func - A function pointer to the injectable function

Examples

use reinhardt_di::{InjectionContext, SingletonScope};
use std::sync::Arc;


let singleton = Arc::new(SingletonScope::new());
let ctx = InjectionContext::builder(singleton).build();

// Set override - create_database is 0-argument after macro expansion
ctx.dependency(create_database).override_with(Database::mock());

// Check if override exists
assert!(ctx.dependency(create_database).has_override());

// Clear override
ctx.dependency(create_database).clear_override();

pub fn get_override<O>(&self, func_ptr: usize) -> Option<O>

where O: Clone + 'static,

Gets an override value for a function pointer.

This is primarily used internally by the #[injectable] macro to check for overrides before executing the actual function.

Arguments

• func_ptr - The function pointer address as usize

Returns

Some(value) if an override is set, None otherwise.

pub fn clear_overrides(&self)

Clears all overrides from the context.

This is useful for cleanup in tests to ensure a clean state.

Examples

use reinhardt_di::{InjectionContext, SingletonScope};
use std::sync::Arc;

fn my_factory() -> i32 { 42 }

let singleton = Arc::new(SingletonScope::new());
let ctx = InjectionContext::builder(singleton).build();

ctx.dependency(my_factory).override_with(100);
assert!(ctx.dependency(my_factory).has_override());

ctx.clear_overrides();
assert!(!ctx.dependency(my_factory).has_override());

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

where T: Any + Send + Sync + 'static,

Resolve a dependency from the global registry

This method implements the core dependency resolution logic:

1. Check cache based on scope (Request or Singleton)
2. If not cached, create using the factory from the global registry
3. Cache the result according to the scope

Examples

use reinhardt_di::{InjectionContext, SingletonScope};
use std::sync::Arc;

let singleton_scope = Arc::new(SingletonScope::new());
let ctx = InjectionContext::builder(singleton_scope).build();

let config = ctx.resolve::<Config>().await?;

Trait Implementations

impl Clone for InjectionContext

fn clone(&self) -> InjectionContext

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.