Struct Scope

Source

pub struct Scope<COMP>where
    COMP: BaseComponent,
{ /* private fields */ }

Expand description

A context which allows sending messages to a component.

Implementations§

Source §

impl<COMP> Scope<COMP>
where COMP: BaseComponent,

Source

pub fn get_parent(&self) -> Option<&AnyScope>

Returns the parent scope

Source

pub fn callback<F, IN, M>(&self, function: F) -> Callback<IN>
where M: Into<<COMP as BaseComponent>::Message>, F: Fn(IN) -> M + 'static,

Creates a Callback which will send a message to the linked component’s update method when invoked.

If your callback function returns a Future, use callback_future instead.

Source

pub fn batch_callback<F, IN, OUT>(&self, function: F) -> Callback<IN>
where F: Fn(IN) -> OUT + 'static, OUT: SendAsMessage<COMP>,

Creates a Callback which will send a batch of messages back to the linked component’s update method when invoked.

The callback function’s return type is generic to allow for dealing with both Option and Vec nicely. Option can be used when dealing with a callback that might not need to send an update.

link.batch_callback(|_| vec![Msg::A, Msg::B]);
link.batch_callback(|_| Some(Msg::A));

Source

pub fn context<T>(&self, callback: Callback<T>) -> Option<(T, ContextHandle<T>)>
where T: Clone + PartialEq + 'static,

Accesses a value provided by a parent ContextProvider component of the same type.

Source

pub fn send_future<Fut, Msg>(&self, future: Fut)
where Msg: Into<<COMP as BaseComponent>::Message>, Fut: Future<Output = Msg> + 'static,

This method asynchronously awaits a Future that returns a message and sends it to the linked component.

§Panics

If the future panics, then the promise will not resolve, and will leak.

Source

pub fn callback_future<F, Fut, IN, Msg>(&self, function: F) -> Callback<IN>
where Msg: Into<<COMP as BaseComponent>::Message>, Fut: Future<Output = Msg> + 'static, F: Fn(IN) -> Fut + 'static,

This method creates a Callback which, when emitted, asynchronously awaits the message returned from the passed function before sending it to the linked component.

§Panics

If the future panics, then the promise will not resolve, and will leak.

Source

pub fn send_future_batch<Fut>(&self, future: Fut)
where Fut: Future + 'static, <Fut as Future>::Output: SendAsMessage<COMP>,

Asynchronously send a batch of messages to a component. This asynchronously awaits the passed Future, before sending the message batch to the linked component.

§Panics

If the future panics, then the promise will not resolve, and will leak.

Source

pub fn send_stream<S, M>(&self, stream: S)
where M: Into<<COMP as BaseComponent>::Message>, S: Stream<Item = M> + 'static,

This method asynchronously awaits a Stream that returns a series of messages and sends them to the linked component.

§Panics

If the stream panics, then the promise will not resolve, and will leak.

§Note

This method will not notify the component when the stream has been fully exhausted. If you want this feature, you can add an EOF message variant for your component and use StreamExt::chain and stream::once to chain an EOF message to the original stream. If your stream is produced by another crate, you can use StreamExt::map to transform the stream’s item type to the component message type.

Source