Struct StateMachine 

#[non_exhaustive]
pub struct StateMachine {
    pub field: String,
    pub states: Vec<(String, String)>,
    pub start: Option<String>,
    pub transitions: Vec<Transition>,
}

The states of a record, in one of its fields, and the ways between them.

use ravenrs_app::{EntityInfo, EnumOption, FieldInfo, FieldKind, StateMachine};

let options = vec![EnumOption::new("draft", "Draft"), EnumOption::new("done", "Done")];
let entity = EntityInfo::new("Task")
    .field(FieldInfo::new("id", FieldKind::Integer).key())
    .field(FieldInfo::new("state", FieldKind::Enum(options)))
    .state_machine(
        StateMachine::new("state").state("draft", "Draft").state("done", "Done").start("draft").transition(
            "draft",
            "done",
            "Finish",
        ),
    );
assert!(entity.check().is_ok());

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

field: String

The field that holds the state: options, text or a reference.

states: Vec<(String, String)>

The states, as stored and as people see them.

start: Option<String>

Where a new record has to start; nothing means any state.

transitions: Vec<Transition>

The ways between states.

Implementations

impl StateMachine

pub fn new(field: impl Into<String>) -> Self

Over this field.

pub fn state(self, code: impl Into<String>, caption: impl Into<String>) -> Self

A state, as stored and as people see it.

pub fn start(self, code: impl Into<String>) -> Self

Where a new record starts, which also is what it starts with.

pub fn transition( self, from: impl Into<String>, to: impl Into<String>, caption: impl Into<String>, ) -> Self

A way between two states, with what its action says.

pub fn when(self, expression: impl Into<String>) -> Self

The last way declared only opens for records this expression holds for.

Trait Implementations

impl Clone for StateMachine

fn clone(&self) -> StateMachine

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for StateMachine

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

Formats the value using the given formatter.

impl Default for StateMachine

fn default() -> StateMachine

Returns the “default value” for a type.

impl Eq for StateMachine

impl PartialEq for StateMachine

fn eq(&self, other: &StateMachine) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for StateMachine