# xdi
Simple service dependency graph container implementation
- Allow resolve nested service dependency graph
- Support Transient
- Support Singletone
- Support Task local (singletone in task scope)
- Support Thread local (singletone in thread scope)
- Allow to map service into any other representation as simple like `.map_as(|service| SomeOther { x: service.x })`
- Allow to map service into trait object as siple like `.map_as_trait::<dyn SomeTrait>()`
- Resolve single (first) service by self or by any mapping
- Resolve all service wich has requested representation, usefull for trait object
- Non blocking for transient, single lock for singletone/task_local/thread_local init
- Allow `!Send` + `!Sync` for transient and thread_local
- Readable errors
- Simple architecture (constructor -> scope -> mapping)
- Allow global `ServiceProvider` registration
- Main test cases allowed in tests folder
```rust
use xdi::builder::DiBuilder;
use std::sync::{Arc, Mutex};
pub trait ISomeTrait {
fn get(&self) -> String;
}
pub struct SomeService {
pub payload: String
}
pub struct SomeServiceDeep {
pub nested_service: Arc<Mutex<SomeService>>
}
impl ISomeTrait for SomeServiceDeep {
fn get(&self) -> String {
self.nested_service.lock().unwrap().payload.clone()
}
}
pub struct SomeServiceDeeper {
pub nested_service: SomeServiceDeep
}
fn main() {
let builder = DiBuilder::new();
// register singletone
builder.singletone(|_| Ok(Arc::new(Mutex::new(SomeService { payload: "1".to_string() }))));
// register transient
builder.transient(|sp| Ok(SomeServiceDeeper { nested_service: sp.resolve()? }));
// register transient with mapping to trait
builder.transient(|sp| Ok(SomeServiceDeep { nested_service: sp.resolve()? }))
.map_as_trait::<dyn ISomeTrait>();
let sp = builder.build();
// automaticaly resolve all service dependency graph
// SomeServiceDeeper -> SomeServiceDeep -> Arc<Mutex<SomeService>>
let service = sp.resolve::<SomeServiceDeeper>().unwrap();
assert_eq!(service.nested_service.nested_service.lock().unwrap().payload, "1");
// change inner singletone
service.nested_service.nested_service.lock().unwrap().payload = "2".to_string();
// resolve dependency second time
// new SomeServiceDeeper and SomeServiceDeep, but old Arc<Mutex<SomeService>>
let service = sp.resolve::<SomeServiceDeeper>().unwrap();
assert_eq!(service.nested_service.nested_service.lock().unwrap().payload, "2");
// SomeServiceDeep also allowed as mapping into Box<dyn ISomeTrait>
let service = sp.resolve::<Box<dyn ISomeTrait>>().unwrap();
assert_eq!(service.get(), "2");
}
```
---
# How to use
Create container builder
```rust
let builder = DiBuilder::new();
// or
// let builder = DiBuilder::default();
```
### Register the service
- Mutable access not required, builder can be shared by ref
- Registration fn takes used ServiceProvider and can resolve nested dependency
##### As transient
- Create new instance every call
- Allowed !Send + !Sync
```rust
pub struct SomeNestedService {}
pub struct SomeService {
service: SomeNestedService,
//... other fields
}
//... some initialization
some_field: sp.resolve::<SomeNestedService>(),
}));
```
##### As singletone
- Lazy creation on the first invocation and return a clone on every next invocation
- Singletone required clone for service (you can wrap to Arc or derive Clone)
- Singletone required Sync + Send because it can be shared anywhere
```rust
#[derive(Clone)]
pub struct SomeService {}
- Lazy creation on the first invocation from the thread scope and return a clone on every next invocation in same thread scope
- Thread local required clone for service (you can wrap to Rc or derive Clone)
- Allowed !Send + !Sync
```rust
#[derive(Clone)]
pub struct SomeService {}
- Create mapping to `Box<dyn ISomeTrait>` if service impl ISomeTrait
```rust
builder.transient(|_| Ok(SomeService {
//... some initialization
}))
.map_as_trait::<dyn ISomeTrait>();
```
### Build container
- You can build container as var, or register global
##### Build container as var
```rust
let sp = builder.build();
```
##### Build and register global
```rust
builder.build_global();
// then access by static global var
let service = ServiceProvider::get().unwrap().resolve::<SomeService>().unwrap()
```
### Resolve service by mapping
##### As service
```rust
let service: SomeService = sp.resolve().unwrap();
// let service: Box<dyn ISomeTrait> = sp.resolve().unwrap();
```
##### As boxed service
```rust
use xdi::types::type_info::TypeInfoSource;
let service = sp.resolve_raw(SomeService::type_info()).unwrap();
// let service = sp.resolve(Box<dyn ISomeTrait>::type_info()).unwrap();
let service = service.unbox::<SomeService>().unwrap();
```
##### As vector of services, which has some mapping
```rust
let services: Vec<Box<dyn ISomeTrait>> = sp.resolve_all().unwrap();
```
##### As vector of boxed services, which has some mapping
```rust
use xdi::types::type_info::TypeInfoSource;
let services: Vec<BoxedService> = sp.resolve_all_raw(Box<dyn ISomeTrait>::type_info()).unwrap();
```
##### As dependency in task scope
```rust
tokio::spawn(async move {
let service = sp.resolve::<SomeService>().unwrap();
// In second time resolve return instanse clone (like singletone)
let service = sp.resolve::<SomeService>().unwrap();
}.add_service_span())
tokio::spawn(async move {
// New task has own SomeService instance
let service = sp.resolve::<SomeService>().unwrap();
}.add_service_span())
```