Struct EntityStore 

pub struct EntityStore<E, MV = NoMac> { /* private fields */ }

Implementations

impl<E, MV> EntityStore<E, MV>

pub fn new(entity: Option<E>) -> Self

pub fn new_default() -> Self

where E: Default,

pub fn reset(&self, entity: Option<E>)

pub fn reset_to_default(&self)

where E: Default,

pub fn replace(&self, entity: Option<E>) -> Option<E>

pub fn empty(&self) -> bool

pub fn not_empty(&self) -> bool

pub fn empty_signal(&self) -> impl Signal<Item = bool> + use<E, MV>

pub fn not_empty_signal(&self) -> impl Signal<Item = bool> + use<E, MV>

pub fn invalidate(&self)

pub fn transfer_state(&self) -> &Mutable<TransferState>

pub fn set_transfer_state(&self, transfer_state: TransferState)

pub fn reset_transfer_error(&self)

pub fn loaded(&self) -> bool

pub fn loaded_signal(&self) -> impl Signal<Item = bool> + use<E, MV>

pub fn loaded_status(&self) -> Option<StatusCode>

pub fn loaded_status_signal( &self, ) -> impl Signal<Item = Option<StatusCode>> + use<E, MV>

pub fn stored(&self) -> bool

pub fn stored_signal(&self) -> impl Signal<Item = bool> + use<E, MV>

pub fn stored_status(&self) -> Option<StatusCode>

pub fn stored_status_signal( &self, ) -> impl Signal<Item = Option<StatusCode>> + use<E, MV>

pub fn pending(&self) -> bool

pub fn pending_signal(&self) -> impl Signal<Item = bool> + use<E, MV>

pub fn entity(&self) -> &MutableOption<E>

pub fn messages(&self) -> &Messages

pub fn dirty_signal(&self) -> impl Signal<Item = bool> + use<E, MV>

where E: Dirty,

pub fn messages_error_signal(&self) -> impl Signal<Item = bool> + use<E, MV>

pub fn can_commit_signal(&self) -> impl Signal<Item = bool> + use<E, MV>

where E: Dirty,

pub fn signal_map<F, U>(&self, f: F) -> impl Signal<Item = U> + use<E, MV, F, U>

where F: FnMut(Option<&E>) -> U,

pub fn signal_map_some<F, U>( &self, f: F, ) -> impl Signal<Item = Option<U>> + use<E, MV, F, U>

where F: FnMut(&E) -> U,

pub fn signal_map_some_or<F, U>( &self, f: F, default: U, ) -> impl Signal<Item = U> + use<E, MV, F, U>

where F: FnMut(&E) -> U, U: Clone,

pub fn signal_map_some_or_else<F, D, U>( &self, f: F, default: D, ) -> impl Signal<Item = U> + use<E, MV, F, D, U>

where F: FnMut(&E) -> U, D: FnOnce() -> U + Clone,

pub fn signal_and_then_some<F, U>( &self, f: F, ) -> impl Signal<Item = Option<U>> + use<E, MV, F, U>

where F: FnMut(&E) -> Option<U>,

pub fn signal_and_then_some_or<F, U>( &self, f: F, default: U, ) -> impl Signal<Item = U> + use<E, MV, F, U>

where F: FnMut(&E) -> Option<U>, U: Clone,

pub fn signal_and_then_some_or_else<F, D, U>( &self, f: F, default: D, ) -> impl Signal<Item = U> + use<E, MV, F, D, U>

where F: FnMut(&E) -> Option<U>, D: FnOnce() -> U + Clone,

pub fn signal_map_some_default<F, U>( &self, f: F, ) -> impl Signal<Item = U> + use<E, MV, F, U>

where F: FnMut(&E) -> U, U: Default,

pub fn lock_ref(&self) -> MutableLockRef<'_, Option<E>>

pub fn lock_mut(&self) -> MutableLockMut<'_, Option<E>>

pub fn inspect<F>(&self, f: F)

where F: FnOnce(&E),

pub fn inspect_mut<F>(&self, f: F)

where F: FnOnce(&mut E),

pub fn inspect_mut_map<F, U>(&self, f: F) -> Option<U>

where F: FnOnce(&mut E) -> U,

pub fn map<F, U>(&self, f: F) -> Option<U>

where F: FnOnce(&E) -> U,

pub fn map_or_default<F, U>(&self, f: F) -> U

where F: FnOnce(&E) -> U, U: Default,

pub fn and_then<F, U>(&self, f: F) -> Option<U>

where F: FnOnce(&E) -> Option<U>,

pub fn get(&self) -> Option<E>

where E: Copy,

pub fn get_cloned(&self) -> Option<E>

where E: Clone,

pub fn set(&self, entity: Option<E>)

pub fn set_neq(&self, entity: Option<E>)

where E: PartialEq,

pub fn set_externally_loaded(&self, entity: Option<E>)

pub fn set_inner<I>(&self, entity: Option<I>)

where E: Inner<I>,

pub fn set_inner_neq<I>(&self, entity: Option<I>)

where E: PartialEq + Inner<I>,

pub fn set_externally_loaded_inner<I>(&self, entity: Option<I>)

where E: Inner<I>,

impl<E, MV> EntityStore<E, MV>

where MV: MacVerify,

pub fn load<C>(&self, request: Request<'_>, result_callback: C)

where E: DeserializeOwned + 'static, C: FnOnce(StatusCode) + 'static,

pub fn load_skip_cache<C>(&self, request: Request<'_>, result_callback: C)

where E: DeserializeOwned + 'static, C: FnOnce(StatusCode) + 'static,

pub fn load_with_request<MS, R, C>( &self, request: Request<'_>, request_entity: MutableOption<R>, result_callback: C, )

where E: DeserializeOwned + 'static, MS: MacSign, R: Serialize, C: FnOnce(StatusCode) + 'static,

pub fn execute<C>(&self, request: Request<'_>, result_callback: C)

where C: FnOnce(StatusCode) + 'static,

pub fn execute_with_response<R, C>( &self, request: Request<'_>, response_entity: MutableOption<R>, result_callback: C, )

where R: DeserializeOwned + 'static, C: FnOnce(StatusCode) + 'static,

pub fn store<MS, C>(&self, request: Request<'_>, result_callback: C)

where E: Serialize + DeserializeOwned + 'static, MS: MacSign, C: FnOnce(StatusCode) + 'static,

pub fn store_with_response<MS, R, C>( &self, request: Request<'_>, response_entity: MutableOption<R>, result_callback: C, )

where E: Serialize, MS: MacSign, R: DeserializeOwned + 'static, C: FnOnce(StatusCode) + 'static,

Trait Implementations

impl<E: Debug, MV: Debug> Debug for EntityStore<E, MV>

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

Formats the value using the given formatter.

impl<E, MV> Default for EntityStore<E, MV>

fn default() -> Self

Returns the “default value” for a type.

impl<E, MV> From<&EntityStore<E, MV>> for Messages

fn from(store: &EntityStore<E, MV>) -> Self

Converts to this type from the input type.

impl<E, MV> From<&EntityStore<E, MV>> for MutableOption<E>

where E: Clone,

fn from(store: &EntityStore<E, MV>) -> Self

Converts to this type from the input type.