Enum DataState 

pub enum DataState<T, E: ErrorBounds = Error> {
    None,
    AwaitingResponse(Awaiting<T, E>),
    Present(T),
    Failed(DataStateError<E>),
}

Used to store a type that is not always available and we need to keep polling it to get it ready

Variants

None

Represent no data present and not pending

AwaitingResponse(Awaiting<T, E>)

Represents data has been requested and awaiting it being available

Present(T)

Represents data that is available for use

Failed(DataStateError<E>)

Represents an error that Occurred

Implementations

impl<T, E: ErrorBounds> DataState<T, E>

pub fn egui_start_task<F, R>(&mut self, ui: &mut Ui, f: F) -> CanMakeProgress

where F: FnOnce() -> R, R: Into<Awaiting<T, E>>,

Calls Self::start_task and adds a spinner if progress can be made. if state may not be Self::None you can chain after Self::set_none to ensure self is Self::None before calling as self should be Self::None before calling

pub fn start_task<F, R>(&mut self, f: F) -> CanMakeProgress

where F: FnOnce() -> R, R: Into<Awaiting<T, E>>,

Starts a new task. Only intended to be on Self::None and if state is any other value it returns CanMakeProgress::UnableToMakeProgress if state may not be Self::None you can chain after Self::set_none to ensure self is Self::None before calling

pub fn set_none(&mut self) -> &mut Self

Resets self to Self::None and returns &mut self for chaining

pub fn poll(&mut self) -> &mut Self

Convenience method that will try to make progress if in Self::AwaitingResponse and does nothing otherwise. Returns a reference to self for chaining

pub fn poll_take(&mut self) -> Option<T>

Will poll and if in Self::Present takes the value out and returns the owned value, leaving self reset to Self::None.

pub fn egui_poll_mut( &mut self, ui: &mut Ui, error_btn_text: Option<&str>, ) -> Option<&mut T>

Meant to be a simple method to just provide the data if it’s ready or help with UI and polling to get it ready if it’s not.

WARNING: Does nothing if self is Self::None

If a error_btn_text is provided then it overrides the default

pub fn egui_poll( &mut self, ui: &mut Ui, error_btn_text: Option<&str>, ) -> Option<&T>

Wraps Self::egui_poll_mut and returns an immutable reference

pub fn egui_poll_take( &mut self, ui: &mut Ui, error_btn_text: Option<&str>, ) -> Option<T>

Wraps Self::egui_poll_mut for the UI but instead returns the output from Self::poll_take which will reset self to Self::None and return the owned value if present

pub fn await_data(rx: &mut Awaiting<T, E>) -> Option<Self>

Checks to see if the data is ready and if it is returns a new Self otherwise None.

pub fn present(&self) -> Option<&T>

Returns a reference to the inner data if available otherwise None.

NOTE: This function does not poll to get the data ready if the state is still awaiting

pub fn present_mut(&mut self) -> Option<&mut T>

Returns a mutable reference to the inner data if available otherwise None

NOTE: This function does not poll to get the data ready if the state is still awaiting

pub fn is_present(&self) -> bool

Returns true if the data state is Present.

pub fn is_none(&self) -> bool

Returns true if the data state is None.

pub fn is_awaiting_response(&self) -> bool

Returns true if the data state is AwaitingResponse.

Trait Implementations

impl<T, E: ErrorBounds> AsMut<DataState<T, E>> for DataState<T, E>

fn as_mut(&mut self) -> &mut Self

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T, E: ErrorBounds> AsRef<DataState<T, E>> for DataState<T, E>

fn as_ref(&self) -> &Self

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Debug, E: Debug + ErrorBounds> Debug for DataState<T, E>

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

Formats the value using the given formatter.

impl<T, E: ErrorBounds> Default for DataState<T, E>

fn default() -> DataState<T, E>

Returns the “default value” for a type.

impl<'de, T, E: ErrorBounds> Deserialize<'de> for DataState<T, E>

where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T, E: ErrorBounds> Serialize for DataState<T, E>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.