Struct Callback

pub struct Callback<IN, OUT> { /* private fields */ }

A generic sized representation of a function that can be attached to a Node. The callback will essentially be owned by the element

Limitations: The callback takes an Fn instead of FnMut, therefore it can not mutate the environment variables

In effect callbacks attached to DOM events are limited to only passing an OUT to the program and not complex statements.

Note: It would have been nice to have the inner value be Rc<FnMut(IN) -> OUT> +'a but there are a lot of issues that this becomes infeasible: 1 - wasm_bindgen::Closure requires that ’static references to the closure 2 - Accessing Rc::get_mut requires that there is no other Rc or Weak references else where. - We could be iterating on the elements for recursively setting the attributes which is not allowed to have recursive mutable iteration - Attributes of the same name are merged therefore cloning the attributes, hence the callback is necessary.

Implementations

impl<IN, OUT> Callback<IN, OUT>

where IN: 'static, OUT: 'static,

pub fn emit(&self, input: IN) -> OUT

This method calls the actual callback.

pub fn map_msg<F, MSG2>(self, cb2: F) -> Callback<IN, MSG2>

where F: Fn(OUT) -> MSG2 + Clone + 'static, MSG2: 'static,

map this Callback msg such that Callback<IN, OUT> becomes Callback<IN, MSG2> Note: the original func_type_id is preserved here

Trait Implementations

impl<IN, OUT> Clone for Callback<IN, OUT>

Note: using the #[derive(Clone)] needs IN and OUT to also be Clone

The reason this is manually implemented is, so that IN and OUT doesn’t need to be Clone as it is part of the Callback objects and cloning here is just cloning the pointer of the actual callback function

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<IN, OUT> Debug for Callback<IN, OUT>

Note: using the #[derive(Debug)] needs IN and OUT to also be Debug

The reason this is manually implemented is, so that IN and OUT doesn’t need to be Debug as it is part of the Callback objects and are not shown.

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

Formats the value using the given formatter.

impl<MSG> From<Callback<Event, MSG>> for AttributeValue<MSG>

fn from(listener: EventCallback<MSG>) -> Self

Converts to this type from the input type.

impl<IN, F, OUT> From<F> for Callback<IN, OUT>

where F: FnMut(IN) -> OUT + 'static, OUT: 'static, IN: 'static,

fn from(func: F) -> Self

Converts to this type from the input type.

impl<IN, OUT> PartialEq for Callback<IN, OUT>

Compare if the callbacks are equal Note, we are only comparing the type_id of the function, the input and the output

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.