[−][src]Struct flv_future_aio::net::Incoming

pub struct Incoming<'a>(_);

A stream of incoming TCP connections.

This stream is infinite, i.e awaiting the next connection will never result in None. It is created by the incoming method on TcpListener.

This type is an async version of std::net::Incoming.

Trait Implementations

`impl<'a> Debug for Incoming<'a>`[src]

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<'a> Stream for Incoming<'a>`[src]

`type Item = Result<TcpStream, Error>`

Values yielded by the stream.

`fn poll_next( self: Pin<&mut Incoming<'a>>, cx: &mut Context<'_> ) -> Poll<Option<<Incoming<'a> as Stream>::Item>>`[src]

`fn size_hint(&self) -> (usize, Option<usize>)`[src]

Auto Trait Implementations

`impl<'a> RefUnwindSafe for Incoming<'a>`

`impl<'a> Send for Incoming<'a>`

`impl<'a> Sync for Incoming<'a>`

`impl<'a> Unpin for Incoming<'a>`

`impl<'a> UnwindSafe for Incoming<'a>`

Blanket Implementations

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

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

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

`fn borrow(&self) -> &TⓘNotable traits for &'_ mut F impl<'_, F> Future for &'_ mut F where F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`[src]

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

`fn borrow_mut(&mut self) -> &mut TⓘNotable traits for &'_ mut F impl<'_, F> Future for &'_ mut F where F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`[src]

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

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

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

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

`impl IntoStream for I where I: Stream,` [src]

`type Item = ::Item`

The type of the elements being iterated over.

`type IntoStream = I`

Which kind of stream are we turning this into?

`fn into_stream(self) -> I`[src]

`impl<T> StreamExt for T where T: Stream + ?Sized,` [src]

`fn next(&mut self) -> NextFuture<'_, Self> where Self: Unpin,` [src]

`fn take(self, n: usize) -> Take<Self>`[src]

`fn take_while(self, predicate: P) -> TakeWhile<Self, P> where P: FnMut(&Self::Item) -> bool,` [src]

`fn throttle(self, d: Duration) -> Throttle<Self>`[src]

`fn step_by(self, step: usize) -> StepBy<Self>`[src]

`fn chain(self, other: U) -> Chain<Self, U> where U: Stream<Item = Self::Item>,` [src]

`fn cloned<'a, T>(self) -> Cloned<Self> where Self: Stream<Item = &'a T>, T: Clone + 'a,` [src]

`fn copied<'a, T>(self) -> Copied<Self> where Self: Stream<Item = &'a T>, T: Copy + 'a,` [src]

`fn cycle(self) -> Cycle<Self> where Self: Clone,` [src]

`fn enumerate(self) -> Enumerate<Self>`[src]

`fn delay(self, dur: Duration) -> Delay<Self>`[src]

`fn map<B, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> B,` [src]

`fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item),` [src]

`fn last(self) -> LastFuture<Self, Self::Item>`[src]

`fn fuse(self) -> Fuse<Self>`[src]

`fn filter(self, predicate: P) -> Filter<Self, P> where P: FnMut(&Self::Item) -> bool,` [src]

`fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where F: FnMut(Self::Item) -> U, U: IntoStream,` [src]

`fn flatten(self) -> Flatten<Self> where Self::Item: IntoStream,` [src]

`fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where F: FnMut(Self::Item) -> Option,` [src]

`fn min_by_key<B, F>(self, key_by: F) -> MinByKeyFuture<Self, Self::Item, F> where B: Ord, F: FnMut(&Self::Item) -> B,` [src]

`fn max_by_key<B, F>(self, key_by: F) -> MaxByKeyFuture<Self, Self::Item, F> where B: Ord, F: FnMut(&Self::Item) -> B,` [src]

`fn min_by<F>(self, compare: F) -> MinByFuture<Self, F, Self::Item> where F: FnMut(&Self::Item, &Self::Item) -> Ordering,` [src]

`fn max(self) -> MaxFuture<Self, Self::Item> where Self::Item: Ord,` [src]

`fn min(self) -> MinFuture<Self, Self::Item> where Self::Item: Ord,` [src]

`fn max_by<F>(self, compare: F) -> MaxByFuture<Self, F, Self::Item> where F: FnMut(&Self::Item, &Self::Item) -> Ordering,` [src]

`fn nth(&mut self, n: usize) -> NthFuture<'_, Self> where Self: Unpin,` [src]

`fn all<F>(&mut self, f: F) -> AllFuture<'_, Self, F, Self::Item> where F: FnMut(Self::Item) -> bool, Self: Unpin,` [src]

`fn find(&mut self, p: P) -> FindFuture<'_, Self, P> where P: FnMut(&Self::Item) -> bool, Self: Unpin,` [src]

`fn find_map<F, B>(&mut self, f: F) -> FindMapFuture<'_, Self, F> where F: FnMut(Self::Item) -> Option, Self: Unpin,` [src]

`fn fold<B, F>(self, init: B, f: F) -> FoldFuture<Self, F, B> where F: FnMut(B, Self::Item) -> B,` [src]

`fn partition<B, F>(self, f: F) -> PartitionFuture<Self, F, B> where B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool,` [src]

`fn for_each<F>(self, f: F) -> ForEachFuture<Self, F> where F: FnMut(Self::Item),` [src]

`fn any<F>(&mut self, f: F) -> AnyFuture<'_, Self, F, Self::Item> where F: FnMut(Self::Item) -> bool, Self: Unpin,` [src]

`fn by_ref(&mut self) -> &mut SelfⓘNotable traits for &'_ mut F impl<'_, F> Future for &'_ mut F where F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`[src]

`fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where F: FnMut(&mut St, Self::Item) -> Option,` [src]

`fn skip_while(self, predicate: P) -> SkipWhile<Self, P> where P: FnMut(&Self::Item) -> bool,` [src]

`fn skip(self, n: usize) -> Skip<Self>`[src]

`fn timeout(self, dur: Duration) -> Timeout<Self> where Self: Stream,` [src]

`fn try_fold<B, F, T, E>( &mut self, init: T, f: F ) -> TryFoldFuture<'_, Self, F, T> where F: FnMut(B, Self::Item) -> Result<T, E>, Self: Unpin,` [src]

`fn try_for_each<F, E>(&mut self, f: F) -> TryForEachFuture<'_, Self, F> where F: FnMut(Self::Item) -> Result<(), E>, Self: Unpin,` [src]

`fn zip(self, other: U) -> Zip<Self, U> where U: Stream,` [src]

`fn unzip<A, B, FromA, FromB>(self) -> UnzipFuture<Self, FromA, FromB> where FromA: Default + Extend<A>, FromB: Default + Extend, Self: Stream<Item = (A, B)>,` [src]

`fn collect<'a, B>(self) -> Pin<Box<dyn Future<Output = B> + 'a + Send>>ⓘNotable traits for Pin impl Future for Pin where P: Unpin + DerefMut, ::Target: Future, type Output = <::Target as Future>::Output; where B: FromStream<Self::Item>, Self: 'a + Send, Self::Item: Send,` [src]

`fn merge(self, other: U) -> Merge<Self, U> where U: Stream<Item = Self::Item>,` [src]

`fn partial_cmp<S>(self, other: S) -> PartialCmpFuture<Self, S> where S: Stream, Self: Stream, Self::Item: PartialOrd<<S as Stream>::Item>,` [src]

`fn position(&mut self, predicate: P) -> PositionFuture<'_, Self, P> where P: FnMut(Self::Item) -> bool, Self: Unpin,` [src]

`fn cmp<S>(self, other: S) -> CmpFuture<Self, S> where S: Stream, Self: Stream, Self::Item: Ord,` [src]

`fn count(self) -> CountFuture<Self>`[src]

`fn ne<S>(self, other: S) -> NeFuture<Self, S> where S: Stream, Self::Item: PartialEq<<S as Stream>::Item>,` [src]

`fn ge<S>(self, other: S) -> GeFuture<Self, S> where S: Stream, Self: Stream, Self::Item: PartialOrd<<S as Stream>::Item>,` [src]

`fn eq<S>(self, other: S) -> EqFuture<Self, S> where S: Stream, Self: Stream, Self::Item: PartialEq<<S as Stream>::Item>,` [src]

`fn gt<S>(self, other: S) -> GtFuture<Self, S> where S: Stream, Self: Stream, Self::Item: PartialOrd<<S as Stream>::Item>,` [src]

`fn le<S>(self, other: S) -> LeFuture<Self, S> where S: Stream, Self: Stream, Self::Item: PartialOrd<<S as Stream>::Item>,` [src]

`fn lt<S>(self, other: S) -> LtFuture<Self, S> where S: Stream, Self: Stream, Self::Item: PartialOrd<<S as Stream>::Item>,` [src]

`fn sum<'a, S>(self) -> Pin<Box<dyn Future<Output = S> + 'a>>ⓘNotable traits for Pin impl Future for Pin where P: Unpin + DerefMut, ::Target: Future, type Output = <::Target as Future>::Output; where S: Sum<Self::Item>, Self: Stream<Item = S> + 'a,` [src]

`fn product<'a, P>(self) -> Pin<Box<dyn Future<Output = P> + 'a>>ⓘNotable traits for Pin impl Future for Pin where P: Unpin + DerefMut, ::Target: Future, type Output = <::Target as Future>::Output; where P: Product, Self: Stream<Item = P> + 'a,` [src]

`impl<S> StreamExt for S where S: Stream + ?Sized,`

`fn next(&mut self) -> NextFuture<'_, Self>ⓘNotable traits for NextFuture<'_, S> impl<'_, S> Future for NextFuture<'_, S> where S: Unpin + Stream + ?Sized, type Output = Option<<S as Stream>::Item>; where Self: Unpin,`

`fn count(self) -> CountFuture<Self>ⓘNotable traits for CountFuture<S> impl<S> Future for CountFuture<S> where S: Stream + ?Sized, type Output = usize;`

`fn map<T, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> T,`

`fn filter(self, predicate: P) -> Filter<Self, P> where P: FnMut(&Self::Item) -> bool,`

`fn filter_map<T, F>(self, f: F) -> FilterMap<Self, F> where F: FnMut(Self::Item) -> Option<T>,`

`fn collect<C>(self) -> CollectFuture<Self, C>ⓘNotable traits for CollectFuture<S, C> impl<S, C> Future for CollectFuture<S, C> where C: Default + Extend<<S as Stream>::Item>, S: Stream, type Output = C; where C: Default + Extend<Self::Item>,`

`fn try_collect<T, C>(self) -> TryCollectFuture<Self, C>ⓘNotable traits for TryCollectFuture<S, C> impl<T, E, S, C> Future for TryCollectFuture<S, C> where C: Default + Extend<T>, S: Stream<Item = Result<T, E>>, type Output = Result<C, E>; where C: Default + Extend<T>, Self::Item: Result, <Self::Item as Result>::Ok == T,`

`fn fold<T, F>(self, init: T, f: F) -> FoldFuture<Self, F, T>ⓘNotable traits for FoldFuture<S, F, T> impl<S, F, T> Future for FoldFuture<S, F, T> where F: FnMut(T, <S as Stream>::Item) -> T, S: Stream, type Output = T; where F: FnMut(T, Self::Item) -> T,`

fn try_fold<T, E, F, B>( &mut self, init: B, f: F ) -> TryFoldFuture<'_, Self, F, B>ⓘNotable traits for TryFoldFuture<'a, S, F, B> impl<'a, T, E, S, F, B> Future for TryFoldFuture<'a, S, F, B> where F: FnMut(B, T) -> Result<B, E>, S: Stream + Unpin, <S as Stream>::Item: Result, <<S as Stream>::Item as Result>::Ok == T, <<S as Stream>::Item as Result>::Err == E, type Output = Result<B, E>; where F: FnMut(B, T) -> Result<B, E>, Self: Unpin, Self::Item: Result, <Self::Item as Result>::Ok == T, <Self::Item as Result>::Err == E,

`fn boxed(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'static + Send>>ⓘNotable traits for Pin impl Future for Pin where P: Unpin + DerefMut, ::Target: Future, type Output = <::Target as Future>::Output; where Self: Send + 'static,`

`fn boxed_local(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'static>>ⓘNotable traits for Pin impl Future for Pin where P: Unpin + DerefMut, ::Target: Future, type Output = <::Target as Future>::Output; where Self: 'static,`

`impl<St> StreamExt for St where St: Stream + ?Sized,` [src]

`fn next(&mut self) -> Next<'_, Self> where Self: Unpin,` [src]

`fn try_next<T, E>(&mut self) -> TryNext<'_, Self> where Self: Stream<Item = Result<T, E>> + Unpin,` [src]

`fn map<T, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> T,` [src]

`fn merge(self, other: U) -> Merge<Self, U> where U: Stream<Item = Self::Item>,` [src]

`fn filter<F>(self, f: F) -> Filter<Self, F> where F: FnMut(&Self::Item) -> bool,` [src]

`fn filter_map<T, F>(self, f: F) -> FilterMap<Self, F> where F: FnMut(Self::Item) -> Option<T>,` [src]

`fn fuse(self) -> Fuse<Self>`[src]

`fn take(self, n: usize) -> Take<Self>`[src]

`fn take_while<F>(self, f: F) -> TakeWhile<Self, F> where F: FnMut(&Self::Item) -> bool,` [src]

`fn skip(self, n: usize) -> Skip<Self>`[src]

`fn skip_while<F>(self, f: F) -> SkipWhile<Self, F> where F: FnMut(&Self::Item) -> bool,` [src]

`fn all<F>(&mut self, f: F) -> AllFuture<'_, Self, F> where F: FnMut(Self::Item) -> bool, Self: Unpin,` [src]

`fn any<F>(&mut self, f: F) -> AnyFuture<'_, Self, F> where F: FnMut(Self::Item) -> bool, Self: Unpin,` [src]

`fn chain(self, other: U) -> Chain<Self, U> where U: Stream<Item = Self::Item>,` [src]

`fn fold<B, F>(self, init: B, f: F) -> FoldFuture<Self, B, F> where F: FnMut(B, Self::Item) -> B,` [src]

`fn collect<T>(self) -> Collect<Self, T> where T: FromStream<Self::Item>,` [src]

`impl<T> StreamExt for T where T: Stream + ?Sized,` [src]

`fn next(&mut self) -> Next<'_, Self>ⓘNotable traits for Next<'_, St> impl<'_, St> Future for Next<'_, St> where St: Unpin + Stream + ?Sized, type Output = Option<<St as Stream>::Item>; where Self: Unpin,` [src]

`fn into_future(self) -> StreamFuture<Self>ⓘNotable traits for StreamFuture<St> impl<St> Future for StreamFuture<St> where St: Unpin + Stream, type Output = (Option<<St as Stream>::Item>, St); where Self: Unpin,` [src]

`fn map<T, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> T,` [src]

`fn enumerate(self) -> Enumerate<Self>`[src]

`fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F> where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>,` [src]

`fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F> where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = Option<T>>,` [src]

`fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where F: FnMut(Self::Item) -> Fut, Fut: Future,` [src]

`fn collect<C>(self) -> Collect<Self, C>ⓘNotable traits for Collect<St, C> impl<St, C> Future for Collect<St, C> where C: Default + Extend<<St as Stream>::Item>, St: Stream, type Output = C; where C: Default + Extend<Self::Item>,` [src]

`fn concat(self) -> Concat<Self>ⓘNotable traits for Concat<St> impl<St> Future for Concat<St> where St: Stream, <St as Stream>::Item: Extend<<<St as Stream>::Item as IntoIterator>::Item>, <St as Stream>::Item: IntoIterator, <St as Stream>::Item: Default, type Output = <St as Stream>::Item; where Self::Item: Extend<<Self::Item as IntoIterator>::Item>, Self::Item: IntoIterator, Self::Item: Default,` [src]

`fn fold<T, Fut, F>(self, init: T, f: F) -> Fold<Self, Fut, T, F>ⓘNotable traits for Fold<St, Fut, T, F> impl<St, Fut, T, F> Future for Fold<St, Fut, T, F> where F: FnMut(T, <St as Stream>::Item) -> Fut, Fut: Future<Output = T>, St: Stream, type Output = T; where F: FnMut(T, Self::Item) -> Fut, Fut: Future<Output = T>,` [src]

`fn flatten(self) -> Flatten<Self> where Self::Item: Stream,` [src]

`fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where F: FnMut(Self::Item) -> U, U: Stream,` [src]

`fn scan<S, B, Fut, F>(self, initial_state: S, f: F) -> Scan<Self, S, Fut, F> where F: FnMut(&mut S, Self::Item) -> Fut, Fut: Future<Output = Option>,` [src]

`fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F> where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>,` [src]

`fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F> where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>,` [src]

`fn take_until<Fut>(self, fut: Fut) -> TakeUntil<Self, Fut> where Fut: Future,` [src]

`fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F>ⓘNotable traits for ForEach<St, Fut, F> impl<St, Fut, F> Future for ForEach<St, Fut, F> where F: FnMut(<St as Stream>::Item) -> Fut, Fut: Future<Output = ()>, St: Stream, type Output = (); where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = ()>,` [src]

`fn for_each_concurrent<Fut, F>( self, limit: impl Into<Option<usize>>, f: F ) -> ForEachConcurrent<Self, Fut, F>ⓘNotable traits for ForEachConcurrent<St, Fut, F> impl<St, Fut, F> Future for ForEachConcurrent<St, Fut, F> where F: FnMut(<St as Stream>::Item) -> Fut, Fut: Future<Output = ()>, St: Stream, type Output = (); where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = ()>,` [src]

`fn take(self, n: usize) -> Take<Self>`[src]

`fn skip(self, n: usize) -> Skip<Self>`[src]

`fn fuse(self) -> Fuse<Self>`[src]

`fn by_ref(&mut self) -> &mut SelfⓘNotable traits for &'_ mut F impl<'_, F> Future for &'_ mut F where F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`[src]

`fn catch_unwind(self) -> CatchUnwind<Self> where Self: UnwindSafe,` [src]

`fn boxed<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a + Send>>ⓘNotable traits for Pin impl Future for Pin where P: Unpin + DerefMut, ::Target: Future, type Output = <::Target as Future>::Output; where Self: Send + 'a,` [src]

`fn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a>>ⓘNotable traits for Pin impl Future for Pin where P: Unpin + DerefMut, ::Target: Future, type Output = <::Target as Future>::Output; where Self: 'a,` [src]

`fn buffered(self, n: usize) -> Buffered<Self> where Self::Item: Future,` [src]

`fn buffer_unordered(self, n: usize) -> BufferUnordered<Self> where Self::Item: Future,` [src]

`fn zip<St>(self, other: St) -> Zip<Self, St> where St: Stream,` [src]

`fn chain<St>(self, other: St) -> Chain<Self, St> where St: Stream<Item = Self::Item>,` [src]

`fn peekable(self) -> Peekable<Self>`[src]

`fn chunks(self, capacity: usize) -> Chunks<Self>`[src]

`fn ready_chunks(self, capacity: usize) -> ReadyChunks<Self>`[src]

`fn forward<S>(self, sink: S) -> Forward<Self, S>ⓘNotable traits for Forward<St, Si> impl<St, Si> Future for Forward<St, Si> where St: TryStream, Forward<St, Si, <St as TryStream>::Ok>: Future, type Output = <Forward<St, Si, <St as TryStream>::Ok> as Future>::Output; where S: Sink<Self::Ok, Error = Self::Error>, Self: TryStream,` [src]

`fn split<Item>(self) -> (SplitSink<Self, Item>, SplitStream<Self>) where Self: Sink<Item>,` [src]

`fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item),` [src]

`fn left_stream(self) -> Either<Self, B>ⓘNotable traits for Either<A, B> impl<A, B> Future for Either<A, B> where A: Future, B: Future<Output = <A as Future>::Output>, type Output = <A as Future>::Output; where B: Stream<Item = Self::Item>,` [src]

`fn right_stream(self) -> Either<B, Self>ⓘNotable traits for Either<A, B> impl<A, B> Future for Either<A, B> where A: Future, B: Future<Output = <A as Future>::Output>, type Output = <A as Future>::Output; where B: Stream<Item = Self::Item>,` [src]

`fn poll_next_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> where Self: Unpin,` [src]

`fn select_next_some(&mut self) -> SelectNextSome<'_, Self>ⓘNotable traits for SelectNextSome<'_, St> impl<'_, St> Future for SelectNextSome<'_, St> where St: Unpin + FusedStream + ?Sized, type Output = <St as Stream>::Item; where Self: Unpin + FusedStream,` [src]

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

`type Error = Infallible`

The type returned in the event of a conversion error.

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

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

`type Error = >::Error`

The type returned in the event of a conversion error.

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

`impl<S, T, E> TryStream for S where S: Stream<Item = Result<T, E>> + ?Sized,` [src]

`type Ok = T`

The type of successful values yielded by this future

`type Error = E`

The type of failures yielded by this future

`fn try_poll_next( self: Pin<&mut S>, cx: &mut Context<'_> ) -> Poll<Option<Result<<S as TryStream>::Ok, <S as TryStream>::Error>>>`[src]

`impl<S> TryStreamExt for S where S: TryStream + ?Sized,` [src]

`fn err_into<E>(self) -> ErrInto<Self, E> where Self::Error: Into<E>,` [src]

`fn map_ok<T, F>(self, f: F) -> MapOk<Self, F> where F: FnMut(Self::Ok) -> T,` [src]

`fn map_err<E, F>(self, f: F) -> MapErr<Self, F> where F: FnMut(Self::Error) -> E,` [src]

`fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F> where F: FnMut(Self::Ok) -> Fut, Fut: TryFuture<Error = Self::Error>,` [src]

`fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> where F: FnMut(Self::Error) -> Fut, Fut: TryFuture<Ok = Self::Ok>,` [src]

`fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F> where F: FnMut(&Self::Ok),` [src]

`fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> where F: FnMut(&Self::Error),` [src]

`fn into_stream(self) -> IntoStream<Self>`[src]

`fn try_next(&mut self) -> TryNext<'_, Self>ⓘNotable traits for TryNext<'_, St> impl<'_, St> Future for TryNext<'_, St> where St: Unpin + TryStream + ?Sized, type Output = Result<Option<<St as TryStream>::Ok>, <St as TryStream>::Error>; where Self: Unpin,` [src]

`fn try_for_each<Fut, F>(self, f: F) -> TryForEach<Self, Fut, F>ⓘNotable traits for TryForEach<St, Fut, F> impl<St, Fut, F> Future for TryForEach<St, Fut, F> where F: FnMut(<St as TryStream>::Ok) -> Fut, Fut: TryFuture<Ok = (), Error = <St as TryStream>::Error>, St: TryStream, type Output = Result<(), <St as TryStream>::Error>; where F: FnMut(Self::Ok) -> Fut, Fut: TryFuture<Ok = (), Error = Self::Error>,` [src]

`fn try_skip_while<Fut, F>(self, f: F) -> TrySkipWhile<Self, Fut, F> where F: FnMut(&Self::Ok) -> Fut, Fut: TryFuture<Ok = bool, Error = Self::Error>,` [src]

fn try_for_each_concurrent<Fut, F>( self, limit: impl Into<Option<usize>>, f: F ) -> TryForEachConcurrent<Self, Fut, F>ⓘNotable traits for TryForEachConcurrent<St, Fut, F> impl<St, Fut, F> Future for TryForEachConcurrent<St, Fut, F> where F: FnMut(<St as TryStream>::Ok) -> Fut, Fut: Future<Output = Result<(), <St as TryStream>::Error>>, St: TryStream, type Output = Result<(), <St as TryStream>::Error>; where F: FnMut(Self::Ok) -> Fut, Fut: Future<Output = Result<(), Self::Error>>, [src]

`fn try_collect<C>(self) -> TryCollect<Self, C>ⓘNotable traits for TryCollect<St, C> impl<St, C> Future for TryCollect<St, C> where C: Default + Extend<<St as TryStream>::Ok>, St: TryStream, type Output = Result<C, <St as TryStream>::Error>; where C: Default + Extend<Self::Ok>,` [src]

`fn try_filter<Fut, F>(self, f: F) -> TryFilter<Self, Fut, F> where F: FnMut(&Self::Ok) -> Fut, Fut: Future<Output = bool>,` [src]

`fn try_filter_map<Fut, F, T>(self, f: F) -> TryFilterMap<Self, Fut, F> where F: FnMut(Self::Ok) -> Fut, Fut: TryFuture<Ok = Option<T>, Error = Self::Error>,` [src]

`fn try_flatten(self) -> TryFlatten<Self> where Self::Ok: TryStream, <Self::Ok as TryStream>::Error: From<Self::Error>,` [src]

`fn try_fold<T, Fut, F>(self, init: T, f: F) -> TryFold<Self, Fut, T, F>ⓘNotable traits for TryFold<St, Fut, T, F> impl<St, Fut, T, F> Future for TryFold<St, Fut, T, F> where F: FnMut(T, <St as TryStream>::Ok) -> Fut, Fut: TryFuture<Ok = T, Error = <St as TryStream>::Error>, St: TryStream, type Output = Result<T, <St as TryStream>::Error>; where F: FnMut(T, Self::Ok) -> Fut, Fut: TryFuture<Ok = T, Error = Self::Error>,` [src]

fn try_concat(self) -> TryConcat<Self>ⓘNotable traits for TryConcat<St> impl<St> Future for TryConcat<St> where St: TryStream, <St as TryStream>::Ok: Extend<<<St as TryStream>::Ok as IntoIterator>::Item>, <St as TryStream>::Ok: IntoIterator, <St as TryStream>::Ok: Default, type Output = Result<<St as TryStream>::Ok, <St as TryStream>::Error>; where Self::Ok: Extend<<Self::Ok as IntoIterator>::Item>, Self::Ok: IntoIterator, Self::Ok: Default, [src]

`fn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self> where Self::Ok: TryFuture, <Self::Ok as TryFuture>::Error == Self::Error,` [src]

`fn try_poll_next_unpin( &mut self, cx: &mut Context<'_> ) -> Poll<Option<Result<Self::Ok, Self::Error>>> where Self: Unpin,` [src]

`fn into_async_read(self) -> IntoAsyncRead<Self> where Self: TryStreamExt<Error = Error> + Unpin, Self::Ok: AsRef<[u8]>,` [src]

[−][src]Struct flv_future_aio::net::Incoming

Trait Implementations

impl<'a> Debug for Incoming<'a>[src]

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

impl<'a> Stream for Incoming<'a>[src]

type Item = Result<TcpStream, Error>

fn poll_next( self: Pin<&mut Incoming<'a>>, cx: &mut Context<'_>) -> Poll<Option<<Incoming<'a> as Stream>::Item>>[src]

fn size_hint(&self) -> (usize, Option<usize>)[src]

Auto Trait Implementations

impl<'a> RefUnwindSafe for Incoming<'a>

impl<'a> Send for Incoming<'a>

impl<'a> Sync for Incoming<'a>

impl<'a> Unpin for Incoming<'a>

impl<'a> UnwindSafe for Incoming<'a>

Blanket Implementations

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

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

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

fn borrow(&self) -> &TⓘNotable traits for &'_ mut Fimpl<'_, F> Future for &'_ mut F where F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;[src]

Notable traits for &'_ mut F

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

fn borrow_mut(&mut self) -> &mut TⓘNotable traits for &'_ mut Fimpl<'_, F> Future for &'_ mut F where F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;[src]

Notable traits for &'_ mut F

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

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

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

fn into(self) -> U[src]

impl<I> IntoStream for I where I: Stream, [src]

type Item = <I as Stream>::Item

type IntoStream = I

fn into_stream(self) -> I[src]

impl<T> StreamExt for T where T: Stream + ?Sized, [src]

fn next(&mut self) -> NextFuture<'_, Self> where Self: Unpin, [src]

fn take(self, n: usize) -> Take<Self>[src]

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where P: FnMut(&Self::Item) -> bool, [src]

fn throttle(self, d: Duration) -> Throttle<Self>[src]

fn step_by(self, step: usize) -> StepBy<Self>[src]

fn chain<U>(self, other: U) -> Chain<Self, U> where U: Stream<Item = Self::Item>, [src]

fn cloned<'a, T>(self) -> Cloned<Self> where Self: Stream<Item = &'a T>, T: Clone + 'a, [src]

fn copied<'a, T>(self) -> Copied<Self> where Self: Stream<Item = &'a T>, T: Copy + 'a, [src]

fn cycle(self) -> Cycle<Self> where Self: Clone, [src]

fn enumerate(self) -> Enumerate<Self>[src]

fn delay(self, dur: Duration) -> Delay<Self>[src]

fn map<B, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> B, [src]

fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item), [src]

fn last(self) -> LastFuture<Self, Self::Item>[src]

fn fuse(self) -> Fuse<Self>[src]

fn filter<P>(self, predicate: P) -> Filter<Self, P> where P: FnMut(&Self::Item) -> bool, [src]

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where F: FnMut(Self::Item) -> U, U: IntoStream, [src]

fn flatten(self) -> Flatten<Self> where Self::Item: IntoStream, [src]

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where F: FnMut(Self::Item) -> Option<B>, [src]

fn min_by_key<B, F>(self, key_by: F) -> MinByKeyFuture<Self, Self::Item, F> where B: Ord, F: FnMut(&Self::Item) -> B, [src]

fn max_by_key<B, F>(self, key_by: F) -> MaxByKeyFuture<Self, Self::Item, F> where B: Ord, F: FnMut(&Self::Item) -> B, [src]

fn min_by<F>(self, compare: F) -> MinByFuture<Self, F, Self::Item> where F: FnMut(&Self::Item, &Self::Item) -> Ordering, [src]

fn max(self) -> MaxFuture<Self, Self::Item> where Self::Item: Ord, [src]

fn min(self) -> MinFuture<Self, Self::Item> where Self::Item: Ord, [src]

fn max_by<F>(self, compare: F) -> MaxByFuture<Self, F, Self::Item> where F: FnMut(&Self::Item, &Self::Item) -> Ordering, [src]

fn nth(&mut self, n: usize) -> NthFuture<'_, Self> where Self: Unpin, [src]

fn all<F>(&mut self, f: F) -> AllFuture<'_, Self, F, Self::Item> where F: FnMut(Self::Item) -> bool, Self: Unpin, [src]

fn find<P>(&mut self, p: P) -> FindFuture<'_, Self, P> where P: FnMut(&Self::Item) -> bool, Self: Unpin, [src]

fn find_map<F, B>(&mut self, f: F) -> FindMapFuture<'_, Self, F> where F: FnMut(Self::Item) -> Option<B>, Self: Unpin, [src]

fn fold<B, F>(self, init: B, f: F) -> FoldFuture<Self, F, B> where F: FnMut(B, Self::Item) -> B, [src]

fn partition<B, F>(self, f: F) -> PartitionFuture<Self, F, B> where B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool, [src]

fn for_each<F>(self, f: F) -> ForEachFuture<Self, F> where F: FnMut(Self::Item), [src]

fn any<F>(&mut self, f: F) -> AnyFuture<'_, Self, F, Self::Item> where F: FnMut(Self::Item) -> bool, Self: Unpin, [src]

fn by_ref(&mut self) -> &mut SelfⓘNotable traits for &'_ mut Fimpl<'_, F> Future for &'_ mut F where F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;[src]

Notable traits for &'_ mut F

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where F: FnMut(&mut St, Self::Item) -> Option<B>, [src]

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where P: FnMut(&Self::Item) -> bool, [src]

fn skip(self, n: usize) -> Skip<Self>[src]

fn timeout(self, dur: Duration) -> Timeout<Self> where Self: Stream, [src]

fn try_fold<B, F, T, E>( &mut self, init: T, f: F) -> TryFoldFuture<'_, Self, F, T> where F: FnMut(B, Self::Item) -> Result<T, E>, Self: Unpin, [src]

fn try_for_each<F, E>(&mut self, f: F) -> TryForEachFuture<'_, Self, F> where F: FnMut(Self::Item) -> Result<(), E>, Self: Unpin, [src]

fn zip<U>(self, other: U) -> Zip<Self, U> where U: Stream, [src]

fn unzip<A, B, FromA, FromB>(self) -> UnzipFuture<Self, FromA, FromB> where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Stream<Item = (A, B)>, [src]

Notable traits for Pin<P>

fn merge<U>(self, other: U) -> Merge<Self, U> where U: Stream<Item = Self::Item>, [src]

fn partial_cmp<S>(self, other: S) -> PartialCmpFuture<Self, S> where S: Stream, Self: Stream, Self::Item: PartialOrd<<S as Stream>::Item>, [src]

fn position<P>(&mut self, predicate: P) -> PositionFuture<'_, Self, P> where P: FnMut(Self::Item) -> bool, Self: Unpin, [src]

fn cmp<S>(self, other: S) -> CmpFuture<Self, S> where S: Stream, Self: Stream, Self::Item: Ord, [src]

`impl<'a> Debug for Incoming<'a>`[src]

`fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<'a> Stream for Incoming<'a>`[src]

`type Item = Result<TcpStream, Error>`

`fn poll_next( self: Pin<&mut Incoming<'a>>, cx: &mut Context<'_> ) -> Poll<Option<<Incoming<'a> as Stream>::Item>>`[src]

`fn size_hint(&self) -> (usize, Option<usize>)`[src]

`impl<'a> RefUnwindSafe for Incoming<'a>`

`impl<'a> Send for Incoming<'a>`

`impl<'a> Sync for Incoming<'a>`

`impl<'a> Unpin for Incoming<'a>`

`impl<'a> UnwindSafe for Incoming<'a>`

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

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

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

`fn borrow(&self) -> &TⓘNotable traits for &'_ mut F impl<'_, F> Future for &'_ mut F where F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`[src]

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

`fn borrow_mut(&mut self) -> &mut TⓘNotable traits for &'_ mut F impl<'_, F> Future for &'_ mut F where F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`[src]

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

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

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

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

`impl<I> IntoStream for I where I: Stream,` [src]

`type Item = <I as Stream>::Item`

`type IntoStream = I`

`fn into_stream(self) -> I`[src]

`impl<T> StreamExt for T where T: Stream + ?Sized,` [src]

`fn next(&mut self) -> NextFuture<'_, Self> where Self: Unpin,` [src]

`fn take(self, n: usize) -> Take<Self>`[src]

`fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where P: FnMut(&Self::Item) -> bool,` [src]

`fn throttle(self, d: Duration) -> Throttle<Self>`[src]

`fn step_by(self, step: usize) -> StepBy<Self>`[src]

`fn chain<U>(self, other: U) -> Chain<Self, U> where U: Stream<Item = Self::Item>,` [src]

`fn cloned<'a, T>(self) -> Cloned<Self> where Self: Stream<Item = &'a T>, T: Clone + 'a,` [src]

`fn copied<'a, T>(self) -> Copied<Self> where Self: Stream<Item = &'a T>, T: Copy + 'a,` [src]

`fn cycle(self) -> Cycle<Self> where Self: Clone,` [src]

`fn enumerate(self) -> Enumerate<Self>`[src]

`fn delay(self, dur: Duration) -> Delay<Self>`[src]

`fn map<B, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> B,` [src]

`fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item),` [src]

`fn last(self) -> LastFuture<Self, Self::Item>`[src]

`fn fuse(self) -> Fuse<Self>`[src]

`fn filter<P>(self, predicate: P) -> Filter<Self, P> where P: FnMut(&Self::Item) -> bool,` [src]

`fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where F: FnMut(Self::Item) -> U, U: IntoStream,` [src]

`fn flatten(self) -> Flatten<Self> where Self::Item: IntoStream,` [src]

`fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where F: FnMut(Self::Item) -> Option<B>,` [src]

`fn min_by_key<B, F>(self, key_by: F) -> MinByKeyFuture<Self, Self::Item, F> where B: Ord, F: FnMut(&Self::Item) -> B,` [src]

`fn max_by_key<B, F>(self, key_by: F) -> MaxByKeyFuture<Self, Self::Item, F> where B: Ord, F: FnMut(&Self::Item) -> B,` [src]

`fn min_by<F>(self, compare: F) -> MinByFuture<Self, F, Self::Item> where F: FnMut(&Self::Item, &Self::Item) -> Ordering,` [src]

`fn max(self) -> MaxFuture<Self, Self::Item> where Self::Item: Ord,` [src]

`fn min(self) -> MinFuture<Self, Self::Item> where Self::Item: Ord,` [src]

`fn max_by<F>(self, compare: F) -> MaxByFuture<Self, F, Self::Item> where F: FnMut(&Self::Item, &Self::Item) -> Ordering,` [src]

`fn nth(&mut self, n: usize) -> NthFuture<'_, Self> where Self: Unpin,` [src]

`fn all<F>(&mut self, f: F) -> AllFuture<'_, Self, F, Self::Item> where F: FnMut(Self::Item) -> bool, Self: Unpin,` [src]

`fn find<P>(&mut self, p: P) -> FindFuture<'_, Self, P> where P: FnMut(&Self::Item) -> bool, Self: Unpin,` [src]

`fn find_map<F, B>(&mut self, f: F) -> FindMapFuture<'_, Self, F> where F: FnMut(Self::Item) -> Option<B>, Self: Unpin,` [src]

`fn fold<B, F>(self, init: B, f: F) -> FoldFuture<Self, F, B> where F: FnMut(B, Self::Item) -> B,` [src]

`fn partition<B, F>(self, f: F) -> PartitionFuture<Self, F, B> where B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool,` [src]

`fn for_each<F>(self, f: F) -> ForEachFuture<Self, F> where F: FnMut(Self::Item),` [src]

`fn any<F>(&mut self, f: F) -> AnyFuture<'_, Self, F, Self::Item> where F: FnMut(Self::Item) -> bool, Self: Unpin,` [src]

`fn by_ref(&mut self) -> &mut SelfⓘNotable traits for &'_ mut F impl<'_, F> Future for &'_ mut F where F: Unpin + Future + ?Sized, type Output = <F as Future>::Output;`[src]

`fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where F: FnMut(&mut St, Self::Item) -> Option<B>,` [src]

`fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where P: FnMut(&Self::Item) -> bool,` [src]

`fn skip(self, n: usize) -> Skip<Self>`[src]

`fn timeout(self, dur: Duration) -> Timeout<Self> where Self: Stream,` [src]

`fn try_fold<B, F, T, E>( &mut self, init: T, f: F ) -> TryFoldFuture<'_, Self, F, T> where F: FnMut(B, Self::Item) -> Result<T, E>, Self: Unpin,` [src]

`fn try_for_each<F, E>(&mut self, f: F) -> TryForEachFuture<'_, Self, F> where F: FnMut(Self::Item) -> Result<(), E>, Self: Unpin,` [src]

`fn zip<U>(self, other: U) -> Zip<Self, U> where U: Stream,` [src]

`fn unzip<A, B, FromA, FromB>(self) -> UnzipFuture<Self, FromA, FromB> where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Stream<Item = (A, B)>,` [src]

`fn merge<U>(self, other: U) -> Merge<Self, U> where U: Stream<Item = Self::Item>,` [src]

`fn partial_cmp<S>(self, other: S) -> PartialCmpFuture<Self, S> where S: Stream, Self: Stream, Self::Item: PartialOrd<<S as Stream>::Item>,` [src]

`fn position<P>(&mut self, predicate: P) -> PositionFuture<'_, Self, P> where P: FnMut(Self::Item) -> bool, Self: Unpin,` [src]

`fn cmp<S>(self, other: S) -> CmpFuture<Self, S> where S: Stream, Self: Stream, Self::Item: Ord,` [src]

`fn count(self) -> CountFuture<Self>`[src]

`fn ne<S>(self, other: S) -> NeFuture<Self, S> where S: Stream, Self::Item: PartialEq<<S as Stream>::Item>,` [src]

`fn ge<S>(self, other: S) -> GeFuture<Self, S> where S: Stream, Self: Stream, Self::Item: PartialOrd<<S as Stream>::Item>,` [src]

`fn eq<S>(self, other: S) -> EqFuture<Self, S> where S: Stream, Self: Stream, Self::Item: PartialEq<<S as Stream>::Item>,` [src]

`fn gt<S>(self, other: S) -> GtFuture<Self, S> where S: Stream, Self: Stream, Self::Item: PartialOrd<<S as Stream>::Item>,` [src]

`fn le<S>(self, other: S) -> LeFuture<Self, S> where S: Stream, Self: Stream, Self::Item: PartialOrd<<S as Stream>::Item>,` [src]

`fn lt<S>(self, other: S) -> LtFuture<Self, S> where S: Stream, Self: Stream, Self::Item: PartialOrd<<S as Stream>::Item>,` [src]

`fn sum<'a, S>(self) -> Pin<Box<dyn Future<Output = S> + 'a>>ⓘNotable traits for Pin<P> impl<P> Future for Pin<P> where P: Unpin + DerefMut, <P as Deref>::Target: Future, type Output = <<P as Deref>::Target as Future>::Output; where S: Sum<Self::Item>, Self: Stream<Item = S> + 'a,` [src]