1 // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
4 //
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
10
11 #![macro_escape]
12 #![doc(hidden)]
13 #![allow(unsigned_negate)]
14
15 macro_rules! uint_module (($T:ty) => (
16
17 // String conversion functions and impl str -> num
18
19 /// Parse a byte slice as a number in the given base
20 ///
21 /// Yields an `Option` because `buf` may or may not actually be parseable.
22 ///
23 /// # Examples
24 ///
25 /// ```
26 /// let num = std::uint::parse_bytes([49,50,51,52,53,54,55,56,57], 10);
27 /// assert!(num == Some(123456789));
28 /// ```
29 #[inline]
30 pub fn parse_bytes(buf: &[u8], radix: uint) -> Option<$T> {
31 strconv::from_str_bytes_common(buf, radix, false, false, false,
32 strconv::ExpNone, false, false)
33 }
34
35 impl FromStr for $T {
36 #[inline]
37 fn from_str(s: &str) -> Option<$T> {
38 strconv::from_str_common(s, 10u, false, false, false,
39 strconv::ExpNone, false, false)
40 }
41 }
42
43 impl FromStrRadix for $T {
44 #[inline]
45 fn from_str_radix(s: &str, radix: uint) -> Option<$T> {
46 strconv::from_str_common(s, radix, false, false, false,
47 strconv::ExpNone, false, false)
48 }
49 }
50
51 // String conversion functions and impl num -> str
52
53 /// Convert to a string as a byte slice in a given base.
54 ///
55 /// Use in place of x.to_str() when you do not need to store the string permanently
56 ///
57 /// # Examples
58 ///
59 /// ```
60 /// std::uint::to_str_bytes(123, 10, |v| {
61 /// assert!(v == "123".as_bytes());
62 /// });
63 /// ```
64 #[inline]
65 pub fn to_str_bytes<U>(n: $T, radix: uint, f: |v: &[u8]| -> U) -> U {
66 // The radix can be as low as 2, so we need at least 64 characters for a
67 // base 2 number.
68 let mut buf = [0u8, ..64];
69 let mut cur = 0;
70 strconv::int_to_str_bytes_common(n, radix, strconv::SignNone, |i| {
71 buf[cur] = i;
72 cur += 1;
73 });
74 f(buf.slice(0, cur))
75 }
76
77 impl ToStrRadix for $T {
78 /// Convert to a string in a given base.
79 #[inline]
80 fn to_str_radix(&self, radix: uint) -> ~str {
81 use slice::Vector;
82 use str::StrAllocating;
83
84 let mut buf = ::vec::Vec::new();
85 strconv::int_to_str_bytes_common(*self, radix, strconv::SignNone, |i| {
86 buf.push(i);
87 });
88 // We know we generated valid utf-8, so we don't need to go through that
89 // check.
90 unsafe { str::raw::from_utf8(buf.as_slice()).to_owned() }
91 }
92 }
93
94 #[cfg(test)]
95 mod tests {
96 use prelude::*;
97 use super::*;
98
99 use num::ToStrRadix;
100 use str::StrSlice;
101 use u16;
102
103 #[test]
104 pub fn test_to_str() {
105 assert_eq!((0 as $T).to_str_radix(10u), "0".to_owned());
106 assert_eq!((1 as $T).to_str_radix(10u), "1".to_owned());
107 assert_eq!((2 as $T).to_str_radix(10u), "2".to_owned());
108 assert_eq!((11 as $T).to_str_radix(10u), "11".to_owned());
109 assert_eq!((11 as $T).to_str_radix(16u), "b".to_owned());
110 assert_eq!((255 as $T).to_str_radix(16u), "ff".to_owned());
111 assert_eq!((0xff as $T).to_str_radix(10u), "255".to_owned());
112 }
113
114 #[test]
115 pub fn test_from_str() {
116 assert_eq!(from_str::<$T>("0"), Some(0u as $T));
117 assert_eq!(from_str::<$T>("3"), Some(3u as $T));
118 assert_eq!(from_str::<$T>("10"), Some(10u as $T));
119 assert_eq!(from_str::<u32>("123456789"), Some(123456789 as u32));
120 assert_eq!(from_str::<$T>("00100"), Some(100u as $T));
121
122 assert!(from_str::<$T>("").is_none());
123 assert!(from_str::<$T>(" ").is_none());
124 assert!(from_str::<$T>("x").is_none());
125 }
126
127 #[test]
128 pub fn test_parse_bytes() {
129 use str::StrSlice;
130 assert_eq!(parse_bytes("123".as_bytes(), 10u), Some(123u as $T));
131 assert_eq!(parse_bytes("1001".as_bytes(), 2u), Some(9u as $T));
132 assert_eq!(parse_bytes("123".as_bytes(), 8u), Some(83u as $T));
133 assert_eq!(u16::parse_bytes("123".as_bytes(), 16u), Some(291u as u16));
134 assert_eq!(u16::parse_bytes("ffff".as_bytes(), 16u), Some(65535u as u16));
135 assert_eq!(parse_bytes("z".as_bytes(), 36u), Some(35u as $T));
136
137 assert!(parse_bytes("Z".as_bytes(), 10u).is_none());
138 assert!(parse_bytes("_".as_bytes(), 2u).is_none());
139 }
140
141 #[test]
142 fn test_uint_to_str_overflow() {
143 let mut u8_val: u8 = 255_u8;
144 assert_eq!(u8_val.to_str(), "255".to_owned());
145
146 u8_val += 1 as u8;
147 assert_eq!(u8_val.to_str(), "0".to_owned());
148
149 let mut u16_val: u16 = 65_535_u16;
150 assert_eq!(u16_val.to_str(), "65535".to_owned());
151
152 u16_val += 1 as u16;
153 assert_eq!(u16_val.to_str(), "0".to_owned());
154
155 let mut u32_val: u32 = 4_294_967_295_u32;
156 assert_eq!(u32_val.to_str(), "4294967295".to_owned());
157
158 u32_val += 1 as u32;
159 assert_eq!(u32_val.to_str(), "0".to_owned());
160
161 let mut u64_val: u64 = 18_446_744_073_709_551_615_u64;
162 assert_eq!(u64_val.to_str(), "18446744073709551615".to_owned());
163
164 u64_val += 1 as u64;
165 assert_eq!(u64_val.to_str(), "0".to_owned());
166 }
167
168 #[test]
169 fn test_uint_from_str_overflow() {
170 let mut u8_val: u8 = 255_u8;
171 assert_eq!(from_str::<u8>("255"), Some(u8_val));
172 assert!(from_str::<u8>("256").is_none());
173
174 u8_val += 1 as u8;
175 assert_eq!(from_str::<u8>("0"), Some(u8_val));
176 assert!(from_str::<u8>("-1").is_none());
177
178 let mut u16_val: u16 = 65_535_u16;
179 assert_eq!(from_str::<u16>("65535"), Some(u16_val));
180 assert!(from_str::<u16>("65536").is_none());
181
182 u16_val += 1 as u16;
183 assert_eq!(from_str::<u16>("0"), Some(u16_val));
184 assert!(from_str::<u16>("-1").is_none());
185
186 let mut u32_val: u32 = 4_294_967_295_u32;
187 assert_eq!(from_str::<u32>("4294967295"), Some(u32_val));
188 assert!(from_str::<u32>("4294967296").is_none());
189
190 u32_val += 1 as u32;
191 assert_eq!(from_str::<u32>("0"), Some(u32_val));
192 assert!(from_str::<u32>("-1").is_none());
193
194 let mut u64_val: u64 = 18_446_744_073_709_551_615_u64;
195 assert_eq!(from_str::<u64>("18446744073709551615"), Some(u64_val));
196 assert!(from_str::<u64>("18446744073709551616").is_none());
197
198 u64_val += 1 as u64;
199 assert_eq!(from_str::<u64>("0"), Some(u64_val));
200 assert!(from_str::<u64>("-1").is_none());
201 }
202
203 #[test]
204 #[should_fail]
205 pub fn to_str_radix1() {
206 100u.to_str_radix(1u);
207 }
208
209 #[test]
210 #[should_fail]
211 pub fn to_str_radix37() {
212 100u.to_str_radix(37u);
213 }
214 }
215
216 ))