gnuplotter_core 0.2.3-alpha

Dependency for gnuplotter
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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

use crate::maybe::Maybe::Nothing;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Maybe<T> {
    Value(T),
    Nothing
}

impl<T> Maybe<T> {
    pub fn value(value: T) -> Self {
        Maybe::Value(value)
    }

    pub fn update<S>(&mut self, value: S) where S: Into<T> {
        std::mem::swap(self, &mut Maybe::Value(value.into()));
    }

    pub fn unwrap(self) -> T {
        match self {
            Maybe::Value(value) => value,
            Maybe::Nothing => panic!("Tried to unwrap a Maybe::Nothing value.")
        }
    }
}

pub mod maybe_conversions {
    use crate::gnu::command::title::Title;
    use crate::maybe::Maybe;

    impl<'a,T> From<&'a str> for Maybe<T>
    where
        T: From<&'a str>
    {
        fn from(value: &'a str) -> Self {
            Maybe::Value(T::from(value))
        }
    }
}

impl<T> Default for Maybe<T> {
    fn default() -> Self {
        Maybe::Nothing
    }
}

#[cfg(test)]
mod tests {
    use crate::prelude::Required;
    use super::*;

    #[test]
    fn test_a_maybe_can_be_constructed() {
        assert_eq!(Maybe::value(1), Maybe::Value(1));
    }

    #[test]
    fn test_an_empty_maybe_can_be_updated() {
        let mut maybe: Maybe<i32> = Maybe::Nothing;
        maybe.update(123);
        assert_eq!(maybe, Maybe::Value(123));
    }

    #[test]
    fn test_a_maybe_can_be_updated(){
        let mut maybe: Maybe<i32> = Maybe::value(123);
        maybe.update(456);
        assert_eq!(maybe, Maybe::Value(456));
    }

    #[test]
    fn test_updating_convertable_value(){
        let mut maybe = Maybe::<String>::Nothing;
        maybe.update("something that can be converted");

        assert_eq!(maybe, Maybe::Value(String::from("something that can be converted")));
    }

    mod conversions {
        use super::super::*;

        #[test]
        fn test_an_str_can_be_converted_into_a_maybe_string() {
            let s = "Hello, world!";
            let maybe_s: Maybe<String> = s.into();
            assert_eq!(maybe_s, Maybe::Value(String::from(s)));
        }
    }
}