Struct epkard::Runtime

pub struct Runtime<'a, N, F = CliFrontend> where
    N: Node,
    F: Frontend,  { /* fields omitted */ }

Wraps the basic state with extra information and functionality

Methods

impl<'a, N, F> Runtime<'a, N, F> where
    N: Node,
    F: Frontend, 

pub fn push<M>(&mut self) -> Interrupt<N> where
    M: Node<State = N::State> + Default, 

Push a Node onto the stack using its default

pub fn push_node<M>(&mut self, node: M) -> Interrupt<N> where
    M: Node<State = N::State>, 

Push a Node onto the stack

pub fn save<P: AsRef<Path>>(&self, path: P) -> RuntimeResult<()> where
    N: Serialize,
    N::State: Serialize, 

Save the Runtime to the given path

pub fn load<P: AsRef<Path>>(&mut self, path: P) -> RuntimeResult<()> where
    N: DeserializeOwned,
    N::State: DeserializeOwned, 

Load the Runtime from the given path

#[must_use] pub fn prompt<S: Display>(&mut self, prompt: S) -> ControlResult<String, N>

Prompt the user to enter text

#[must_use] pub fn wait(&mut self) -> ControlResult<(), N>

Wait for the user to continue

#[must_use] pub fn multiple_choice<M, C>(
    &mut self,
    message: M,
    choices: &[C]
) -> ControlResult<usize, N> where
    M: Display,
    C: Display, 

Prompt the user with multiple choices

#[must_use] pub fn multiple_choice_named<M, S, C, I>(
    &mut self,
    message: M,
    choices: I
) -> ControlResult<C, N> where
    M: Display,
    S: Display,
    I: IntoIterator<Item = (S, C)>, 

Prompt the user with custom-named multiple choices

Trait Implementations

impl<'a, N, F> Frontend for Runtime<'a, N, F> where
    N: Node,
    F: Frontend, 

fn background_color(&self) -> Color

Get the background color

fn set_background_color(&mut self, color: Color)

Set the background color

fn clear(&mut self)

Clear the display

fn print_colored<S: ToString>(&mut self, text: S, color: Color)

Print text to the display with the given color

fn newline(&mut self)

Print a newline to the display

fn input(&mut self) -> String

Get input from the user

fn print<S: ToString>(&mut self, text: S)

Print text to the display

fn println<S: ToString>(&mut self, text: S)

Print text and a newline to the display

impl<'a, N, F> AsRef<<N as Node>::State> for Runtime<'a, N, F> where
    N: Node,
    F: Frontend, 

fn as_ref(&self) -> &N::State

Performs the conversion.

impl<'a, N, F> AsMut<<N as Node>::State> for Runtime<'a, N, F> where
    N: Node,
    F: Frontend, 

fn as_mut(&mut self) -> &mut N::State

Performs the conversion.

impl<'a, N, F> DerefMut for Runtime<'a, N, F> where
    N: Node,
    F: Frontend, 

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a, N, F> Deref for Runtime<'a, N, F> where
    N: Node,
    F: Frontend, 

type Target = N::State

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.