Struct Radio 

pub struct Radio<Value, Channel>
where
    Channel: RadioChannel<Value>,
    Value: 'static,
{ /* private fields */ }

A reactive handle to the global state for a specific channel. Radio provides methods to read and write the global state, and automatically subscribes the current component to re-render when the associated channel is notified.

Each Radio instance is tied to a specific channel, allowing fine-grained control over which components update when the state changes.

Examples

Basic usage

#[derive(PartialEq)]
struct MyComponent {}

impl Component for MyComponent {
    fn render(&self) -> impl IntoElement {
        let mut radio = use_radio(MyChannel::Count);

        rect()
            .child(label().text(format!("Count: {}", radio.read().count)))
            .child(
                Button::new()
                    .on_press(move |_| radio.write().count += 1)
                    .child("Increment"),
            )
    }
}

Using reducers

#[derive(Clone)]
struct CounterState {
    count: i32,
}

impl DataReducer for CounterState {
    type Channel = CounterChannel;
    type Action = CounterAction;

    fn reduce(&mut self, action: CounterAction) -> ChannelSelection<CounterChannel> {
        match action {
            CounterAction::Increment => self.count += 1,
            CounterAction::Decrement => self.count -= 1,
        }
        ChannelSelection::Current
    }
}

#[derive(PartialEq)]
struct CounterComponent {}

impl Component for CounterComponent {
    fn render(&self) -> impl IntoElement {
        let mut radio = use_radio(CounterChannel::Count);

        rect()
            .child(
                Button::new()
                    .on_press(move |_| radio.apply(CounterAction::Increment))
                    .child("+"),
            )
            .child(label().text(format!("{}", radio.read().count)))
            .child(
                Button::new()
                    .on_press(move |_| radio.apply(CounterAction::Decrement))
                    .child("-"),
            )
    }
}

Implementations

impl<Value, Channel> Radio<Value, Channel>

where Channel: RadioChannel<Value>,

pub fn read(&self) -> ReadRef<'_, Value>

Read the current state value and subscribe the current component to changes on this radio’s channel. The component will re-render when this channel is notified.

Example

let count = radio.read().count;

pub fn with(&self, cb: impl FnOnce(ReadRef<'_, Value>))

Read the current state value inside a callback.

Example:

radio.with(|value| {
    // Do something with `value`
});

pub fn write(&mut self) -> RadioGuard<Value, Channel>

Get a mutable reference to the state for writing. Changes will notify subscribers to this radio’s channel.

Returns a RadioGuard that allows direct mutation of the state.

Example

radio.write().count += 1;

pub fn write_with(&mut self, cb: impl FnOnce(RadioGuard<Value, Channel>))

Get a mutable reference to the current state value, inside a callback.

Example:

radio.write_with(|value| {
    // Modify `value`
});

pub fn write_channel(&mut self, channel: Channel) -> RadioGuard<Value, Channel>

Modify the state using a custom Channel.

Example:

radio.write(Channel::Whatever).value = 1;

pub fn write_channel_with( &mut self, channel: Channel, cb: impl FnOnce(RadioGuard<Value, Channel>), )

Get a mutable reference to the current state value, inside a callback.

Example:

radio.write_channel_with(Channel::Whatever, |value| {
    // Modify `value`
});

pub fn write_with_channel_selection( &mut self, cb: impl FnOnce(&mut Value) -> ChannelSelection<Channel>, ) -> ChannelSelection<Channel>

Get a mutable reference to the current state value, inside a callback that returns the channel to be used.

Example:

radio.write_with_channel_selection(|value| {
    // Modify `value`
    if value.cool {
        ChannelSelection::Select(Channel::Whatever)
    } else {
        ChannelSelection::Silence
    }
});

pub fn write_silently(&mut self) -> RadioGuard<Value, Channel>

Modify the state silently, no component will be notified.

This is not recommended, the only intended usage for this is inside RadioAsyncReducer.

Trait Implementations

impl<Value, Channel> Clone for Radio<Value, Channel>

where Channel: RadioChannel<Value>,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Value, Channel> MutView<'static, Value> for Radio<Value, Channel>

where Channel: RadioChannel<Value>,

fn read(&mut self) -> ReadRef<'static, Value>

fn peek(&mut self) -> ReadRef<'static, Value>

fn write(&mut self) -> WriteRef<'static, Value>

fn write_if(&mut self, with: impl FnOnce(WriteRef<'static, Value>) -> bool)

impl<Value, Channel> PartialEq for Radio<Value, Channel>

where Channel: RadioChannel<Value>,

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.

impl<Data: DataAsyncReducer<Channel = Channel, Action = Action>, Channel: RadioChannel<Data>, Action> RadioAsyncReducer for Radio<Data, Channel>

type Action = Action

fn async_apply(&mut self, action: Self::Action)

where Self::Action: 'static,

impl<Data: DataReducer<Channel = Channel, Action = Action>, Channel: RadioChannel<Data>, Action> RadioReducer for Radio<Data, Channel>

type Action = Action

type Channel = Channel

fn apply(&mut self, action: Action) -> ChannelSelection<Channel>

impl<Value, Channel> Copy for Radio<Value, Channel>

where Channel: RadioChannel<Value>,