Struct tokio_udp_framed::UdpFramedRecv [−][src]
Implementations
impl<T, C> UdpFramedRecv<T, C> where
T: Borrow<UdpSocket>,
[src]
T: Borrow<UdpSocket>,
pub fn new(socket: T, codec: C) -> UdpFramedRecv<T, C>
[src]
Create a new UdpFramed
backed by the given socket and codec.
See struct level documentation for more details.
pub fn get_ref(&self) -> &UdpSocket
[src]
Returns a reference to the underlying I/O stream wrapped by Framed
.
Note
Care should be taken to not tamper with the underlying stream of data coming in as it may corrupt the stream of frames otherwise being worked with.
pub fn codec(&self) -> &C
[src]
Returns a reference to the underlying codec wrapped by
Framed
.
Note that care should be taken to not tamper with the underlying codec as it may corrupt the stream of frames otherwise being worked with.
pub fn codec_mut(&mut self) -> &mut C
[src]
Returns a mutable reference to the underlying codec wrapped by
UdpFramed
.
Note that care should be taken to not tamper with the underlying codec as it may corrupt the stream of frames otherwise being worked with.
pub fn read_buffer(&self) -> &BytesMut
[src]
Returns a reference to the read buffer.
pub fn read_buffer_mut(&mut self) -> &mut BytesMut
[src]
Returns a mutable reference to the read buffer.
pub fn into_inner(self) -> T
[src]
Consumes the Framed
, returning its underlying I/O stream.
Trait Implementations
impl<T, C> Debug for UdpFramedRecv<T, C> where
T: Borrow<UdpSocket>,
C: Debug,
[src]
T: Borrow<UdpSocket>,
C: Debug,
impl<T, C> Stream for UdpFramedRecv<T, C> where
T: Borrow<UdpSocket>,
C: Decoder,
[src]
T: Borrow<UdpSocket>,
C: Decoder,
type Item = Result<(C::Item, SocketAddr), C::Error>
Values yielded by the stream.
fn poll_next(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Option<Self::Item>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Option<Self::Item>>
pub fn size_hint(&self) -> (usize, Option<usize>)
[src]
impl<'__pin, T, C> Unpin for UdpFramedRecv<T, C> where
__Origin<'__pin, T, C>: Unpin,
[src]
__Origin<'__pin, T, C>: Unpin,
Auto Trait Implementations
impl<T, C> RefUnwindSafe for UdpFramedRecv<T, C> where
C: RefUnwindSafe,
T: RefUnwindSafe,
[src]
C: RefUnwindSafe,
T: RefUnwindSafe,
impl<T, C> Send for UdpFramedRecv<T, C> where
C: Send,
T: Send,
[src]
C: Send,
T: Send,
impl<T, C> Sync for UdpFramedRecv<T, C> where
C: Sync,
T: Sync,
[src]
C: Sync,
T: Sync,
impl<T, C> UnwindSafe for UdpFramedRecv<T, C> where
C: UnwindSafe,
T: UnwindSafe,
[src]
C: UnwindSafe,
T: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<St> StreamExt for St where
St: Stream + ?Sized,
[src]
St: Stream + ?Sized,
pub fn next(&mut self) -> Next<'_, Self> where
Self: Unpin,
[src]
Self: Unpin,
pub fn try_next<T, E>(&mut self) -> TryNext<'_, Self> where
Self: Stream<Item = Result<T, E>> + Unpin,
[src]
Self: Stream<Item = Result<T, E>> + Unpin,
pub fn map<T, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> T,
[src]
F: FnMut(Self::Item) -> T,
pub fn merge<U>(self, other: U) -> Merge<Self, U> where
U: Stream<Item = Self::Item>,
[src]
U: Stream<Item = Self::Item>,
pub fn filter<F>(self, f: F) -> Filter<Self, F> where
F: FnMut(&Self::Item) -> bool,
[src]
F: FnMut(&Self::Item) -> bool,
pub fn filter_map<T, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<T>,
[src]
F: FnMut(Self::Item) -> Option<T>,
pub fn fuse(self) -> Fuse<Self>
[src]
pub fn take(self, n: usize) -> Take<Self>
[src]
pub fn take_while<F>(self, f: F) -> TakeWhile<Self, F> where
F: FnMut(&Self::Item) -> bool,
[src]
F: FnMut(&Self::Item) -> bool,
pub fn skip(self, n: usize) -> Skip<Self>
[src]
pub fn skip_while<F>(self, f: F) -> SkipWhile<Self, F> where
F: FnMut(&Self::Item) -> bool,
[src]
F: FnMut(&Self::Item) -> bool,
pub fn all<F>(&mut self, f: F) -> AllFuture<'_, Self, F> where
Self: Unpin,
F: FnMut(Self::Item) -> bool,
[src]
Self: Unpin,
F: FnMut(Self::Item) -> bool,
pub fn any<F>(&mut self, f: F) -> AnyFuture<'_, Self, F> where
Self: Unpin,
F: FnMut(Self::Item) -> bool,
[src]
Self: Unpin,
F: FnMut(Self::Item) -> bool,
pub fn chain<U>(self, other: U) -> Chain<Self, U> where
U: Stream<Item = Self::Item>,
[src]
U: Stream<Item = Self::Item>,
pub fn fold<B, F>(self, init: B, f: F) -> FoldFuture<Self, B, F> where
F: FnMut(B, Self::Item) -> B,
[src]
F: FnMut(B, Self::Item) -> B,
pub fn collect<T>(self) -> Collect<Self, T> where
T: FromStream<Self::Item>,
[src]
T: FromStream<Self::Item>,
pub fn timeout(self, duration: Duration) -> Timeout<Self>
[src]
pub fn throttle(self, duration: Duration) -> Throttle<Self>
[src]
impl<T> StreamExt for T where
T: Stream + ?Sized,
[src]
T: Stream + ?Sized,
pub fn next(&mut self) -> Next<'_, Self> where
Self: Unpin,
[src]
Self: Unpin,
pub fn into_future(self) -> StreamFuture<Self> where
Self: Unpin,
[src]
Self: Unpin,
pub fn map<T, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> T,
[src]
F: FnMut(Self::Item) -> T,
pub fn enumerate(self) -> Enumerate<Self>
[src]
pub fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F> where
Fut: Future<Output = bool>,
F: FnMut(&Self::Item) -> Fut,
[src]
Fut: Future<Output = bool>,
F: FnMut(&Self::Item) -> Fut,
pub fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F> where
Fut: Future<Output = Option<T>>,
F: FnMut(Self::Item) -> Fut,
[src]
Fut: Future<Output = Option<T>>,
F: FnMut(Self::Item) -> Fut,
pub fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where
Fut: Future,
F: FnMut(Self::Item) -> Fut,
[src]
Fut: Future,
F: FnMut(Self::Item) -> Fut,
pub fn collect<C>(self) -> Collect<Self, C> where
C: Default + Extend<Self::Item>,
[src]
C: Default + Extend<Self::Item>,
pub fn unzip<A, B, FromA, FromB>(self) -> Unzip<Self, FromA, FromB> where
Self: Stream<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
[src]
Self: Stream<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
pub fn concat(self) -> Concat<Self> where
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default,
[src]
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default,
pub fn cycle(self) -> Cycle<Self> where
Self: Clone,
[src]
Self: Clone,
pub fn fold<T, Fut, F>(self, init: T, f: F) -> Fold<Self, Fut, T, F> where
Fut: Future<Output = T>,
F: FnMut(T, Self::Item) -> Fut,
[src]
Fut: Future<Output = T>,
F: FnMut(T, Self::Item) -> Fut,
pub fn flatten(self) -> Flatten<Self> where
Self::Item: Stream,
[src]
Self::Item: Stream,
pub fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
U: Stream,
F: FnMut(Self::Item) -> U,
[src]
U: Stream,
F: FnMut(Self::Item) -> U,
pub fn scan<S, B, Fut, F>(self, initial_state: S, f: F) -> Scan<Self, S, Fut, F> where
Fut: Future<Output = Option<B>>,
F: FnMut(&mut S, Self::Item) -> Fut,
[src]
Fut: Future<Output = Option<B>>,
F: FnMut(&mut S, Self::Item) -> Fut,
pub fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F> where
Fut: Future<Output = bool>,
F: FnMut(&Self::Item) -> Fut,
[src]
Fut: Future<Output = bool>,
F: FnMut(&Self::Item) -> Fut,
pub fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F> where
Fut: Future<Output = bool>,
F: FnMut(&Self::Item) -> Fut,
[src]
Fut: Future<Output = bool>,
F: FnMut(&Self::Item) -> Fut,
pub fn take_until<Fut>(self, fut: Fut) -> TakeUntil<Self, Fut> where
Fut: Future,
[src]
Fut: Future,
pub fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F> where
Fut: Future<Output = ()>,
F: FnMut(Self::Item) -> Fut,
[src]
Fut: Future<Output = ()>,
F: FnMut(Self::Item) -> Fut,
pub fn for_each_concurrent<Fut, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> ForEachConcurrent<Self, Fut, F> where
Fut: Future<Output = ()>,
F: FnMut(Self::Item) -> Fut,
[src]
self,
limit: impl Into<Option<usize>>,
f: F
) -> ForEachConcurrent<Self, Fut, F> where
Fut: Future<Output = ()>,
F: FnMut(Self::Item) -> Fut,
pub fn take(self, n: usize) -> Take<Self>
[src]
pub fn skip(self, n: usize) -> Skip<Self>
[src]
pub fn fuse(self) -> Fuse<Self>
[src]
pub fn by_ref(&mut self) -> &mut Self
[src]
pub fn catch_unwind(self) -> CatchUnwind<Self> where
Self: UnwindSafe,
[src]
Self: UnwindSafe,
pub fn boxed<'a>(
self
) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a + Send, Global>> where
Self: Send + 'a,
[src]
self
) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a + Send, Global>> where
Self: Send + 'a,
pub fn boxed_local<'a>(
self
) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a, Global>> where
Self: 'a,
[src]
self
) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a, Global>> where
Self: 'a,
pub fn buffered(self, n: usize) -> Buffered<Self> where
Self::Item: Future,
[src]
Self::Item: Future,
pub fn buffer_unordered(self, n: usize) -> BufferUnordered<Self> where
Self::Item: Future,
[src]
Self::Item: Future,
pub fn zip<St>(self, other: St) -> Zip<Self, St> where
St: Stream,
[src]
St: Stream,
pub fn chain<St>(self, other: St) -> Chain<Self, St> where
St: Stream<Item = Self::Item>,
[src]
St: Stream<Item = Self::Item>,
pub fn peekable(self) -> Peekable<Self>
[src]
pub fn chunks(self, capacity: usize) -> Chunks<Self>
[src]
pub fn ready_chunks(self, capacity: usize) -> ReadyChunks<Self>
[src]
pub fn forward<S>(self, sink: S) -> Forward<Self, S> where
Self: TryStream,
S: Sink<Self::Ok, Error = Self::Error>,
[src]
Self: TryStream,
S: Sink<Self::Ok, Error = Self::Error>,
pub fn split<Item>(self) -> (SplitSink<Self, Item>, SplitStream<Self>) where
Self: Sink<Item>,
[src]
Self: Sink<Item>,
pub fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
[src]
F: FnMut(&Self::Item),
pub fn left_stream<B>(self) -> Either<Self, B> where
B: Stream<Item = Self::Item>,
[src]
B: Stream<Item = Self::Item>,
pub fn right_stream<B>(self) -> Either<B, Self> where
B: Stream<Item = Self::Item>,
[src]
B: Stream<Item = Self::Item>,
pub fn poll_next_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Option<Self::Item>> where
Self: Unpin,
[src]
&mut self,
cx: &mut Context<'_>
) -> Poll<Option<Self::Item>> where
Self: Unpin,
pub fn select_next_some(&mut self) -> SelectNextSome<'_, Self> where
Self: Unpin + FusedStream,
[src]
Self: Unpin + FusedStream,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
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]
U: TryFrom<T>,
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]
impl<S, T, E> TryStream for S where
S: Stream<Item = Result<T, E>> + ?Sized,
[src]
S: Stream<Item = Result<T, E>> + ?Sized,
type Ok = T
The type of successful values yielded by this future
type Error = E
The type of failures yielded by this future
pub fn try_poll_next(
self: Pin<&mut S>,
cx: &mut Context<'_>
) -> Poll<Option<Result<<S as TryStream>::Ok, <S as TryStream>::Error>>>
[src]
self: Pin<&mut S>,
cx: &mut Context<'_>
) -> Poll<Option<Result<<S as TryStream>::Ok, <S as TryStream>::Error>>>
impl<S> TryStreamExt for S where
S: TryStream + ?Sized,
[src]
S: TryStream + ?Sized,
pub fn err_into<E>(self) -> ErrInto<Self, E> where
Self::Error: Into<E>,
[src]
Self::Error: Into<E>,
pub fn map_ok<T, F>(self, f: F) -> MapOk<Self, F> where
F: FnMut(Self::Ok) -> T,
[src]
F: FnMut(Self::Ok) -> T,
pub fn map_err<E, F>(self, f: F) -> MapErr<Self, F> where
F: FnMut(Self::Error) -> E,
[src]
F: FnMut(Self::Error) -> E,
pub fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F> where
Fut: TryFuture<Error = Self::Error>,
F: FnMut(Self::Ok) -> Fut,
[src]
Fut: TryFuture<Error = Self::Error>,
F: FnMut(Self::Ok) -> Fut,
pub fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> where
Fut: TryFuture<Ok = Self::Ok>,
F: FnMut(Self::Error) -> Fut,
[src]
Fut: TryFuture<Ok = Self::Ok>,
F: FnMut(Self::Error) -> Fut,
pub fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F> where
F: FnMut(&Self::Ok),
[src]
F: FnMut(&Self::Ok),
pub fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> where
F: FnMut(&Self::Error),
[src]
F: FnMut(&Self::Error),
pub fn into_stream(self) -> IntoStream<Self>
[src]
pub fn try_next(&mut self) -> TryNext<'_, Self> where
Self: Unpin,
[src]
Self: Unpin,
pub fn try_for_each<Fut, F>(self, f: F) -> TryForEach<Self, Fut, F> where
Fut: TryFuture<Ok = (), Error = Self::Error>,
F: FnMut(Self::Ok) -> Fut,
[src]
Fut: TryFuture<Ok = (), Error = Self::Error>,
F: FnMut(Self::Ok) -> Fut,
pub fn try_skip_while<Fut, F>(self, f: F) -> TrySkipWhile<Self, Fut, F> where
Fut: TryFuture<Ok = bool, Error = Self::Error>,
F: FnMut(&Self::Ok) -> Fut,
[src]
Fut: TryFuture<Ok = bool, Error = Self::Error>,
F: FnMut(&Self::Ok) -> Fut,
pub fn try_take_while<Fut, F>(self, f: F) -> TryTakeWhile<Self, Fut, F> where
Fut: TryFuture<Ok = bool, Error = Self::Error>,
F: FnMut(&Self::Ok) -> Fut,
[src]
Fut: TryFuture<Ok = bool, Error = Self::Error>,
F: FnMut(&Self::Ok) -> Fut,
pub fn try_for_each_concurrent<Fut, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> TryForEachConcurrent<Self, Fut, F> where
Fut: Future<Output = Result<(), Self::Error>>,
F: FnMut(Self::Ok) -> Fut,
[src]
self,
limit: impl Into<Option<usize>>,
f: F
) -> TryForEachConcurrent<Self, Fut, F> where
Fut: Future<Output = Result<(), Self::Error>>,
F: FnMut(Self::Ok) -> Fut,
pub fn try_collect<C>(self) -> TryCollect<Self, C> where
C: Default + Extend<Self::Ok>,
[src]
C: Default + Extend<Self::Ok>,
pub fn try_filter<Fut, F>(self, f: F) -> TryFilter<Self, Fut, F> where
Fut: Future<Output = bool>,
F: FnMut(&Self::Ok) -> Fut,
[src]
Fut: Future<Output = bool>,
F: FnMut(&Self::Ok) -> Fut,
pub fn try_filter_map<Fut, F, T>(self, f: F) -> TryFilterMap<Self, Fut, F> where
Fut: TryFuture<Ok = Option<T>, Error = Self::Error>,
F: FnMut(Self::Ok) -> Fut,
[src]
Fut: TryFuture<Ok = Option<T>, Error = Self::Error>,
F: FnMut(Self::Ok) -> Fut,
pub fn try_flatten(self) -> TryFlatten<Self> where
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error: From<Self::Error>,
[src]
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error: From<Self::Error>,
pub fn try_fold<T, Fut, F>(self, init: T, f: F) -> TryFold<Self, Fut, T, F> where
Fut: TryFuture<Ok = T, Error = Self::Error>,
F: FnMut(T, Self::Ok) -> Fut,
[src]
Fut: TryFuture<Ok = T, Error = Self::Error>,
F: FnMut(T, Self::Ok) -> Fut,
pub fn try_concat(self) -> TryConcat<Self> where
Self::Ok: Extend<<Self::Ok as IntoIterator>::Item>,
Self::Ok: IntoIterator,
Self::Ok: Default,
[src]
Self::Ok: Extend<<Self::Ok as IntoIterator>::Item>,
Self::Ok: IntoIterator,
Self::Ok: Default,
pub fn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self> where
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
[src]
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
pub fn try_buffered(self, n: usize) -> TryBuffered<Self> where
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
[src]
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
pub fn try_poll_next_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Option<Result<Self::Ok, Self::Error>>> where
Self: Unpin,
[src]
&mut self,
cx: &mut Context<'_>
) -> Poll<Option<Result<Self::Ok, Self::Error>>> where
Self: Unpin,
pub fn into_async_read(self) -> IntoAsyncRead<Self> where
Self: TryStreamExt<Error = Error> + Unpin,
Self::Ok: AsRef<[u8]>,
[src]
Self: TryStreamExt<Error = Error> + Unpin,
Self::Ok: AsRef<[u8]>,