Struct Global 

pub struct Global<T, R = T> { /* private fields */ }

Available on crate feature prelude only.

A lazy value that is created once per application and can be accessed from anywhere in that application

Implementations

impl<T> Global<Memo<T>, T>

where T: PartialEq + 'static,

pub fn id(&self) -> GenerationalBoxId

Get the generational id of the signal.

pub fn memo(&self) -> Memo<T>

Resolve the global memo. This will try to get the existing value from the current virtual dom, and if it doesn’t exist, it will create a new one.

impl<T> Global<Signal<T>, T>

where T: 'static,

pub fn id(&self) -> GenerationalBoxId

Get the generational id of the signal.

pub fn signal(&self) -> Signal<T>

Resolve the global signal. This will try to get the existing value from the current virtual dom, and if it doesn’t exist, it will create a new one.

impl<T, R> Global<T, R>

where T: Clone + Writable<Target = R> + InitializeFromFunction<R> + 'static,

pub fn write( &self, ) -> WriteLock<'static, R, <T as Readable>::Storage, <T as Writable>::WriteMetadata>

Write this value

pub fn with_mut<O>(&self, f: impl FnOnce(&mut R) -> O) -> O

where <T as Readable>::Target: 'static,

Run a closure with a mutable reference to the signal’s value. If the signal has been dropped, this will panic.

impl<T, R> Global<T, R>

where T: Clone + InitializeFromFunction<R>,

pub const fn new(constructor: fn() -> R) -> Global<T, R>

Create a new global value

pub const fn with_name( constructor: fn() -> R, key: &'static str, ) -> Global<T, R>

Create this global signal with a specific key. This is useful for ensuring that the signal is unique across the application and accessible from outside the application too.

pub const fn with_location( constructor: fn() -> R, file: &'static str, line: u32, column: u32, index: usize, ) -> Global<T, R>

Create this global signal with a specific key. This is useful for ensuring that the signal is unique across the application and accessible from outside the application too.

pub fn key(&self) -> GlobalKey<'static>

Get the key for this global

pub fn resolve(&self) -> T

where T: 'static,

Resolve the global value. This will try to get the existing value from the current virtual dom, and if it doesn’t exist, it will create a new one.

pub fn origin_scope(&self) -> ScopeId

Get the scope the signal was created in.

Trait Implementations

impl<T> Debug for Global<Memo<T>, T>

where T: Debug + 'static + PartialEq,

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

Formats the value using the given formatter.

impl<T> Debug for Global<Signal<T>, T>

where T: Debug + 'static,

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

Formats the value using the given formatter.

impl<T, R> Deref for Global<T, R>

where T: Clone + Readable<Target = R> + InitializeFromFunction<R> + 'static, R: Clone, <T as Readable>::Target: 'static,

Allow calling a signal with signal() syntax

Currently only limited to copy types, though could probably specialize for string/arc/rc

type Target = dyn Fn() -> R

The resulting type after dereferencing.

fn deref(&self) -> &<Global<T, R> as Deref>::Target

Dereferences the value.

impl<T> Display for Global<Memo<T>, T>

where T: Display + 'static + PartialEq,

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

Formats the value using the given formatter.

impl<T> Display for Global<Signal<T>, T>

where T: Display + 'static,

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

Formats the value using the given formatter.

impl<T, R> From<Global<T, R>> for ReadSignal<R>

where T: Readable<Target = R, Storage = UnsyncStorage> + InitializeFromFunction<R> + Clone + 'static, R: 'static,

fn from(value: Global<T, R>) -> ReadSignal<R>

Converts to this type from the input type.

impl<T, R> From<Global<T, R>> for WriteSignal<R>

where T: Writable<Target = R, Storage = UnsyncStorage> + InitializeFromFunction<R> + Clone + 'static, R: 'static,

fn from(value: Global<T, R>) -> WriteSignal<R>

Converts to this type from the input type.

impl<T> PartialEq<T> for Global<Memo<T>, T>

where T: PartialEq + 'static,

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

Equality operator ==.

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

Inequality operator !=.

impl<T> PartialEq<T> for Global<Signal<T>, T>

where T: PartialEq + 'static,

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

Equality operator ==.

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

Inequality operator !=.

impl<T, R> Readable for Global<T, R>

where T: Readable<Target = R> + InitializeFromFunction<R> + Clone + 'static,

type Target = R

The target type of the reference.

type Storage = <T as Readable>::Storage

The type of the storage this readable uses.

fn try_read_unchecked( &self, ) -> Result<<<Global<T, R> as Readable>::Storage as AnyStorage>::Ref<'static, <Global<T, R> as Readable>::Target>, BorrowError>

where R: 'static,

Try to get a reference to the value without checking the lifetime. This will subscribe the current scope to the signal.

fn try_peek_unchecked( &self, ) -> Result<<<Global<T, R> as Readable>::Storage as AnyStorage>::Ref<'static, <Global<T, R> as Readable>::Target>, BorrowError>

where R: 'static,

Try to peek the current value of the signal without subscribing to updates. If the value has been dropped, this will return an error.

fn subscribers(&self) -> Subscribers

where R: 'static,

Get the underlying subscriber list for this readable. This is used to track when the value changes and notify subscribers.

impl<T, R> Writable for Global<T, R>

where T: Clone + Writable<Target = R> + InitializeFromFunction<R> + 'static,

type WriteMetadata = <T as Writable>::WriteMetadata

Additional data associated with the write reference.

fn try_write_unchecked( &self, ) -> Result<WriteLock<'static, <Global<T, R> as Readable>::Target, <Global<T, R> as Readable>::Storage, <Global<T, R> as Writable>::WriteMetadata>, BorrowMutError>

Try to get a mutable reference to the value without checking the lifetime. This will update any subscribers.