Struct ReadableStreamDefaultReader

pub struct ReadableStreamDefaultReader<'stream> { /* private fields */ }

A ReadableStreamDefaultReader that can be used to read chunks from a ReadableStream.

This is returned by the get_reader method.

When the reader is dropped, it automatically releases its lock.

Implementations

impl<'stream> ReadableStreamDefaultReader<'stream>

pub fn as_raw(&self) -> &ReadableStreamDefaultReader

Acquires a reference to the underlying JavaScript reader.

pub async fn closed(&self) -> Result<(), JsValue>

Waits for the stream to become closed.

This returns an error if the stream ever errors, or if the reader’s lock is released before the stream finishes closing.

pub async fn cancel(&mut self) -> Result<(), JsValue>

Cancels the stream, signaling a loss of interest in the stream by a consumer.

Equivalent to ReadableStream.cancel.

pub async fn cancel_with_reason( &mut self, reason: &JsValue, ) -> Result<(), JsValue>

Cancels the stream, signaling a loss of interest in the stream by a consumer.

Equivalent to ReadableStream.cancel_with_reason.

pub async fn read(&mut self) -> Result<Option<JsValue>, JsValue>

Reads the next chunk from the stream’s internal queue.

• If a next chunk becomes available, this returns Ok(Some(chunk)).
• If the stream closes and no more chunks are available, this returns Ok(None).
• If the stream encounters an error, this returns Err(error).

pub fn release_lock(self)

Releases this reader’s lock on the corresponding stream.

As of January 2022, the Streams standard allows the lock to be released even when there are still pending read requests. Such requests will automatically become rejected, and this function will always succeed.

However, if the Streams implementation is not yet up-to-date with this change, then releasing the lock while there are pending read requests will panic. For a non-panicking variant, use try_release_lock.

pub fn try_release_lock(self) -> Result<(), (Error, Self)>

Try to release this reader’s lock on the corresponding stream.

As of January 2022, the Streams standard allows the lock to be released even when there are still pending read requests. Such requests will automatically become rejected, and this function will always return Ok(()).

However, if the Streams implementation is not yet up-to-date with this change, then the lock cannot be released while there are pending read requests. Attempting to do so will return an error and leave the reader locked to the stream.

pub fn into_stream(self) -> IntoStream<'stream>

Converts this ReadableStreamDefaultReader into a Stream.

This is similar to ReadableStream.into_stream, except that after the returned Stream is dropped, the original ReadableStream is still usable. This allows reading only a few chunks from the Stream, while still allowing another reader to read the remaining chunks later on.

Trait Implementations

impl<'stream> Debug for ReadableStreamDefaultReader<'stream>

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

Formats the value using the given formatter.

impl Drop for ReadableStreamDefaultReader<'_>

fn drop(&mut self)

Executes the destructor for this type.