src/libstd/num/uint_macros.rs

   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 #![experimental]
  12 #![macro_escape]
  13 #![doc(hidden)]
  14 #![allow(unsigned_negate)]
  15
  16 macro_rules! uint_module (($T:ty) => (
  17
  18 // String conversion functions and impl str -> num
  19
  20 /// Parse a byte slice as a number in the given base
  21 ///
  22 /// Yields an `Option` because `buf` may or may not actually be parseable.
  23 ///
  24 /// # Examples
  25 ///
  26 /// ```
  27 /// let num = std::uint::parse_bytes([49,50,51,52,53,54,55,56,57], 10);
  28 /// assert!(num == Some(123456789));
  29 /// ```
  30 #[inline]
  31 #[experimental = "might need to return Result"]
  32 pub fn parse_bytes(buf: &[u8], radix: uint) -> Option<$T> {
  33     strconv::from_str_bytes_common(buf, radix, false, false, false,
  34                                    strconv::ExpNone, false, false)
  35 }
  36
  37 #[experimental = "might need to return Result"]
  38 impl FromStr for $T {
  39     #[inline]
  40     fn from_str(s: &str) -> Option<$T> {
  41         strconv::from_str_common(s, 10u, false, false, false,
  42                                  strconv::ExpNone, false, false)
  43     }
  44 }
  45
  46 #[experimental = "might need to return Result"]
  47 impl FromStrRadix for $T {
  48     #[inline]
  49     fn from_str_radix(s: &str, radix: uint) -> Option<$T> {
  50         strconv::from_str_common(s, radix, false, false, false,
  51                                  strconv::ExpNone, false, false)
  52     }
  53 }
  54
  55 // String conversion functions and impl num -> str
  56
  57 /// Convert to a string as a byte slice in a given base.
  58 ///
  59 /// Use in place of x.to_str() when you do not need to store the string permanently
  60 ///
  61 /// # Examples
  62 ///
  63 /// ```
  64 /// #![allow(deprecated)]
  65 ///
  66 /// std::uint::to_str_bytes(123, 10, |v| {
  67 ///     assert!(v == "123".as_bytes());
  68 /// });
  69 /// ```
  70 #[inline]
  71 #[deprecated = "just use .to_string(), or a BufWriter with write! if you mustn't allocate"]
  72 pub fn to_str_bytes<U>(n: $T, radix: uint, f: |v: &[u8]| -> U) -> U {
  73     use io::{Writer, Seek};
  74     // The radix can be as low as 2, so we need at least 64 characters for a
  75     // base 2 number, and then we need another for a possible '-' character.
  76     let mut buf = [0u8, ..65];
  77     let amt = {
  78         let mut wr = ::io::BufWriter::new(buf);
  79         (write!(&mut wr, "{}", ::fmt::radix(n, radix as u8))).unwrap();
  80         wr.tell().unwrap() as uint
  81     };
  82     f(buf.slice(0, amt))
  83 }
  84
  85 #[deprecated = "use fmt::radix"]
  86 impl ToStrRadix for $T {
  87     /// Convert to a string in a given base.
  88     #[inline]
  89     fn to_str_radix(&self, radix: uint) -> String {
  90         format!("{}", ::fmt::radix(*self, radix as u8))
  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_string());
 106         assert_eq!((1 as $T).to_str_radix(10u), "1".to_string());
 107         assert_eq!((2 as $T).to_str_radix(10u), "2".to_string());
 108         assert_eq!((11 as $T).to_str_radix(10u), "11".to_string());
 109         assert_eq!((11 as $T).to_str_radix(16u), "b".to_string());
 110         assert_eq!((255 as $T).to_str_radix(16u), "ff".to_string());
 111         assert_eq!((0xff as $T).to_str_radix(10u), "255".to_string());
 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_string());
 145
 146         u8_val += 1 as u8;
 147         assert_eq!(u8_val.to_str(), "0".to_string());
 148
 149         let mut u16_val: u16 = 65_535_u16;
 150         assert_eq!(u16_val.to_str(), "65535".to_string());
 151
 152         u16_val += 1 as u16;
 153         assert_eq!(u16_val.to_str(), "0".to_string());
 154
 155         let mut u32_val: u32 = 4_294_967_295_u32;
 156         assert_eq!(u32_val.to_str(), "4294967295".to_string());
 157
 158         u32_val += 1 as u32;
 159         assert_eq!(u32_val.to_str(), "0".to_string());
 160
 161         let mut u64_val: u64 = 18_446_744_073_709_551_615_u64;
 162         assert_eq!(u64_val.to_str(), "18446744073709551615".to_string());
 163
 164         u64_val += 1 as u64;
 165         assert_eq!(u64_val.to_str(), "0".to_string());
 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 ))