Struct ServiceProviderFactory

pub struct ServiceProviderFactory<T: Clone + Send + Sync, TS: Strategy + 'static = AnyStrategy> { /* private fields */ }

Performs all checks to build a ServiceProvider on premise that an instance of type T will be available. Therefore, multiple ServiceProvider with a different base can be created very efficiently. This base could e.g. be the ApplicationSettings for the DomainServices or the HttpContext, if one ServiceProvider is generated per HTTP-Request in a WebApi

use {minfac::{Registered, ServiceCollection}};

let mut collection = ServiceCollection::new();
collection.with::<Registered<i32>>().register(|v| v as i64);
let factory = collection.build_factory().expect("Config should be valid");
let provider1 = factory.build(1);
let provider2 = factory.build(2);

assert_eq!(Some(1i64), provider1.get::<i64>());
assert_eq!(Some(2i64), provider2.get::<i64>());

Implementations

impl<TS: Strategy + 'static, T: Identifyable<TS::Id> + Clone + Send + Sync> ServiceProviderFactory<T, TS>

pub fn create( collection: GenericServiceCollection<TS>, parents: RVec<WeakServiceProvider<TS>>, ) -> Result<Self, BuildError<TS>>

pub fn build(&self, remaining: T) -> ServiceProvider<TS>

The ServiceProvider should always be assigned to a variable. Otherwise, a requested shared service it will outlive its ServiceProvider, resulting in a panic if debug_assertions are enabled

use {minfac::{Registered, ServiceCollection}, std::sync::Arc};
let result = std::panic::catch_unwind(|| {
    let mut collection = ServiceCollection::new();
    collection.register_shared(|| Arc::new(42));
    let factory = collection.build_factory().expect("Configuration is valid");
    let x = factory.build(1).get::<Arc<i32>>(); // ServiceProvider is dropped too early
});
assert!(result.is_err());

Examples found in repository

examples/complete.rs (line 24)

fn main() {
    let mut parent_collection = ServiceCollection::new();
    parent_collection
        .with::<AllRegistered<u8>>()
        .register(|bytes| bytes.map(|signed| signed as i8).sum::<i8>());

    parent_collection
        .with::<Registered<Arc<u16>>>()
        .register(|i| *i as u32 * 2);
    parent_collection.register(|| 1u8);
    parent_collection.register_shared(|| Arc::new(10u16));

    let parent_provider = parent_collection
        .build_factory()
        .expect("All dependencies of parent should be resolvable")
        .build(2u8);

    let mut child_collection = ServiceCollection::new();
    child_collection.register(|| 3u8);
    child_collection
        .with::<(WeakServiceProvider, AllRegistered<u8>, Registered<u32>)>()
        .register(|(provider, bytes, int)| {
            provider.get::<Arc<u16>>().map(|i| *i as u64).unwrap_or(1000) // Optional Dependency, fallback not used
                + provider.get::<u128>().map(|i| i as u64).unwrap_or(2000) // Optional Dependency, fallback
                + bytes.map(|i| { i as u64 }).sum::<u64>()
                + int as u64
        });

    let child_provider = child_collection
        .with_parent(&parent_provider)
        .build_factory()
        .expect("All dependencies of child should be resolvable")
        .build(4u8);

    assert_eq!(Some(2), parent_provider.get::<u8>()); // Last registered i8 on parent
    assert_eq!(Some(4), child_provider.get::<u8>()); // Last registered i8 on client

    assert_eq!(
        Some(10 + 2000 + (1 + 2 + 3 + 4) + (2 * 10)),
        child_provider.get::<u64>()
    );

    assert_eq!(
        1 + 2, // Despite u8 beign received by child_provider, u8 is just the sum of i8 from parent
        child_provider.get::<i8>().unwrap()
    );
    println!("Everything works as expected");
}