Struct Reader

pub struct Reader<'a, T>
where
    T: Storable + 'static,
{ /* private fields */ }

Reader for a Storable type.

Allows Actors to read a value of a type written by another actor. The generic type T from the reader specifies the type of the value that is being read.

The reader allows reading the current value. If no value for type T has been written to yet, Reader::read will return None. See Self::wait_init for creating a reader that ensures available values for T.

Usage

Reader::wait_for_update allows waiting until the type is written to. It will return immediately if an unseen value is available. Unseen does not imply the value actually changed, just that an Actor has written a value. A write of the same value still triggers Reader::wait_for_update to resolve.

To illustrate:

- Writer writes 5
- Reader is woken and reads 5.
  Reader waits for updates.
...
- Writer writes 5 once again.
- Reader is woken and reads 5.
...

The reader is woken, even if the new value equals the old one. The Reader is only aware of the act of writing.

Example

#[veecle_os_runtime::actor]
async fn foo_reader(mut reader: Reader<'_, Foo>) -> std::convert::Infallible {
    loop {
        let processed_value = reader.wait_for_update().await.read(|value: Option<&Foo>| {
            // do something with the value.
        });
    }
}

Implementations

impl<T> Reader<'_, T>

where T: Storable + 'static,

pub fn read<U>( &self, f: impl FnOnce(Option<&<T as Storable>::DataType>) -> U, ) -> U

Reads the current value of a type.

Can be combined with Self::wait_for_update to wait for the value to be updated before reading it.

This method takes a closure to ensure the reference is not held across await points.

pub fn read_cloned(&self) -> Option<<T as Storable>::DataType>

where <T as Storable>::DataType: Clone,

Reads and clones the current value.

This is a wrapper around Self::read that additionally clones the value. You can use it instead of reader.read(|c| c.clone()).

pub async fn wait_for_update(&mut self) -> &mut Reader<'_, T>

Waits for any write to occur.

This future resolving does not imply that previous_value != new_value, just that a Writer has written a value of T since the last time this future resolved.

This returns &mut Self to allow chaining a call to methods accessing the value, for example read.

impl<'a, T> Reader<'a, T>

where T: Storable + 'static,

pub async fn wait_init(self) -> InitializedReader<'a, T>

Converts the Reader into an InitializedReader.

Pends until a value for T is available or resolves immediately if a value is already available. This will not mark the value as seen, InitializedReader::wait_for_update is unaffected by this method.

Trait Implementations

impl<T> CombinableReader for Reader<'_, T>

where T: Storable,

type ToBeRead = Option<<T as Storable>::DataType>

The (owned) type that this type reads, will be exposed as a reference in the CombineReaders::read callback.

impl<'a, T> Debug for Reader<'a, T>

where T: Debug + Storable + 'static,

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

Formats the value using the given formatter.

impl<'a, T> StoreRequest<'a> for Reader<'a, T>

where T: Storable + 'static,

impl<'pin, 'a, T> Unpin for Reader<'a, T>

where T: Storable + 'static, <PinnedFieldsOfHelperStruct<__Reader<'pin, 'a, T>> as PinnedFieldsOfHelperTrait>::Actual: Unpin,