jlib 0.3.7

A lightweight blockchain lib.
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

static TOKEN_E      : &'static str = "e";
static TOKEN_ZERO   : &'static str = "0";
static TOKEN_POINT  : &'static str = ".";

pub fn to_expo(s: &str) -> Result<String, &'static str> {
    let len = s.len();
    if len == 1 && s == "." {
        return Err("invalid input!");
    }

    for c in s.chars() {
        if c >= '0' && c <= '9' || c == '.' {

        } else {
            return Err("invalid input!");
        }
    }

    let mut idx: isize = - 1;
    if let Some(x) = s.find(".") {
        idx = x as isize;
    }

    match get_format(idx, len) {
        FormatType::AtHead => {
            if len > 2 {
                let ret = s.chars().nth(1).unwrap().to_string() + TOKEN_POINT + s.get(2..).unwrap() + TOKEN_E + "-1".to_string().as_str();
                Ok(ret)
            } else {
                let ret = s.chars().nth(1).unwrap().to_string() + TOKEN_POINT + TOKEN_ZERO + TOKEN_E + "-1".to_string().as_str();
                Ok(ret)
            }
        },

        FormatType::AtRear => {
            let left_len = len - 1;
            let move_steps = left_len - 1;
            let ret = s.chars().nth(0).unwrap().to_string() + TOKEN_POINT + s.get(1..left_len).unwrap() + TOKEN_E + move_steps.to_string().as_str();
            Ok(ret)
        },

        FormatType::AtMid => {
            let idx = idx as usize;
            let left = s.get(0..idx).unwrap();
            let right = s.get(idx+1..).unwrap();
            let left_len = left.len();
            let right_len = right.len();
            if s.chars().nth(0).unwrap() != '0' {
                let ret = s.chars().nth(0).unwrap().to_string() + TOKEN_POINT + left.get(1..).unwrap() + right + TOKEN_E + (left_len - 1).to_string().as_str();
                return Ok(ret);
            }

            let mut right_index = 0;
            while right_index < right_len {
                if right.chars().nth(right_index).unwrap() != '0' {
                    break;
                }

                right_index += 1;
            }

            if right_index == right_len - 1 {
                let ret = right.chars().nth(right_index).unwrap().to_string() + TOKEN_POINT + "0" + TOKEN_E + (-1 - right_index as isize).to_string().as_str();
                Ok(ret)
            } else {
                let ret = right.chars().nth(right_index).unwrap().to_string() + TOKEN_POINT + right.get(right_index+1..).unwrap() + TOKEN_E + (-1 - right_index as isize).to_string().as_str();
                Ok(ret)
            }
        }

        FormatType::AtNone => {
            let ret = s.chars().nth(0).unwrap().to_string() + TOKEN_POINT + s.get(1..).unwrap() + TOKEN_E + (len-1).to_string().as_str();
            Ok(ret)
        }
    }
}

pub fn get_exponent(s: &str) -> isize {
    let mut ret = 0isize;
    if let Some(x) = s.find("e") {
        if let Some(y) = s.get(x+1..) {
            if let Ok(z) = y.parse::<isize>() {
                ret = z;
            }
        }
    }

    ret
}

pub enum FormatType {
    //.开头格式 .11
    AtHead,

    //.在中间的格式 11.22
    AtMid,

    //.结尾的格式  11.
    AtRear,

    //没有.的格式 22
    AtNone,
}

pub fn get_format(idx: isize, len: usize) -> FormatType {
    if idx == 0 {
        return FormatType::AtHead;
    }

    if idx == (len - 1) as isize {
        return FormatType::AtRear;
    }

    if idx == -1 {
        return FormatType::AtNone;
    }

    return FormatType::AtMid;
}