Struct async_injector::Injector

pub struct Injector { /* fields omitted */ }

An injector of dependencies.

Injectors are defined in hierarchies where an injector is either the root injector as created using [setup] or [setup_with_driver], or the child of another injector through [Injector::child].

Child injectors receive all the updates of their ancestors.

Implementations

impl Injector

pub fn new() -> Self

Construct an Injector.

Example

#[tokio::main]
async fn main() {
    let injector = async_injector::Injector::new();

    assert_eq!(None, injector.get::<u32>().await);
    injector.update(1u32).await;
    assert_eq!(Some(1u32), injector.get::<u32>().await);
    assert!(injector.clear::<u32>().await.is_some());
    assert_eq!(None, injector.get::<u32>().await);
}

Example using a Stream

use std::error::Error;

#[derive(Clone)]
struct Database;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let injector = async_injector::Injector::new();

    let database = injector.var::<Database>().await;

    assert!(database.read().await.is_none());
    injector.update(Database).await;
    assert!(database.read().await.is_some());
    Ok(())
}

pub async fn clear<T>(&self) -> Option<T> where
    T: Clone + Any + Send + Sync, 

Get a value from the injector.

This will cause the clear to be propagated to all streams set up using stream. And for future calls to get to return the updated value.

Examples

#[tokio::main]
async fn main() {
    let injector = async_injector::Injector::new();

    assert_eq!(None, injector.get::<u32>().await);
    injector.update(1u32).await;
    assert_eq!(Some(1u32), injector.get::<u32>().await);
    assert!(injector.clear::<u32>().await.is_some());
    assert_eq!(None, injector.get::<u32>().await);
}

pub async fn clear_key<T>(&self, key: impl AsRef<Key<T>>) -> Option<T> where
    T: Clone + Any + Send + Sync, 

Clear the given value with the given key.

This will cause the clear to be propagated to all streams set up using stream. And for future calls to get to return the updated value.

Examples

use async_injector::{Key, Injector};
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let injector = async_injector::Injector::new();
    let k = Key::<u32>::tagged("foo")?;

    assert_eq!(None, injector.get_key(&k).await);
    injector.update_key(&k, 1u32).await;
    assert_eq!(Some(1u32), injector.get_key(&k).await);
    assert!(injector.clear_key(&k).await.is_some());
    assert_eq!(None, injector.get_key(&k).await);

    Ok(())
}

pub async fn update<T>(&self, value: T) -> Option<T> where
    T: Clone + Any + Send + Sync, 

Set the given value and notify any subscribers.

This will cause the update to be propagated to all streams set up using stream. And for future calls to get to return the updated value.

Examples

#[tokio::main]
async fn main() {
    let injector = async_injector::Injector::new();

    assert_eq!(None, injector.get::<u32>().await);
    injector.update(1u32).await;
    assert_eq!(Some(1u32), injector.get::<u32>().await);
}

pub async fn update_key<T>(
    &self,
    key: impl AsRef<Key<T>>,
    value: T
) -> Option<T> where
    T: Clone + Any + Send + Sync, 

Update the value associated with the given key.

This will cause the update to be propagated to all streams set up using stream. And for future calls to get to return the updated value.

Examples

use async_injector::{Key, Injector};
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let injector = async_injector::Injector::new();
    let k = Key::<u32>::tagged("foo")?;

    assert_eq!(None, injector.get_key(&k).await);
    injector.update_key(&k, 1u32).await;
    assert_eq!(Some(1u32), injector.get_key(&k).await);

    Ok(())
}

pub async fn exists<T>(&self) -> bool where
    T: Clone + Any + Send + Sync, 

Test if a given value exists by type.

Examples

#[tokio::main]
async fn main() {
    let injector = async_injector::Injector::new();

    assert_eq!(false, injector.exists::<u32>().await);
    injector.update(1u32).await;
    assert_eq!(true, injector.exists::<u32>().await);
}

pub async fn exists_key<T>(&self, key: impl AsRef<Key<T>>) -> bool where
    T: Clone + Any + Send + Sync, 

Test if a given value exists by key.

Examples

use async_injector::{Key, Injector};
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let injector = async_injector::Injector::new();
    let k = Key::<u32>::tagged("foo")?;

    assert_eq!(false, injector.exists_key(&k).await);
    injector.update_key(&k, 1u32).await;
    assert_eq!(true, injector.exists_key(&k).await);

    Ok(())
}

pub async fn mutate<T, M, R>(&self, mutator: M) -> Option<R> where
    T: Clone + Any + Send + Sync,
    M: FnMut(&mut T) -> R, 

Mutate the given value by type.

Examples

#[tokio::main]
async fn main() {
    let injector = async_injector::Injector::new();

    injector.update(1u32).await;

    let old = injector.mutate(|value: &mut u32| {
        let old = *value;
        *value += 1;
        old
    }).await;

    assert_eq!(Some(1u32), old);
}

pub async fn mutate_key<T, M, R>(
    &self,
    key: impl AsRef<Key<T>>,
    mutator: M
) -> Option<R> where
    T: Clone + Any + Send + Sync,
    M: FnMut(&mut T) -> R, 

Mutate the given value by key.

Examples

use async_injector::{Key, Injector};
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let injector = async_injector::Injector::new();
    let k = Key::<u32>::tagged("foo")?;

    injector.update_key(&k, 1u32).await;

    let old = injector.mutate_key(&k, |value| {
        let old = *value;
        *value += 1;
        old
    }).await;

    assert_eq!(Some(1u32), old);
    Ok(())
}

pub async fn get<T>(&self) -> Option<T> where
    T: Clone + Any + Send + Sync, 

Get a value from the injector.

Examples

#[tokio::main]
async fn main() {
    let injector = async_injector::Injector::new();

    assert_eq!(None, injector.get::<u32>().await);
    injector.update(1u32).await;
    assert_eq!(Some(1u32), injector.get::<u32>().await);
}

pub async fn get_key<T>(&self, key: impl AsRef<Key<T>>) -> Option<T> where
    T: Clone + Any + Send + Sync, 

Get a value from the injector with the given key.

Examples

use async_injector::{Injector, Key};
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let k1 = Key::<u32>::tagged("foo")?;
    let k2 = Key::<u32>::tagged("bar")?;

    let injector = async_injector::Injector::new();

    assert_eq!(None, injector.get_key(&k1).await);
    assert_eq!(None, injector.get_key(&k2).await);

    injector.update_key(&k1, 1u32).await;

    assert_eq!(Some(1u32), injector.get_key(&k1).await);
    assert_eq!(None, injector.get_key(&k2).await);

    Ok(())
}

pub async fn stream<T>(&self) -> (Stream<T>, Option<T>) where
    T: Clone + Any + Send + Sync, 

Get an existing value and setup a stream for updates at the same time.

Examples

use std::error::Error;

#[derive(Debug, Clone, PartialEq, Eq)]
struct Database;

#[tokio::main]
async fn main() {
    let injector = async_injector::Injector::new();
    let (mut database_stream, mut database) = injector.stream::<Database>().await;

    // Update the key somewhere else.
    tokio::spawn({
        let injector = injector.clone();

        async move {
            injector.update(Database).await;
        }
    });

    let database = loop {
        if let Some(update) = database_stream.recv().await {
            break update;
        }
    };

    assert_eq!(database, Database);
}

pub async fn stream_key<T>(
    &self,
    key: impl AsRef<Key<T>>
) -> (Stream<T>, Option<T>) where
    T: Clone + Any + Send + Sync, 

Get an existing value and setup a stream for updates at the same time.

Examples

use async_injector::{Injector, Key};
use std::error::Error;

#[derive(Debug, Clone, PartialEq, Eq)]
struct Database;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let injector = async_injector::Injector::new();
    let db = Key::<Database>::tagged("foo")?;
    let (mut database_stream, mut database) = injector.stream_key(&db).await;

    // Update the key somewhere else.
    tokio::spawn({
        let db = db.clone();
        let injector = injector.clone();

        async move {
            injector.update_key(&db, Database).await;
        }
    });

    let database = loop {
        if let Some(update) = database_stream.recv().await {
            break update;
        }
    };

    assert_eq!(database, Database);
    Ok(())
}

pub async fn var<T>(&self) -> Ref<T> where
    T: Clone + Any + Send + Sync + Unpin, 

Get a synchronized reference for the given configuration key.

Examples

use std::error::Error;

#[derive(Clone)]
struct Database;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let injector = async_injector::Injector::new();

    let database = injector.var::<Database>().await;

    assert!(database.read().await.is_none());
    injector.update(Database).await;
    assert!(database.read().await.is_some());
    Ok(())
}

pub async fn var_key<T>(&self, key: impl AsRef<Key<T>>) -> Ref<T> where
    T: Clone + Any + Send + Sync + Unpin, 

Get a synchronized reference for the given configuration key.

Examples

use async_injector::{Injector, Key};
use std::error::Error;

#[derive(Clone)]
struct Database;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let injector = async_injector::Injector::new();
    let db = Key::<Database>::tagged("foo")?;

    let database = injector.var_key(&db).await;

    assert!(database.read().await.is_none());
    injector.update_key(&db, Database).await;
    assert!(database.read().await.is_some());
    Ok(())
}

Trait Implementations

impl Clone for Injector

fn clone(&self) -> Injector

Returns a copy of the value.

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

Performs copy-assignment from source.