utils 0.0.3

Common utilities suitable for use in Rust Builders
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

/// `Empty` trait definition.
///
/// The `Empty` trait wraps `is_empty` calls for various types.  Use with
/// `to_opt` to convert different types to `Option`.
///
/// ```rust
/// use utils::empty::to_opt;
///
/// let opt = to_opt("val");                 // Some("val")
/// let opt1 = to_opt("".to_string());       // None
/// let opt2 = to_opt(Vec::<&str>::new());   // None
/// let opt3 = to_opt(Vec::<String>::new()); // None
/// ```
#[experimental]
pub trait Empty {
    /// Return true if self is empty, false otherwise.
    fn empty(&self) -> bool;
}

/// `Empty` implementation for string slice.
#[experimental]
impl <'a>Empty for &'a str {
    fn empty(&self) -> bool {
        self.is_empty()
    }
}

/// `Empty` implementation for String.
#[experimental]
impl Empty for String {
    fn empty(&self) -> bool {
        self.as_slice().is_empty()
    }
}

/// `Empty` implementation for Vec<String>.
#[experimental]
impl Empty for Vec<String> {
    fn empty(&self) -> bool {
        self.is_empty()
    }
}

/// `Empty` implementation for Vec<&str>.
#[experimental]
impl <'a>Empty for Vec<&'a str> {
    fn empty(&self) -> bool {
        self.is_empty()
    }
}

/// Convert an `Empty` element of type `T` to an `Option` of type `T`.
///
///
/// ```rust
/// use utils::empty::to_opt;
///
/// let opt = to_opt("val"); // Some("val")
/// ```
///
/// # Arguments
/// * `arg` - The element to convert from an `Empty` to an `Option`.
#[experimental]
pub fn to_opt<T: Empty>(arg: T) -> Option<T> {
    if arg.empty() {
        None
    } else {
        Some(arg)
    }
}

#[cfg(test)]
mod test {
    use super::to_opt;

    #[test]
    fn test_to_opt() {
        assert_eq!(to_opt(""), None);
        assert_eq!(to_opt("val"), Some("val"));
        assert_eq!(to_opt("".to_string()), None);
        assert_eq!(to_opt("val".to_string()), Some("val".to_string()));
        assert_eq!(to_opt(Vec::<&str>::new()), None);
        assert_eq!(to_opt(vec!["a"]), Some(vec!["a"]));
        assert_eq!(to_opt(Vec::<String>::new()), None);
        assert_eq!(to_opt(vec!["a".to_string()]),
                   Some(vec!["a".to_string()]));
    }
}