Merge branch 'master' into stream-delay
k-nasa
5 years ago
commit
3b055f364e
@ -1,68 +0,0 @@
|
|||||||
language: rust
|
|
||||||
|
|
||||||
env:
|
|
||||||
- RUSTFLAGS="-D warnings"
|
|
||||||
|
|
||||||
# Cache the whole `~/.cargo` directory to keep `~/cargo/.crates.toml`.
|
|
||||||
cache:
|
|
||||||
directories:
|
|
||||||
- /home/travis/.cargo
|
|
||||||
|
|
||||||
# Don't cache the cargo registry because it's too big.
|
|
||||||
before_cache:
|
|
||||||
- rm -rf /home/travis/.cargo/registry
|
|
||||||
|
|
||||||
|
|
||||||
branches:
|
|
||||||
only:
|
|
||||||
- master
|
|
||||||
- staging
|
|
||||||
- trying
|
|
||||||
|
|
||||||
matrix:
|
|
||||||
fast_finish: true
|
|
||||||
include:
|
|
||||||
- rust: nightly
|
|
||||||
os: linux
|
|
||||||
|
|
||||||
- rust: nightly
|
|
||||||
os: osx
|
|
||||||
osx_image: xcode9.2
|
|
||||||
|
|
||||||
- rust: nightly-x86_64-pc-windows-msvc
|
|
||||||
os: windows
|
|
||||||
|
|
||||||
- name: fmt
|
|
||||||
rust: nightly
|
|
||||||
os: linux
|
|
||||||
before_script: |
|
|
||||||
if ! rustup component add rustfmt; then
|
|
||||||
target=`curl https://rust-lang.github.io/rustup-components-history/x86_64-unknown-linux-gnu/rustfmt`;
|
|
||||||
echo "'rustfmt' is unavailable on the toolchain 'nightly', use the toolchain 'nightly-$target' instead";
|
|
||||||
rustup toolchain install nightly-$target;
|
|
||||||
rustup default nightly-$target;
|
|
||||||
rustup component add rustfmt;
|
|
||||||
fi
|
|
||||||
script:
|
|
||||||
- cargo fmt --all -- --check
|
|
||||||
|
|
||||||
- name: docs
|
|
||||||
rust: nightly
|
|
||||||
os: linux
|
|
||||||
script:
|
|
||||||
- cargo doc --features docs
|
|
||||||
|
|
||||||
- name: book
|
|
||||||
rust: nightly
|
|
||||||
os: linux
|
|
||||||
before_script:
|
|
||||||
- test -x $HOME/.cargo/bin/mdbook || ./ci/install-mdbook.sh
|
|
||||||
- cargo build # to find 'extern crate async_std' by `mdbook test`
|
|
||||||
script:
|
|
||||||
- mdbook build docs
|
|
||||||
- mdbook test -L ./target/debug/deps docs
|
|
||||||
|
|
||||||
script:
|
|
||||||
- cargo check --all --benches --bins --examples --tests
|
|
||||||
- cargo check --features unstable --all --benches --bins --examples --tests
|
|
||||||
- cargo test --all --doc --features unstable
|
|
||||||
@ -1,142 +1,139 @@
|
|||||||
# Async version of the Rust standard library
|
<h1 align="center">async-std</h1>
|
||||||
|
<div align="center">
|
||||||
[](https://travis-ci.com/async-rs/async-std)
|
<strong>
|
||||||
[](https://github.com/async-rs/async-std)
|
Async version of the Rust standard library
|
||||||
[](https://crates.io/crates/async-std)
|
</strong>
|
||||||
[](https://docs.rs/async-std)
|
</div>
|
||||||
[](https://discord.gg/JvZeVNe)
|
|
||||||
|
<br />
|
||||||
This crate provides an async version of [`std`]. It provides all the interfaces you
|
|
||||||
are used to, but in an async version and ready for Rust's `async`/`await` syntax.
|
<div align="center">
|
||||||
|
<!-- Crates version -->
|
||||||
|
<a href="https://crates.io/crates/async-std">
|
||||||
|
<img src="https://img.shields.io/crates/v/async-std.svg?style=flat-square"
|
||||||
|
alt="Crates.io version" />
|
||||||
|
</a>
|
||||||
|
<!-- Downloads -->
|
||||||
|
<a href="https://crates.io/crates/async-std">
|
||||||
|
<img src="https://img.shields.io/crates/d/async-std.svg?style=flat-square"
|
||||||
|
alt="Download" />
|
||||||
|
</a>
|
||||||
|
<!-- docs.rs docs -->
|
||||||
|
<a href="https://docs.rs/async-std">
|
||||||
|
<img src="https://img.shields.io/badge/docs-latest-blue.svg?style=flat-square"
|
||||||
|
alt="docs.rs docs" />
|
||||||
|
</a>
|
||||||
|
|
||||||
|
<a href="https://discord.gg/JvZeVNe">
|
||||||
|
<img src="https://img.shields.io/discord/598880689856970762.svg?logo=discord&style=flat-square"
|
||||||
|
alt="chat" />
|
||||||
|
</a>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
<div align="center">
|
||||||
|
<h3>
|
||||||
|
<a href="https://docs.rs/async-std">
|
||||||
|
API Docs
|
||||||
|
</a>
|
||||||
|
<span> | </span>
|
||||||
|
<a href="https://book.async.rs">
|
||||||
|
Book
|
||||||
|
</a>
|
||||||
|
<span> | </span>
|
||||||
|
<a href="https://github.com/async-rs/async-std/releases">
|
||||||
|
Releases
|
||||||
|
</a>
|
||||||
|
<span> | </span>
|
||||||
|
<a href="https://async.rs/contribute">
|
||||||
|
Contributing
|
||||||
|
</a>
|
||||||
|
</h3>
|
||||||
|
</div>
|
||||||
|
|
||||||
|
<br/>
|
||||||
|
|
||||||
|
This crate provides an async version of [`std`]. It provides all the interfaces
|
||||||
|
you are used to, but in an async version and ready for Rust's `async`/`await`
|
||||||
|
syntax.
|
||||||
|
|
||||||
[`std`]: https://doc.rust-lang.org/std/index.html
|
[`std`]: https://doc.rust-lang.org/std/index.html
|
||||||
|
|
||||||
## Documentation
|
## Features
|
||||||
|
|
||||||
`async-std` comes with [extensive API documentation][docs] and a [book][book].
|
- __Modern:__ Built from the ground up for `std::future` and `async/await` with
|
||||||
|
blazing fast compilation time.
|
||||||
|
- __Fast:__ Our robust allocator and threadpool designs provide ultra-high
|
||||||
|
throughput with predictably low latency.
|
||||||
|
- __Intuitive:__ Complete parity with the stdlib means you only need to learn
|
||||||
|
APIs once.
|
||||||
|
- __Clear:__ [Detailed documentation][docs] and [accessible guides][book] mean
|
||||||
|
using async Rust was never easier.
|
||||||
|
|
||||||
[docs]: https://docs.rs/async-std
|
[docs]: https://docs.rs/async-std
|
||||||
[book]: https://book.async.rs
|
[book]: https://book.async.rs
|
||||||
|
|
||||||
## Quickstart
|
## Examples
|
||||||
|
|
||||||
Add the following lines to your `Cargo.toml`:
|
|
||||||
|
|
||||||
```toml
|
|
||||||
[dependencies]
|
|
||||||
async-std = "0.99"
|
|
||||||
```
|
|
||||||
|
|
||||||
Or use [cargo add][cargo-add] if you have it installed:
|
|
||||||
|
|
||||||
```sh
|
|
||||||
$ cargo add async-std
|
|
||||||
```
|
|
||||||
|
|
||||||
[cargo-add]: https://github.com/killercup/cargo-edit
|
|
||||||
|
|
||||||
## Hello world
|
All examples require the [`"attributes"` feature] to be enabled. This feature
|
||||||
|
is not enabled by default because it significantly impacts compile times. See
|
||||||
|
[`task::block_on`] for an alternative way to start executing tasks.
|
||||||
|
|
||||||
```rust
|
```rust
|
||||||
use async_std::task;
|
async fn say_hello() {
|
||||||
|
|
||||||
fn main() {
|
|
||||||
task::block_on(async {
|
|
||||||
println!("Hello, world!");
|
println!("Hello, world!");
|
||||||
})
|
|
||||||
}
|
|
||||||
```
|
|
||||||
|
|
||||||
## Low-Friction Sockets with Built-In Timeouts
|
|
||||||
|
|
||||||
```rust
|
|
||||||
use std::time::Duration;
|
|
||||||
|
|
||||||
use async_std::{
|
|
||||||
prelude::*,
|
|
||||||
task,
|
|
||||||
io,
|
|
||||||
net::TcpStream,
|
|
||||||
};
|
|
||||||
|
|
||||||
async fn get() -> io::Result<Vec<u8>> {
|
|
||||||
let mut stream = TcpStream::connect("example.com:80").await?;
|
|
||||||
stream.write_all(b"GET /index.html HTTP/1.0\r\n\r\n").await?;
|
|
||||||
|
|
||||||
let mut buf = vec![];
|
|
||||||
|
|
||||||
io::timeout(Duration::from_secs(5), async {
|
|
||||||
stream.read_to_end(&mut buf).await?;
|
|
||||||
Ok(buf)
|
|
||||||
}).await
|
|
||||||
}
|
}
|
||||||
|
|
||||||
fn main() {
|
#[async_std::main]
|
||||||
task::block_on(async {
|
async fn main() {
|
||||||
let raw_response = get().await.expect("request");
|
say_hello().await;
|
||||||
let response = String::from_utf8(raw_response)
|
|
||||||
.expect("utf8 conversion");
|
|
||||||
println!("received: {}", response);
|
|
||||||
});
|
|
||||||
}
|
}
|
||||||
```
|
```
|
||||||
|
|
||||||
## Features
|
More examples, including networking and file access, can be found in our
|
||||||
|
[`examples`] directory and in our [documentation].
|
||||||
`async-std` is strongly commited to following semver. This means your code won't
|
|
||||||
break unless _you_ decide to upgrade.
|
|
||||||
|
|
||||||
However every now and then we come up with something that we think will work
|
|
||||||
_great_ for `async-std`, and we want to provide a sneak-peek so you can try it
|
|
||||||
out. This is what we call _"unstable"_ features. You can try out the unstable
|
|
||||||
features by enabling the `unstable` feature in your `Cargo.toml` file:
|
|
||||||
|
|
||||||
```toml
|
|
||||||
[dependencies.async-std]
|
|
||||||
version = "0.99"
|
|
||||||
features = ["unstable"]
|
|
||||||
```
|
|
||||||
|
|
||||||
Just be careful when using these features, as they may change between
|
|
||||||
versions.
|
|
||||||
|
|
||||||
## Take a look around
|
[`examples`]: https://github.com/async-rs/async-std/tree/master/examples
|
||||||
|
[documentation]: https://docs.rs/async-std#examples
|
||||||
|
[`task::block_on`]: task/fn.block_on.html
|
||||||
|
[`"attributes"` feature]: https://docs.rs/async-std/#features
|
||||||
|
|
||||||
Clone the repo:
|
## Philosophy
|
||||||
|
|
||||||
```
|
We believe Async Rust should be as easy to pick up as Sync Rust. We also believe
|
||||||
git clone git@github.com:async-rs/async-std.git && cd async-std
|
that the best API is the one you already know. And finally, we believe that
|
||||||
```
|
providing an asynchronous counterpart to the standard library is the best way
|
||||||
|
stdlib provides a reliable basis for both performance and productivity.
|
||||||
|
|
||||||
Generate docs:
|
Async-std is the embodiment of that vision. It combines single-allocation task
|
||||||
|
creation, with an adaptive lock-free executor, threadpool and network driver to
|
||||||
|
create a smooth system that processes work at a high pace with low latency,
|
||||||
|
using Rust's familiar stdlib API.
|
||||||
|
|
||||||
```
|
## Installation
|
||||||
cargo +nightly doc --features docs --open
|
|
||||||
```
|
|
||||||
|
|
||||||
Check out the [examples](examples). To run an example:
|
With [cargo add][cargo-add] installed run:
|
||||||
|
|
||||||
|
```sh
|
||||||
|
$ cargo add async-std
|
||||||
```
|
```
|
||||||
cargo +nightly run --example hello-world
|
|
||||||
```
|
|
||||||
|
|
||||||
## Contributing
|
|
||||||
|
|
||||||
See [our contribution document][contribution].
|
We also provide a set of "unstable" features with async-std. See the [features
|
||||||
|
documentation] on how to enable them.
|
||||||
|
|
||||||
[contribution]: https://async.rs/contribute
|
[cargo-add]: https://github.com/killercup/cargo-edit
|
||||||
|
[features documentation]: https://docs.rs/async-std/#features
|
||||||
|
|
||||||
## License
|
## License
|
||||||
|
|
||||||
Licensed under either of
|
<sup>
|
||||||
|
Licensed under either of <a href="LICENSE-APACHE">Apache License, Version
|
||||||
* Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
|
2.0</a> or <a href="LICENSE-MIT">MIT license</a> at your option.
|
||||||
* MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
|
</sup>
|
||||||
|
|
||||||
at your option.
|
|
||||||
|
|
||||||
#### Contribution
|
<br/>
|
||||||
|
|
||||||
|
<sub>
|
||||||
Unless you explicitly state otherwise, any contribution intentionally submitted
|
Unless you explicitly state otherwise, any contribution intentionally submitted
|
||||||
for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
|
for inclusion in this crate by you, as defined in the Apache-2.0 license, shall
|
||||||
dual licensed as above, without any additional terms or conditions.
|
be dual licensed as above, without any additional terms or conditions.
|
||||||
|
</sub>
|
||||||
|
|||||||
@ -0,0 +1,40 @@
|
|||||||
|
#![feature(test)]
|
||||||
|
|
||||||
|
extern crate test;
|
||||||
|
|
||||||
|
use async_std::sync::{Arc, Mutex};
|
||||||
|
use async_std::task;
|
||||||
|
use test::Bencher;
|
||||||
|
|
||||||
|
#[bench]
|
||||||
|
fn create(b: &mut Bencher) {
|
||||||
|
b.iter(|| Mutex::new(()));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[bench]
|
||||||
|
fn contention(b: &mut Bencher) {
|
||||||
|
b.iter(|| task::block_on(run(10, 1000)));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[bench]
|
||||||
|
fn no_contention(b: &mut Bencher) {
|
||||||
|
b.iter(|| task::block_on(run(1, 10000)));
|
||||||
|
}
|
||||||
|
|
||||||
|
async fn run(task: usize, iter: usize) {
|
||||||
|
let m = Arc::new(Mutex::new(()));
|
||||||
|
let mut tasks = Vec::new();
|
||||||
|
|
||||||
|
for _ in 0..task {
|
||||||
|
let m = m.clone();
|
||||||
|
tasks.push(task::spawn(async move {
|
||||||
|
for _ in 0..iter {
|
||||||
|
let _ = m.lock().await;
|
||||||
|
}
|
||||||
|
}));
|
||||||
|
}
|
||||||
|
|
||||||
|
for t in tasks {
|
||||||
|
t.await;
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,11 @@
|
|||||||
|
#![feature(test)]
|
||||||
|
|
||||||
|
extern crate test;
|
||||||
|
|
||||||
|
use async_std::task;
|
||||||
|
use test::Bencher;
|
||||||
|
|
||||||
|
#[bench]
|
||||||
|
fn block_on(b: &mut Bencher) {
|
||||||
|
b.iter(|| task::block_on(async {}));
|
||||||
|
}
|
||||||
@ -1,11 +1,14 @@
|
|||||||
# Tutorial: Writing a chat
|
# Tutorial: Writing a chat
|
||||||
|
|
||||||
Nothing is as simple as a chat server, right? Not quite, chat servers
|
Nothing is simpler than creating a chat server, right?
|
||||||
already expose you to all the fun of asynchronous programming: how
|
Not quite, chat servers expose you to all the fun of asynchronous programming:
|
||||||
do you handle clients connecting concurrently. How do you handle them disconnecting?
|
|
||||||
|
|
||||||
How do you distribute the messages?
|
How will the server handle clients connecting concurrently?
|
||||||
|
|
||||||
In this tutorial, we will show you how to write one in `async-std`.
|
How will it handle them disconnecting?
|
||||||
|
|
||||||
|
How will it distribute the messages?
|
||||||
|
|
||||||
|
This tutorial explains how to write a chat server in `async-std`.
|
||||||
|
|
||||||
You can also find the tutorial in [our repository](https://github.com/async-rs/async-std/blob/master/examples/a-chat).
|
You can also find the tutorial in [our repository](https://github.com/async-rs/async-std/blob/master/examples/a-chat).
|
||||||
|
|||||||
@ -0,0 +1,44 @@
|
|||||||
|
//! TCP echo server, accepting connections both on both ipv4 and ipv6 sockets.
|
||||||
|
//!
|
||||||
|
//! To send messages, do:
|
||||||
|
//!
|
||||||
|
//! ```sh
|
||||||
|
//! $ nc 127.0.0.1 8080
|
||||||
|
//! $ nc ::1 8080
|
||||||
|
//! ```
|
||||||
|
|
||||||
|
use async_std::io;
|
||||||
|
use async_std::net::{TcpListener, TcpStream};
|
||||||
|
use async_std::prelude::*;
|
||||||
|
use async_std::task;
|
||||||
|
|
||||||
|
async fn process(stream: TcpStream) -> io::Result<()> {
|
||||||
|
println!("Accepted from: {}", stream.peer_addr()?);
|
||||||
|
|
||||||
|
let (reader, writer) = &mut (&stream, &stream);
|
||||||
|
io::copy(reader, writer).await?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn main() -> io::Result<()> {
|
||||||
|
task::block_on(async {
|
||||||
|
let ipv4_listener = TcpListener::bind("127.0.0.1:8080").await?;
|
||||||
|
println!("Listening on {}", ipv4_listener.local_addr()?);
|
||||||
|
let ipv6_listener = TcpListener::bind("[::1]:8080").await?;
|
||||||
|
println!("Listening on {}", ipv6_listener.local_addr()?);
|
||||||
|
|
||||||
|
let ipv4_incoming = ipv4_listener.incoming();
|
||||||
|
let ipv6_incoming = ipv6_listener.incoming();
|
||||||
|
|
||||||
|
let mut incoming = ipv4_incoming.merge(ipv6_incoming);
|
||||||
|
|
||||||
|
while let Some(stream) = incoming.next().await {
|
||||||
|
let stream = stream?;
|
||||||
|
task::spawn(async {
|
||||||
|
process(stream).await.unwrap();
|
||||||
|
});
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
})
|
||||||
|
}
|
||||||
@ -1 +1,2 @@
|
|||||||
version = "Two"
|
version = "Two"
|
||||||
|
format_code_in_doc_comments = true
|
||||||
|
|||||||
@ -0,0 +1,43 @@
|
|||||||
|
use std::future::Future;
|
||||||
|
use std::pin::Pin;
|
||||||
|
use std::time::Duration;
|
||||||
|
|
||||||
|
use futures_timer::Delay;
|
||||||
|
use pin_project_lite::pin_project;
|
||||||
|
|
||||||
|
use crate::task::{Context, Poll};
|
||||||
|
|
||||||
|
pin_project! {
|
||||||
|
#[doc(hidden)]
|
||||||
|
#[allow(missing_debug_implementations)]
|
||||||
|
pub struct DelayFuture<F> {
|
||||||
|
#[pin]
|
||||||
|
future: F,
|
||||||
|
#[pin]
|
||||||
|
delay: Delay,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<F> DelayFuture<F> {
|
||||||
|
pub fn new(future: F, dur: Duration) -> DelayFuture<F> {
|
||||||
|
let delay = Delay::new(dur);
|
||||||
|
|
||||||
|
DelayFuture { future, delay }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<F: Future> Future for DelayFuture<F> {
|
||||||
|
type Output = F::Output;
|
||||||
|
|
||||||
|
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
|
||||||
|
let this = self.project();
|
||||||
|
|
||||||
|
match this.delay.poll(cx) {
|
||||||
|
Poll::Pending => Poll::Pending,
|
||||||
|
Poll::Ready(_) => match this.future.poll(cx) {
|
||||||
|
Poll::Ready(v) => Poll::Ready(v),
|
||||||
|
Poll::Pending => Poll::Pending,
|
||||||
|
},
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,52 @@
|
|||||||
|
use std::future::Future;
|
||||||
|
use std::pin::Pin;
|
||||||
|
|
||||||
|
use crate::future::IntoFuture;
|
||||||
|
use crate::task::{ready, Context, Poll};
|
||||||
|
|
||||||
|
#[doc(hidden)]
|
||||||
|
#[allow(missing_debug_implementations)]
|
||||||
|
pub struct FlattenFuture<Fut1, Fut2> {
|
||||||
|
state: State<Fut1, Fut2>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
enum State<Fut1, Fut2> {
|
||||||
|
First(Fut1),
|
||||||
|
Second(Fut2),
|
||||||
|
Empty,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<Fut1, Fut2> FlattenFuture<Fut1, Fut2> {
|
||||||
|
pub(crate) fn new(future: Fut1) -> FlattenFuture<Fut1, Fut2> {
|
||||||
|
FlattenFuture {
|
||||||
|
state: State::First(future),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<Fut1> Future for FlattenFuture<Fut1, <Fut1::Output as IntoFuture>::Future>
|
||||||
|
where
|
||||||
|
Fut1: Future,
|
||||||
|
Fut1::Output: IntoFuture,
|
||||||
|
{
|
||||||
|
type Output = <Fut1::Output as IntoFuture>::Output;
|
||||||
|
|
||||||
|
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
|
||||||
|
let Self { state } = unsafe { self.get_unchecked_mut() };
|
||||||
|
loop {
|
||||||
|
match state {
|
||||||
|
State::First(fut1) => {
|
||||||
|
let fut2 = ready!(unsafe { Pin::new_unchecked(fut1) }.poll(cx)).into_future();
|
||||||
|
*state = State::Second(fut2);
|
||||||
|
}
|
||||||
|
State::Second(fut2) => {
|
||||||
|
let v = ready!(unsafe { Pin::new_unchecked(fut2) }.poll(cx));
|
||||||
|
*state = State::Empty;
|
||||||
|
return Poll::Ready(v);
|
||||||
|
}
|
||||||
|
State::Empty => panic!("polled a completed future"),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,60 @@
|
|||||||
|
use std::pin::Pin;
|
||||||
|
|
||||||
|
use async_macros::MaybeDone;
|
||||||
|
use pin_project_lite::pin_project;
|
||||||
|
|
||||||
|
use crate::task::{Context, Poll};
|
||||||
|
use std::future::Future;
|
||||||
|
|
||||||
|
pin_project! {
|
||||||
|
#[allow(missing_docs)]
|
||||||
|
#[allow(missing_debug_implementations)]
|
||||||
|
pub struct Join<L, R>
|
||||||
|
where
|
||||||
|
L: Future,
|
||||||
|
R: Future<Output = L::Output>
|
||||||
|
{
|
||||||
|
#[pin] left: MaybeDone<L>,
|
||||||
|
#[pin] right: MaybeDone<R>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<L, R> Join<L, R>
|
||||||
|
where
|
||||||
|
L: Future,
|
||||||
|
R: Future<Output = L::Output>,
|
||||||
|
{
|
||||||
|
pub(crate) fn new(left: L, right: R) -> Self {
|
||||||
|
Self {
|
||||||
|
left: MaybeDone::new(left),
|
||||||
|
right: MaybeDone::new(right),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<L, R> Future for Join<L, R>
|
||||||
|
where
|
||||||
|
L: Future,
|
||||||
|
R: Future<Output = L::Output>,
|
||||||
|
{
|
||||||
|
type Output = (L::Output, R::Output);
|
||||||
|
|
||||||
|
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
|
||||||
|
let this = self.project();
|
||||||
|
|
||||||
|
let mut left = this.left;
|
||||||
|
let mut right = this.right;
|
||||||
|
|
||||||
|
let is_left_ready = Future::poll(Pin::new(&mut left), cx).is_ready();
|
||||||
|
if is_left_ready && right.as_ref().output().is_some() {
|
||||||
|
return Poll::Ready((left.take().unwrap(), right.take().unwrap()));
|
||||||
|
}
|
||||||
|
|
||||||
|
let is_right_ready = Future::poll(Pin::new(&mut right), cx).is_ready();
|
||||||
|
if is_right_ready && left.as_ref().output().is_some() {
|
||||||
|
return Poll::Ready((left.take().unwrap(), right.take().unwrap()));
|
||||||
|
}
|
||||||
|
|
||||||
|
Poll::Pending
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,395 @@
|
|||||||
|
cfg_unstable! {
|
||||||
|
mod delay;
|
||||||
|
mod flatten;
|
||||||
|
mod race;
|
||||||
|
mod try_race;
|
||||||
|
mod join;
|
||||||
|
mod try_join;
|
||||||
|
|
||||||
|
use std::time::Duration;
|
||||||
|
|
||||||
|
use delay::DelayFuture;
|
||||||
|
use flatten::FlattenFuture;
|
||||||
|
use crate::future::IntoFuture;
|
||||||
|
use race::Race;
|
||||||
|
use try_race::TryRace;
|
||||||
|
use join::Join;
|
||||||
|
use try_join::TryJoin;
|
||||||
|
}
|
||||||
|
|
||||||
|
extension_trait! {
|
||||||
|
use std::pin::Pin;
|
||||||
|
use std::ops::{Deref, DerefMut};
|
||||||
|
|
||||||
|
use crate::task::{Context, Poll};
|
||||||
|
|
||||||
|
#[doc = r#"
|
||||||
|
A future represents an asynchronous computation.
|
||||||
|
|
||||||
|
A future is a value that may not have finished computing yet. This kind of
|
||||||
|
"asynchronous value" makes it possible for a thread to continue doing useful
|
||||||
|
work while it waits for the value to become available.
|
||||||
|
|
||||||
|
The [provided methods] do not really exist in the trait itself, but they become
|
||||||
|
available when [`FutureExt`] from the [prelude] is imported:
|
||||||
|
|
||||||
|
```
|
||||||
|
# #[allow(unused_imports)]
|
||||||
|
use async_std::prelude::*;
|
||||||
|
```
|
||||||
|
|
||||||
|
# The `poll` method
|
||||||
|
|
||||||
|
The core method of future, `poll`, *attempts* to resolve the future into a
|
||||||
|
final value. This method does not block if the value is not ready. Instead,
|
||||||
|
the current task is scheduled to be woken up when it's possible to make
|
||||||
|
further progress by `poll`ing again. The `context` passed to the `poll`
|
||||||
|
method can provide a [`Waker`], which is a handle for waking up the current
|
||||||
|
task.
|
||||||
|
|
||||||
|
When using a future, you generally won't call `poll` directly, but instead
|
||||||
|
`.await` the value.
|
||||||
|
|
||||||
|
[`Waker`]: ../task/struct.Waker.html
|
||||||
|
[provided methods]: #provided-methods
|
||||||
|
[`FutureExt`]: ../prelude/trait.FutureExt.html
|
||||||
|
[prelude]: ../prelude/index.html
|
||||||
|
"#]
|
||||||
|
pub trait Future {
|
||||||
|
#[doc = r#"
|
||||||
|
The type of value produced on completion.
|
||||||
|
"#]
|
||||||
|
type Output;
|
||||||
|
|
||||||
|
#[doc = r#"
|
||||||
|
Attempt to resolve the future to a final value, registering
|
||||||
|
the current task for wakeup if the value is not yet available.
|
||||||
|
|
||||||
|
# Return value
|
||||||
|
|
||||||
|
This function returns:
|
||||||
|
|
||||||
|
- [`Poll::Pending`] if the future is not ready yet
|
||||||
|
- [`Poll::Ready(val)`] with the result `val` of this future if it
|
||||||
|
finished successfully.
|
||||||
|
|
||||||
|
Once a future has finished, clients should not `poll` it again.
|
||||||
|
|
||||||
|
When a future is not ready yet, `poll` returns `Poll::Pending` and
|
||||||
|
stores a clone of the [`Waker`] copied from the current [`Context`].
|
||||||
|
This [`Waker`] is then woken once the future can make progress.
|
||||||
|
For example, a future waiting for a socket to become
|
||||||
|
readable would call `.clone()` on the [`Waker`] and store it.
|
||||||
|
When a signal arrives elsewhere indicating that the socket is readable,
|
||||||
|
[`Waker::wake`] is called and the socket future's task is awoken.
|
||||||
|
Once a task has been woken up, it should attempt to `poll` the future
|
||||||
|
again, which may or may not produce a final value.
|
||||||
|
|
||||||
|
Note that on multiple calls to `poll`, only the [`Waker`] from the
|
||||||
|
[`Context`] passed to the most recent call should be scheduled to
|
||||||
|
receive a wakeup.
|
||||||
|
|
||||||
|
# Runtime characteristics
|
||||||
|
|
||||||
|
Futures alone are *inert*; they must be *actively* `poll`ed to make
|
||||||
|
progress, meaning that each time the current task is woken up, it should
|
||||||
|
actively re-`poll` pending futures that it still has an interest in.
|
||||||
|
|
||||||
|
The `poll` function is not called repeatedly in a tight loop -- instead,
|
||||||
|
it should only be called when the future indicates that it is ready to
|
||||||
|
make progress (by calling `wake()`). If you're familiar with the
|
||||||
|
`poll(2)` or `select(2)` syscalls on Unix it's worth noting that futures
|
||||||
|
typically do *not* suffer the same problems of "all wakeups must poll
|
||||||
|
all events"; they are more like `epoll(4)`.
|
||||||
|
|
||||||
|
An implementation of `poll` should strive to return quickly, and should
|
||||||
|
not block. Returning quickly prevents unnecessarily clogging up
|
||||||
|
threads or event loops. If it is known ahead of time that a call to
|
||||||
|
`poll` may end up taking awhile, the work should be offloaded to a
|
||||||
|
thread pool (or something similar) to ensure that `poll` can return
|
||||||
|
quickly.
|
||||||
|
|
||||||
|
# Panics
|
||||||
|
|
||||||
|
Once a future has completed (returned `Ready` from `poll`), calling its
|
||||||
|
`poll` method again may panic, block forever, or cause other kinds of
|
||||||
|
problems; the `Future` trait places no requirements on the effects of
|
||||||
|
such a call. However, as the `poll` method is not marked `unsafe`,
|
||||||
|
Rust's usual rules apply: calls must never cause undefined behavior
|
||||||
|
(memory corruption, incorrect use of `unsafe` functions, or the like),
|
||||||
|
regardless of the future's state.
|
||||||
|
|
||||||
|
[`Poll::Pending`]: ../task/enum.Poll.html#variant.Pending
|
||||||
|
[`Poll::Ready(val)`]: ../task/enum.Poll.html#variant.Ready
|
||||||
|
[`Context`]: ../task/struct.Context.html
|
||||||
|
[`Waker`]: ../task/struct.Waker.html
|
||||||
|
[`Waker::wake`]: ../task/struct.Waker.html#method.wake
|
||||||
|
"#]
|
||||||
|
fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output>;
|
||||||
|
}
|
||||||
|
|
||||||
|
#[doc = r#"
|
||||||
|
Extension methods for [`Future`].
|
||||||
|
|
||||||
|
[`Future`]: ../future/trait.Future.html
|
||||||
|
"#]
|
||||||
|
pub trait FutureExt: std::future::Future {
|
||||||
|
/// Returns a Future that delays execution for a specified time.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// # async_std::task::block_on(async {
|
||||||
|
/// use async_std::prelude::*;
|
||||||
|
/// use async_std::future;
|
||||||
|
/// use std::time::Duration;
|
||||||
|
///
|
||||||
|
/// let a = future::ready(1).delay(Duration::from_millis(2000));
|
||||||
|
/// dbg!(a.await);
|
||||||
|
/// # })
|
||||||
|
/// ```
|
||||||
|
#[cfg(all(feature = "default", feature = "unstable"))]
|
||||||
|
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||||
|
fn delay(self, dur: Duration) -> impl Future<Output = Self::Output> [DelayFuture<Self>]
|
||||||
|
where
|
||||||
|
Self: Sized,
|
||||||
|
{
|
||||||
|
DelayFuture::new(self, dur)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Flatten out the execution of this future when the result itself
|
||||||
|
/// can be converted into another future.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// # async_std::task::block_on(async {
|
||||||
|
/// use async_std::prelude::*;
|
||||||
|
///
|
||||||
|
/// let nested_future = async { async { 1 } };
|
||||||
|
/// let future = nested_future.flatten();
|
||||||
|
/// assert_eq!(future.await, 1);
|
||||||
|
/// # })
|
||||||
|
/// ```
|
||||||
|
#[cfg(feature = "unstable")]
|
||||||
|
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||||
|
fn flatten(
|
||||||
|
self,
|
||||||
|
) -> impl Future<Output = <Self::Output as IntoFuture>::Output>
|
||||||
|
[FlattenFuture<Self, <Self::Output as IntoFuture>::Future>]
|
||||||
|
where
|
||||||
|
Self: Sized,
|
||||||
|
<Self as Future>::Output: IntoFuture,
|
||||||
|
{
|
||||||
|
FlattenFuture::new(self)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[doc = r#"
|
||||||
|
Waits for one of two similarly-typed futures to complete.
|
||||||
|
|
||||||
|
Awaits multiple futures simultaneously, returning the output of the
|
||||||
|
first future that completes.
|
||||||
|
|
||||||
|
This function will return a new future which awaits for either one of both
|
||||||
|
futures to complete. If multiple futures are completed at the same time,
|
||||||
|
resolution will occur in the order that they have been passed.
|
||||||
|
|
||||||
|
Note that this function consumes all futures passed, and once a future is
|
||||||
|
completed, all other futures are dropped.
|
||||||
|
|
||||||
|
# Examples
|
||||||
|
|
||||||
|
```
|
||||||
|
# async_std::task::block_on(async {
|
||||||
|
use async_std::prelude::*;
|
||||||
|
use async_std::future;
|
||||||
|
|
||||||
|
let a = future::pending();
|
||||||
|
let b = future::ready(1u8);
|
||||||
|
let c = future::ready(2u8);
|
||||||
|
|
||||||
|
let f = a.race(b).race(c);
|
||||||
|
assert_eq!(f.await, 1u8);
|
||||||
|
# });
|
||||||
|
```
|
||||||
|
"#]
|
||||||
|
#[cfg(feature = "unstable")]
|
||||||
|
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||||
|
fn race<F>(
|
||||||
|
self,
|
||||||
|
other: F,
|
||||||
|
) -> impl Future<Output = <Self as std::future::Future>::Output> [Race<Self, F>]
|
||||||
|
where
|
||||||
|
Self: std::future::Future + Sized,
|
||||||
|
F: std::future::Future<Output = <Self as std::future::Future>::Output>,
|
||||||
|
{
|
||||||
|
Race::new(self, other)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[doc = r#"
|
||||||
|
Waits for one of two similarly-typed fallible futures to complete.
|
||||||
|
|
||||||
|
Awaits multiple futures simultaneously, returning all results once complete.
|
||||||
|
|
||||||
|
`try_race` is similar to [`race`], but keeps going if a future
|
||||||
|
resolved to an error until all futures have been resolved. In which case
|
||||||
|
an error is returned.
|
||||||
|
|
||||||
|
The ordering of which value is yielded when two futures resolve
|
||||||
|
simultaneously is intentionally left unspecified.
|
||||||
|
|
||||||
|
[`race`]: #method.race
|
||||||
|
|
||||||
|
# Examples
|
||||||
|
|
||||||
|
```
|
||||||
|
# fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
||||||
|
#
|
||||||
|
use async_std::prelude::*;
|
||||||
|
use async_std::future;
|
||||||
|
use std::io::{Error, ErrorKind};
|
||||||
|
|
||||||
|
let a = future::pending::<Result<_, Error>>();
|
||||||
|
let b = future::ready(Err(Error::from(ErrorKind::Other)));
|
||||||
|
let c = future::ready(Ok(1u8));
|
||||||
|
|
||||||
|
let f = a.try_race(b).try_race(c);
|
||||||
|
assert_eq!(f.await?, 1u8);
|
||||||
|
#
|
||||||
|
# Ok(()) }) }
|
||||||
|
```
|
||||||
|
"#]
|
||||||
|
#[cfg(feature = "unstable")]
|
||||||
|
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||||
|
fn try_race<F, T, E>(
|
||||||
|
self,
|
||||||
|
other: F
|
||||||
|
) -> impl Future<Output = <Self as std::future::Future>::Output> [TryRace<Self, F>]
|
||||||
|
where
|
||||||
|
Self: std::future::Future<Output = Result<T, E>> + Sized,
|
||||||
|
F: std::future::Future<Output = <Self as std::future::Future>::Output>,
|
||||||
|
{
|
||||||
|
TryRace::new(self, other)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[doc = r#"
|
||||||
|
Waits for two similarly-typed futures to complete.
|
||||||
|
|
||||||
|
Awaits multiple futures simultaneously, returning the output of the
|
||||||
|
futures once both complete.
|
||||||
|
|
||||||
|
This function returns a new future which polls both futures
|
||||||
|
concurrently.
|
||||||
|
|
||||||
|
# Examples
|
||||||
|
|
||||||
|
```
|
||||||
|
# async_std::task::block_on(async {
|
||||||
|
use async_std::prelude::*;
|
||||||
|
use async_std::future;
|
||||||
|
|
||||||
|
let a = future::ready(1u8);
|
||||||
|
let b = future::ready(2u8);
|
||||||
|
|
||||||
|
let f = a.join(b);
|
||||||
|
assert_eq!(f.await, (1u8, 2u8));
|
||||||
|
# });
|
||||||
|
```
|
||||||
|
"#]
|
||||||
|
#[cfg(any(feature = "unstable", feature = "docs"))]
|
||||||
|
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||||
|
fn join<F>(
|
||||||
|
self,
|
||||||
|
other: F
|
||||||
|
) -> impl Future<Output = (<Self as std::future::Future>::Output, <F as std::future::Future>::Output)> [Join<Self, F>]
|
||||||
|
where
|
||||||
|
Self: std::future::Future + Sized,
|
||||||
|
F: std::future::Future<Output = <Self as std::future::Future>::Output>,
|
||||||
|
{
|
||||||
|
Join::new(self, other)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[doc = r#"
|
||||||
|
Waits for two similarly-typed fallible futures to complete.
|
||||||
|
|
||||||
|
Awaits multiple futures simultaneously, returning all results once
|
||||||
|
complete.
|
||||||
|
|
||||||
|
`try_join` is similar to [`join`], but returns an error immediately
|
||||||
|
if a future resolves to an error.
|
||||||
|
|
||||||
|
[`join`]: #method.join
|
||||||
|
|
||||||
|
# Examples
|
||||||
|
|
||||||
|
```
|
||||||
|
# fn main() -> std::io::Result<()> { async_std::task::block_on(async {
|
||||||
|
#
|
||||||
|
use async_std::prelude::*;
|
||||||
|
use async_std::future;
|
||||||
|
|
||||||
|
let a = future::ready(Err("Error"));
|
||||||
|
let b = future::ready(Ok(1u8));
|
||||||
|
|
||||||
|
let f = a.try_join(b);
|
||||||
|
assert_eq!(f.await, Err("Error"));
|
||||||
|
|
||||||
|
let a = future::ready(Ok::<u8, String>(1u8));
|
||||||
|
let b = future::ready(Ok::<u8, String>(2u8));
|
||||||
|
|
||||||
|
let f = a.try_join(b);
|
||||||
|
assert_eq!(f.await, Ok((1u8, 2u8)));
|
||||||
|
#
|
||||||
|
# Ok(()) }) }
|
||||||
|
```
|
||||||
|
"#]
|
||||||
|
#[cfg(any(feature = "unstable", feature = "docs"))]
|
||||||
|
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||||
|
fn try_join<F, T, E>(
|
||||||
|
self,
|
||||||
|
other: F
|
||||||
|
) -> impl Future<Output = Result<(T, T), E>> [TryJoin<Self, F>]
|
||||||
|
where
|
||||||
|
Self: std::future::Future<Output = Result<T, E>> + Sized,
|
||||||
|
F: std::future::Future<Output = <Self as std::future::Future>::Output>,
|
||||||
|
{
|
||||||
|
TryJoin::new(self, other)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<F: Future + Unpin + ?Sized> Future for Box<F> {
|
||||||
|
type Output = F::Output;
|
||||||
|
|
||||||
|
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
|
||||||
|
unreachable!("this impl only appears in the rendered docs")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<F: Future + Unpin + ?Sized> Future for &mut F {
|
||||||
|
type Output = F::Output;
|
||||||
|
|
||||||
|
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
|
||||||
|
unreachable!("this impl only appears in the rendered docs")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<P> Future for Pin<P>
|
||||||
|
where
|
||||||
|
P: DerefMut + Unpin,
|
||||||
|
<P as Deref>::Target: Future,
|
||||||
|
{
|
||||||
|
type Output = <<P as Deref>::Target as Future>::Output;
|
||||||
|
|
||||||
|
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
|
||||||
|
unreachable!("this impl only appears in the rendered docs")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<F: Future> Future for std::panic::AssertUnwindSafe<F> {
|
||||||
|
type Output = F::Output;
|
||||||
|
|
||||||
|
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
|
||||||
|
unreachable!("this impl only appears in the rendered docs")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,57 @@
|
|||||||
|
use std::future::Future;
|
||||||
|
use std::pin::Pin;
|
||||||
|
|
||||||
|
use async_macros::MaybeDone;
|
||||||
|
use pin_project_lite::pin_project;
|
||||||
|
|
||||||
|
use crate::task::{Context, Poll};
|
||||||
|
|
||||||
|
pin_project! {
|
||||||
|
#[allow(missing_docs)]
|
||||||
|
#[allow(missing_debug_implementations)]
|
||||||
|
pub struct Race<L, R>
|
||||||
|
where
|
||||||
|
L: Future,
|
||||||
|
R: Future<Output = L::Output>
|
||||||
|
{
|
||||||
|
#[pin] left: MaybeDone<L>,
|
||||||
|
#[pin] right: MaybeDone<R>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<L, R> Race<L, R>
|
||||||
|
where
|
||||||
|
L: Future,
|
||||||
|
R: Future<Output = L::Output>,
|
||||||
|
{
|
||||||
|
pub(crate) fn new(left: L, right: R) -> Self {
|
||||||
|
Self {
|
||||||
|
left: MaybeDone::new(left),
|
||||||
|
right: MaybeDone::new(right),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<L, R> Future for Race<L, R>
|
||||||
|
where
|
||||||
|
L: Future,
|
||||||
|
R: Future<Output = L::Output>,
|
||||||
|
{
|
||||||
|
type Output = L::Output;
|
||||||
|
|
||||||
|
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
|
||||||
|
let this = self.project();
|
||||||
|
|
||||||
|
let mut left = this.left;
|
||||||
|
if Future::poll(Pin::new(&mut left), cx).is_ready() {
|
||||||
|
return Poll::Ready(left.take().unwrap());
|
||||||
|
}
|
||||||
|
|
||||||
|
let mut right = this.right;
|
||||||
|
if Future::poll(Pin::new(&mut right), cx).is_ready() {
|
||||||
|
return Poll::Ready(right.take().unwrap());
|
||||||
|
}
|
||||||
|
|
||||||
|
Poll::Pending
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,72 @@
|
|||||||
|
use std::pin::Pin;
|
||||||
|
|
||||||
|
use async_macros::MaybeDone;
|
||||||
|
use pin_project_lite::pin_project;
|
||||||
|
|
||||||
|
use crate::task::{Context, Poll};
|
||||||
|
use std::future::Future;
|
||||||
|
|
||||||
|
pin_project! {
|
||||||
|
#[allow(missing_docs)]
|
||||||
|
#[allow(missing_debug_implementations)]
|
||||||
|
pub struct TryJoin<L, R>
|
||||||
|
where
|
||||||
|
L: Future,
|
||||||
|
R: Future<Output = L::Output>
|
||||||
|
{
|
||||||
|
#[pin] left: MaybeDone<L>,
|
||||||
|
#[pin] right: MaybeDone<R>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<L, R> TryJoin<L, R>
|
||||||
|
where
|
||||||
|
L: Future,
|
||||||
|
R: Future<Output = L::Output>,
|
||||||
|
{
|
||||||
|
pub(crate) fn new(left: L, right: R) -> Self {
|
||||||
|
Self {
|
||||||
|
left: MaybeDone::new(left),
|
||||||
|
right: MaybeDone::new(right),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<L, R, T, E> Future for TryJoin<L, R>
|
||||||
|
where
|
||||||
|
L: Future<Output = Result<T, E>>,
|
||||||
|
R: Future<Output = L::Output>,
|
||||||
|
{
|
||||||
|
type Output = Result<(T, T), E>;
|
||||||
|
|
||||||
|
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
|
||||||
|
let this = self.project();
|
||||||
|
|
||||||
|
let mut left = this.left;
|
||||||
|
let mut right = this.right;
|
||||||
|
|
||||||
|
if Future::poll(Pin::new(&mut left), cx).is_ready() {
|
||||||
|
if left.as_ref().output().unwrap().is_err() {
|
||||||
|
return Poll::Ready(Err(left.take().unwrap().err().unwrap()));
|
||||||
|
} else if right.as_ref().output().is_some() {
|
||||||
|
return Poll::Ready(Ok((
|
||||||
|
left.take().unwrap().ok().unwrap(),
|
||||||
|
right.take().unwrap().ok().unwrap(),
|
||||||
|
)));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if Future::poll(Pin::new(&mut right), cx).is_ready() {
|
||||||
|
if right.as_ref().output().unwrap().is_err() {
|
||||||
|
return Poll::Ready(Err(right.take().unwrap().err().unwrap()));
|
||||||
|
} else if left.as_ref().output().is_some() {
|
||||||
|
return Poll::Ready(Ok((
|
||||||
|
left.take().unwrap().ok().unwrap(),
|
||||||
|
right.take().unwrap().ok().unwrap(),
|
||||||
|
)));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Poll::Pending
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,66 @@
|
|||||||
|
use std::pin::Pin;
|
||||||
|
|
||||||
|
use async_macros::MaybeDone;
|
||||||
|
use pin_project_lite::pin_project;
|
||||||
|
|
||||||
|
use crate::task::{Context, Poll};
|
||||||
|
use std::future::Future;
|
||||||
|
|
||||||
|
pin_project! {
|
||||||
|
#[allow(missing_docs)]
|
||||||
|
#[allow(missing_debug_implementations)]
|
||||||
|
pub struct TryRace<L, R>
|
||||||
|
where
|
||||||
|
L: Future,
|
||||||
|
R: Future<Output = L::Output>
|
||||||
|
{
|
||||||
|
#[pin] left: MaybeDone<L>,
|
||||||
|
#[pin] right: MaybeDone<R>,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<L, R> TryRace<L, R>
|
||||||
|
where
|
||||||
|
L: Future,
|
||||||
|
R: Future<Output = L::Output>,
|
||||||
|
{
|
||||||
|
pub(crate) fn new(left: L, right: R) -> Self {
|
||||||
|
Self {
|
||||||
|
left: MaybeDone::new(left),
|
||||||
|
right: MaybeDone::new(right),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<L, R, T, E> Future for TryRace<L, R>
|
||||||
|
where
|
||||||
|
L: Future<Output = Result<T, E>>,
|
||||||
|
R: Future<Output = L::Output>,
|
||||||
|
{
|
||||||
|
type Output = L::Output;
|
||||||
|
|
||||||
|
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
|
||||||
|
let this = self.project();
|
||||||
|
let mut left_errored = false;
|
||||||
|
|
||||||
|
// Check if the left future is ready & successful. Continue if not.
|
||||||
|
let mut left = this.left;
|
||||||
|
if Future::poll(Pin::new(&mut left), cx).is_ready() {
|
||||||
|
if left.as_ref().output().unwrap().is_ok() {
|
||||||
|
return Poll::Ready(left.take().unwrap());
|
||||||
|
} else {
|
||||||
|
left_errored = true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Check if the right future is ready & successful. Return err if left
|
||||||
|
// future also resolved to err. Continue if not.
|
||||||
|
let mut right = this.right;
|
||||||
|
let is_ready = Future::poll(Pin::new(&mut right), cx).is_ready();
|
||||||
|
if is_ready && (right.as_ref().output().unwrap().is_ok() || left_errored) {
|
||||||
|
return Poll::Ready(right.take().unwrap());
|
||||||
|
}
|
||||||
|
|
||||||
|
Poll::Pending
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,53 @@
|
|||||||
|
use std::future::Future;
|
||||||
|
|
||||||
|
/// Convert a type into a `Future`.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use async_std::future::{Future, IntoFuture};
|
||||||
|
/// use async_std::io;
|
||||||
|
/// use async_std::pin::Pin;
|
||||||
|
///
|
||||||
|
/// struct Client;
|
||||||
|
///
|
||||||
|
/// impl Client {
|
||||||
|
/// pub async fn send(self) -> io::Result<()> {
|
||||||
|
/// // Send a request
|
||||||
|
/// Ok(())
|
||||||
|
/// }
|
||||||
|
/// }
|
||||||
|
///
|
||||||
|
/// impl IntoFuture for Client {
|
||||||
|
/// type Output = io::Result<()>;
|
||||||
|
///
|
||||||
|
/// type Future = Pin<Box<dyn Future<Output = Self::Output>>>;
|
||||||
|
///
|
||||||
|
/// fn into_future(self) -> Self::Future {
|
||||||
|
/// Box::pin(async {
|
||||||
|
/// self.send().await
|
||||||
|
/// })
|
||||||
|
/// }
|
||||||
|
/// }
|
||||||
|
/// ```
|
||||||
|
#[cfg(feature = "unstable")]
|
||||||
|
#[cfg_attr(feature = "docs", doc(cfg(unstable)))]
|
||||||
|
pub trait IntoFuture {
|
||||||
|
/// The type of value produced on completion.
|
||||||
|
type Output;
|
||||||
|
|
||||||
|
/// Which kind of future are we turning this into?
|
||||||
|
type Future: Future<Output = Self::Output>;
|
||||||
|
|
||||||
|
/// Create a future from a value
|
||||||
|
fn into_future(self) -> Self::Future;
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T: Future> IntoFuture for T {
|
||||||
|
type Output = T::Output;
|
||||||
|
type Future = T;
|
||||||
|
|
||||||
|
fn into_future(self) -> Self::Future {
|
||||||
|
self
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,51 @@
|
|||||||
|
use std::mem;
|
||||||
|
use std::pin::Pin;
|
||||||
|
|
||||||
|
use pin_project_lite::pin_project;
|
||||||
|
|
||||||
|
use super::read_until_internal;
|
||||||
|
use crate::io::{self, BufRead};
|
||||||
|
use crate::stream::Stream;
|
||||||
|
use crate::task::{Context, Poll};
|
||||||
|
|
||||||
|
pin_project! {
|
||||||
|
/// A stream over the contents of an instance of [`BufRead`] split on a particular byte.
|
||||||
|
///
|
||||||
|
/// This stream is created by the [`split`] method on types that implement [`BufRead`].
|
||||||
|
///
|
||||||
|
/// This type is an async version of [`std::io::Split`].
|
||||||
|
///
|
||||||
|
/// [`split`]: trait.BufRead.html#method.lines
|
||||||
|
/// [`BufRead`]: trait.BufRead.html
|
||||||
|
/// [`std::io::Split`]: https://doc.rust-lang.org/std/io/struct.Split.html
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub struct Split<R> {
|
||||||
|
#[pin]
|
||||||
|
pub(crate) reader: R,
|
||||||
|
pub(crate) buf: Vec<u8>,
|
||||||
|
pub(crate) read: usize,
|
||||||
|
pub(crate) delim: u8,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<R: BufRead> Stream for Split<R> {
|
||||||
|
type Item = io::Result<Vec<u8>>;
|
||||||
|
|
||||||
|
fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
|
||||||
|
let this = self.project();
|
||||||
|
let n = futures_core::ready!(read_until_internal(
|
||||||
|
this.reader,
|
||||||
|
cx,
|
||||||
|
*this.delim,
|
||||||
|
this.buf,
|
||||||
|
this.read
|
||||||
|
))?;
|
||||||
|
if n == 0 && this.buf.is_empty() {
|
||||||
|
return Poll::Ready(None);
|
||||||
|
}
|
||||||
|
if this.buf[this.buf.len() - 1] == *this.delim {
|
||||||
|
this.buf.pop();
|
||||||
|
}
|
||||||
|
Poll::Ready(Some(Ok(mem::replace(this.buf, vec![]))))
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,21 @@
|
|||||||
|
use std::pin::Pin;
|
||||||
|
use std::future::Future;
|
||||||
|
|
||||||
|
use crate::io::{self, Seek, SeekFrom};
|
||||||
|
use crate::task::{Context, Poll};
|
||||||
|
|
||||||
|
#[doc(hidden)]
|
||||||
|
#[allow(missing_debug_implementations)]
|
||||||
|
pub struct SeekFuture<'a, T: Unpin + ?Sized> {
|
||||||
|
pub(crate) seeker: &'a mut T,
|
||||||
|
pub(crate) pos: SeekFrom,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T: Seek + Unpin + ?Sized> Future for SeekFuture<'_, T> {
|
||||||
|
type Output = io::Result<u64>;
|
||||||
|
|
||||||
|
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
|
||||||
|
let pos = self.pos;
|
||||||
|
Pin::new(&mut *self.seeker).poll_seek(cx, pos)
|
||||||
|
}
|
||||||
|
}
|
||||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue