bioscopelib/enums/
microscope_event.rs

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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
//!
//! Events coming from the microscope
//!
use serde::Deserialize;
use serde::Serialize;
use std::io::Write;

#[cfg(feature = "diesel")]
use {
    diesel::backend::Backend,
    diesel::deserialize::FromSql,
    diesel::pg::Pg,
    diesel::serialize::{IsNull, Output, ToSql},
    diesel::sql_types::Varchar,
    diesel::{deserialize, not_none, serialize},
};

#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
#[cfg_attr(feature = "diesel", derive(AsExpression, FromSqlRow))]
#[cfg_attr(feature = "diesel", sql_type = "Varchar")]
pub enum MicroscopeEvent {
    /// The stepper motor responsible for the movement along the X axis has stopped
    StepperXStop,
    /// The stepper motor responsible for the movement along the X axis has stopped
    StepperYStop,
    /// The stepper motor responsible for the movement along the X axis has stopped
    StepperZStop,
    /// The stepper motor responsible for the movement along the X axis reaching the highest point
    StepperXHighLimit,
    /// The stepper motor responsible for the movement along the X axis reaching the highest point
    StepperYHighLimit,
    /// The stepper motor responsible for the movement along the X axis reaching the highest point
    StepperZHighLimit,
    /// The stepper motor responsible for the movement along the X axis reaching the lowest point
    StepperXLowLimit,
    /// The stepper motor responsible for the movement along the X axis reaching the lowest point
    StepperYLowLimit,
    /// The stepper motor responsible for the movement along the X axis reaching the lowest point
    StepperZLowLimit,
    /// An error has occurred with one of the stepper motors.
    StepperError,
    /// The picture has been sent
    CameraPictureUpdate,
    /// An error has occurred with camera.
    CameraError,
}

#[cfg(feature = "diesel")]
impl MicroscopeEvent {
    /// Gets the string value corresponding to the enum value
    pub fn to_string(&self) -> String {
        let res = match *self {
            MicroscopeEvent::StepperXStop => "stepperXStop",
            MicroscopeEvent::StepperYStop => "stepperYStop",
            MicroscopeEvent::StepperZStop => "stepperZStop",
            MicroscopeEvent::StepperXHighLimit => "stepperXHighLimit",
            MicroscopeEvent::StepperYHighLimit => "stepperYHighLimit",
            MicroscopeEvent::StepperZHighLimit => "stepperZHighLimit",
            MicroscopeEvent::StepperXLowLimit => "stepperXLowLimit",
            MicroscopeEvent::StepperYLowLimit => "stepperYLowLimit",
            MicroscopeEvent::StepperZLowLimit => "stepperZLowLimit",
            MicroscopeEvent::StepperError => "stepperError",
            MicroscopeEvent::CameraPictureUpdate => "cameraPictureUpdate",
            MicroscopeEvent::CameraError => "cameraError",
        };
        res.to_string()
    }

    /// Gets the string value corresponding to the enum value, but without creating an object
    pub fn get_string(event: MicroscopeEvent) -> String {
        let res = match event {
            MicroscopeEvent::StepperXStop => "stepperXStop",
            MicroscopeEvent::StepperYStop => "stepperYStop",
            MicroscopeEvent::StepperZStop => "stepperZStop",
            MicroscopeEvent::StepperXHighLimit => "stepperXHighLimit",
            MicroscopeEvent::StepperYHighLimit => "stepperYHighLimit",
            MicroscopeEvent::StepperZHighLimit => "stepperZHighLimit",
            MicroscopeEvent::StepperXLowLimit => "stepperXLowLimit",
            MicroscopeEvent::StepperYLowLimit => "stepperYLowLimit",
            MicroscopeEvent::StepperZLowLimit => "stepperZLowLimit",
            MicroscopeEvent::StepperError => "stepperError",
            MicroscopeEvent::CameraPictureUpdate => "cameraPictureUpdate",
            MicroscopeEvent::CameraError => "cameraError",
        };
        res.to_string()
    }

    pub fn from_string(str: String) -> Option<MicroscopeEvent> {
        let str = str.as_str();
        return match str {
            "stepperXStop" => Option::from(MicroscopeEvent::StepperXStop),
            "stepperYStop" => Option::from(MicroscopeEvent::StepperYStop),
            "stepperZStop" => Option::from(MicroscopeEvent::StepperZStop),
            "stepperXHighLimit" => Option::from(MicroscopeEvent::StepperXHighLimit),
            "stepperYHighLimit" => Option::from(MicroscopeEvent::StepperYHighLimit),
            "stepperZHighLimit" => Option::from(MicroscopeEvent::StepperZHighLimit),
            "stepperXLowLimit" => Option::from(MicroscopeEvent::StepperXLowLimit),
            "stepperYLowLimit" => Option::from(MicroscopeEvent::StepperYLowLimit),
            "stepperZLowLimit" => Option::from(MicroscopeEvent::StepperZLowLimit),
            "stepperError" => Option::from(MicroscopeEvent::StepperError),
            "cameraPictureUpdate" => Option::from(MicroscopeEvent::CameraPictureUpdate),
            "cameraError" => Option::from(MicroscopeEvent::CameraError),
            _ => None,
        };
    }
}

#[cfg(feature = "diesel")]
impl ToSql<Varchar, Pg> for MicroscopeEvent {
    fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> serialize::Result {
        match *self {
            MicroscopeEvent::StepperXStop => out.write_all(b"stepperXStop")?,
            MicroscopeEvent::StepperYStop => out.write_all(b"stepperYStop")?,
            MicroscopeEvent::StepperZStop => out.write_all(b"stepperZStop")?,
            MicroscopeEvent::StepperXHighLimit => out.write_all(b"stepperXHighLimit")?,
            MicroscopeEvent::StepperYHighLimit => out.write_all(b"stepperYHighLimit")?,
            MicroscopeEvent::StepperZHighLimit => out.write_all(b"stepperZHighLimit")?,
            MicroscopeEvent::StepperXLowLimit => out.write_all(b"stepperXLowLimit")?,
            MicroscopeEvent::StepperYLowLimit => out.write_all(b"stepperYLowLimit")?,
            MicroscopeEvent::StepperZLowLimit => out.write_all(b"stepperZLowLimit")?,
            MicroscopeEvent::StepperError => out.write_all(b"stepperError")?,
            MicroscopeEvent::CameraPictureUpdate => out.write_all(b"cameraPictureUpdate")?,
            MicroscopeEvent::CameraError => out.write_all(b"cameraError")?,
        }
        Ok(IsNull::No)
    }
}

#[cfg(feature = "diesel")]
impl FromSql<Varchar, Pg> for MicroscopeEvent {
    fn from_sql(bytes: Option<&<Pg as Backend>::RawValue>) -> deserialize::Result<Self> {
        match not_none!(bytes) {
            b"stepperXStop" => Ok(MicroscopeEvent::StepperXStop),
            b"stepperYStop" => Ok(MicroscopeEvent::StepperYStop),
            b"stepperZStop" => Ok(MicroscopeEvent::StepperZStop),
            b"stepperXHighLimit" => Ok(MicroscopeEvent::StepperXHighLimit),
            b"stepperYHighLimit" => Ok(MicroscopeEvent::StepperYHighLimit),
            b"stepperZHighLimit" => Ok(MicroscopeEvent::StepperZHighLimit),
            b"stepperXLowLimit" => Ok(MicroscopeEvent::StepperXLowLimit),
            b"stepperYLowLimit" => Ok(MicroscopeEvent::StepperYLowLimit),
            b"stepperZLowLimit" => Ok(MicroscopeEvent::StepperZLowLimit),
            b"stepperError" => Ok(MicroscopeEvent::StepperError),
            b"cameraPictureUpdate" => Ok(MicroscopeEvent::CameraPictureUpdate),
            b"cameraError" => Ok(MicroscopeEvent::CameraError),
            _ => Err("Unrecognized enum variant".into()),
        }
    }
}