如何在Rust中选择Future和Stream?

问题描述

我刚刚开始在Rust中进行期货/东京的实验.我可以只用期货或流就可以做一些基本的事情.我想知道如何在将来和流之间进行选择.

I've just started experimenting with futures/tokio in Rust. I can do really basic things with just futures or just with streams. I was wondering how you can select between future and a stream.

如何从tokio文档中扩展玩具问题，以使用 tokio_timer::Timer 来执行定时的HTTPS请求?

How can I extend the toy problem from the tokio documentation to use tokio_timer::Timer to do a timed HTTPS request?

extern crate futures; // v0.1 (old)
extern crate native_tls;
extern crate tokio_core;
extern crate tokio_io;
extern crate tokio_tls;

use std::io;
use std::net::ToSocketAddrs;

use futures::Future;
use native_tls::TlsConnector;
use tokio_core::net::TcpStream;
use tokio_core::reactor::Core;
use tokio_tls::TlsConnectorExt;

fn main() {
    let mut core = Core::new().unwrap();
    let handle = core.handle();
    let addr = "www.rust-lang.org:443".to_socket_addrs().unwrap().next().unwrap();

    let cx = TlsConnector::builder().unwrap().build().unwrap();
    let socket = TcpStream::connect(&addr, &handle);

    let tls_handshake = socket.and_then(|socket| {
        let tls = cx.connect_async("www.rust-lang.org", socket);
        tls.map_err(|e| {
            io::Error::new(io::ErrorKind::Other, e)
        })
    });
    let request = tls_handshake.and_then(|socket| {
        tokio_io::io::write_all(socket, "\
            GET / HTTP/1.0\r\n\
            Host: www.rust-lang.org\r\n\
            \r\n\
        ".as_bytes())
    });
    let response = request.and_then(|(socket, _request)| {
        tokio_io::io::read_to_end(socket, Vec::new())
    });

    let (_socket, data) = core.run(response).unwrap();
    println!("{}", String::from_utf8_lossy(&data));
}

推荐答案

您可以使用Future转换为Stream/future/trait.FutureExt.html#method.into_stream"rel =" nofollow noreferrer> FutureExt::into_stream) ，然后在两个流中进行选择:

You can convert a Future into a Stream using FutureExt::into_stream) and then select on the two streams:

use futures::prelude::*; // 0.3.1

fn select_stream_or_future_as_stream<S, F>(stream: S, future: F) -> impl Stream<Item = S::Item>
where
    S: Stream,
    F: Future<Output = S::Item>,
{
    stream::select(future.into_stream(), stream)
}

另请参阅:

• 如何将Future转换为Stream?

这篇关于如何在Rust中选择Future和Stream?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！