Struct lignin::EventBinding

pub struct EventBinding<'a, S: ThreadSafety> {
    pub name: &'a str,
    pub callback: CallbackRef<S, fn(event: Event)>,
    pub options: EventBindingOptions,
}

Vdom Represents a single DOM event binding with name and callback.

Renderers usually should either manage these through EventTarget.addEventListener/….removeEventListener or ignore them entirely. See web for a bit more information on that.

Note that the running total of CallbackRegistrations made can be limited to u32::MAX or around four billion. (See callback_registry for information on how to get around this, if necessary.)

While this limit is likely hard to hit, economizing registrations a little will still (indirectly) improve app performance. Lazily registering callbacks for events only when rendering is also the easiest way for framework developers to use pinning to avoid heap allocations.

Fields

name: &'a str

The event name.

callback: CallbackRef<S, fn(event: Event)>

A callback reference created via CallbackRegistration.

options: EventBindingOptions

Controls the options parameter of EventTarget.addEventListener().

Note that EventBindingOptions is created with the [EventBindingOptions.passive()] flag already enabled!

Implementations

impl<'a, S: ThreadSafety> EventBinding<'a, S>

#[must_use]

pub fn deanonymize(self) -> Self

👎 Deprecated:

Call of .deanonymize() on named type.

When called on an opaque type, deanonymizes it into the underlying named type.

Both AutoSafe and Deanonymize must be in scope and the method must be called without qualification for this to work.

Calling this method on a named type returns the value and type unchanged and produces a deprecation warning.

impl<'a> EventBinding<'a, ThreadSafe>

#[must_use]

pub fn prefer_thread_safe(self) -> Self

Gently nudges the compiler to choose the ThreadSafe version of a value if both are possible.

This method is by value, so it will resolve with higher priority than the by-reference method on the ThreadBound type.

Note that not all tooling will show the correct overload here, but the compiler knows which to pick.

#[must_use]

pub fn prefer_thread_safe_ref(&self) -> &Self

Gently nudges the compiler to choose the ThreadSafe version of a reference if both are possible.

This method is once by single reference, so it will resolve with higher priority than the twice-by-reference method on the ThreadBound type.

Note that not all tooling will show the correct overload here, but the compiler knows which to pick.

impl<'a> EventBinding<'a, ThreadBound>

#[must_use]

pub fn prefer_thread_safe(&self) -> Self

Gently nudges the compiler to choose the ThreadSafe version of a value if both are is possible.

This method is by reference, so it will resolve with lower priority than the by-value method on the ThreadSafe type.

Note that not all tooling will show the correct overload here, but the compiler knows which to pick.

#[must_use]

pub fn prefer_thread_safe_ref<'b>(self: &&'b Self) -> &'b Self

Gently nudges the compiler to choose the ThreadSafe version of a reference if both are is possible.

This method is twice by reference, so it will resolve with lower priority than the once-by-reference method on the ThreadSafe type.

Note that not all tooling will show the correct overload here, but the compiler knows which to pick.

Trait Implementations

impl<'a, S1, S2> Align<EventBinding<'a, S2>> for EventBinding<'a, S1> where
    S1: ThreadSafety + Into<S2>,
    S2: ThreadSafety, 

Not derived from the Into constraints on $Name directly since those are too broad.

fn align(self) -> T

Contextually thread-binds an instance, or not. Use only without qualification.

fn align_ref(&self) -> &T

Contextually thread-binds a reference, or not. Use only without qualification.

impl<'a, S> Clone for EventBinding<'a, S> where
    S: ThreadSafety, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, V> Deanonymize<EventBinding<'a, ThreadSafe>> for V where
    V: Send + Sync + AutoSafe<EventBinding<'a, ThreadBound>>, 

#[must_use]

fn deanonymize(self) -> SafeVariant

Deanonymize towards a compatible concrete type.

impl<'a, S> Debug for EventBinding<'a, S> where
    S: ThreadSafety, 

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

Formats the value using the given formatter.

impl<'a> From<EventBinding<'a, ThreadSafe>> for EventBinding<'a, ThreadBound>

fn from(thread_safe: EventBinding<'a, ThreadSafe>) -> Self

Performs the conversion.

impl<'a, S> Hash for EventBinding<'a, S> where
    S: ThreadSafety, 

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<'a, S> Ord for EventBinding<'a, S> where
    S: ThreadSafety, 

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

#[must_use]

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<'a, S1, S2> PartialEq<EventBinding<'a, S2>> for EventBinding<'a, S1> where
    S1: ThreadSafety,
    S2: ThreadSafety, 

fn eq(&self, other: &EventBinding<'a, S2>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

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

This method tests for !=.

impl<'a, S1, S2> PartialOrd<EventBinding<'a, S2>> for EventBinding<'a, S1> where
    S1: ThreadSafety,
    S2: ThreadSafety, 

fn partial_cmp(&self, other: &EventBinding<'a, S2>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]

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

This method tests less than (for self and other) and is used by the < operator.

#[must_use]

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]

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

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a, S> Vdom for EventBinding<'a, S> where
    S: ThreadSafety, 

type ThreadSafety = S

The ThreadSafety of the Vdom type, either ThreadSafe or ThreadBound.

impl<'a, S> Copy for EventBinding<'a, S> where
    S: ThreadSafety, 

impl<'a, S> Eq for EventBinding<'a, S> where
    S: ThreadSafety,