Struct runtime_injector::Services

pub struct Services<I: ?Sized + Interface> { /* fields omitted */ }

A collection of all the providers for a particular interface.

If an interface will only have one implementation registered for it, then it may be easier to request Svc<T> from the container instead. However, if multiple implementations are registered (or no implementations are registered), then this will allow all of those implementations to be iterated over.

An iterator over all the implementations of an interface. Each service is activated on demand.

use runtime_injector::{
    interface, Injector, IntoTransient, Services, Svc, TypedProvider,
};

trait Fooable: Send + Sync {
    fn baz(&self) {}
}

interface!(dyn Fooable = [Foo, Bar]);

#[derive(Default)]
struct Foo;
impl Fooable for Foo {}

#[derive(Default)]
struct Bar;
impl Fooable for Bar {}

let mut builder = Injector::builder();
builder.provide(Foo::default.transient().with_interface::<dyn Fooable>());
builder.provide(Bar::default.transient().with_interface::<dyn Fooable>());

let injector = builder.build();
let mut counter = 0;
let mut fooables: Services<dyn Fooable> = injector.get().unwrap();
for foo in fooables.get_all() {
    counter += 1;
    foo.unwrap().baz();
}

assert_eq!(2, counter);

Implementations

impl<I: ?Sized + Interface> Services<I>

pub fn get_all(&mut self) -> ServicesIter<'_, I>

Lazily gets all the implementations of this interface. Each service will be requested on demand rather than all at once.

pub fn get_all_owned(&mut self) -> OwnedServicesIter<'_, I>

Lazily gets all the implementations of this interface as owned service pointers. Each service will be requested on demand rather than all at once. Not all providers can provide owned service pointers, so some requests may fail.

#[must_use]

pub fn len(&self) -> usize

Gets the max number of possible implementations of this interface. This does not take into account conditional providers, which may not return an implementation of the service.

#[must_use]

pub fn is_empty(&self) -> bool

Returns true if there are no possible implementations of this interface. This does not take into account conditional providers, which may not return an implementation of the service.

Trait Implementations

impl<I: ?Sized + Interface> Drop for Services<I>

fn drop(&mut self)

Executes the destructor for this type.

impl<I: ?Sized + Interface> Request for Services<I>

Lazily requests all the implementations of an interface.

fn request(injector: &Injector, info: &RequestInfo) -> InjectResult<Self>

Performs the request to the injector.