Simple zero cost dependency injection library made for rust
Add the following to your Cargo.toml:
toml
[dependencies]
nject = "0.3"
nject?nject will fail at compile time.```rust use nject::{injectable, provider};
struct DepOne;
struct DepTwo { dep: DepOne, }
struct Facade { dep: DepTwo, }
struct Provider;
fn main() { let _facade: Facade = Provider.provide(); }
```
```rust use nject::{injectable, provider};
struct DepOne;
struct Facade<'a> { dep: &'a DepOne, }
struct Provider<'a> { #[provide] shared: &'a DepOne, }
fn main() { let provider = Provider { shared: &DepOne }; let _facade: Facade = provider.provide(); }
```
```rust use nject::{injectable, provider};
trait Greeter { fn greet(&self); }
struct GreeterOne;
impl Greeter for GreeterOne { fn greet(&self) { println!("Greeting"); } }
struct Facade<'a> {
boxeddep: Box
struct Provider { #[provide(dyn Greeter)] greeter: GreeterOne, }
fn main() { let provider = Provider { greeter: GreeterOne }; let _facade: Facade = provider.provide(); }
```
```rust use nject::{injectable, provider};
struct DepOne;
struct Facade
struct Provider;
fn main() {
let _facade: Facade
```
```rust use nject::{injectable, provider};
trait Greeter { fn greet(&self); }
struct DevGreeter;
impl Greeter for DevGreeter { fn greet(&self) { println!("Greeting Dev"); } }
struct ProdGreeter;
impl Greeter for ProdGreeter { fn greet(&self) { println!("Greeting production"); } }
struct Facade<'a> { dep: &'a dyn Greeter, }
struct Provider<'a, T: Greeter>(#[provide(dyn Greeter)] &'a T);
fn main() { let devfacade: Facade = Provider(&DevGreeter).provide(); let prodfacade: Facade = Provider(&ProdGreeter).provide(); } ```
```rust use nject::{inject, injectable, provider};
struct InjectableFromInjectAttr { noninjectablevalue: i32, }
struct NonInjectable { noninjectablevalue: i32, }
non_injectable_value: injectable_dep.non_injectable_value + 10,
injectable_dep
}, injectabledep: InjectableFromInjectAttr)] struct PartiallyInjectable { noninjectablevalue: i32, injectabledep: InjectableFromInjectAttr }
struct Facade { depfrominjected: InjectableFromInjectAttr, depfrompartialinject: PartiallyInjectable, #[inject(NonInjectable { noninjectablevalue: 456 })] depfrominjectattr: NonInjectable, #[inject(InjectableFromInjectAttr { noninjectablevalue: 789 })] depfrominjectattroverride: InjectableFromInjectAttr, #[inject(PartiallyInjectable { noninjectablevalue: 111, injectabledep }, injectabledep: InjectableFromInjectAttr)] depfrompartialinjectattr_override: PartiallyInjectable, }
struct Provider;
fn main() {
let _facade = Provider.provide::
```rust use nject::{injectable, provider};
mod sub { use nject::{injectable, module};
#[injectable]
struct InternalType( #[inject(123)] i32); // Not visible outside of module.
#[injectable]
pub struct Facade<'a> {
hidden: &'a InternalType
}
#[injectable]
#[module]
pub struct Module {
#[export]
hidden: InternalType
}
}
struct Provider { #[import] subModule: sub::Module }
fn main() { #[provider] struct InitProvider;
let provider = InitProvider.provide::<Provider>();
let _facade = provider.provide::<sub::Facade>();
}
```
You can look into the axum example for a Web API use case or into the Leptos example for a Web App.