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

#[derive(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(PartialEq, Debug, Clone)]
#[repr(u8)]
pub enum Lang {
    NONE = 0,
    /// Русский
    RU = 1,
    /// Английский
    EN = 2,
}

impl Lang {
    pub fn new_from_str(l: &str) -> Lang {
        match l {
            "ru" => Lang::RU,
            "en" => Lang::EN,
            _ => Lang::NONE,
        }
    }

    pub fn new_from_i64(l: i64) -> Lang {
        match l {
            1 => Lang::RU,
            2 => Lang::EN,
            _ => Lang::NONE,
        }
    }

    pub fn to_string(&self) -> &str {
        match self {
            Lang::RU => "ru",
            Lang::EN => "en",
            Lang::NONE => "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)
}