Struct aimc_hal::automation::All

pub struct All<A, const N: usize> { /* fields omitted */ }

A combinator which combines many AutomationSequences and will poll them all to completion, stopping when either a fault is raised or there are no more incomplete sequences.

Examples

use aimc_hal::automation::{AutomationSequence, Transition, All};

/// A simple automation sequence which will return `Transition::Incomplete`
/// until it reaches zero.
struct CountDown(usize);

impl<I, O> AutomationSequence<I, O> for CountDown {
    type FaultInfo = ();

    fn poll(&mut self, inputs: &I, outputs: &mut O) -> Transition<()> {
        if self.0 == 0 {
            Transition::Complete
        } else {
            self.0 -= 1;
            Transition::Incomplete
        }
    }
}

// Combine the sequences into one big automation sequence
let mut seq = All::new([CountDown(1), CountDown(5), CountDown(2)]);

// we'll keep track of the number of polls
let mut polls = 0;

// keep polling until all the timers have reached zero
while seq.poll(&(), &mut ()) != Transition::Complete {
    polls += 1;
}

// we should have polled 5 times (`max(1, 5, 2)`)
assert_eq!(polls, 5);

Implementations

impl<A, const N: usize> All<A, { N }>

pub fn new(items: [A; N]) -> Self

Trait Implementations

impl<I, O, A, const N: usize> AutomationSequence<I, O> for All<A, { N }> where
    A: AutomationSequence<I, O>, 

type FaultInfo = A::FaultInfo

Extra info attached to a fault.

fn poll(&mut self, inputs: &I, outputs: &mut O) -> Transition<Self::FaultInfo>

impl<A, const N: usize> Clone for All<A, { N }> where
    [Option<A>; N]: LengthAtMost32,
    [Option<A>; N]: Clone, 

fn clone(&self) -> All<A, { N }>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A, const N: usize> Copy for All<A, { N }> where
    [Option<A>; N]: LengthAtMost32,
    [Option<A>; N]: Copy, 

impl<A, const N: usize> Debug for All<A, { N }> where
    [Option<A>; N]: LengthAtMost32,
    [Option<A>; N]: Debug, 

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

Formats the value using the given formatter.

impl<A, const N: usize> Default for All<A, { N }> where
    [Option<A>; N]: LengthAtMost32,
    [Option<A>; N]: Default, 

fn default() -> All<A, { N }>

Returns the "default value" for a type.

impl<A, const N: usize> PartialEq<All<A, N>> for All<A, { N }> where
    [Option<A>; N]: LengthAtMost32,
    [Option<A>; N]: PartialEq, 

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.