Struct mail_core::context::CompositeContext

pub struct CompositeContext<R: ResourceLoaderComponent, O: OffloaderComponent, M: MailIdGenComponent> { /* private fields */ }

The CompositeContext is the simplest way to get an Context implementation.

Any custom Context implementations should be realized through the CompositeContext if possible.

This type consists of 3 components it forward all method calls from Context to. This allows the library to have a single Context type but match and mix the parts about resource loading, offloading and id generation in whichever way it fits best.

The composite context will store the components inside of an Arc so that it can be easily shared through an application, it also means non of the components have to implement Clone.

Implementations

impl<R, O, M> CompositeContext<R, O, M>where
    R: ResourceLoaderComponent,
    O: OffloaderComponent,
    M: MailIdGenComponent,

pub fn new(resource_loader: R, offloader: O, message_id_gen: M) -> Self

Create a new context from the given components.

pub fn resource_loader(&self) -> &R

Returns a reference to the resource loader component.

pub fn offloader(&self) -> &O

Returns a reference to the offloader component.

pub fn id_gen(&self) -> &M

Returns a reference to the id generation component.

Trait Implementations

impl<R, O, M> Clone for CompositeContext<R, O, M>where
    R: ResourceLoaderComponent,
    O: OffloaderComponent,
    M: MailIdGenComponent,

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<R, O, M> Context for CompositeContext<R, O, M>where
    R: ResourceLoaderComponent,
    O: OffloaderComponent,
    M: MailIdGenComponent,

fn load_resource(
    &self,
    source: &Source
) -> SendBoxFuture<MaybeEncData, ResourceLoadingError>

Loads and transfer encodes a Data instance.

fn load_transfer_encoded_resource(
    &self,
    resource: &Resource
) -> SendBoxFuture<EncData, ResourceLoadingError>

Loads and Transfer encodes a Resource instance.

fn offload<F>(&self, fut: F) -> SendBoxFuture<F::Item, F::Error>where
    F: Future + Send + 'static,
    F::Item: Send + 'static,
    F::Error: Send + 'static,

offloads the execution of the future fut to somewhere else e.g. a cpu pool

fn generate_content_id(&self) -> ContentId

generate a unique content id

fn generate_message_id(&self) -> MessageId

generate a unique content id

fn offload_fn<FN, I>(&self, func: FN) -> SendBoxFuture<I::Item, I::Error>where
    FN: FnOnce() -> I + Send + 'static,
    I: IntoFuture + 'static,
    I::Future: Send + 'static,
    I::Item: Send + 'static,
    I::Error: Send + 'static,

offloads the execution of the function func to somewhere else e.g. a cpu pool

impl<R: Debug + ResourceLoaderComponent, O: Debug + OffloaderComponent, M: Debug + MailIdGenComponent> Debug for CompositeContext<R, O, M>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.