Trait runtime_injector_actix::TypedProvider[][src]

pub trait TypedProvider: Provider {
    type Result: Interface;
    fn provide_typed(
        &mut self,
        injector: &Injector,
        request_info: &RequestInfo
    ) -> Result<Arc<Self::Result>, InjectError>; fn provide_owned_typed(
        &mut self,
        _injector: &Injector,
        _request_info: &RequestInfo
    ) -> Result<Box<Self::Result, Global>, InjectError> { ... }
fn with_interface<I>(self) -> InterfaceProvider<I, Self>
    where
        I: InterfaceFor<Self::Result> + ?Sized
, { ... } }
Expand description

A strongly-typed service provider.

Types which implement this trait can provide strongly-typed instances of a particular service type. Examples of typed providers include providers created from service factories or constant providers. This should be preferred over Provider for custom service providers if possible due to the strong type guarantees this provides. Provider is automatically implemented for all types which implement TypedProvider.

Example

use runtime_injector::{
    InjectResult, Injector, RequestInfo, Svc, TypedProvider,
};

struct Foo;

struct FooProvider;
impl TypedProvider for FooProvider {
    type Result = Foo;

    fn provide_typed(
        &mut self,
        _injector: &Injector,
        _request_info: &RequestInfo,
    ) -> InjectResult<Svc<Self::Result>> {
        Ok(Svc::new(Foo))
    }
}

let mut builder = Injector::builder();
builder.provide(FooProvider);

let injector = builder.build();
let _foo: Svc<Foo> = injector.get().unwrap();

Associated Types

type Result: Interface[src]

Expand description

The type of service this can provide.

Loading content...

Required methods

fn provide_typed(
    &mut self,
    injector: &Injector,
    request_info: &RequestInfo
) -> Result<Arc<Self::Result>, InjectError>
[src]

Expand description

Provides an instance of the service. The Injector passed in can be used to retrieve instances of any dependencies this service has.

Loading content...

Provided methods

fn provide_owned_typed(
    &mut self,
    _injector: &Injector,
    _request_info: &RequestInfo
) -> Result<Box<Self::Result, Global>, InjectError>
[src]

Expand description

Provides an owned instance of the service. Not all providers can provide an owned variant of the service.

fn with_interface<I>(self) -> InterfaceProvider<I, Self> where
    I: InterfaceFor<Self::Result> + ?Sized
[src]

Expand description

Provides this service as an implementation of a particular interface. Rather than requesting this service with its concrete type, it can instead be requested by its interface type.

Note: it cannot be requested with its concrete type once it has been assigned an interface.

Example

use runtime_injector::{
    interface, InjectResult, Injector, IntoSingleton, Service, Svc,
    TypedProvider,
};

trait Fooable: Service {
    fn bar(&self) {}
}

interface!(dyn Fooable = [Foo]);

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

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

// Foo can now be requested through its interface of `dyn Fooable`.
let injector = builder.build();
let fooable: Svc<dyn Fooable> = injector.get().unwrap();
fooable.bar();

// It can't be requested through its original type
assert!(injector.get::<Svc<Foo>>().is_err());
Loading content...

Implementors

impl<D, R, F> TypedProvider for SingletonProvider<D, R, F> where
    R: Service,
    F: ServiceFactory<D, Result = R>,
    D: Service
[src]

type Result = R

pub fn provide_typed(
    &mut self,
    injector: &Injector,
    request_info: &RequestInfo
) -> Result<Arc<<SingletonProvider<D, R, F> as TypedProvider>::Result>, InjectError>
[src]

impl<D, R, F> TypedProvider for TransientProvider<D, R, F> where
    R: Service,
    F: ServiceFactory<D, Result = R>,
    D: Service
[src]

type Result = R

pub fn provide_typed(
    &mut self,
    injector: &Injector,
    request_info: &RequestInfo
) -> Result<Arc<<TransientProvider<D, R, F> as TypedProvider>::Result>, InjectError>
[src]

pub fn provide_owned_typed(
    &mut self,
    injector: &Injector,
    request_info: &RequestInfo
) -> Result<Box<<TransientProvider<D, R, F> as TypedProvider>::Result, Global>, InjectError>
[src]

impl<P, F> TypedProvider for ConditionalProvider<P, F> where
    F: Service + Fn(&Injector, &RequestInfo) -> bool,
    P: TypedProvider
[src]

type Result = <P as TypedProvider>::Result

pub fn provide_typed(
    &mut self,
    injector: &Injector,
    request_info: &RequestInfo
) -> Result<Arc<<ConditionalProvider<P, F> as TypedProvider>::Result>, InjectError>
[src]

pub fn provide_owned_typed(
    &mut self,
    injector: &Injector,
    request_info: &RequestInfo
) -> Result<Box<<ConditionalProvider<P, F> as TypedProvider>::Result, Global>, InjectError>
[src]

impl<R> TypedProvider for ConstantProvider<R> where
    R: Service
[src]

type Result = R

pub fn provide_typed(
    &mut self,
    _injector: &Injector,
    _request_info: &RequestInfo
) -> Result<Arc<<ConstantProvider<R> as TypedProvider>::Result>, InjectError>
[src]

Loading content...