Struct ElementMaybeSignal 

pub struct ElementMaybeSignal<T: 'static> { /* private fields */ }

Used as an argument type to make it easily possible to pass either

• a &str for example “div > p.some-class”,
• a web_sys element that implements E (for example EventTarget, Element or HtmlElement),
• an Option<T> where T is the web_sys element,
• a Signal<T>, RwSignal<T>, ReadSignal<T> or Memo<T> where T is the web_sys element or a String,
• a Signal<Option<T>> where T is the web_sys element,
• a Signal<SendWrapper<T>> where T is the web_sys element,
• a NodeRef

into a function. Used for example in crate::use_event_listener.

let test = "div > p.some-class";
use_element_size(&test); // &str
use_element_size(document().body()); // Option<web_sys::Element>
use_element_size(document().body().unwrap()); // web_sys::Element

let (string_signal, _set_string_signal) = signal("div > p.some-class".to_string());
use_element_size(string_signal); // Signal<String>

let (el_signal, _set_el_signal) = signal(
    Some(SendWrapper::new(
        document().query_selector("div > p.some-class").unwrap().unwrap()
    ))
);
use_element_size(el_signal); // Signal<Option<SendWrapper<web_sys::Element>>>

let (el_signal_send_wrapper, _set_el_signal_send_wrapper) = signal(
    SendWrapper::new(
        document().query_selector("div > p.some-class").unwrap().unwrap()
    )
);
use_element_size(el_signal_send_wrapper); // Signal<SendWrapper<web_sys::Element>>

let el = NodeRef::<Div>::new();
use_element_size(el); // NodeRef

Trait Implementations

impl<T> Clone for ElementMaybeSignal<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Default for ElementMaybeSignal<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> DefinedAt for ElementMaybeSignal<T>

fn defined_at(&self) -> Option<&'static Location<'static>>

Returns the location at which the signal was defined. This is usually simply None in release mode.

impl<T> ReadUntracked for ElementMaybeSignal<T>

type Value = ReadGuard<Option<SendWrapper<T>>, SignalReadGuard<Option<SendWrapper<T>>, SyncStorage>>

The guard type that will be returned, which can be dereferenced to the value.

fn try_read_untracked(&self) -> Option<Self::Value>

Returns the guard, or None if the signal has already been disposed.

fn read_untracked(&self) -> Self::Value

Returns the guard.

fn custom_try_read(&self) -> Option<Option<Self::Value>>

This is a backdoor to allow overriding the Read::try_read implementation despite it being auto implemented.

impl<T> Track for ElementMaybeSignal<T>

fn track(&self)

Subscribes to this signal in the current reactive scope without doing anything with its value.

impl<T> Copy for ElementMaybeSignal<T>