csvenum 0.1.4

Generate code for enums with associated constants from a .csv in your command line.
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use super::{RType, RTypeTrait, NestedValueParser};

pub struct TupleType {

}

impl TupleType {
    /// Wrap type, depending on the passed function, references to the type and or lifetimes will be ignored.
    pub fn wrap_types_with_typefn<T: RTypeTrait, R>(rtypes: &Vec<Box<T>>, func: fn(&T) -> R) -> String 
    where
        R: AsRef<str>,
    {
        let mut tuplestr = String::from("(");
        for x in rtypes { //  v &RType    v String.as_ref()
            tuplestr = tuplestr + func(x.as_ref()).as_ref() + ", ";
        }
        tuplestr.pop(); 
        tuplestr.pop();
        tuplestr.push(')');
        tuplestr        
    }

    pub fn value_is_valid(valuestr: &str, rtypes: &Vec<Box<RType>>) -> bool {
        let values = NestedValueParser::parse_nested_str(valuestr, '(', true);

        // we expect as many values as there are elements in our vector 
        let tuple_size = rtypes.len();
        if values.len() != tuple_size {return false}
        for i in 0..tuple_size {
            if !rtypes[i].value_is_valid(&values[i]) {return false}
        }
        true
    }

    pub fn wrap_valuestr(valuestr: &str, rtypes: &Vec<Box<RType>>) -> String {
        let values = NestedValueParser::parse_nested_str(valuestr, '(', true);
        let mut wrapped_str = String::from("(");
        let tuple_size = rtypes.len();
        for i in 0..tuple_size {
            let valstr = rtypes[i].wrap_valuestr(&values[i]);
            wrapped_str = format!("{}{}, ", wrapped_str, valstr);
        }
        wrapped_str.pop(); wrapped_str.pop();
        wrapped_str += ")";
        wrapped_str


    }
}




#[cfg(test)]
mod tests {

    use crate::{RType, RTypeTrait};//, NumericType, StringType, Reference};

    #[test]
    fn test_wrap_tuple() {
        //let tupletypes = vec![Box::new(RType::Numeric(Reference::None, NumericType::u8)), Box::new(RType::String(Reference::Naked, StringType::str))];
        //let typestr = tupletypes


    }

    #[test]
    fn test_tupletype_valid_values() { 
        let input = "(usize, usize, usize)";
        let rtype = RType::from_typestr(input).unwrap();
        let values = "(3,3,3)";
        assert_eq!(true, rtype.value_is_valid(values));
        let values = "[3,3,3]";
        assert_eq!(false, rtype.value_is_valid(values));
        let values = "(art,5.43,3)";
        //assert_eq!(false, ArrayType::value_is_valid(values, &Box::new(RType::Container(Reference::None, result)), &3));
        assert_eq!(false, rtype.value_is_valid(values));
    }

    #[test]
    fn test_tupletype_valid_values_complex() { 
        let input = "((usize, usize), usize, [usize; 3])";
        let rtype = RType::from_typestr(input).unwrap();
        let values = "((2,2),3,[5,5,5])";
        assert_eq!(true, rtype.value_is_valid(values));
        let values = "((2,2)3,[5,5,5])";
        assert_eq!(false, rtype.value_is_valid(values));
        let values = "(art,5.43,3)";
        assert_eq!(false, rtype.value_is_valid(values));
    }

    #[test]
    fn test_tupletype_wrap_values() { 
        let input = "((usize, usize), usize, [usize; 3])";
        let rtype = RType::from_typestr(input).unwrap();
        let values = "((2,2),3,[5,5,5])";
        let expected = "((2, 2), 3, [5, 5, 5])".to_string();
        assert_eq!(expected, rtype.wrap_valuestr(values));

        let input = "((usize, usize), &str, [usize; 3])";
        let rtype = RType::from_typestr(input).unwrap();
        let values = "((2,2),3,[5,5,5])";
        let expected = "((2, 2), \"3\", [5, 5, 5])".to_string();
        assert_eq!(expected, rtype.wrap_valuestr(values));
    }

}