openscad_customizer_rs/
lib.rs

1
2use serde::{Serialize, Deserialize};
3use serde_json::{Value, Map};
4use std::vec::Vec;
5
6// Std 
7// use std::env;
8use std::fs::File;
9use std::io::{Read, BufReader};
10
11#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
12#[serde(rename_all = "camelCase")]
13pub struct ParameterSets{
14    parameter_sets: Map<String, Value>,
15    file_format_version: String
16}
17
18impl ParameterSets{
19    pub fn new(sets: Vec<ParameterSet>, version: String) -> ParameterSets{
20        let mut map_tranlsation = Map::new();
21        for set in sets{
22            map_tranlsation.insert(set.name, serde_json::Value::Object(set.key_values));
23        }
24
25        ParameterSets{
26            parameter_sets: map_tranlsation,
27            file_format_version: version
28        }
29    }
30
31    pub fn from_file_path(path: String)->Result<ParameterSets, String>{
32        let data = File::open(path);
33
34        match data{
35
36            Ok(stream)=>{
37                let mut buf_reader = BufReader::new(stream);
38                let mut contents = String::new();
39                let buf_reader_result = buf_reader.read_to_string(&mut contents);
40    
41                match buf_reader_result{
42                    Ok(contents_length)=>{
43                        if contents_length > 0{
44                            println!("Contents: {:?}", contents);
45                            let deserialized: Result<ParameterSets, _> = serde_json::from_str(&contents);
46                            match deserialized{
47                                Ok(values)=>{
48                                    println!("Deserialized: {:?}", values);
49                                    return Ok(values);
50                                }
51                                Err(_)=>{
52                                    let error = String::from("Unable to Deserialize");
53                                    return Err(error);
54                                }
55                            }
56                        }
57                        else{
58                            let error = String::from("Unable to Deserialize");
59                            return Err(error);
60                        }                 
61                    }
62                    Err(error_contents)=>{
63                        let error = error_contents.to_string();
64                        return Err(error);
65                    }
66                }   
67            }
68            Err(stream_err)=>{
69                return Err(stream_err.to_string());
70
71            }
72        }
73    }
74    pub fn get_parameter_sets(&self)->Result<&Map<String, Value>, String>{
75        if self.parameter_sets.len() > 0{
76            return Ok(&self.parameter_sets);
77        }
78        return Err(String::from("No Parameter Sets"));
79    }
80    pub fn set_parameter_sets(&mut self, sets: Vec<ParameterSet>){
81        let mut map_tranlsation = Map::new();
82        for set in sets{
83            map_tranlsation.insert(set.name, serde_json::Value::Object(set.key_values));
84        }
85        self.parameter_sets = map_tranlsation;
86    }
87    
88    // I think this is broken...
89    pub fn get_parameter_set(&self, key: String)->Result<ParameterSet, String>{
90        let key_values = self.parameter_sets.get(&key);
91        let mut error = Err(String::from("Error..."));
92        match key_values{
93            Some(map) => {
94                let value = map.as_object();
95                match value{
96                    Some(map_value)=>{
97                        let set = ParameterSet::new(key, map_value.clone());
98                        return Ok(set);
99                    }
100                    None=>{
101                        error = Err(String::from("Parameter set has no values."));
102                    }
103                }
104            }
105            None=>{
106                error = Err(String::from("Key Value Not Found"))
107            }
108        }
109        return error;
110    }
111    pub fn set_parameter_set(&mut self, key: String, values: Map<String, Value>){
112        let sets = self.parameter_sets.get_mut(&key);
113        match sets{
114            Some(set_values)=>{
115                let set_values_as_object = set_values.as_object_mut();
116                match set_values_as_object{
117                    Some(values_object)=>{
118                        values_object.insert(key, Value::Object(values));
119                    }
120                    None=>{
121                        println!("Couldn't set...");
122                    }
123                }
124            }
125            None=>{
126                println!("Couldn't set...");
127            }
128        }
129
130    }
131}
132
133#[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone)]
134pub struct ParameterSet{
135    name: String,
136    key_values: Map<String, Value>
137}
138impl ParameterSet{
139    pub fn new(name: String, key_values: Map<String, Value>)->ParameterSet{
140        ParameterSet { 
141            name: name, 
142            key_values: key_values 
143        }
144    }
145    pub fn get_name(&self)->&String{
146        return &self.name;
147    }
148    pub fn get_key_values(&self)->&Map<String, Value>{
149        return &self.key_values;
150    }
151
152}
153
154#[cfg(test)]
155mod test;
openscad_customizer_rs/lib.rs

openscad_customizer_rs/
lib.rs
