Struct Sequential 

pub struct Sequential<D> {
    pub inner: D,
    /* private fields */
}

Wraps another decision maker by performing one read from sensor or one write to actuator at a time.

This is used for testing or developing new decision makers. The inner decision maker can be written using the assumption that there are no concurrent reads or writes.

Fields

inner: D

The inner decison maker.

Implementations

impl<D> Sequential<D>

pub fn new(inner: D) -> Self

Returns a new sequential decision maker.

Examples found in repository

examples/bob_sleeps.rs (line 163)

fn main() {
    use asi::Runtime;

    println!("Bob is sleeping.");
    println!("Enter - One time step forward");
    println!("'bye' - Exit");
    println!("'wake up!' - Wake up Bob");
    println!("");

    let ref mut runtime = asi::StandardRuntime::new();
    runtime.load(asi::Agent {
        // Try remove the `()` to cause invalid memory access.
        memory: vec![()],
        // Don't need any sensors in this example.
        sensors: Vec::<Sensor>::new(),
        actuators: vec![
            // Try comment this to write to wrong actuator.
            Actuator::INeedJustFiveMinutes(false),
            // Try comment this to cause invalid actuator access.
            Actuator::LookAround(false),
        ],
        // Make sure Bob takes sequential decisions,
        // because we don't want to think about concurrency.
        decision_maker: asi::Sequential::new(Bob::Sleep),
    });
    runtime.start();

    let stdin = ::std::io::stdin();
    loop {
        runtime.update(1.0);

        let mut input = String::new();
        stdin.read_line(&mut input).unwrap();
        input = input.trim().into();

        if input == "bye" {
            println!("Bob: Bye!");
            break;
        } else if input == "wake up!" {
            runtime.wake_up();
        }
    }
}

Trait Implementations

impl<D, T> DecisionMaker<T> for Sequential<D>

where D: DecisionMaker<T>,

fn next_action(&mut self, memory: &[T], dt: f64) -> Action

Outputs the next action to take from the memory states and time step.

fn feedback(&mut self, feedback: Result<Feedback, Error>)

Receiving feedback when something new happens.

fn shut_down(&mut self, dt: f64) -> f64

Return estimate of how long it takes to shut down from now, given a deadline. This is 0 if the decison maker is ready to shut down. When this is called, the decision maker should start preparing for shutdown. It might be called multiple times to check how the decision maker is preparing.