Struct ReadableStream

#[repr(C)]
pub(crate) struct ReadableStream {
    reflector_: Reflector,
    controller: ControllerType,
    stored_error: Heap<JSVal>,
    disturbed: Cell<bool>,
    reader: ReaderType,
    state: Cell<ReadableStreamState>,
}

https://streams.spec.whatwg.org/#rs-class

Fields

reflector_: Reflector

controller: ControllerType

https://streams.spec.whatwg.org/#readablestream-controller Note: the inner MutNullableDom should really be an Option<Dom>, because it is never unset once set.

stored_error: Heap<JSVal>

https://streams.spec.whatwg.org/#readablestream-storederror

disturbed: Cell<bool>

https://streams.spec.whatwg.org/#readablestream-disturbed

reader: ReaderType

https://streams.spec.whatwg.org/#readablestream-reader

state: Cell<ReadableStreamState>

https://streams.spec.whatwg.org/#readablestream-state

Implementations

impl ReadableStream

fn __assert_parent_type(&self)

impl ReadableStream

fn new_inherited(controller: ControllerType) -> ReadableStream

https://streams.spec.whatwg.org/#initialize-readable-stream

fn new_with_proto( global: &GlobalScope, proto: Option<SafeHandleObject<'_>>, controller: ControllerType, can_gc: CanGc, ) -> Root<Dom<ReadableStream>>

pub(crate) fn set_default_controller( &self, controller: &ReadableStreamDefaultController, )

Used as part of https://streams.spec.whatwg.org/#set-up-readable-stream-default-controller

pub(crate) fn assert_no_controller(&self)

Used as part of https://streams.spec.whatwg.org/#set-up-readable-stream-default-controller

pub(crate) fn new_from_bytes( global: &GlobalScope, bytes: Vec<u8>, can_gc: CanGc, ) -> Result<Root<Dom<ReadableStream>>, Error>

Build a stream backed by a Rust source that has already been read into memory.

pub(crate) fn new_with_external_underlying_source( global: &GlobalScope, source: UnderlyingSourceType, can_gc: CanGc, ) -> Result<Root<Dom<ReadableStream>>, Error>

Build a stream backed by a Rust underlying source. Note: external sources are always paired with a default controller.

pub(crate) fn perform_release_steps(&self) -> Result<(), Error>

Call into the release steps of the controller,

pub(crate) fn perform_pull_steps( &self, read_request: &ReadRequest, can_gc: CanGc, )

Call into the pull steps of the controller, as part of https://streams.spec.whatwg.org/#readable-stream-default-reader-read

pub(crate) fn add_read_request(&self, read_request: &ReadRequest)

https://streams.spec.whatwg.org/#readable-stream-add-read-request

pub(crate) fn enqueue_native(&self, bytes: Vec<u8>)

Endpoint to enqueue chunks directly from Rust. Note: in other use cases this call happens via the controller.

pub(crate) fn error(&self, e: SafeHandleValue<'_>)

https://streams.spec.whatwg.org/#readable-stream-error

pub(crate) fn get_stored_error(&self, handle_mut: SafeMutableHandleValue<'_>)

https://streams.spec.whatwg.org/#readablestream-storederror

pub(crate) fn error_native(&self, error: Error)

https://streams.spec.whatwg.org/#readable-stream-error Note: in other use cases this call happens via the controller.

pub(crate) fn controller_close_native(&self)

Call into the controller’s Close method. https://streams.spec.whatwg.org/#readable-stream-default-controller-close

pub(crate) fn in_memory(&self) -> bool

Returns a boolean reflecting whether the stream has all data in memory. Useful for native source integration only.

pub(crate) fn get_in_memory_bytes(&self) -> Option<Vec<u8>>

Return bytes for synchronous use, if the stream has all data in memory. Useful for native source integration only.

pub(crate) fn acquire_default_reader( &self, can_gc: CanGc, ) -> Result<Root<Dom<ReadableStreamDefaultReader>>, Error>

Acquires a reader and locks the stream, must be done before read_a_chunk. Native call to https://streams.spec.whatwg.org/#acquire-readable-stream-reader

pub(crate) fn acquire_byob_reader( &self, can_gc: CanGc, ) -> Result<Root<Dom<ReadableStreamBYOBReader>>, Error>

https://streams.spec.whatwg.org/#acquire-readable-stream-byob-reader

pub(crate) fn get_default_controller( &self, ) -> Root<Dom<ReadableStreamDefaultController>>

pub(crate) fn read_a_chunk(&self, can_gc: CanGc) -> Rc<Promise>

Read a chunk from the stream, must be called after start_reading, and before stop_reading. Native call to https://streams.spec.whatwg.org/#readable-stream-default-reader-read

pub(crate) fn stop_reading(&self)

Releases the lock on the reader, must be done after start_reading. Native call to https://streams.spec.whatwg.org/#abstract-opdef-readablestreamdefaultreaderrelease

pub(crate) fn is_locked(&self) -> bool

https://streams.spec.whatwg.org/#is-readable-stream-locked

pub(crate) fn is_disturbed(&self) -> bool

pub(crate) fn set_is_disturbed(&self, disturbed: bool)

pub(crate) fn is_closed(&self) -> bool

pub(crate) fn is_errored(&self) -> bool

pub(crate) fn is_readable(&self) -> bool

pub(crate) fn has_default_reader(&self) -> bool

pub(crate) fn has_byte_controller(&self) -> bool

pub(crate) fn get_num_read_requests(&self) -> usize

https://streams.spec.whatwg.org/#readable-stream-get-num-read-requests

pub(crate) fn fulfill_read_request( &self, chunk: SafeHandleValue<'_>, done: bool, )

https://streams.spec.whatwg.org/#readable-stream-fulfill-read-request

pub(crate) fn close(&self)

https://streams.spec.whatwg.org/#readable-stream-close

pub(crate) fn cancel( &self, reason: SafeHandleValue<'_>, can_gc: CanGc, ) -> Rc<Promise>

https://streams.spec.whatwg.org/#readable-stream-cancel

pub(crate) fn set_reader(&self, new_reader: Option<ReaderType>)

fn default_tee( &self, clone_for_branch_2: bool, can_gc: CanGc, ) -> Result<Vec<Root<Dom<ReadableStream>>>, Error>

https://streams.spec.whatwg.org/#abstract-opdef-readablestreamdefaulttee

fn tee( &self, clone_for_branch_2: bool, can_gc: CanGc, ) -> Result<Vec<Root<Dom<ReadableStream>>>, Error>

https://streams.spec.whatwg.org/#readable-stream-tee

Trait Implementations

impl DomObject for ReadableStream

fn reflector(&self) -> &Reflector

Returns the receiver’s reflector.

fn global(&self) -> Root<Dom<GlobalScope>>

where Self: Sized,

Returns the GlobalScope of the realm that the DomObject was created in. If this object is a Node, this will be different from it’s owning Document if adopted by. For Nodes it’s almost always better to use NodeTraits::owning_global.

impl DomObjectWrap for ReadableStream

const WRAP: unsafe fn(_: SafeJSContext, _: &GlobalScope, _: Option<HandleObject<'_>>, _: Box<Self>, _: CanGc) -> Root<Dom<Self>> = {dom::bindings::codegen::Bindings::ReadableStreamBinding::ReadableStream_Binding::Wrap as for<'a, 'b> unsafe fn(script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::readablestream::ReadableStream>, script_runtime::CanGc) -> dom::bindings::root::Root<dom::bindings::root::Dom<dom::readablestream::ReadableStream>>}

Function pointer to the general wrap function type

impl HasParent for ReadableStream

fn as_parent(&self) -> &Reflector

This is used in a type assertion to ensure that the source and webidls agree as to what the parent type is

type Parent = Reflector

impl IDLInterface for ReadableStream

fn derives(class: &'static DOMClass) -> bool

Returns whether the given DOM class derives that interface.

impl MallocSizeOf for ReadableStream

fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

Measure the heap usage of all descendant heap-allocated structures, but not the space taken up by the value itself.

impl MutDomObject for ReadableStream

unsafe fn init_reflector(&self, obj: *mut JSObject)

Initializes the Reflector

impl PartialEq for ReadableStream

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl ReadableStreamMethods<DomTypeHolder> for ReadableStream

fn Constructor( cx: SafeJSContext, global: &GlobalScope, proto: Option<SafeHandleObject<'_>>, can_gc: CanGc, underlying_source: Option<*mut JSObject>, strategy: &QueuingStrategy, ) -> Result<Root<Dom<Self>>, Error>

https://streams.spec.whatwg.org/#rs-constructor

fn Locked(&self) -> bool

https://streams.spec.whatwg.org/#rs-locked

fn Cancel( &self, _cx: SafeJSContext, reason: SafeHandleValue<'_>, can_gc: CanGc, ) -> Rc<Promise>

https://streams.spec.whatwg.org/#rs-cancel

fn GetReader( &self, options: &ReadableStreamGetReaderOptions, can_gc: CanGc, ) -> Result<ReadableStreamReader, Error>

https://streams.spec.whatwg.org/#rs-get-reader

fn Tee(&self, can_gc: CanGc) -> Result<Vec<Root<Dom<ReadableStream>>>, Error>

https://streams.spec.whatwg.org/#rs-tee

impl ToJSValConvertible for ReadableStream

unsafe fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue<'_>)

Convert self to a JSVal. JSAPI failure causes a panic.

impl Traceable for ReadableStream

unsafe fn trace(&self, tracer: *mut JSTracer)

Trace self.

impl Eq for ReadableStream