Struct Rack 

pub struct Rack { /* private fields */ }

State of the process or a group of logic lines. Acts as a factory for Processor instances. Shares recording state with the created processors.

Implementations

impl Rack

pub fn new() -> Self

Creates a new state

Examples found in repository

examples/fan_control.rs (line 4)

fn main() {
    let mut state = Rack::new().with_recording_enabled();
    let mut processor = state.processor();

    // Some fan state
    let mut fan = false;

    // A temperature sensor value
    let temperature = 31.0;

    processor
        // a sequence to turn on the fan on if the temperature is above 30 degrees
        .line("fan_on", temperature)
        .then(action!("temp_high", |t| (t > 30.0).then_some(())))
        .then(action!("fan_on", |()| {
            fan = true;
            Some(())
        }));
    processor
        // a sequence to turn off the fan if the temperature is below 25 degrees
        .line("fan_off", temperature)
        .then(action!("temp_low", |t| (t < 25.0).then_some(())))
        .then(action!("fan_off", |()| {
            fan = false;
            Some(())
        }));

    state.ingress(&mut processor);
    println!("{}", state);

    println!("{}", serde_json::to_string_pretty(&state).unwrap());
}

pub fn ingress(&mut self, processor: &mut Processor)

Record the state of the lines and reset the processor

Examples found in repository

examples/fan_control.rs (line 30)

fn main() {
    let mut state = Rack::new().with_recording_enabled();
    let mut processor = state.processor();

    // Some fan state
    let mut fan = false;

    // A temperature sensor value
    let temperature = 31.0;

    processor
        // a sequence to turn on the fan on if the temperature is above 30 degrees
        .line("fan_on", temperature)
        .then(action!("temp_high", |t| (t > 30.0).then_some(())))
        .then(action!("fan_on", |()| {
            fan = true;
            Some(())
        }));
    processor
        // a sequence to turn off the fan if the temperature is below 25 degrees
        .line("fan_off", temperature)
        .then(action!("temp_low", |t| (t < 25.0).then_some(())))
        .then(action!("fan_off", |()| {
            fan = false;
            Some(())
        }));

    state.ingress(&mut processor);
    println!("{}", state);

    println!("{}", serde_json::to_string_pretty(&state).unwrap());
}

pub fn line_state(&self, name: &str) -> Option<&LineState>

Returns the state of the line

pub fn lines(&self) -> &BTreeMap<Cow<'static, str>, LineState>

Returns all states of the lines

pub fn snapshot(&self) -> Snapshot

Creates a snapshot of the current state of the lines

pub fn snapshot_filtered<P>(&self, predicate: P) -> Snapshot

where P: Fn(&LineState) -> bool,

Creates a filtered snapshot of the current state of the lines

pub fn processor(&self) -> Processor

Creates a new processor

Examples found in repository

examples/fan_control.rs (line 5)

fn main() {
    let mut state = Rack::new().with_recording_enabled();
    let mut processor = state.processor();

    // Some fan state
    let mut fan = false;

    // A temperature sensor value
    let temperature = 31.0;

    processor
        // a sequence to turn on the fan on if the temperature is above 30 degrees
        .line("fan_on", temperature)
        .then(action!("temp_high", |t| (t > 30.0).then_some(())))
        .then(action!("fan_on", |()| {
            fan = true;
            Some(())
        }));
    processor
        // a sequence to turn off the fan if the temperature is below 25 degrees
        .line("fan_off", temperature)
        .then(action!("temp_low", |t| (t < 25.0).then_some(())))
        .then(action!("fan_off", |()| {
            fan = false;
            Some(())
        }));

    state.ingress(&mut processor);
    println!("{}", state);

    println!("{}", serde_json::to_string_pretty(&state).unwrap());
}

pub fn with_recording_enabled(self) -> Self

Enables recording for the state

Examples found in repository

examples/fan_control.rs (line 4)

fn main() {
    let mut state = Rack::new().with_recording_enabled();
    let mut processor = state.processor();

    // Some fan state
    let mut fan = false;

    // A temperature sensor value
    let temperature = 31.0;

    processor
        // a sequence to turn on the fan on if the temperature is above 30 degrees
        .line("fan_on", temperature)
        .then(action!("temp_high", |t| (t > 30.0).then_some(())))
        .then(action!("fan_on", |()| {
            fan = true;
            Some(())
        }));
    processor
        // a sequence to turn off the fan if the temperature is below 25 degrees
        .line("fan_off", temperature)
        .then(action!("temp_low", |t| (t < 25.0).then_some(())))
        .then(action!("fan_off", |()| {
            fan = false;
            Some(())
        }));

    state.ingress(&mut processor);
    println!("{}", state);

    println!("{}", serde_json::to_string_pretty(&state).unwrap());
}

pub fn set_recording(&mut self, recording: bool)

Sets the recording state for the state

pub fn is_recording(&self) -> bool

Returns true if the rack is recording

Trait Implementations

impl Clone for Rack

fn clone(&self) -> Rack

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Rack

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

Formats the value using the given formatter.

impl Default for Rack

fn default() -> Rack

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Rack

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Rack

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

Formats the value using the given formatter.

impl Serialize for Rack

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.