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

use crate::{RType, RTypeTrait};


use super::NestedValueParser;




pub struct ArrayType {

}

impl ArrayType {
    pub fn wrap_typestr(vstr: &str, size: &usize) -> String {
        format!("[{}; {}]", vstr, size)
    }

    /// let aaa: [[usize; 3]; 3] = [[3,3,3], [3,3,3], [3,3,3]];
    /// 
    /// After step 1 = [3,3,3], [3,3,3], [3,3,3]
    /// 
    /// 
    /// rtype = type T of the array [T; N]
    pub fn value_is_valid(valuestr: &str, rtype: &RType, size: &usize) -> bool {
        //let aaa: [Vec<String>; 3] = [vec![], vec![], vec![]];
        let values = NestedValueParser::parse_nested_str(valuestr, '[', true);

/*         println!("RType: {:?}", rtype);
        println!("ValStr: {:?}", valuestr);
        println!("Size: {:?}", size);
        println!("Parsed values: {:?}", values); */
        // We expect N values for an array [T; N]
        if values.len() != *size {
            return false;
        }
        //let mut is_valid = true;
        for value in values {
            if !rtype.value_is_valid(&value) {return false}
        }
        true
    }

    pub fn wrap_valuestr(valuestr: &str, rtype: &RType) -> String {
        let values = NestedValueParser::parse_nested_str(valuestr, '[', true);

        let mut wrapped_str = String::from("[");
        //let mut is_valid = true;
        for value in values {
            let valstr = rtype.wrap_valuestr(&value);
            wrapped_str = format!("{}{}, ", wrapped_str, valstr);
        }
        wrapped_str.pop(); wrapped_str.pop();
        wrapped_str += "]";
        wrapped_str
    }
}



#[cfg(test)]
mod tests {
    use super::*;
    use crate::{ RType, ContainerType}; //NumericType, StringType, SpecialType,

    #[test]
    fn test_arraytype_valid_values() { 
        let input = "[usize; 3]";
        let result = ContainerType::from_typestr(input).unwrap();
        let res = result.to_typestr();
        assert_eq!(input, res);

        let rtype = RType::from_typestr(input).unwrap();
        let values = "[3,3,3]";
        assert!(result.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_arraytype_valid_values_complex() {
        let typestr = "[[usize; 3]; 3]";
        let values = "[[3,3,3], [3,3,3], [3,3,3]]";
        let rtype = RType::from_typestr(typestr).unwrap();
        assert_eq!(true, rtype.value_is_valid(values));

        let values = "[[3,3,3], [3,3,3], [3,3,3,4]]";
        assert_eq!(false, rtype.value_is_valid(values));
    }

    #[test]
    fn test_arraytype_wrap_values() {
        let typestr = "[[usize; 3]; 3]";
        let values = "[[3,3,3], [3,3,3], [3,3,3]]";
        let rtype = RType::from_typestr(typestr).unwrap();
        assert_eq!(true, rtype.value_is_valid(values));
        let expected = "[[3, 3, 3], [3, 3, 3], [3, 3, 3]]";
        assert_eq!(expected, rtype.wrap_valuestr(values));
    }


}