docchi_core/imp/intf/
root.rs

1use crate::imp::structs::root_obj::RootObject;
2use crate::imp::structs::qv::Qv;
3use crate::imp::structs::root_value::RootValue;
4use crate::imp::structs::rust_param::RustParam;
5use crate::imp::structs::rust_string::RustString;
6use crate::imp::intf::clist::CListPtr;
7use crate::imp::intf::table::TablePtr;
8use crate::imp::intf::citem::CItemPtr;
9use crate::imp::structs::rust_array::{RustIntArray, RustFloatArray};
10use crate::structs::{RustBinary, MutListDef, MutListVal};
11use crate::imp::structs::root_sab_value::RootSabValue;
12use crate::imp::structs::root_def_obj::RootDefObj;
13use crate::imp::intf::{MListPtr, MItemPtr};
14
15#[derive(Debug, PartialEq, Clone, Copy)]
16pub struct RootObjectPtr{
17    ptr : *mut RootObject
18}
19impl RootObjectPtr {
20    pub fn new(ptr: *mut RootObject) -> RootObjectPtr { RootObjectPtr { ptr } }
21    pub fn def(&self) -> *const RootDefObj{
22        (unsafe{ &*self.ptr }).default()
23    }
24}
25
26pub fn get_bool(root : RootObjectPtr, name : &str) -> Option<Qv<bool>>{
27    if let Some(RustParam::Bool(b)) = get_param(root, name){
28        Some(b.clone())
29    } else{
30        None
31    }
32}
33pub fn get_bool_def(root : RootObjectPtr, name : &str) -> Option<Qv<bool>>{
34    if let Some(RustParam::Bool(b)) = get_param_def(root, name){
35        Some(b.clone())
36    } else{
37        None
38    }
39}
40
41pub fn get_float(root : RootObjectPtr, name : &str) -> Option<Qv<f64>>{
42    if let Some(RustParam::Float(b)) = get_param(root, name){
43        Some(b.clone())
44    } else{
45        None
46    }
47}
48
49pub fn get_float_def(root : RootObjectPtr, name : &str) -> Option<Qv<f64>>{
50    if let Some(RustParam::Float(b)) = get_param_def(root, name){
51        Some(b.clone())
52    } else{
53        None
54    }
55}
56
57pub fn get_int(root : RootObjectPtr, name : &str) -> Option<Qv<i64>>{
58    if let Some(RustParam::Int(b)) = get_param(root, name){
59        Some(b.clone())
60    } else{
61        None
62    }
63}
64
65pub fn get_int_def(root : RootObjectPtr, name : &str) -> Option<Qv<i64>>{
66    if let Some(RustParam::Int(b)) = get_param_def(root, name){
67        Some(b.clone())
68    } else{
69        None
70    }
71}
72
73pub fn get_str(root : RootObjectPtr, name : &str) -> Option<Qv<String>>{
74    if let Some(RustParam::String(b)) = get_param(root, name){
75        Some(b.as_ref().map(|s| s.str().to_string()))
76    } else{
77        None
78    }
79}
80
81pub fn get_str_def<'a, 'b>(root : RootObjectPtr, name : &'a str) -> Option<Qv<&'b String>>{
82    if let Some(RustParam::String(b)) = get_param_def(root, name){
83        match b{
84            Qv::Val(v) => Some(Qv::Val(v.string())),
85            Qv::Null => Some(Qv::Null),
86            Qv::Undefined => Some(Qv::Undefined)
87        }
88    } else{
89        None
90    }
91}
92
93pub fn get_int_array(root : RootObjectPtr, name : &str) -> Option<Qv<Vec<i64>>>{
94    if let Some(RustParam::IntArray(b)) = get_param(root, name){
95        Some(b.as_ref().map(|s| s.vec().clone()))
96    } else{
97        None
98    }
99}
100
101pub fn get_int_array_def<'a, 'b>(root : RootObjectPtr, name : &'a str) -> Option<Qv<&'b Vec<i64>>>{
102    if let Some(RustParam::IntArray(b)) = get_param_def(root, name){
103        match b{
104            Qv::Val(v) => Some(Qv::Val(v.vec())),
105            Qv::Null => Some(Qv::Null),
106            Qv::Undefined => Some(Qv::Undefined)
107        }
108    } else{
109        None
110    }
111}
112
113pub fn get_float_array(root : RootObjectPtr, name : &str) -> Option<Qv<Vec<f64>>>{
114    if let Some(RustParam::FloatArray(b)) = get_param(root, name){
115        Some(b.as_ref().map(|s| s.vec().clone()))
116    } else{
117        None
118    }
119}
120
121pub fn get_float_array_def<'a, 'b>(root : RootObjectPtr, name : &'a str) -> Option<Qv<&'b Vec<f64>>>{
122    if let Some(RustParam::FloatArray(b)) = get_param_def(root, name){
123        match b{
124            Qv::Val(v) => Some(Qv::Val(v.vec())),
125            Qv::Null => Some(Qv::Null),
126            Qv::Undefined => Some(Qv::Undefined)
127        }
128    } else{
129        None
130    }
131}
132pub fn get_binary(root : RootObjectPtr, name : &str) -> Option<Qv<Vec<u8>>>{
133    if let Some(RustParam::Binary(b)) = get_param(root, name){
134        Some(b.as_ref().map(|s| s.vec().clone()))
135    } else{
136        None
137    }
138}
139pub fn get_binary_def<'a, 'b>(root : RootObjectPtr, name : &'a str) -> Option<Qv<&'b Vec<u8>>>{
140    if let Some(RustParam::Binary(b)) = get_param_def(root, name){
141        match b{
142            Qv::Val(v) => Some(Qv::Val(v.vec())),
143            Qv::Null => Some(Qv::Null),
144            Qv::Undefined => Some(Qv::Undefined)
145        }
146    } else{
147        None
148    }
149}
150pub fn get_immutable_binary<'a, 'b>(root : RootObjectPtr, name : &'a str) -> Option<Qv<&'b Vec<u8>>>{
151    if let Some(RustParam::Binary(b)) = get_param(root, name){
152        match b{
153            Qv::Val(v) => Some(Qv::Val(v.vec())),
154            Qv::Null => Some(Qv::Null),
155            Qv::Undefined => Some(Qv::Undefined)
156        }
157    } else{
158        None
159    }
160}
161pub fn get_immutable_str<'a, 'b>(root : RootObjectPtr, name : &'a str) -> Option<Qv<&'b String>>{
162    if let Some(RustParam::String(b)) = get_param(root, name){
163        match b{
164            Qv::Val(v) => Some(Qv::Val(v.string())),
165            Qv::Null => Some(Qv::Null),
166            Qv::Undefined => Some(Qv::Undefined)
167        }
168    } else{
169        None
170    }
171}
172pub fn get_immutable_int_array<'a, 'b>(root : RootObjectPtr, name : &'a str) -> Option<Qv<&'b Vec<i64>>>{
173    if let Some(RustParam::IntArray(b)) = get_param(root, name){
174        match b{
175            Qv::Val(v) => Some(Qv::Val(v.vec())),
176            Qv::Null => Some(Qv::Null),
177            Qv::Undefined => Some(Qv::Undefined)
178        }
179    } else{
180        None
181    }
182}
183pub fn get_immutable_float_array<'a, 'b>(root : RootObjectPtr, name : &'a str) -> Option<Qv<&'b Vec<f64>>>{
184    if let Some(RustParam::FloatArray(b)) = get_param(root, name){
185        match b{
186            Qv::Val(v) => Some(Qv::Val(v.vec())),
187            Qv::Null => Some(Qv::Null),
188            Qv::Undefined => Some(Qv::Undefined)
189        }
190    } else{
191        None
192    }
193}
194
195pub fn get_mutable_binary<'a, 'b>(ps : RootObjectPtr, name : &'a str) -> Option<Qv<&'b mut Vec<u8>>>{
196
197    if let Some(RustParam::Binary(b)) = get_param_mut(ps, name){
198        match b{
199            Qv::Val(v) => Some(Qv::Val(v.vec_mut())),
200            Qv::Null => Some(Qv::Null),
201            Qv::Undefined => Some(Qv::Undefined)
202        }
203    } else{
204        None
205    }
206}
207pub fn get_mutable_str<'a, 'b>(ps : RootObjectPtr, name : &'a str) -> Option<Qv<&'b mut String>>{
208
209    if let Some(RustParam::String(b)) = get_param_mut(ps, name){
210        match b{
211            Qv::Val(v) => Some(Qv::Val(v.string_mut())),
212            Qv::Null => Some(Qv::Null),
213            Qv::Undefined => Some(Qv::Undefined)
214        }
215    } else{
216        None
217    }
218}
219pub fn get_mutable_int_array<'a, 'b>(ps : RootObjectPtr, name : &'a str) -> Option<Qv<&'b mut Vec<i64>>>{
220    if let Some(RustParam::IntArray(b)) = get_param_mut(ps, name){
221        match b{
222            Qv::Val(v) => Some(Qv::Val(v.vec_mut())),
223            Qv::Null => Some(Qv::Null),
224            Qv::Undefined => Some(Qv::Undefined)
225        }
226    } else{
227        None
228    }
229}
230pub fn get_mutable_float_array<'a, 'b>(ps : RootObjectPtr, name : &'a str) -> Option<Qv<&'b mut Vec<f64>>>{
231    if let Some(RustParam::FloatArray(b)) = get_param_mut(ps, name){
232        match b{
233            Qv::Val(v) => Some(Qv::Val(v.vec_mut())),
234            Qv::Null => Some(Qv::Null),
235            Qv::Undefined => Some(Qv::Undefined)
236        }
237    } else{
238        None
239    }
240}
241
242pub fn get_table(root_def : *const RootDefObj, name : &str) -> Option<TablePtr>{
243    let root = unsafe{ &*root_def };
244    if let Some(RootValue::Table(d)) = root.get(name){
245        Some(TablePtr::new(d, root_def))
246    } else{ None }
247}
248
249
250pub fn get_clist<T : From<CItemPtr>>(root_ptr : RootObjectPtr, name : &str) -> Option<CListPtr<T>>{
251    let root = unsafe{ &*root_ptr.ptr };
252    if let Some(RootValue::CList(l)) = root.default().get(name){
253        Some(CListPtr::new(l.list(), l.default(), root.default()))
254    } else {
255        None
256    }
257}
258
259pub fn get_mlist_mut<T : From<MItemPtr>>(root : RootObjectPtr, name : &str) -> Option<MListPtr<T>>{
260    let (def, sabun, _meta) = unsafe{  (*root.ptr).def_and_mut_sab() };
261    if let Some(RootValue::MList(l)) = def.get(name){
262        if let Some(v) = f::<T>(sabun.get_mut(name), l, def) {
263            return Some(v);
264        }
265        sabun.insert(name.to_string(), RootSabValue::Mut(Some(MutListVal::crate_empty_list())));
266        if let Some(v) = f::<T>(sabun.get_mut(name), l, def) {
267            return Some(v);
268        } else{
269            unreachable!()
270        }
271    }
272    return None;
273
274    fn f<U : From<MItemPtr>>(sab : Option<&mut RootSabValue>, list_def : &MutListDef, root_def : &RootDefObj) -> Option<MListPtr<U>>{
275        if let Some(RootSabValue::Mut(Some(m))) = sab {
276            Some(MListPtr::new(m.list_mut(), list_def.default(), root_def))
277        } else{
278            None
279        }
280    }
281}
282
283pub fn get_mlist_const<T : From<MItemPtr>>(root : RootObjectPtr, name : &str) -> Option<Option<MListPtr<T>>>{
284    let root = unsafe{ &*root.ptr };
285    let (def, sabun) = (root.default(), root.sabun());
286    if let Some(RootValue::MList(l)) = def.get(name){
287        if let Some(RootSabValue::Mut(m)) = sabun.get(name) {
288            if let Some(m) = m {
289                return Some(Some(MListPtr::new(m.list(), l.default(), def)));
290            } else{
291                return Some(None);
292            }
293        }
294    }
295    return None;
296}
297
298pub fn get_param<'a>(ps : RootObjectPtr, name : &str) -> Option<&'a RustParam> {
299    let ptr = unsafe{ &*ps.ptr };
300    let def = ptr.default();
301    let sab = ptr.sabun();
302
303    if let Some(RootSabValue::Param(p)) = sab.get(name) {
304        Some(p)
305    } else if let Some(RootValue::Param(p, _v)) = def.get(name) {
306        Some(p)
307    } else { None }
308}
309pub fn get_param_mut<'a, 'b>(p : RootObjectPtr, name : &'a str) -> Option<&'b mut RustParam> {
310    {
311        let r = unsafe{ &mut *p.ptr };
312        let (_def, m, _) = r.def_and_mut_sab();
313        if let Some(RootSabValue::Param(p)) = m.get_mut(name) {
314            return Some(p);
315        }
316    }
317
318    let r = unsafe{ &mut *p.ptr };
319    let (def, m, _) = r.def_and_mut_sab();
320    if let Some(RootValue::Param(p,_)) = def.get(name){
321        m.insert(name.to_string(), RootSabValue::Param(p.clone()));
322    } else{
323        return None;
324    }
325    if let Some(RootSabValue::Param(p)) = m.get_mut(name) {
326        return Some(p);
327    }
328    unreachable!()
329}
330pub fn get_param_def<'a>(ps : RootObjectPtr, name : &str) -> Option<&'a RustParam> {
331    let def = unsafe{ &*ps.ptr}.default();
332
333    if let Some(RootValue::Param(p, _v)) = def.get(name) {
334        Some(p)
335    } else { None }
336}
337
338pub fn set_sabun(root : RootObjectPtr, name : &str, val : RustParam) -> bool{
339    let root = unsafe{ &mut *root.ptr };
340    match root.set_sabun_param(name.to_string(), val){
341        Ok(_) => true,
342        Err(_) => false,
343    }
344}
345
346pub fn set_bool(root : RootObjectPtr, name : &str, val : Qv<bool>) -> bool{
347    set_sabun(root, name, RustParam::Bool(val))
348}
349pub fn set_float(root : RootObjectPtr, name : &str, val : Qv<f64>) -> bool{
350    set_sabun(root, name, RustParam::Float(val))
351}
352pub fn set_int(root : RootObjectPtr, name : &str, val : Qv<i64>) -> bool{
353    set_sabun(root, name, RustParam::Int(val))
354}
355pub fn set_str(root : RootObjectPtr, name : &str, val : Qv<String>) -> bool{
356    set_sabun(root,name, RustParam::String(val.map(|s| RustString::new(s))))
357}
358pub fn set_int_array(root : RootObjectPtr, name : &str, val : Qv<Vec<i64>>) -> bool{
359    set_sabun(root,name, RustParam::IntArray(val.map(|s| RustIntArray::new(s))))
360}
361pub fn set_float_array(root : RootObjectPtr, name : &str, val : Qv<Vec<f64>>) -> bool{
362    set_sabun(root,name, RustParam::FloatArray(val.map(|s| RustFloatArray::new(s))))
363}
364pub fn set_binary(root : RootObjectPtr, name : &str, val : Qv<Vec<u8>>) -> bool{
365    set_sabun(root,name, RustParam::Binary(val.map(|s| RustBinary::new(s))))
366}
367/// Sets itinital value(0, empty string, zero-filled vec) to the parameter.
368/// len is ignored except for vec-types.
369/// This will be needed in the C interface.
370pub fn set_initial_value<'a>(ps : RootObjectPtr, name : &str, len : usize) -> bool{
371    let (def,sabun, _meta) =  unsafe{ &mut *ps.ptr }.def_and_mut_sab();
372
373    if let Some(RootValue::Param(p, _)) = def.get(name) {
374        sabun.insert(name.to_string(),RootSabValue::Param(p.to_default_value(len)));
375        return true;
376    } else{
377        return false;
378    }
379}
380
381/// Checks if the param hasn't been modified yet
382pub fn is_unmodified(ps : RootObjectPtr, name : &str) -> bool{
383    let item =  unsafe{ &mut *ps.ptr };
384
385    !item.sabun().contains_key(name)
386}
docchi_core/imp/intf/root.rs

docchi_core/imp/intf/
root.rs
