Struct rocket::response::stream::TextStream

pub struct TextStream<S>(pub S);

A potentially infinite stream of text: T: AsRef<str>.

A TextStream can be constructed from any Stream of items of type T where T: AsRef<str>. This includes &str, String, Cow<str>, &RawStr, and more. The stream can be constructed directly, via TextStream(..) or TextStream::from(), or through generator syntax via TextStream!.

Responder

TextStream is a (potentially infinite) responder. The response Content-Type is set to Text. The body is unsized, and values are sent as soon as they are yielded by the internal iterator.

Example

Use TextStream! to yield 10 strings, one every second, of the form "n: $k" for $k from 0 to 10 exclusive:

use rocket::response::stream::TextStream;
use rocket::futures::stream::{repeat, StreamExt};
use rocket::tokio::time::{self, Duration};

#[get("/text")]
fn text() -> TextStream![&'static str] {
    TextStream(repeat("hi"))
}

#[get("/text/stream")]
fn stream() -> TextStream![String] {
    TextStream! {
        let mut interval = time::interval(Duration::from_secs(1));
        for i in 0..10 {
            yield format!("n: {}", i);
            interval.tick().await;
        }
    }
}

The syntax of TextStream! as an expression is identical to that of stream!.

Tuple Fields

0: S

Trait Implementations

impl<S: Clone> Clone for TextStream<S>

fn clone(&self) -> TextStream<S>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: Debug> Debug for TextStream<S>

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

Formats the value using the given formatter.

impl<S> From<S> for TextStream<S>

fn from(stream: S) -> Self

Creates a TextStream from any S: Stream.

impl<'r, S> Responder<'r, 'r> for TextStream<S>

where S: Send + 'r + Stream, S::Item: AsRef<str> + Send + Unpin + 'r,

fn respond_to(self, _: &'r Request<'_>) -> Result<'r>

Returns Ok if a Response could be generated successfully. Otherwise, returns an Err with a failing Status.