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

#[derive(Eq, PartialEq, Debug, Clone)]
#[repr(u8)]
pub enum DataType {
    Uri = 1,
    String = 2,
    Integer = 4,
    Datetime = 8,
    Decimal = 32,
    Boolean = 64,
    Binary = 128,
}

impl DataType {
    pub fn new_from_str(l: &str) -> Option<DataType> {
        match l {
            "Uri" => Some(DataType::Uri),
            "String" => Some(DataType::String),
            "Integer" => Some(DataType::Integer),
            "Datetime" => Some(DataType::Datetime),
            "Decimal" => Some(DataType::Decimal),
            "Boolean" => Some(DataType::Boolean),
            "Binary" => Some(DataType::Binary),
            _ => None,
        }
    }

    pub fn new_from_u64(l: u64) -> Option<DataType> {
        match l {
            1 => Some(DataType::Uri),
            2 => Some(DataType::String),
            4 => Some(DataType::Integer),
            8 => Some(DataType::Datetime),
            32 => Some(DataType::Decimal),
            64 => Some(DataType::Boolean),
            128 => Some(DataType::Binary),
            _ => None,
        }
    }
}

#[derive(Eq, PartialEq, Debug, Clone)]
pub struct Lang {
    data: Option<String>,
}

impl Lang {
    pub fn none() -> Lang {
        Lang {
            data: None,
        }
    }

    pub fn is_some(&self) -> bool {
        self.data.is_some()
    }

    pub fn new_from_str(l: &str) -> Lang {
        let lu = l.to_uppercase();

        if lu == "NONE" || lu == "UNDEFINED" {
            Lang::none()
        } else {
            Lang {
                data: Some(lu),
            }
        }
    }

    pub fn new_from_i64(l: i64) -> Lang {
        match l {
            1 => Lang {
                data: Some("RU".to_owned()),
            },
            2 => Lang {
                data: Some("EN".to_owned()),
            },
            _ => Lang::none(),
        }
    }

    pub fn to_string(&self) -> &str {
        if let Some(v) = &self.data {
            v
        } else {
            "NONE"
        }
    }
}

pub fn exponent_to_scale(m: &i64, e: &i64) -> (i64, u32) {
    let scale = if *e < 0 {
        (*e * -1) as u32
    } else {
        0
    };

    let num = if *e > 0 {
        *m * 10_i64.pow(*e as u32)
    } else {
        *m
    };

    (num, scale)
}