usc 1.20230730.1349

A common lib for unitedservices
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


use once_map::OnceMap;
use serde_json::Value;

use std::default::Default;


use crate::{myfield};
use crate::db::{BOOL_FALSE, BOOL_TRUE};
use crate::myjson::{myjson_get_f64, myjson_get_i64, myjson_get_string};

#[derive(Debug,Default)]
pub struct MyParameter {
    query_map:OnceMap<String,String>,
    data: Value,
}

impl MyParameter{
    pub fn get_query(&self,name:&str)->String{
        self.query_map.get_cloned(name).unwrap_or("".to_string())
    }

    pub fn contains_key(&self,path:&str)->bool{
        if self.query_map.get_cloned(path).is_some() {
            return true
        }
        if self.data.as_object().unwrap().contains_key(path) {
            return true
        }
        false
    }

    pub fn get_string(&self,path:&str)->String{
        return self.query_map.get_cloned(path).unwrap_or_else(||{
             return myjson_get_string(&self.data, path, "");
        });
    }

    pub fn get_data_string(&self,path:&str)->String{
        myjson_get_string(&self.data, path, "")
    }

    pub fn get_data_i64(&self,path:&str)->i64{
        myjson_get_i64(&self.data, path, 0)
    }

    pub fn get_data_f64(&self,path:&str)->f64{
        myjson_get_f64(&self.data, path, 0.0)
    }

    pub fn get_data(&  self)->& Value{
        & self.data
    }

    pub fn set_data(& mut self,_data:Value){
        self.data=_data;
    }

    pub fn set_query_map(& mut self,_query_map:OnceMap<String,String>){
        self.query_map=_query_map;
    }

    pub fn get_object<T: Default+ bevy_reflect::Struct >(&self)->  T {
        let mut objref = T::default();
        let obj:&mut T=& mut objref;
        for (column_name,column_val) in self.query_map.read_only_view().iter() {
            let _=myfield::set_field_by_str(obj, column_name.as_str(), column_val.as_str());
        }
        let map=self.data.as_object().unwrap();
        let field_types=myfield::field_types(obj).unwrap();
        for (column_name,column_type) in field_types.iter(){
            if map.contains_key(column_name) {
            let _=match column_type.as_str(){
                    "i64"|"i32"=>  myfield::set_field(obj, column_name.as_str(), myjson_get_i64(&self.data, column_name.as_str(), 0)),
                    "f64"|"f32"=>  myfield::set_field(obj, column_name.as_str(), myjson_get_f64(&self.data, column_name.as_str(), 0.0)),
                    "unitedservices::db::const_type_defaults::Bool"=>{
                        let num=myjson_get_i64(&self.data, column_name.as_str(), 0);
                        match num{
                             num if num>0 => myfield::set_field(obj, column_name.as_str(),BOOL_FALSE ),
                            _ => myfield::set_field(obj, column_name.as_str(),BOOL_TRUE ),
                        }
                    },
                    _ =>  myfield::set_field(obj, column_name.as_str(), myjson_get_string(&self.data, column_name.as_str(), "")),
                };
            }
        }
        objref
    }
}