Expand description
§Rudi
Rudi - an out-of-the-box dependency injection framework for Rust.
§Quick Links
Here are links to the most important sections of the docs:
Context
: The core of the entire dependency injection framework, responsible for managing all providers.#[Singleton]
/#[Transient]
/#[SingleOwner]
: Three attribute macros used to generate the implementation ofDefaultProvider
, thus registering providers.
§Feature Flags
rudi-macro
(Default): Enables the#[Singleton]
,#[Transient]
and#[SingleOwner]
attribute macros.auto-register
(Default): Enables automatic registration of types and functions.tracing
: Adds support for logging withtracing
.
§Example
use rudi::{Context, Singleton, Transient};
// Register `fn(cx) -> A { A }` as the constructor for `A`
#[derive(Debug)]
#[Transient]
struct A;
#[derive(Debug)]
struct B(A);
// Register `fn(cx) -> B { B::new(cx.resolve::<A>()) }` as the constructor for `B`
#[Transient]
impl B {
#[di]
fn new(a: A) -> B {
B(a)
}
}
// Register `fn(cx) -> C { C::B(cx.resolve::<B>()) }` as the constructor for `C`
#[allow(dead_code)]
#[Transient]
enum C {
A(A),
#[di]
B(B),
}
// Register `fn(cx) -> () { Run(cx.resolve::<B>(), cx.resolve::<C>()) }` as the constructor for `()`
#[Singleton]
fn Run(b: B, c: C) {
println!("{:?}", b);
assert!(matches!(c, C::B(_)));
}
fn main() {
// Automatically register all types and functions with the `#[Singleton]`, `#[Transient]` or `#[SingleOwner]` attribute.
let mut cx = Context::auto_register();
// Get an instance of `()` from the `Context`, which will call the `Run` function.
// This is equivalent to `cx.resolve::<()>();`
cx.resolve()
}
Macros§
- Convert a set of types that implement
DefaultProvider
to a set ofDynProvider
instances - enable
auto-register
Generate a function to enable auto-registration. - Convert a set of types that implement
Module
to a set ofResolveModule
instances. - Convert a set of instances that implement
Into<DynProvider>
to a set ofDynProvider
instances - register_provider
auto-register
Register aProvider
that will be collected byauto_registered_providers
.
Structs§
- AutoRegisterModule
auto-register
A module that auto-registers all providers. - A context is a container for all the providers and instances.
- Options and flags which can be used to configure how a context is created.
- Represents a definition of a provider.
- Represents a
Provider
that erased its type. - Represents a
Single
that erased its type. - Represents a unique key for a provider.
- Represents the provider of an instance of type
T
. - A type representing a Module, converted from a type that implements
Module
. - Represents a
Singleton
orSingleOwner
instance. - Represents a specialized
Provider
. - Represents a specialized
Provider
. - Represents a specialized
Provider
. - Represents a specialized
Provider
. - Represents a specialized
Provider
. - Represents a specialized
Provider
. - Represents a type.
Enums§
- Represents the color of the function, i.e., async or sync.
- Represents the eager create function.
- Represents the scope of the provider.
Traits§
- A trait for giving a type a default
Provider
. - An extension trait for
Future
s that provides a convenient adapter. - Represents a module.
Functions§
- auto_registered_providers
auto-register
Returns an iterator over all auto-registered providers. - create a
SingleOwnerProvider
instance - Create a
SingleOwnerAsyncProvider
instance - create a
SingletonProvider
instance - Create a
SingletonAsyncProvider
instance - create a
TransientProvider
instance - Create a
TransientAsyncProvider
instance
Type Aliases§
- An owned dynamically typed
Future
for use in cases where you can’t statically type your result or need to add some indirection.
Attribute Macros§
- SingleOwner
rudi-macro
Define a single owner provider. - Singleton
rudi-macro
Define a singleton provider. - Transient
rudi-macro
Define a transient provider.