Struct rudi::TransientProvider

pub struct TransientProvider<T> { /* private fields */ }

Represents a specialized Provider.

Use the transient function to create this provider.

Implementations

impl<T> TransientProvider<T>

pub fn name<N>(self, name: N) -> Self

where N: Into<Cow<'static, str>>,

Sets the name of the provider.

pub fn eager_create(self, eager_create: bool) -> Self

Sets whether the provider is eager to create.

pub fn condition(self, condition: Option<fn(_: &Context) -> bool>) -> Self

Sets whether or not to insert the provider into the Context based on the condition.

impl<T: 'static> TransientProvider<T>

pub fn bind<U, F>(self, transform: F) -> Self

where U: 'static, F: Fn(T) -> U + 'static,

Create a provider of type Provider<U>, save it to the current provider.

This method accepts a parameter of fn(T) -> U, which in combination with the current provider’s constructor of type fn(&mut Context) -> T, creates a Provider<U> with constructor fn(&mut Context) -> U and other fields consistent with the current provider.

All bound providers will be registered together when the current provider is registered in the Context.

Example

use std::{fmt::Debug, rc::Rc, sync::Arc};

use rudi::{transient, Provider, TransientProvider};

#[derive(Clone, Debug)]
struct A(i32);

fn into_debug(a: A) -> Rc<dyn Debug> {
    Rc::new(a)
}

fn main() {
    let p: TransientProvider<A> = transient(|cx| A(cx.resolve()))
        .bind(Rc::new)
        .bind(Arc::new)
        .bind(Box::new)
        .bind(into_debug);

    let p: Provider<A> = p.into();

    assert_eq!(p.binding_definitions().unwrap().len(), 4);
}

Trait Implementations

impl<T: 'static> From<TransientProvider<T>> for DynProvider

fn from(value: TransientProvider<T>) -> Self

Converts to this type from the input type.

impl<T: 'static> From<TransientProvider<T>> for Provider<T>

fn from(value: TransientProvider<T>) -> Self

Converts to this type from the input type.