Trait runtime_injector_actix::Request

pub trait Request {
    fn request(
        injector: &Injector, 
        info: RequestInfo
    ) -> Result<Self, InjectError>;
}

A request to an injector.

Grouping requests

Requests can be grouped together by using tuples to make multiple requests at once. Since there is a limit of 12 supported parameters/dependencies for factories, tuples can also be used to get around that limitation.

use runtime_injector::{Injector, IntoSingleton, Svc};

struct Bar;
struct Baz;
struct Foo(Svc<Bar>, Svc<Baz>);

impl Foo {
    pub fn new((bar, baz): (Svc<Bar>, Svc<Baz>)) -> Self {
        Foo(bar, baz)
    }
}

let mut builder = Injector::builder();
builder.provide(Foo::new.singleton());

let _injector = builder.build();

Owned service requests

Some services can be provided directly via owned pointers (Box<I>). These services can be requested directly via Box<I>, as a collection via Vec<Box<I>>, or lazily via an iterator via Services<I>.

use runtime_injector::{define_module, Injector, IntoTransient, Svc};

#[derive(Default)]
struct Foo;
struct Bar(Box<Foo>);

let module = define_module! {
    services = [
        Foo::default.transient(),
        Bar.transient(),
    ]
};

let mut builder = Injector::builder();
builder.add_module(module);

let injector = builder.build();
let _bar: Box<Bar> = injector.get().unwrap();

Required methods

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

Performs the request to the injector.

Loading content...

Implementations on Foreign Types

impl<T6, T7, T8, T9, T10, T11> Request for (T6, T7, T8, T9, T10, T11) where
    T6: Request,
    T7: Request,
    T8: Request,
    T9: Request,
    T10: Request,
    T11: Request, 

Performs multiple requests at once. This is useful for grouping together related requests.

pub fn request(
    injector: &Injector,
    info: RequestInfo
) -> Result<(T6, T7, T8, T9, T10, T11), InjectError>

impl<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Request for (T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
    T2: Request,
    T3: Request,
    T4: Request,
    T5: Request,
    T6: Request,
    T7: Request,
    T8: Request,
    T9: Request,
    T10: Request,
    T11: Request, 

Performs multiple requests at once. This is useful for grouping together related requests.

pub fn request(
    injector: &Injector,
    info: RequestInfo
) -> Result<(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), InjectError>

impl<T9, T10, T11> Request for (T9, T10, T11) where
    T9: Request,
    T10: Request,
    T11: Request, 

Performs multiple requests at once. This is useful for grouping together related requests.

pub fn request(
    injector: &Injector,
    info: RequestInfo
) -> Result<(T9, T10, T11), InjectError>

impl<I> Request for Vec<Box<I, Global>, Global> where
    I: Interface + ?Sized, 

Requests all the implementations of an interface as owned service pointers. If no provider is registered for the given interface, then this will return an empty Vec<T>. If any provider cannot provide an owned service pointer, then an error is returned instead.

pub fn request(
    injector: &Injector,
    info: RequestInfo
) -> Result<Vec<Box<I, Global>, Global>, InjectError>

impl<T7, T8, T9, T10, T11> Request for (T7, T8, T9, T10, T11) where
    T7: Request,
    T8: Request,
    T9: Request,
    T10: Request,
    T11: Request, 

Performs multiple requests at once. This is useful for grouping together related requests.

pub fn request(
    injector: &Injector,
    info: RequestInfo
) -> Result<(T7, T8, T9, T10, T11), InjectError>

impl<I> Request for Vec<Arc<I>, Global> where
    I: Interface + ?Sized, 

Requests all the implementations of an interface. For sized types, this will return at most one implementation. If no provider is registered for the given interface, then this will return an empty Vec<T>.

pub fn request(
    injector: &Injector,
    info: RequestInfo
) -> Result<Vec<Arc<I>, Global>, InjectError>

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Request for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
    T0: Request,
    T1: Request,
    T2: Request,
    T3: Request,
    T4: Request,
    T5: Request,
    T6: Request,
    T7: Request,
    T8: Request,
    T9: Request,
    T10: Request,
    T11: Request, 

Performs multiple requests at once. This is useful for grouping together related requests.

pub fn request(
    injector: &Injector,
    info: RequestInfo
) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), InjectError>

impl<T11> Request for (T11,) where
    T11: Request, 

Performs multiple requests at once. This is useful for grouping together related requests.

pub fn request(
    injector: &Injector,
    info: RequestInfo
) -> Result<(T11,), InjectError>

impl<I> Request for Box<I, Global> where
    I: Interface + ?Sized, 

Requests an owned pointer to a service or interface. Not all providers can provide owned pointers to their service, so this may fail where Svc<T> requests would otherwise succeed.

pub fn request(
    injector: &Injector,
    info: RequestInfo
) -> Result<Box<I, Global>, InjectError>

impl<T10, T11> Request for (T10, T11) where
    T10: Request,
    T11: Request, 

Performs multiple requests at once. This is useful for grouping together related requests.

pub fn request(
    injector: &Injector,
    info: RequestInfo
) -> Result<(T10, T11), InjectError>

impl<T5, T6, T7, T8, T9, T10, T11> Request for (T5, T6, T7, T8, T9, T10, T11) where
    T5: Request,
    T6: Request,
    T7: Request,
    T8: Request,
    T9: Request,
    T10: Request,
    T11: Request, 

Performs multiple requests at once. This is useful for grouping together related requests.

pub fn request(
    injector: &Injector,
    info: RequestInfo
) -> Result<(T5, T6, T7, T8, T9, T10, T11), InjectError>

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Request for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) where
    T1: Request,
    T2: Request,
    T3: Request,
    T4: Request,
    T5: Request,
    T6: Request,
    T7: Request,
    T8: Request,
    T9: Request,
    T10: Request,
    T11: Request, 

Performs multiple requests at once. This is useful for grouping together related requests.

pub fn request(
    injector: &Injector,
    info: RequestInfo
) -> Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), InjectError>

impl<I> Request for Option<Box<I, Global>> where
    I: Interface + ?Sized, 

Tries to request an ownedservice pointer for a service or interface. If no provider has been registered for it, then returns None. This fails if there are multiple implementations of the given interface or if the service cannot be provided via an owned service pointer.

pub fn request(
    injector: &Injector,
    info: RequestInfo
) -> Result<Option<Box<I, Global>>, InjectError>

impl<T3, T4, T5, T6, T7, T8, T9, T10, T11> Request for (T3, T4, T5, T6, T7, T8, T9, T10, T11) where
    T3: Request,
    T4: Request,
    T5: Request,
    T6: Request,
    T7: Request,
    T8: Request,
    T9: Request,
    T10: Request,
    T11: Request, 

Performs multiple requests at once. This is useful for grouping together related requests.

pub fn request(
    injector: &Injector,
    info: RequestInfo
) -> Result<(T3, T4, T5, T6, T7, T8, T9, T10, T11), InjectError>

impl<I> Request for Arc<I> where
    I: Interface + ?Sized, 

Requests a service pointer to a service or interface. This request fails if there is not exactly one implementation of the given interface.

pub fn request(
    injector: &Injector,
    info: RequestInfo
) -> Result<Arc<I>, InjectError>

impl Request for ()

Performs multiple requests at once. This is useful for grouping together related requests.

pub fn request(
    injector: &Injector,
    info: RequestInfo
) -> Result<(), InjectError>

impl<T4, T5, T6, T7, T8, T9, T10, T11> Request for (T4, T5, T6, T7, T8, T9, T10, T11) where
    T4: Request,
    T5: Request,
    T6: Request,
    T7: Request,
    T8: Request,
    T9: Request,
    T10: Request,
    T11: Request, 

Performs multiple requests at once. This is useful for grouping together related requests.

pub fn request(
    injector: &Injector,
    info: RequestInfo
) -> Result<(T4, T5, T6, T7, T8, T9, T10, T11), InjectError>

impl<I> Request for Option<Arc<I>> where
    I: Interface + ?Sized, 

Tries to request a service pointer for a service or interface. If no provider has been registered for it, then returns None. This fails if there are multiple implementations of the given interface.

pub fn request(
    injector: &Injector,
    info: RequestInfo
) -> Result<Option<Arc<I>>, InjectError>

impl<T8, T9, T10, T11> Request for (T8, T9, T10, T11) where
    T8: Request,
    T9: Request,
    T10: Request,
    T11: Request, 

Performs multiple requests at once. This is useful for grouping together related requests.

pub fn request(
    injector: &Injector,
    info: RequestInfo
) -> Result<(T8, T9, T10, T11), InjectError>

Loading content...

Implementors

impl Request for Injector

Requests the injector used to resolve services.

pub fn request(
    injector: &Injector,
    _info: RequestInfo
) -> Result<Injector, InjectError>

impl Request for RequestInfo

Requests the information about the current request.

pub fn request(
    _injector: &Injector,
    info: RequestInfo
) -> Result<RequestInfo, InjectError>

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

Lazily requests all the implementations of an interface.

pub fn request(
    injector: &Injector,
    info: RequestInfo
) -> Result<Services<I>, InjectError>

Loading content...