Struct amadeus_core::par_sink::ReduceA8Async[−][src]

pub struct ReduceA8Async<A, B, C, D, E, F, G, H, S0, S1, S2, S3, S4, S5, S6, S7> where
    A: Sink<S0>,
    B: Sink<S1>,
    C: Sink<S2>,
    D: Sink<S3>,
    E: Sink<S4>,
    F: Sink<S5>,
    G: Sink<S6>,
    H: Sink<S7>,  { /* fields omitted */ }

Trait Implementations

impl<A, B, C, D, E, F, G, H, S0, S1, S2, S3, S4, S5, S6, S7> PinnedDrop for ReduceA8Async<A, B, C, D, E, F, G, H, S0, S1, S2, S3, S4, S5, S6, S7> where
    A: Sink<S0>,
    B: Sink<S1>,
    C: Sink<S2>,
    D: Sink<S3>,
    E: Sink<S4>,
    F: Sink<S5>,
    G: Sink<S6>,
    H: Sink<S7>, [src]

unsafe fn drop(self: Pin<&mut Self>)[src]

impl<A: Sink<S0>, B: Sink<S1>, C: Sink<S2>, D: Sink<S3>, E: Sink<S4>, F: Sink<S5>, G: Sink<S6>, H: Sink<S7>, S0, S1, S2, S3, S4, S5, S6, S7> Sink<Sum8<S0, S1, S2, S3, S4, S5, S6, S7>> for ReduceA8Async<A, B, C, D, E, F, G, H, S0, S1, S2, S3, S4, S5, S6, S7>[src]

type Done = (A::Done, B::Done, C::Done, D::Done, E::Done, F::Done, G::Done, H::Done)

fn poll_forward(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>,
    stream: Pin<&mut impl Stream<Item = Sum8<S0, S1, S2, S3, S4, S5, S6, S7>>>
) -> Poll<Self::Done>[src]

Returns Poll::Ready when a) it can’t accept any more elements from stream and b) all accepted elements have been fully processed. By convention, stream yielding None typically triggers (a). Read more

fn send(&mut self, item: Item) -> Send<'_, Self, Item>ⓘ

Notable traits for Send<'_, S, Item>

impl<S: ?Sized + Sink<Item> + Unpin, Item> Future for Send<'_, S, Item> type Output = Option<S::Done>;
 where
    Self: Unpin, [src]

fn send_all<'a, S: ?Sized>(
    &'a mut self,
    items: &'a mut S
) -> SendAll<'a, Self, S>ⓘ

Notable traits for SendAll<'_, S, St>

impl<S: ?Sized + Sink<Item> + Unpin, St: ?Sized + Stream<Item = Item> + Unpin, Item> Future for SendAll<'_, S, St> type Output = Option<S::Done>;
 where
    S: Stream<Item = Item> + Unpin,
    Self: Unpin, [src]

fn done(&mut self) -> Done<'_, Self, Item>ⓘ

Notable traits for Done<'_, S, Item>

impl<S: ?Sized + Sink<Item> + Unpin, Item> Future for Done<'_, S, Item> type Output = S::Done;
 where
    Self: Unpin, [src]

impl<'pin, A, B, C, D, E, F, G, H, S0, S1, S2, S3, S4, S5, S6, S7> Unpin for ReduceA8Async<A, B, C, D, E, F, G, H, S0, S1, S2, S3, S4, S5, S6, S7> where
    A: Sink<S0>,
    B: Sink<S1>,
    C: Sink<S2>,
    D: Sink<S3>,
    E: Sink<S4>,
    F: Sink<S5>,
    G: Sink<S6>,
    H: Sink<S7>,
    __ReduceA8Async<'pin, A, B, C, D, E, F, G, H, S0, S1, S2, S3, S4, S5, S6, S7>: Unpin, [src]

impl<A, B, C, D, E, F, G, H, S0, S1, S2, S3, S4, S5, S6, S7> UnsafeUnpin for ReduceA8Async<A, B, C, D, E, F, G, H, S0, S1, S2, S3, S4, S5, S6, S7> where
    A: Sink<S0>,
    B: Sink<S1>,
    C: Sink<S2>,
    D: Sink<S3>,
    E: Sink<S4>,
    F: Sink<S5>,
    G: Sink<S6>,
    H: Sink<S7>, [src]

Auto Trait Implementations

impl<A, B, C, D, E, F, G, H, S0, S1, S2, S3, S4, S5, S6, S7> RefUnwindSafe for ReduceA8Async<A, B, C, D, E, F, G, H, S0, S1, S2, S3, S4, S5, S6, S7> where
    A: RefUnwindSafe,
    B: RefUnwindSafe,
    C: RefUnwindSafe,
    D: RefUnwindSafe,
    E: RefUnwindSafe,
    F: RefUnwindSafe,
    G: RefUnwindSafe,
    H: RefUnwindSafe,
    S0: RefUnwindSafe,
    S1: RefUnwindSafe,
    S2: RefUnwindSafe,
    S3: RefUnwindSafe,
    S4: RefUnwindSafe,
    S5: RefUnwindSafe,
    S6: RefUnwindSafe,
    S7: RefUnwindSafe,
    <A as Sink<S0>>::Done: RefUnwindSafe,
    <B as Sink<S1>>::Done: RefUnwindSafe,
    <C as Sink<S2>>::Done: RefUnwindSafe,
    <D as Sink<S3>>::Done: RefUnwindSafe,
    <E as Sink<S4>>::Done: RefUnwindSafe,
    <F as Sink<S5>>::Done: RefUnwindSafe,
    <G as Sink<S6>>::Done: RefUnwindSafe,
    <H as Sink<S7>>::Done: RefUnwindSafe, 

impl<A, B, C, D, E, F, G, H, S0, S1, S2, S3, S4, S5, S6, S7> Send for ReduceA8Async<A, B, C, D, E, F, G, H, S0, S1, S2, S3, S4, S5, S6, S7> where
    A: Send,
    B: Send,
    C: Send,
    D: Send,
    E: Send,
    F: Send,
    G: Send,
    H: Send,
    S0: Send,
    S1: Send,
    S2: Send,
    S3: Send,
    S4: Send,
    S5: Send,
    S6: Send,
    S7: Send,
    <A as Sink<S0>>::Done: Send,
    <B as Sink<S1>>::Done: Send,
    <C as Sink<S2>>::Done: Send,
    <D as Sink<S3>>::Done: Send,
    <E as Sink<S4>>::Done: Send,
    <F as Sink<S5>>::Done: Send,
    <G as Sink<S6>>::Done: Send,
    <H as Sink<S7>>::Done: Send, 

impl<A, B, C, D, E, F, G, H, S0, S1, S2, S3, S4, S5, S6, S7> Sync for ReduceA8Async<A, B, C, D, E, F, G, H, S0, S1, S2, S3, S4, S5, S6, S7> where
    A: Sync,
    B: Sync,
    C: Sync,
    D: Sync,
    E: Sync,
    F: Sync,
    G: Sync,
    H: Sync,
    S0: Sync,
    S1: Sync,
    S2: Sync,
    S3: Sync,
    S4: Sync,
    S5: Sync,
    S6: Sync,
    S7: Sync,
    <A as Sink<S0>>::Done: Sync,
    <B as Sink<S1>>::Done: Sync,
    <C as Sink<S2>>::Done: Sync,
    <D as Sink<S3>>::Done: Sync,
    <E as Sink<S4>>::Done: Sync,
    <F as Sink<S5>>::Done: Sync,
    <G as Sink<S6>>::Done: Sync,
    <H as Sink<S7>>::Done: Sync, 

impl<A, B, C, D, E, F, G, H, S0, S1, S2, S3, S4, S5, S6, S7> UnwindSafe for ReduceA8Async<A, B, C, D, E, F, G, H, S0, S1, S2, S3, S4, S5, S6, S7> where
    A: UnwindSafe,
    B: UnwindSafe,
    C: UnwindSafe,
    D: UnwindSafe,
    E: UnwindSafe,
    F: UnwindSafe,
    G: UnwindSafe,
    H: UnwindSafe,
    S0: UnwindSafe,
    S1: UnwindSafe,
    S2: UnwindSafe,
    S3: UnwindSafe,
    S4: UnwindSafe,
    S5: UnwindSafe,
    S6: UnwindSafe,
    S7: UnwindSafe,
    <A as Sink<S0>>::Done: UnwindSafe,
    <B as Sink<S1>>::Done: UnwindSafe,
    <C as Sink<S2>>::Done: UnwindSafe,
    <D as Sink<S3>>::Done: UnwindSafe,
    <E as Sink<S4>>::Done: UnwindSafe,
    <F as Sink<S5>>::Done: UnwindSafe,
    <G as Sink<S6>>::Done: UnwindSafe,
    <H as Sink<S7>>::Done: UnwindSafe, 

Blanket Implementations

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

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

Gets the TypeId of self. Read more

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

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

Immutably borrows from an owned value. Read more

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

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

Mutably borrows from an owned value. Read more

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

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

Performs the conversion.

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

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

Performs the conversion.

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]

Performs the conversion.

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]

Performs the conversion.

impl<V, T> VZip<V> for T where
    V: MultiLane<T>, 

pub fn vzip(self) -> V