hab-rs 0.3.3

Rust rule engine for openHAB
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

use crate::event::{Message, MessageType, StatusInfoEvent};

/// Wrapper around an openHAB thing identified by its name.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Thing(pub String);

impl Thing {
    /// Thing received an update.
    ///
    /// Checks the entity and optionally the status.
    pub fn received_update<'a>(
        &'_ self,
        message: &'a Message,
        state: Option<&'_ str>,
    ) -> Option<&'a StatusInfoEvent> {
        match &message.message_type {
            MessageType::ThingStatusInfoEvent(event) if message.topic.entity == self.0 => {
                match state {
                    Some(command) if command == event.status => {
                        return Some(event);
                    }
                    None => return Some(event),
                    _ => (),
                }
            }
            _ => (),
        }
        None
    }

    /// Thing changed its status.
    ///
    /// Checks the entity and optionally the old and/or new status.
    pub fn changed<'a>(
        &'_ self,
        message: &'a Message,
        from: Option<&'_ str>,
        to: Option<&'_ str>,
        ignore_change_in_status_detail: bool,
    ) -> Option<&'a [StatusInfoEvent; 2]> {
        match &message.message_type {
            MessageType::ThingStatusInfoChangedEvent(event) if message.topic.entity == self.0 => {
                let new_status = &event[0];
                let old_status = &event[1];
                if ignore_change_in_status_detail && new_status.status == old_status.status {
                    // Only status detail changed
                    return None;
                }
                match (from, to) {
                    (Some(from), Some(to))
                        if from == old_status.status && to == new_status.status =>
                    {
                        return Some(event);
                    }
                    (Some(from), None) if from == old_status.status => {
                        return Some(event);
                    }
                    (None, Some(to)) if to == new_status.status => {
                        return Some(event);
                    }
                    (None, None) => return Some(event),
                    _ => (),
                }
            }
            _ => (),
        }
        None
    }
}