//! Integer and floating-point number formatting
+#![allow(deprecated)]
+
// FIXME: #6220 Implement floating point formatting
use prelude::v1::*;
// The radix can be as low as 2, so we need a buffer of at least 64
// characters for a base 2 number.
let zero = T::zero();
- let is_positive = x >= zero;
+ let is_nonnegative = x >= zero;
let mut buf = [0; 64];
let mut curr = buf.len();
let base = T::from_u8(self.base());
- if is_positive {
+ if is_nonnegative {
// Accumulate each digit of the number from the least significant
// to the most significant figure.
for byte in buf.iter_mut().rev() {
}
}
let buf = unsafe { str::from_utf8_unchecked(&buf[curr..]) };
- f.pad_integral(is_positive, self.prefix(), buf)
+ f.pad_integral(is_nonnegative, self.prefix(), buf)
}
}
radix! { UpperHex, 16, "0x", x @ 0 ... 9 => b'0' + x,
x @ 10 ... 15 => b'A' + (x - 10) }
-/// A radix with in the range of `2..36`.
-#[derive(Clone, Copy, PartialEq)]
-#[unstable(feature = "fmt_radix",
- reason = "may be renamed or move to a different module",
- issue = "27728")]
-pub struct Radix {
- base: u8,
-}
-
-impl Radix {
- fn new(base: u8) -> Radix {
- assert!(2 <= base && base <= 36,
- "the base must be in the range of 2..36: {}",
- base);
- Radix { base: base }
- }
-}
-
-impl GenericRadix for Radix {
- fn base(&self) -> u8 {
- self.base
- }
- fn digit(&self, x: u8) -> u8 {
- match x {
- x @ 0 ... 9 => b'0' + x,
- x if x < self.base() => b'a' + (x - 10),
- x => panic!("number not in the range 0..{}: {}", self.base() - 1, x),
- }
- }
-}
-
-/// A helper type for formatting radixes.
-#[unstable(feature = "fmt_radix",
- reason = "may be renamed or move to a different module",
- issue = "27728")]
-#[derive(Copy, Clone)]
-pub struct RadixFmt<T, R>(T, R);
-
-/// Constructs a radix formatter in the range of `2..36`.
-///
-/// # Examples
-///
-/// ```
-/// #![feature(fmt_radix)]
-///
-/// use std::fmt::radix;
-/// assert_eq!(format!("{}", radix(55, 36)), "1j".to_string());
-/// ```
-#[unstable(feature = "fmt_radix",
- reason = "may be renamed or move to a different module",
- issue = "27728")]
-pub fn radix<T>(x: T, base: u8) -> RadixFmt<T, Radix> {
- RadixFmt(x, Radix::new(base))
-}
-
-macro_rules! radix_fmt {
- ($T:ty as $U:ty, $fmt:ident) => {
- #[stable(feature = "rust1", since = "1.0.0")]
- impl fmt::Debug for RadixFmt<$T, Radix> {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- fmt::Display::fmt(self, f)
- }
- }
- #[stable(feature = "rust1", since = "1.0.0")]
- impl fmt::Display for RadixFmt<$T, Radix> {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- match *self { RadixFmt(ref x, radix) => radix.$fmt(*x as $U, f) }
- }
- }
- }
-}
-
macro_rules! int_base {
($Trait:ident for $T:ident as $U:ident -> $Radix:ident) => {
#[stable(feature = "rust1", since = "1.0.0")]
int_base! { Octal for $Int as $Uint -> Octal }
int_base! { LowerHex for $Int as $Uint -> LowerHex }
int_base! { UpperHex for $Int as $Uint -> UpperHex }
- radix_fmt! { $Int as $Int, fmt_int }
debug! { $Int }
int_base! { Binary for $Uint as $Uint -> Binary }
int_base! { Octal for $Uint as $Uint -> Octal }
int_base! { LowerHex for $Uint as $Uint -> LowerHex }
int_base! { UpperHex for $Uint as $Uint -> UpperHex }
- radix_fmt! { $Uint as $Uint, fmt_int }
debug! { $Uint }
}
}
macro_rules! impl_Display {
($($t:ident),*: $conv_fn:ident) => ($(
+ #[stable(feature = "rust1", since = "1.0.0")]
impl fmt::Display for $t {
#[allow(unused_comparisons)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- let is_positive = *self >= 0;
- let mut n = if is_positive {
+ let is_nonnegative = *self >= 0;
+ let mut n = if is_nonnegative {
self.$conv_fn()
} else {
// convert the negative num to positive by summing 1 to it's 2 complement
str::from_utf8_unchecked(
slice::from_raw_parts(buf_ptr.offset(curr), buf.len() - curr as usize))
};
- f.pad_integral(is_positive, "", buf_slice)
+ f.pad_integral(is_nonnegative, "", buf_slice)
}
})*);
}