Struct UseContext 

pub struct UseContext;

The UseContext pattern is used to define a trivial implementation of a provider trait, by forwarding the implementation to the consumer trait implementation of the context.

This pattern is the dual of the blanket implementation of a consumer trait, which forwards the implementation to its provider through the CgpProvider trait.

The main use case for UseContext is to be used as a higher-order provider in the argument to a different provider implementation. This decouples the dependencies between different CGP traits, and allows non-default providers to be used within another provider implementation.

For obvious reasons, UseContext should not be used as the delegation target from the context provider, as it would result in a cyclic dependency error.

The UseContext provider is automatically implemented for all CPG traits that are generated from #[cgp_component].

Example

Given the following component definition:

#[cgp_component(Greeter)]
pub trait CanGreet {
    fn greet(&self);
}

The following UseContext implementation would be generated:

impl<Context> Greeter<Context> for UseContext
where
    Context: CanGreet,
{
    fn greet(context: &Context) {
        context.greet()
    }
}

Trait Implementations

impl<__Context__, Code, Input> AsyncComputer<__Context__, Code, Input> for UseContext

where __Context__: CanComputeAsync<Code, Input>,

type Output = <__Context__ as CanComputeAsync<Code, Input>>::Output

fn compute_async( __context__: &__Context__, _code: PhantomData<Code>, input: Input, ) -> impl Future<Output = <UseContext as AsyncComputer<__Context__, Code, Input>>::Output>

impl<__Context__, Code, Input> AsyncComputerRef<__Context__, Code, Input> for UseContext

where __Context__: CanComputeAsyncRef<Code, Input>,

type Output = <__Context__ as CanComputeAsyncRef<Code, Input>>::Output

fn compute_async_ref( __context__: &__Context__, _code: PhantomData<Code>, input: &Input, ) -> impl Future<Output = <UseContext as AsyncComputerRef<__Context__, Code, Input>>::Output>

impl<__Context__, Code, Input> Computer<__Context__, Code, Input> for UseContext

where __Context__: CanCompute<Code, Input>,

type Output = <__Context__ as CanCompute<Code, Input>>::Output

fn compute( __context__: &__Context__, _code: PhantomData<Code>, input: Input, ) -> <UseContext as Computer<__Context__, Code, Input>>::Output

impl<__Context__, Code, Input> ComputerRef<__Context__, Code, Input> for UseContext

where __Context__: CanComputeRef<Code, Input>,

type Output = <__Context__ as CanComputeRef<Code, Input>>::Output

fn compute_ref( __context__: &__Context__, _code: PhantomData<Code>, input: &Input, ) -> <UseContext as ComputerRef<__Context__, Code, Input>>::Output

impl<__Context__, SourceError> ErrorRaiser<__Context__, SourceError> for UseContext

where __Context__: HasErrorType + CanRaiseError<SourceError>,

The CanRaiseError trait is used to raise any concrete error type into an abstract error provided by HasErrorType.

fn raise_error(error: SourceError) -> <__Context__ as HasErrorType>::Error

impl<__Context__> ErrorTypeProvider<__Context__> for UseContext

where __Context__: HasErrorType,

The HasErrorType trait provides an abstract error type that can be used by CGP components to decouple the code from any concrete error implementation.

Although it is possible for each context to declare their own associated Error type, doing so may result in having multiple ambiguous Self::Error types, if there are multiple associated types with the same name in different traits.

As a result, it is better for context traits to include HasError as their parent traits, so that multiple traits can all refer to the same abstract Self::Error type.

The Error associated type is also required to implement Debug. This is to allow Self::Error to be used in calls like .unwrap(), as well as for simpler error logging.

More details about how to use HasErrorType is available at https://patterns.contextgeneric.dev/error-handling.html

type Error = <__Context__ as HasErrorType>::Error

impl<__Context__, Detail> ErrorWrapper<__Context__, Detail> for UseContext

where __Context__: HasErrorType + CanWrapError<Detail>,

fn wrap_error( error: <__Context__ as HasErrorType>::Error, detail: Detail, ) -> <__Context__ as HasErrorType>::Error

impl<Context, Tag, Field> FieldGetter<Context, Tag> for UseContext

where Context: HasField<Tag, Value = Field>,

type Value = Field

fn get_field( context: &Context, _tag: PhantomData<Tag>, ) -> &<UseContext as FieldGetter<Context, Tag>>::Value

impl<__Context__, Code, Input> Handler<__Context__, Code, Input> for UseContext

where __Context__: HasErrorType + CanHandle<Code, Input>,

type Output = <__Context__ as CanHandle<Code, Input>>::Output

fn handle( __context__: &__Context__, _tag: PhantomData<Code>, input: Input, ) -> impl Future<Output = Result<<UseContext as Handler<__Context__, Code, Input>>::Output, <__Context__ as HasErrorType>::Error>>

impl<__Context__, Code, Input> HandlerRef<__Context__, Code, Input> for UseContext

where __Context__: HasErrorType + CanHandleRef<Code, Input>,

type Output = <__Context__ as CanHandleRef<Code, Input>>::Output

fn handle_ref( __context__: &__Context__, _tag: PhantomData<Code>, input: &Input, ) -> impl Future<Output = Result<<UseContext as HandlerRef<__Context__, Code, Input>>::Output, <__Context__ as HasErrorType>::Error>>

impl<__Context__, Code> Producer<__Context__, Code> for UseContext

where __Context__: CanProduce<Code>,

type Output = <__Context__ as CanProduce<Code>>::Output

fn produce( __context__: &__Context__, _code: PhantomData<Code>, ) -> <UseContext as Producer<__Context__, Code>>::Output

impl<__Context__, Code> Runner<__Context__, Code> for UseContext

where __Context__: HasErrorType + CanRun<Code>,

async fn run( __context__: &__Context__, _code: PhantomData<Code>, ) -> Result<(), <__Context__ as HasErrorType>::Error>

impl<__Context__> RuntimeGetter<__Context__> for UseContext

where __Context__: HasRuntimeType + HasRuntime,

fn runtime( __context__: &__Context__, ) -> &<__Context__ as HasRuntimeType>::Runtime

impl<__Context__> RuntimeTypeProvider<__Context__> for UseContext

where __Context__: HasRuntimeType,

type Runtime = <__Context__ as HasRuntimeType>::Runtime

impl<__Context__, Code> SendRunner<__Context__, Code> for UseContext

where __Context__: HasErrorType + CanSendRun<Code>,

fn send_run( __context__: &__Context__, _code: PhantomData<Code>, ) -> impl Future<Output = Result<(), <__Context__ as HasErrorType>::Error>> + Send

impl<__Context__, Code, Input> TryComputer<__Context__, Code, Input> for UseContext

where __Context__: HasErrorType + CanTryCompute<Code, Input>,

type Output = <__Context__ as CanTryCompute<Code, Input>>::Output

fn try_compute( __context__: &__Context__, _code: PhantomData<Code>, input: Input, ) -> Result<<UseContext as TryComputer<__Context__, Code, Input>>::Output, <__Context__ as HasErrorType>::Error>

impl<__Context__, Code, Input> TryComputerRef<__Context__, Code, Input> for UseContext

where __Context__: HasErrorType + CanTryComputeRef<Code, Input>,

type Output = <__Context__ as CanTryComputeRef<Code, Input>>::Output

fn try_compute_ref( __context__: &__Context__, _code: PhantomData<Code>, input: &Input, ) -> Result<<UseContext as TryComputerRef<__Context__, Code, Input>>::Output, <__Context__ as HasErrorType>::Error>

impl<__Context__, Tag> TypeProvider<__Context__, Tag> for UseContext

where __Context__: HasType<Tag>,

type Type = <__Context__ as HasType<Tag>>::Type

impl<__Context__, Code, Input> IsProviderFor<AsyncComputerComponent, __Context__, (Code, Input)> for UseContext

where __Context__: CanComputeAsync<Code, Input>,

impl<__Context__, Code, Input> IsProviderFor<AsyncComputerRefComponent, __Context__, (Code, Input)> for UseContext

where __Context__: CanComputeAsyncRef<Code, Input>,

impl<__Context__, Code, Input> IsProviderFor<ComputerComponent, __Context__, (Code, Input)> for UseContext

where __Context__: CanCompute<Code, Input>,

impl<__Context__, Code, Input> IsProviderFor<ComputerRefComponent, __Context__, (Code, Input)> for UseContext

where __Context__: CanComputeRef<Code, Input>,

impl<__Context__, SourceError> IsProviderFor<ErrorRaiserComponent, __Context__, SourceError> for UseContext

where __Context__: HasErrorType + CanRaiseError<SourceError>,

impl<__Context__> IsProviderFor<ErrorTypeProviderComponent, __Context__> for UseContext

where __Context__: HasErrorType,

impl<__Context__, Detail> IsProviderFor<ErrorWrapperComponent, __Context__, Detail> for UseContext

where __Context__: HasErrorType + CanWrapError<Detail>,

impl<__Context__, Code, Input> IsProviderFor<HandlerComponent, __Context__, (Code, Input)> for UseContext

where __Context__: HasErrorType + CanHandle<Code, Input>,

impl<__Context__, Code, Input> IsProviderFor<HandlerRefComponent, __Context__, (Code, Input)> for UseContext

where __Context__: HasErrorType + CanHandleRef<Code, Input>,

impl<__Context__, Code> IsProviderFor<ProducerComponent, __Context__, Code> for UseContext

where __Context__: CanProduce<Code>,

impl<__Context__, Code> IsProviderFor<RunnerComponent, __Context__, Code> for UseContext

where __Context__: HasErrorType + CanRun<Code>,

impl<__Context__> IsProviderFor<RuntimeGetterComponent, __Context__> for UseContext

where __Context__: HasRuntimeType + HasRuntime,

impl<__Context__> IsProviderFor<RuntimeTypeProviderComponent, __Context__> for UseContext

where __Context__: HasRuntimeType,

impl<__Context__, Code> IsProviderFor<SendRunnerComponent, __Context__, Code> for UseContext

where __Context__: HasErrorType + CanSendRun<Code>,

impl<__Context__, Code, Input> IsProviderFor<TryComputerComponent, __Context__, (Code, Input)> for UseContext

where __Context__: HasErrorType + CanTryCompute<Code, Input>,

impl<__Context__, Code, Input> IsProviderFor<TryComputerRefComponent, __Context__, (Code, Input)> for UseContext

where __Context__: HasErrorType + CanTryComputeRef<Code, Input>,

impl<__Context__, Tag> IsProviderFor<TypeProviderComponent, __Context__, Tag> for UseContext

where __Context__: HasType<Tag>,