Enum async_dataloader::BatchLoad[−][src]

pub enum BatchLoad<Input, Output: ?Sized> {
    New {
        load_fn: fn(_: Batch) -> Pin<Box<dyn Future<Output = ()>>>,
        input: Box<Input>,
        phantom: PhantomData<Box<Output>>,
    },
    Pending(Receiver<Box<dyn Any>>),
}

Future returned by a batch loader

Variants

New

Fields of New

load_fn: fn(_: Batch) -> Pin<Box<dyn Future<Output = ()>>>input: Box<Input>phantom: PhantomData<Box<Output>>

Pending(Receiver<Box<dyn Any>>)

Implementations

`impl<Input: 'static, Output: ?Sized> BatchLoad<Input, Output>`[src]

`pub fn schedule(&mut self)`[src]

Schedules this input to be loaded within the current batch context.

Rust futures are lazy, meaning they have do nothing until polled. Calling this method will cause the load to be added to the next batch, even if it the future is not polled until later.

Trait Implementations

`impl<Input: 'static, Output: 'static> Future for BatchLoad<Input, Output>`[src]

`type Output = Box<Output>`

The type of value produced on completion.

`fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>`[src]

Auto Trait Implementations

`impl<Input, Output> !RefUnwindSafe for BatchLoad<Input, Output>`

`impl<Input, Output> !Send for BatchLoad<Input, Output>`

`impl<Input, Output> !Sync for BatchLoad<Input, Output>`

`impl<Input, Output: ?Sized> Unpin for BatchLoad<Input, Output>`

`impl<Input, Output> !UnwindSafe for BatchLoad<Input, Output>`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`pub fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`pub fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`pub fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> From<T> for T`[src]

`pub fn from(t: T) -> T`[src]

`impl<T> FutureExt for T where T: Future + ?Sized,`

`pub fn map<U, F>(self, f: F) -> Map<Self, F> where F: FnOnce(Self::Output) -> U,`

`pub fn map_into<U>(self) -> MapInto<Self, U> where Self::Output: Into<U>,`

`pub fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where F: FnOnce(Self::Output) -> Fut, Fut: Future,`

`pub fn left_future<B>(self) -> Either<Self, B> where B: Future<Output = Self::Output>,`

`pub fn right_future<A>(self) -> Either<A, Self> where A: Future<Output = Self::Output>,`

`pub fn into_stream(self) -> IntoStream<Self>`

`pub fn flatten(self) -> Flatten<Self> where Self::Output: Future,`

`pub fn flatten_stream(self) -> FlattenStream<Self> where Self::Output: Stream,`

`pub fn fuse(self) -> Fuse<Self>`

`pub fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnOnce(&Self::Output),`

`pub fn catch_unwind(self) -> CatchUnwind<Self> where Self: UnwindSafe,`

`pub fn shared(self) -> Shared<Self> where Self::Output: Clone,`

`pub fn remote_handle(self) -> (Remote<Self>, RemoteHandle<Self::Output>)`

`pub fn boxed<'a>( self ) -> Pin<Box<dyn Future<Output = Self::Output> + 'a + Send, Global>> where Self: Send + 'a,`

`pub fn boxed_local<'a>( self ) -> Pin<Box<dyn Future<Output = Self::Output> + 'a, Global>> where Self: 'a,`

`pub fn unit_error(self) -> UnitError<Self>`

`pub fn never_error(self) -> NeverError<Self>`

`pub fn poll_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Self::Output> where Self: Unpin,`

`pub fn now_or_never(self) -> Option<Self::Output>`

`impl<T, U> Into<U> for T where U: From<T>,` [src]

`pub fn into(self) -> U`[src]

`impl<F> IntoFuture for F where F: Future,` [src]

`type Output = <F as Future>::Output`

🔬 This is a nightly-only experimental API. (into_future)

The output that the future will produce on completion.

`type Future = F`

🔬 This is a nightly-only experimental API. (into_future)

Which kind of future are we turning this into?

`pub fn into_future(self) -> <F as IntoFuture>::Future`[src]

`impl<T, U> TryFrom<U> for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

`impl<T, U> TryInto<U> for T where U: TryFrom<T>,` [src]

`type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

`pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]

Enum async_dataloader::BatchLoad[−][src]

Variants

Fields of New

Implementations

impl<Input: 'static, Output: ?Sized> BatchLoad<Input, Output>[src]

pub fn schedule(&mut self)[src]

Trait Implementations

impl<Input: 'static, Output: 'static> Future for BatchLoad<Input, Output>[src]

type Output = Box<Output>

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>[src]

Auto Trait Implementations

impl<Input, Output> !RefUnwindSafe for BatchLoad<Input, Output>

impl<Input, Output> !Send for BatchLoad<Input, Output>

impl<Input, Output> !Sync for BatchLoad<Input, Output>

impl<Input, Output: ?Sized> Unpin for BatchLoad<Input, Output>

impl<Input, Output> !UnwindSafe for BatchLoad<Input, Output>

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized, [src]

pub fn type_id(&self) -> TypeId[src]

impl<T> Borrow<T> for T where T: ?Sized, [src]

pub fn borrow(&self) -> &T[src]

impl<T> BorrowMut<T> for T where T: ?Sized, [src]

pub fn borrow_mut(&mut self) -> &mut T[src]

impl<T> From<T> for T[src]

pub fn from(t: T) -> T[src]

impl<T> FutureExt for T where T: Future + ?Sized,

pub fn map<U, F>(self, f: F) -> Map<Self, F> where F: FnOnce(Self::Output) -> U,

pub fn map_into<U>(self) -> MapInto<Self, U> where Self::Output: Into<U>,

pub fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where F: FnOnce(Self::Output) -> Fut, Fut: Future,

pub fn left_future<B>(self) -> Either<Self, B> where B: Future<Output = Self::Output>,

pub fn right_future<A>(self) -> Either<A, Self> where A: Future<Output = Self::Output>,

pub fn into_stream(self) -> IntoStream<Self>

pub fn flatten(self) -> Flatten<Self> where Self::Output: Future,

pub fn flatten_stream(self) -> FlattenStream<Self> where Self::Output: Stream,

pub fn fuse(self) -> Fuse<Self>

pub fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnOnce(&Self::Output),

pub fn catch_unwind(self) -> CatchUnwind<Self> where Self: UnwindSafe,

pub fn shared(self) -> Shared<Self> where Self::Output: Clone,

pub fn remote_handle(self) -> (Remote<Self>, RemoteHandle<Self::Output>)

pub fn boxed<'a>( self) -> Pin<Box<dyn Future<Output = Self::Output> + 'a + Send, Global>> where Self: Send + 'a,

pub fn boxed_local<'a>( self) -> Pin<Box<dyn Future<Output = Self::Output> + 'a, Global>> where Self: 'a,

pub fn unit_error(self) -> UnitError<Self>

pub fn never_error(self) -> NeverError<Self>

pub fn poll_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Self::Output> where Self: Unpin,

pub fn now_or_never(self) -> Option<Self::Output>

impl<T, U> Into<U> for T where U: From<T>, [src]

pub fn into(self) -> U[src]

impl<F> IntoFuture for F where F: Future, [src]

type Output = <F as Future>::Output

type Future = F

pub fn into_future(self) -> <F as IntoFuture>::Future[src]

impl<T, U> TryFrom<U> for T where U: Into<T>, [src]

type Error = Infallible

pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]

impl<T, U> TryInto<U> for T where U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]