rustils/parse/
usize.rs

1use error::ParseError;
2use RoundingMode;
3use RoundingMode::*;
4
5pub trait ToUsize {
6
7    fn to_usize_res(self)
8        -> ParseResultUsize;
9
10    fn to_usize(self)
11        -> usize;
12}
13
14pub trait ToUsizeRM {
15
16    fn to_usize_rm_res(self, rm: RoundingMode)
17        -> ParseResultUsize;
18
19    fn to_usize_rm(self, rm: RoundingMode)
20        -> usize;
21}
22
23/// Parse [`bool`](https://doc.rust-lang.org/std/primitive.bool.html) to
24/// [`usize`](https://doc.rust-lang.org/std/primitive.usize.html)
25///
26/// If `a` is `false` then returns `Ok(0)`.<br>
27/// If `a` is `true` then returns `Ok(1)`.
28///
29/// # Arguments
30///
31/// * `a` - [`bool`](https://doc.rust-lang.org/std/primitive.bool.html)
32///
33/// # Examples
34///
35/// ```
36/// use rustils::parse::usize::bool_to_usize_res;
37///
38/// assert_eq!(bool_to_usize_res(true), Ok(1_usize));
39/// assert_eq!(bool_to_usize_res(false), Ok(0_usize));
40/// ```
41pub fn bool_to_usize_res(a: bool)
42    -> ParseResultUsize {
43
44    if a { Ok(1) } else { Ok(0) }
45}
46
47/// Parse [`bool`](https://doc.rust-lang.org/std/primitive.bool.html) to
48/// [`usize`](https://doc.rust-lang.org/std/primitive.usize.html)
49///
50/// If `a` is `false` then returns 0.<br>
51/// If `a` is `true` then returns 1.
52///
53/// # Arguments
54///
55/// * `a` - [`bool`](https://doc.rust-lang.org/std/primitive.bool.html)
56///
57/// # Examples
58///
59/// ```
60/// use rustils::parse::usize::bool_to_usize;
61///
62/// assert_eq!(bool_to_usize(true), 1_usize);
63/// assert_eq!(bool_to_usize(false), 0_usize);
64/// ```
65pub fn bool_to_usize(a: bool)
66    -> usize {
67
68    if a { 1 } else { 0 }
69}
70
71pub fn i8_to_usize_res(a: i8)
72    -> ParseResultUsize {
73
74    if a < 0 {
75        Err(ParseError::InvalidNumber(a.to_string()))
76    } else { Ok(a as usize) }
77}
78
79pub fn i8_to_usize(a: i8)
80    -> usize {
81
82    match i8_to_usize_res(a) {
83        Ok(i) => i,
84        Err(err) => panic!("{}",err)
85    }
86}
87
88pub fn i16_to_usize_res(a: i16)
89    -> ParseResultUsize {
90
91    if a < 0 {
92        Err(ParseError::InvalidNumber(a.to_string()))
93    } else { Ok(a as usize) }
94}
95
96pub fn i16_to_usize(a: i16)
97    -> usize {
98
99    match i16_to_usize_res(a) {
100        Ok(i) => i,
101        Err(err) => panic!("{}",err)
102    }
103}
104
105pub fn i32_to_usize_res(a: i32)
106    -> ParseResultUsize {
107
108    if a < 0 {
109        Err(ParseError::InvalidNumber(a.to_string()))
110    } else { Ok(a as usize) }
111}
112
113pub fn i32_to_usize(a: i32)
114    -> usize {
115
116    match i32_to_usize_res(a) {
117        Ok(i) => i,
118        Err(err) => panic!("{}",err)
119    }
120}
121
122pub fn f32_to_usize_res(a: f32)
123    -> ParseResultUsize {
124
125    f32_to_usize_rm_res(a, Trunc)
126}
127
128pub fn f32_to_usize(a: f32)
129    -> usize {
130
131    f32_to_usize_rm(a, Trunc)
132}
133
134pub fn f32_to_usize_rm_res(a: f32, rm: RoundingMode)
135    -> ParseResultUsize {
136
137    let max = 16777215_f32;
138
139    let x = match rm {
140        Round => a.round(),
141        Ceil => a.ceil(),
142        Floor => a.floor(),
143        Trunc => a.trunc()
144    };
145
146    if x.is_nan() || x < 0.0 || x > max {
147        Err(ParseError::InvalidNumber(a.to_string()))
148    } else { Ok(x as usize) }
149}
150
151pub fn f32_to_usize_rm(a: f32, rm: RoundingMode)
152    -> usize {
153
154    match f32_to_usize_rm_res(a, rm) {
155        Ok(i) => i,
156        Err(err) => panic!("{}",err)
157    }
158}
159
160pub fn i64_to_usize_res(a: i64)
161    -> ParseResultUsize {
162
163    if a < 0 {
164        Err(ParseError::InvalidNumber(a.to_string()))
165    } else { Ok(a as usize) }
166}
167
168pub fn i64_to_usize(a: i64)
169    -> usize {
170
171    match i64_to_usize_res(a) {
172        Ok(i) => i,
173        Err(err) => panic!("{}",err)
174    }
175}
176
177pub fn f64_to_usize_res(a: f64)
178    -> ParseResultUsize {
179
180    f64_to_usize_rm_res(a, Trunc)
181}
182
183pub fn f64_to_usize(a: f64)
184    -> usize {
185
186    f64_to_usize_rm(a, Trunc)
187}
188
189pub fn f64_to_usize_rm_res(a: f64, rm: RoundingMode)
190    -> ParseResultUsize {
191
192    let max = 9007199254740991_f64;
193
194    let x = match rm {
195        Round => a.round(),
196        Ceil => a.ceil(),
197        Floor => a.floor(),
198        Trunc => a.trunc()
199    };
200
201    if x.is_nan() || x < 0.0 || x > max {
202        Err(ParseError::InvalidNumber(a.to_string()))
203    } else { Ok(x as usize) }
204}
205
206pub fn f64_to_usize_rm(a: f64, rm: RoundingMode)
207    -> usize {
208
209    match f64_to_usize_rm_res(a, rm) {
210        Ok(i) => i,
211        Err(err) => panic!("{}",err)
212    }
213}
214
215pub fn isize_to_usize_res(a: isize)
216    -> ParseResultUsize {
217
218    if a < 0 {
219        Err(ParseError::InvalidNumber(a.to_string()))
220    } else { Ok(a as usize) }
221}
222
223pub fn isize_to_usize(a: isize)
224    -> usize {
225
226    match isize_to_usize_res(a) {
227        Ok(i) => i,
228        Err(err) => panic!("{}",err)
229    }
230}
231
232pub fn string_to_usize_res(a: String)
233    -> ParseResultUsize {
234
235    match a.parse::<usize>() {
236        Ok(n) => Ok(n),
237        Err(_) => Err(ParseError::InvalidNumber(a))
238    }
239}
240
241pub fn string_to_usize(a: String)
242    -> usize {
243
244    match string_to_usize_res(a) {
245        Ok(i) => i,
246        Err(err) => panic!("{}",err)
247    }
248}
249
250pub fn str_to_usize_res(a: &str)
251    -> ParseResultUsize {
252
253    match a.parse::<usize>() {
254        Ok(n) => Ok(n),
255        Err(_) => Err(ParseError::InvalidNumber(a.to_string()))
256    }
257}
258
259pub fn str_to_usize(a: &str)
260    -> usize {
261
262    match str_to_usize_res(a) {
263        Ok(i) => i,
264        Err(err) => panic!("{}",err)
265    }
266}
267
268pub type ParseResultUsize = Result<usize, ParseError>;
rustils/parse/usize.rs

rustils/parse/
usize.rs
