Struct StateMachine 

pub struct StateMachine<M>
where
    M: IntoStateMachine,
{ /* private fields */ }

A state machine that will be lazily initialized.

Implementations

impl<M> StateMachine<M>

where M: IntoStateMachine, M::State: State<M>, for<'sub> M::Superstate<'sub>: Superstate<M>,

pub fn init(&mut self)

where for<'ctx> M: IntoStateMachine<Context<'ctx> = ()>,

Explicitly initialize the state machine. If the state machine is already initialized this is a no-op.

pub fn init_with_context(&mut self, context: &mut M::Context<'_>)

Explicitly initialize the state machine. If the state machine is already initialized this is a no-op.

pub fn handle(&mut self, event: &M::Event<'_>)

where for<'ctx> M: IntoStateMachine<Context<'ctx> = ()>,

Handle an event. If the state machine is still uninitialized, it will be initialized before handling the event.

pub fn handle_with_context( &mut self, event: &M::Event<'_>, context: &mut M::Context<'_>, )

Handle an event. If the state machine is still uninitialized, it will be initialized before handling the event.

pub fn step(&mut self)

where for<'evt, 'ctx> M: IntoStateMachine<Event<'evt> = (), Context<'ctx> = ()>,

pub fn step_with_context(&mut self, context: &mut M::Context<'_>)

where for<'evt> M: IntoStateMachine<Event<'evt> = ()>,

pub fn state(&self) -> &M::State

Get the current state.

pub fn inner(&self) -> &M

Get a reference to the StateMachine’s underlying type.

let state_machine = Blinky::default().state_machine();
assert_eq!(state_machine.inner().led, false);

pub unsafe fn inner_mut(&mut self) -> &mut M

Get a mutable reference to the StateMachine’s underlying type.

Safety

• The user is responsible for validating that mutating a StateMachine does not break any invariants.

let mut state_machine = Blinky::default().state_machine();

unsafe {
    state_machine.inner_mut().led = true;
}

pub unsafe fn state_mut(&mut self) -> &mut M::State

Get a mutable reference to the StateMachine’s current state.

Safety

• The user is responsible for validating that mutating a StateMachine does not break any invariants.

let mut state_machine = Blinky::default().state_machine();

unsafe {
    *state_machine.state_mut() = State::on();
}

Trait Implementations

impl<M> Clone for StateMachine<M>

where M: IntoStateMachine + Clone, M::State: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M> Component for StateMachine<M>

where Self: 'static + Send + Sync, M: IntoStateMachine,

Available on crate feature bevy only.

type Storage = TableStorage

A marker type indicating the storage type used for this component. This must be either TableStorage or SparseStorage.

impl<M> Default for StateMachine<M>

where M: IntoStateMachine + Default,

fn default() -> Self

Returns the “default value” for a type.

impl<M> Deref for StateMachine<M>

where M: IntoStateMachine,

type Target = M

The resulting type after dereferencing.

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

Dereferences the value.

impl<'de, M> Deserialize<'de> for StateMachine<M>

where M: IntoStateMachine + Deserialize<'de>, M::State: Deserialize<'de>,

Available on crate feature serde only.

A serialized state machine can only be deserialized into an UninitializedStateMachine and can then be initialized with init.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<M> From<InitializedStateMachine<M>> for StateMachine<M>

where M: IntoStateMachine,

fn from(value: InitializedStateMachine<M>) -> Self

Converts to this type from the input type.

impl<M> From<UninitializedStateMachine<M>> for StateMachine<M>

where M: IntoStateMachine,

fn from(value: UninitializedStateMachine<M>) -> Self

Converts to this type from the input type.

impl<M> PartialEq for StateMachine<M>

where M: IntoStateMachine + PartialEq, M::State: PartialEq,

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<M> Serialize for StateMachine<M>

where M: IntoStateMachine + Serialize, M::State: Serialize,

Available on crate feature serde only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<M> Eq for StateMachine<M>

where M: IntoStateMachine + PartialEq, M::State: PartialEq,