rscontainer 0.1.0

Manages dependencies between objects.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

# rscontainer


rscontainer is a library for the Rust programming language to manage 
dependencies between objects. The main type is the `ServiceContainer`, which
serves two purposes: it acts as a registry for shared instances (singletons)
and custom constructors, and it provides a mechanism for dependency injection.

For more information see the documentation.

## Resolving instances


There are different kind of instances:

  * **Owned instances**: a fresh instance to be used in a owned scope. This
    instance will not be stored in the service container, you will get a new
    instance each time you resolve a owned instance.
  * **Shared instances**: an instance behind a smart pointer that is stored
    in the service container. You will get the same instance each time you
    resolve a shared service.
  * **Some instances**: an enum over owned and shared instances. Use this in a
    type when you want the user of your type to decide what kind of instance
    they want to supply.

## How to use


Resolving a owned instance:

```Rust
use rscontainer::ServiceContainer;

let mut container = ServiceContainer::new();
let mut foo = container.resolver().owned::<SomeService>(())?;
foo.do_something();
```

Resolving a shared instance (singleton):

```Rust
use rscontainer::{ServiceContainer, Shared};

let mut container = ServiceContainer::new();
let foo: Shared<SomeService> = container.resolver().shared()?;

foo.access_mut(|foo| {
    let foo = foo.assert_healthy();
    foo.do_something();
});
```