[−][src]Struct zbus::azync::connection::Connection
The asynchronous sibling of zbus::Connection
.
Most of the API is very similar to zbus::Connection
, except it's asynchronous. However,
there are a few differences:
Generic over Socket
This type is generic over zbus::raw::Socket
so that support for new socket types can be
added with the same type easily later on.
Cloning and Mutability
Unlike zbus::Connection
, this type does not implement std::clone::Clone
. The reason is
that implementation will be very difficult (and still prone to deadlocks) if connection is
owned by multiple tasks/threads. Create separate connection instances or use
futures::stream::StreamExt::split
to split reading and writing between two separate async
tasks.
Also notice that unlike zbus::Connection
, most methods take a &mut self
, rather than a
&self
. If they'd take &self
, Connection
will need to manage mutability internally, which
is not a very good match with the general async/await machinery and runtimes in Rust and could
easily lead into some hard-to-debug deadlocks. You can use std::cell::Cell
,
std::sync::Mutex
or other related API combined with std::rc::Rc
or std::sync::Arc
for sharing a mutable Connection
instance between different parts of your code (or threads).
Sending Messages
For sending messages you can either use Connection::send_message
method or make use of the
Sink
implementation. For latter, you might find SinkExt
API very useful. Keep in mind
that Connection
will not manage the serial numbers (cookies) on the messages for you when
they are sent through the Sink
implementation. You can manually assign unique serial numbers
to them using the Connection::assign_serial_num
method before sending them off, if needed.
Having said that, Sink
is mainly useful for sending out signals, as they do not expect a
reply, and serial numbers are not very useful for signals either for the same reason.
Receiving Messages
Unlike zbus::Connection
, there is no direct async equivalent of
zbus::Connection::receive_message
method provided. This is because the futures
crate
already provides a nice rich API that makes use of the Stream
implementation.
Examples
Get the session bus ID
use zbus::azync::Connection; let mut connection = Connection::new_session().await?; let reply = connection .call_method( Some("org.freedesktop.DBus"), "/org/freedesktop/DBus", Some("org.freedesktop.DBus"), "GetId", &(), ) .await?; let id: &str = reply.body()?; println!("Unique ID of the bus: {}", id);
Monitoring all messages
Let's eavesdrop on the session bus 😈 using the Monitor interface:
use futures::TryStreamExt; use zbus::azync::Connection; let mut connection = Connection::new_session().await?; connection .call_method( Some("org.freedesktop.DBus"), "/org/freedesktop/DBus", Some("org.freedesktop.DBus.Monitoring"), "BecomeMonitor", &(&[] as &[&str], 0u32), ) .await?; while let Some(msg) = connection.try_next().await? { println!("Got message: {}", msg); }
This should print something like:
Got message: Signal NameAcquired from org.freedesktop.DBus
Got message: Signal NameLost from org.freedesktop.DBus
Got message: Method call GetConnectionUnixProcessID from :1.1324
Got message: Error org.freedesktop.DBus.Error.NameHasNoOwner:
Could not get PID of name ':1.1332': no such name from org.freedesktop.DBus
Got message: Method call AddMatch from :1.918
Got message: Method return from org.freedesktop.DBus
Implementations
impl<S> Connection<S> where
S: AsRawFd + Debug + Unpin + Socket,
Async<S>: Socket,
[src]
S: AsRawFd + Debug + Unpin + Socket,
Async<S>: Socket,
pub async fn new_client(stream: S, bus_connection: bool) -> Result<Self>
[src]
Create and open a D-Bus connection from the given stream
.
The connection may either be set up for a bus connection, or not (for peer-to-peer communications).
Upon successful return, the connection is fully established and negotiated: D-Bus messages can be sent and received.
pub async fn new_server(stream: S, guid: &Guid) -> Result<Self>
[src]
Create a server Connection
for the given stream
and the server guid
.
The connection will wait for incoming client authentication handshake & negotiation messages, for peer-to-peer communications.
Upon successful return, the connection is fully established and negotiated: D-Bus messages can be sent and received.
pub async fn send_message(&mut self, msg: Message) -> Result<u32>
[src]
Send msg
to the peer.
Unlike Sink
implementation, this method sets a unique (to this connection) serial
number on the message before sending it off, for you.
On successfully sending off msg
, the assigned serial number is returned.
pub async fn call_method<B>(
&mut self,
destination: Option<&str>,
path: &str,
iface: Option<&str>,
method_name: &str,
body: &B
) -> Result<Message> where
B: Serialize + Type,
[src]
&mut self,
destination: Option<&str>,
path: &str,
iface: Option<&str>,
method_name: &str,
body: &B
) -> Result<Message> where
B: Serialize + Type,
Send a method call.
Create a method-call message, send it over the connection, then wait for the reply.
On succesful reply, an Ok(Message)
is returned. On error, an Err
is returned. D-Bus
error replies are returned as Error::MethodError
.
pub async fn emit_signal<B>(
&mut self,
destination: Option<&str>,
path: &str,
iface: &str,
signal_name: &str,
body: &B
) -> Result<()> where
B: Serialize + Type,
[src]
&mut self,
destination: Option<&str>,
path: &str,
iface: &str,
signal_name: &str,
body: &B
) -> Result<()> where
B: Serialize + Type,
Emit a signal.
Create a signal message, and send it over the connection.
pub async fn reply<B>(&mut self, call: &Message, body: &B) -> Result<u32> where
B: Serialize + Type,
[src]
B: Serialize + Type,
Reply to a message.
Given an existing message (likely a method call), send a reply back to the caller with the
given body
.
Returns the message serial number.
pub async fn reply_error<B>(
&mut self,
call: &Message,
error_name: &str,
body: &B
) -> Result<u32> where
B: Serialize + Type,
[src]
&mut self,
call: &Message,
error_name: &str,
body: &B
) -> Result<u32> where
B: Serialize + Type,
Reply an error to a message.
Given an existing message (likely a method call), send an error reply back to the caller
with the given error_name
and body
.
Returns the message serial number.
pub fn set_unique_name(self, name: String) -> Result<Self, String>
[src]
Sets the unique name for this connection.
This method should only be used when initializing a client bus connection with
Connection::new_authenticated
. Setting the unique name to anything other than the return
value of the bus hello is a protocol violation.
Returns and error if the name has already been set.
pub fn assign_serial_num(&mut self, msg: &mut Message) -> Result<u32>
[src]
Assigns a serial number to msg
that is unique to this connection.
This method can fail if msg
is corrupt.
pub fn unique_name(&self) -> Option<&str>
[src]
The unique name as assigned by the message bus or None
if not a message bus connection.
pub fn max_queued(&self) -> usize
[src]
Max number of messages to queue.
pub fn set_max_queued(self, max: usize) -> Self
[src]
Set the max number of messages to queue.
Since typically you'd want to set this at instantiation time, this method takes ownership
of self
and returns an owned Connection
instance so you can use the builder pattern to
set the value.
Example
use futures::executor::block_on; let conn = block_on(Connection::new_session())?.set_max_queued(30); assert_eq!(conn.max_queued(), 30); // Do something usefull with `conn`..
pub fn server_guid(&self) -> &str
[src]
The server's GUID.
impl Connection<UnixStream>
[src]
pub async fn new_session() -> Result<Self>
[src]
Create a Connection
to the session/user message bus.
Although, session bus hardly ever runs on anything other than UNIX domain sockets, if you
want your code to be able to handle those rare cases, use ConnectionType::new_session
instead.
pub async fn new_system() -> Result<Self>
[src]
Create a Connection
to the system-wide message bus.
Although, system bus hardly ever runs on anything other than UNIX domain sockets, if you
want your code to be able to handle those rare cases, use ConnectionType::new_system
instead.
Trait Implementations
impl<S: Debug> Debug for Connection<S>
[src]
impl<S> Sink<Message> for Connection<S> where
S: AsRawFd + Debug + Unpin + Socket,
Async<S>: Socket,
[src]
S: AsRawFd + Debug + Unpin + Socket,
Async<S>: Socket,
type Error = Error
The type of value produced by the sink when an error occurs.
pub fn poll_ready(
self: Pin<&mut Self>,
_cx: &mut Context<'_>
) -> Poll<Result<()>>
[src]
self: Pin<&mut Self>,
_cx: &mut Context<'_>
) -> Poll<Result<()>>
pub fn start_send(self: Pin<&mut Self>, msg: Message) -> Result<()>
[src]
pub fn poll_flush(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<()>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<()>>
pub fn poll_close(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<()>>
[src]
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Result<()>>
impl<S> Stream for Connection<S> where
S: Socket,
Async<S>: Socket,
[src]
S: Socket,
Async<S>: Socket,
Auto Trait Implementations
impl<S> RefUnwindSafe for Connection<S> where
S: RefUnwindSafe,
[src]
S: RefUnwindSafe,
impl<S> Send for Connection<S> where
S: Send,
[src]
S: Send,
impl<S> Sync for Connection<S> where
S: Sync,
[src]
S: Sync,
impl<S> Unpin for Connection<S>
[src]
impl<S> UnwindSafe for Connection<S> where
S: UnwindSafe,
[src]
S: 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<T, Item> SinkExt<Item> for T where
T: Sink<Item> + ?Sized,
[src]
T: Sink<Item> + ?Sized,
pub fn with<U, Fut, F, E>(self, f: F) -> With<Self, Item, U, Fut, F> where
F: FnMut(U) -> Fut,
E: From<Self::Error>,
Fut: Future<Output = Result<Item, E>>,
[src]
F: FnMut(U) -> Fut,
E: From<Self::Error>,
Fut: Future<Output = Result<Item, E>>,
pub fn with_flat_map<U, St, F>(self, f: F) -> WithFlatMap<Self, Item, U, St, F> where
F: FnMut(U) -> St,
St: Stream<Item = Result<Item, Self::Error>>,
[src]
F: FnMut(U) -> St,
St: Stream<Item = Result<Item, Self::Error>>,
pub fn sink_map_err<E, F>(self, f: F) -> SinkMapErr<Self, F> where
F: FnOnce(Self::Error) -> E,
[src]
F: FnOnce(Self::Error) -> E,
pub fn sink_err_into<E>(self) -> SinkErrInto<Self, Item, E> where
Self::Error: Into<E>,
[src]
Self::Error: Into<E>,
pub fn buffer(self, capacity: usize) -> Buffer<Self, Item>
[src]
pub fn close(&mut self) -> Close<'_, Self, Item> where
Self: Unpin,
[src]
Self: Unpin,
pub fn fanout<Si>(self, other: Si) -> Fanout<Self, Si> where
Item: Clone,
Si: Sink<Item, Error = Self::Error>,
[src]
Item: Clone,
Si: Sink<Item, Error = Self::Error>,
pub fn flush(&mut self) -> Flush<'_, Self, Item> where
Self: Unpin,
[src]
Self: Unpin,
pub fn send(&mut self, item: Item) -> Send<'_, Self, Item> where
Self: Unpin,
[src]
Self: Unpin,
pub fn send_all<St>(&'a mut self, stream: &'a mut St) -> SendAll<'a, Self, St> where
Self: Unpin,
St: TryStream<Ok = Item, Error = Self::Error> + Stream + Unpin + ?Sized,
[src]
Self: Unpin,
St: TryStream<Ok = Item, Error = Self::Error> + Stream + Unpin + ?Sized,
pub fn left_sink<Si2>(self) -> Either<Self, Si2> where
Si2: Sink<Item, Error = Self::Error>,
[src]
Si2: Sink<Item, Error = Self::Error>,
pub fn right_sink<Si1>(self) -> Either<Si1, Self> where
Si1: Sink<Item, Error = Self::Error>,
[src]
Si1: Sink<Item, Error = Self::Error>,
pub fn poll_ready_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>> where
Self: Unpin,
[src]
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>> where
Self: Unpin,
pub fn start_send_unpin(&mut self, item: Item) -> Result<(), Self::Error> where
Self: Unpin,
[src]
Self: Unpin,
pub fn poll_flush_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>> where
Self: Unpin,
[src]
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>> where
Self: Unpin,
pub fn poll_close_unpin(
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>> where
Self: Unpin,
[src]
&mut self,
cx: &mut Context<'_>
) -> Poll<Result<(), Self::Error>> where
Self: Unpin,
impl<S> StreamExt for S where
S: Stream + ?Sized,
S: Stream + ?Sized,
pub fn poll_next(&mut self, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> where
Self: Unpin,
Self: Unpin,
pub fn next(&mut self) -> NextFuture<'_, Self> where
Self: Unpin,
Self: Unpin,
pub fn try_next<T, E>(&mut self) -> TryNextFuture<'_, Self> where
Self: Stream<Item = Result<T, E>> + Unpin,
Self: Stream<Item = Result<T, E>> + Unpin,
pub fn count(self) -> CountFuture<Self>
pub fn map<T, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> T,
F: FnMut(Self::Item) -> T,
pub fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: Stream,
F: FnMut(Self::Item) -> U,
U: Stream,
pub fn flatten(self) -> Flatten<Self> where
Self::Item: Stream,
Self::Item: Stream,
pub fn then<F, Fut>(self, f: F) -> Then<Self, F, Fut> where
F: FnMut(Self::Item) -> Fut,
Fut: Future,
F: FnMut(Self::Item) -> Fut,
Fut: Future,
pub fn filter<P>(self, predicate: P) -> Filter<Self, P> where
P: FnMut(&Self::Item) -> bool,
P: FnMut(&Self::Item) -> bool,
pub fn filter_map<T, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<T>,
F: FnMut(Self::Item) -> Option<T>,
pub fn take(self, n: usize) -> Take<Self>
pub fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
P: FnMut(&Self::Item) -> bool,
pub fn skip(self, n: usize) -> Skip<Self>
pub fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
P: FnMut(&Self::Item) -> bool,
pub fn step_by(self, step: usize) -> StepBy<Self>
pub fn chain<U>(self, other: U) -> Chain<Self, U> where
U: Stream<Item = Self::Item>,
U: Stream<Item = Self::Item>,
pub fn cloned<'a, T>(self) -> Cloned<Self> where
Self: Stream<Item = &'a T>,
T: Clone + 'a,
Self: Stream<Item = &'a T>,
T: Clone + 'a,
pub fn copied<'a, T>(self) -> Copied<Self> where
Self: Stream<Item = &'a T>,
T: Copy + 'a,
Self: Stream<Item = &'a T>,
T: Copy + 'a,
pub fn collect<C>(self) -> CollectFuture<Self, C> where
C: Default + Extend<Self::Item>,
C: Default + Extend<Self::Item>,
pub fn try_collect<T, E, C>(self) -> TryCollectFuture<Self, C> where
Self: Stream<Item = Result<T, E>>,
C: Default + Extend<T>,
Self: Stream<Item = Result<T, E>>,
C: Default + Extend<T>,
pub fn partition<B, P>(self, predicate: P) -> PartitionFuture<Self, P, B> where
B: Default + Extend<Self::Item>,
P: FnMut(&Self::Item) -> bool,
B: Default + Extend<Self::Item>,
P: FnMut(&Self::Item) -> bool,
pub fn fold<T, F>(self, init: T, f: F) -> FoldFuture<Self, F, T> where
F: FnMut(T, Self::Item) -> T,
F: FnMut(T, Self::Item) -> T,
pub fn try_fold<T, E, F, B>(
&mut self,
init: B,
f: F
) -> TryFoldFuture<'_, Self, F, B> where
Self: Stream<Item = Result<T, E>> + Unpin,
F: FnMut(B, T) -> Result<B, E>,
&mut self,
init: B,
f: F
) -> TryFoldFuture<'_, Self, F, B> where
Self: Stream<Item = Result<T, E>> + Unpin,
F: FnMut(B, T) -> Result<B, E>,
pub fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
F: FnMut(&mut St, Self::Item) -> Option<B>,
F: FnMut(&mut St, Self::Item) -> Option<B>,
pub fn fuse(self) -> Fuse<Self>
pub fn cycle(self) -> Cycle<Self> where
Self: Clone,
Self: Clone,
pub fn enumerate(self) -> Enumerate<Self>
pub fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
F: FnMut(&Self::Item),
pub fn nth(&mut self, n: usize) -> NthFuture<'_, Self> where
Self: Unpin,
Self: Unpin,
pub fn last(self) -> LastFuture<Self>
pub fn find<P>(&mut self, predicate: P) -> FindFuture<'_, Self, P> where
Self: Unpin,
P: FnMut(&Self::Item) -> bool,
Self: Unpin,
P: FnMut(&Self::Item) -> bool,
pub fn find_map<F, B>(&mut self, f: F) -> FindMapFuture<'_, Self, F> where
Self: Unpin,
F: FnMut(Self::Item) -> Option<B>,
Self: Unpin,
F: FnMut(Self::Item) -> Option<B>,
pub fn position<P>(&mut self, predicate: P) -> PositionFuture<'_, Self, P> where
Self: Unpin,
P: FnMut(Self::Item) -> bool,
Self: Unpin,
P: FnMut(Self::Item) -> bool,
pub fn all<P>(&mut self, predicate: P) -> AllFuture<'_, Self, P> where
Self: Unpin,
P: FnMut(Self::Item) -> bool,
Self: Unpin,
P: FnMut(Self::Item) -> bool,
pub fn any<P>(&mut self, predicate: P) -> AnyFuture<'_, Self, P> where
Self: Unpin,
P: FnMut(Self::Item) -> bool,
Self: Unpin,
P: FnMut(Self::Item) -> bool,
pub fn for_each<F>(self, f: F) -> ForEachFuture<Self, F> where
F: FnMut(Self::Item),
F: FnMut(Self::Item),
pub fn try_for_each<F, E>(&mut self, f: F) -> TryForEachFuture<'_, Self, F> where
Self: Unpin,
F: FnMut(Self::Item) -> Result<(), E>,
Self: Unpin,
F: FnMut(Self::Item) -> Result<(), E>,
pub fn zip<U>(self, other: U) -> Zip<Self, U> where
U: Stream,
U: Stream,
pub fn unzip<A, B, FromA, FromB>(self) -> UnzipFuture<Self, FromA, FromB> where
Self: Stream<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Stream<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
pub fn or<S>(self, other: S) -> Or<Self, S> where
S: Stream<Item = Self::Item>,
S: Stream<Item = Self::Item>,
pub fn race<S>(self, other: S) -> Race<Self, S> where
S: Stream<Item = Self::Item>,
S: Stream<Item = Self::Item>,
pub fn boxed<'a>(
self
) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a + Send, Global>> where
Self: Send + 'a,
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,
self
) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a, Global>> where
Self: 'a,
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
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
[src]
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
pub 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]
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = Option<T>>,
pub fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future,
[src]
F: FnMut(Self::Item) -> Fut,
Fut: Future,
pub fn collect<C>(self) -> Collect<Self, C> where
C: Default + Extend<Self::Item>,
[src]
C: Default + Extend<Self::Item>,
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
F: FnMut(T, Self::Item) -> Fut,
Fut: Future<Output = T>,
[src]
F: FnMut(T, Self::Item) -> Fut,
Fut: Future<Output = T>,
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
F: FnMut(Self::Item) -> U,
U: Stream,
[src]
F: FnMut(Self::Item) -> U,
U: Stream,
pub 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<B>>,
[src]
F: FnMut(&mut S, Self::Item) -> Fut,
Fut: Future<Output = Option<B>>,
pub fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
[src]
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
pub fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
[src]
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
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
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
[src]
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
pub fn for_each_concurrent<Fut, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> ForEachConcurrent<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
[src]
self,
limit: impl Into<Option<usize>>,
f: F
) -> ForEachConcurrent<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
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
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,
[src]
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,
pub fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> where
F: FnMut(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,
[src]
F: FnMut(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,
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
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = (), Error = Self::Error>,
[src]
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = (), Error = Self::Error>,
pub 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]
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>,
pub fn try_take_while<Fut, F>(self, f: F) -> TryTakeWhile<Self, Fut, F> where
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>,
[src]
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>,
pub fn try_for_each_concurrent<Fut, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> TryForEachConcurrent<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: Future<Output = Result<(), Self::Error>>,
[src]
self,
limit: impl Into<Option<usize>>,
f: F
) -> TryForEachConcurrent<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: Future<Output = Result<(), Self::Error>>,
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
F: FnMut(&Self::Ok) -> Fut,
Fut: Future<Output = bool>,
[src]
F: FnMut(&Self::Ok) -> Fut,
Fut: Future<Output = bool>,
pub 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]
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = Option<T>, Error = Self::Error>,
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
F: FnMut(T, Self::Ok) -> Fut,
Fut: TryFuture<Ok = T, Error = Self::Error>,
[src]
F: FnMut(T, Self::Ok) -> Fut,
Fut: TryFuture<Ok = T, Error = Self::Error>,
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]>,