Trait tide_disco::method::ReadState

pub trait ReadState {
    type State: 'static;

    // Required method
    fn read<'life0, 'async_trait, T>(
        &'life0 self,
        op: impl 'async_trait + Send + for<'a> FnOnce(&'a Self::State) -> BoxFuture<'a, T>,
    ) -> Pin<Box<dyn Future<Output = T> + Send + 'async_trait>>
       where T: 'async_trait,
             Self: 'async_trait,
             'life0: 'async_trait;
}

A state which allows read access.

Implementations may allow shared read access (for instance, [RwLock]) but some implementations do not (for instance, [Mutex]). Therefore, do not assume that read is reentrant, or you may have a deadlock.

Required Associated Types

type State: 'static

The type of state which this type allows a caller to read.

Required Methods

fn read<'life0, 'async_trait, T>( &'life0 self, op: impl 'async_trait + Send + for<'a> FnOnce(&'a Self::State) -> BoxFuture<'a, T>, ) -> Pin<Box<dyn Future<Output = T> + Send + 'async_trait>>

where T: 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Do an operation with immutable access to the state.

Limitations

The reason this function takes a visitor function to apply to the state, rather than just returning a reference to the state, is to allow implementations that cannot provide a plain reference directly. For example, [RwLock] can produce a smart reference, a RwLockReadGuard, but not a plain reference.

Note that GATs may allow us to make this interface more ergonomic in the future. With stable GATs, this trait could be written like

trait ReadState {
    type State: 'static;
    type Reference<'a>: 'a + Deref<Target = Self::State>;
    fn read(&self) -> Self::Reference<'_>;
}

Like many function parameters in tide_disco, the function to apply to the state is also required to return a boxed future.

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl ReadState for ()

This allows you to do api.get(...) in a simple API where the state is ().

type State = ()

fn read<'life0, 'async_trait, T>( &'life0 self, op: impl 'async_trait + Send + for<'a> FnOnce(&'a Self::State) -> BoxFuture<'a, T>, ) -> Pin<Box<dyn Future<Output = T> + Send + 'async_trait>>

where T: 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<R: Send + Sync + ReadState> ReadState for Arc<R>

type State = <R as ReadState>::State

fn read<'life0, 'async_trait, T>( &'life0 self, op: impl 'async_trait + Send + for<'a> FnOnce(&'a Self::State) -> BoxFuture<'a, T>, ) -> Pin<Box<dyn Future<Output = T> + Send + 'async_trait>>

where T: 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<State: 'static + Send + Sync> ReadState for Mutex<State>

type State = State

fn read<'life0, 'async_trait, T>( &'life0 self, op: impl 'async_trait + Send + for<'a> FnOnce(&'a Self::State) -> BoxFuture<'a, T>, ) -> Pin<Box<dyn Future<Output = T> + Send + 'async_trait>>

where T: 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

impl<State: 'static + Send + Sync> ReadState for RwLock<State>

type State = State

fn read<'life0, 'async_trait, T>( &'life0 self, op: impl 'async_trait + Send + for<'a> FnOnce(&'a Self::State) -> BoxFuture<'a, T>, ) -> Pin<Box<dyn Future<Output = T> + Send + 'async_trait>>

where T: 'async_trait, Self: 'async_trait, 'life0: 'async_trait,

Implementors