mongors 0.2.2

Rust driver for MongoDB
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183

macro_rules! separated_uint_with_output {
    ($string:expr, $output:expr) => {{
        let mut place = $string.len();
        let mut later_loop = false;

        for ch in $string.chars() {
            if later_loop && place % 3 == 0 {
                $output.push(',');
            }

            $output.push(ch);
            later_loop = true;
            place -= 1;
        };

        $output
    }};
}

macro_rules! separated_uint {
    ($string:expr) => {{
        let mut output = String::new();
        separated_uint_with_output!($string, output)
    }}
}

macro_rules! separated_int {
    ($string:expr) => {{
        let mut output = String::new();
        let magnitude = if $string.starts_with('-') {
            output.push('-');
            (&$string)[1..].to_string()
        } else {
            $string
        };

        separated_uint_with_output!(magnitude, output)
    }};
}

macro_rules! separated_float {
    ($string:expr) => {{
        let idx = match $string.find('.') {
            Some(i) => i,
            None => $string.len()
        };

        let int_part = (&$string[..idx]).to_string();
        let fract_part = &$string[idx..];
        let output = separated_int!(int_part);
        output + fract_part
    }};
}

macro_rules! separated_float2 {
    ($string:expr) => {{
        let idx = match $string.find('.') {
            Some(i) => i,
            None => $string.len()
        };

        let int_part = &$string[..idx];
        let fract_part = &$string[idx..];

        let mut output = String::new();
        let magnitude = if int_part.starts_with('-') {
            output.push('-');
            int_part[1..].to_string()
        } else {
            int_part.to_string()
        };

        let mut place = magnitude.len();
        let mut later_loop = false;

        for ch in magnitude.chars() {
            if later_loop && place % 3 == 0 {
                output.push(',');
            }

            output.push(ch);
            later_loop = true;
            place -= 1;
        };

        output.push_str(fract_part);
        output
    }};
}

pub trait Separatable {

    /// Converts the number to a string with thousands separator.
    fn separated_string(&self) -> String;
}

impl Separatable for i16 {
    fn separated_string(&self) -> String {
        let string = format!("{}", self);
        separated_int!(string)
    }
}

impl Separatable for i32 {
    fn separated_string(&self) -> String {
        let string = format!("{}", self);
        separated_int!(string)
    }
}

impl Separatable for i64 {
    fn separated_string(&self) -> String {
        let string = format!("{}", self);
        separated_int!(string)
    }
}

impl Separatable for isize {
    fn separated_string(&self) -> String {
        let string = format!("{}", self);
        separated_int!(string)
    }
}

impl Separatable for u16 {
    fn separated_string(&self) -> String {
        let string = format!("{}", self);
        separated_uint!(string)
    }
}

impl Separatable for u32 {
    fn separated_string(&self) -> String {
        let string = format!("{}", self);
        separated_uint!(string)
    }
}

impl Separatable for u64 {
    fn separated_string(&self) -> String {
        let string = format!("{}", self);
        separated_uint!(string)
    }
}

impl Separatable for usize {
    fn separated_string(&self) -> String {
        let string = format!("{}", self);
        separated_uint!(string)
    }
}

impl Separatable for f32 {
    fn separated_string(&self) -> String {
        let string = format!("{}", self);
        separated_float!(string)
    }
}

impl Separatable for f64 {
    fn separated_string(&self) -> String {
        let string = format!("{}", self);
        separated_float!(string)
    }
}

pub trait FixedPlaceSeparatable {
    fn separated_string_with_fixed_place(&self, places: usize) -> String;
}

impl FixedPlaceSeparatable for f32 {
    fn separated_string_with_fixed_place(&self, places: usize) -> String {
        let string = format!("{:.*}", places, self);
        separated_float2!(string)
    }
}

impl FixedPlaceSeparatable for f64 {
    fn separated_string_with_fixed_place(&self, places: usize) -> String {
        let string = format!("{:.*}", places, self);
        separated_float2!(string)
    }
}