has_fields: bool,
}
-pub fn debug_struct_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>, name: &str)
+pub fn debug_struct_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>,
+ name: &str)
-> DebugStruct<'a, 'b> {
let result = fmt.write_str(name);
DebugStruct {
if self.is_pretty() {
let mut writer = PadAdapter::new(self.fmt);
- fmt::write(&mut writer, format_args!("{}\n{}: {:#?}", prefix, name, value))
+ fmt::write(&mut writer,
+ format_args!("{}\n{}: {:#?}", prefix, name, value))
} else {
write!(self.fmt, "{} {}: {:?}", prefix, name, value)
}
self.result = self.result.and_then(|_| {
if self.is_pretty() {
let mut writer = PadAdapter::new(self.fmt);
- let prefix = if self.has_fields { "," } else { "" };
+ let prefix = if self.has_fields {
+ ","
+ } else {
+ ""
+ };
fmt::write(&mut writer, format_args!("{}\n{:#?}", prefix, entry))
} else {
- let prefix = if self.has_fields { ", " } else { "" };
+ let prefix = if self.has_fields {
+ ", "
+ } else {
+ ""
+ };
write!(self.fmt, "{}{:?}", prefix, entry)
}
});
}
pub fn finish(&mut self) {
- let prefix = if self.is_pretty() && self.has_fields { "\n" } else { "" };
+ let prefix = if self.is_pretty() && self.has_fields {
+ "\n"
+ } else {
+ ""
+ };
self.result = self.result.and_then(|_| self.fmt.write_str(prefix));
}
fmt: fmt,
result: result,
has_fields: false,
- }
+ },
}
}
/// Adds the contents of an iterator of entries to the set output.
#[stable(feature = "debug_builders", since = "1.2.0")]
pub fn entries<D, I>(&mut self, entries: I) -> &mut DebugSet<'a, 'b>
- where D: fmt::Debug, I: IntoIterator<Item=D> {
+ where D: fmt::Debug,
+ I: IntoIterator<Item = D>
+ {
for entry in entries {
self.entry(&entry);
}
fmt: fmt,
result: result,
has_fields: false,
- }
+ },
}
}
/// Adds the contents of an iterator of entries to the list output.
#[stable(feature = "debug_builders", since = "1.2.0")]
pub fn entries<D, I>(&mut self, entries: I) -> &mut DebugList<'a, 'b>
- where D: fmt::Debug, I: IntoIterator<Item=D> {
+ where D: fmt::Debug,
+ I: IntoIterator<Item = D>
+ {
for entry in entries {
self.entry(&entry);
}
self.result = self.result.and_then(|_| {
if self.is_pretty() {
let mut writer = PadAdapter::new(self.fmt);
- let prefix = if self.has_fields { "," } else { "" };
- fmt::write(&mut writer, format_args!("{}\n{:#?}: {:#?}", prefix, key, value))
+ let prefix = if self.has_fields {
+ ","
+ } else {
+ ""
+ };
+ fmt::write(&mut writer,
+ format_args!("{}\n{:#?}: {:#?}", prefix, key, value))
} else {
- let prefix = if self.has_fields { ", " } else { "" };
+ let prefix = if self.has_fields {
+ ", "
+ } else {
+ ""
+ };
write!(self.fmt, "{}{:?}: {:?}", prefix, key, value)
}
});
/// Adds the contents of an iterator of entries to the map output.
#[stable(feature = "debug_builders", since = "1.2.0")]
pub fn entries<K, V, I>(&mut self, entries: I) -> &mut DebugMap<'a, 'b>
- where K: fmt::Debug, V: fmt::Debug, I: IntoIterator<Item=(K, V)> {
+ where K: fmt::Debug,
+ V: fmt::Debug,
+ I: IntoIterator<Item = (K, V)>
+ {
for (k, v) in entries {
self.entry(&k, &v);
}
/// Finishes output and returns any error encountered.
#[stable(feature = "debug_builders", since = "1.2.0")]
pub fn finish(&mut self) -> fmt::Result {
- let prefix = if self.is_pretty() && self.has_fields { "\n" } else { "" };
+ let prefix = if self.is_pretty() && self.has_fields {
+ "\n"
+ } else {
+ ""
+ };
self.result.and_then(|_| write!(self.fmt, "{}}}", prefix))
}
fn base(&self) -> u8;
/// A radix-specific prefix string.
- fn prefix(&self) -> &'static str { "" }
+ fn prefix(&self) -> &'static str {
+ ""
+ }
/// Converts an integer to corresponding radix digit.
fn digit(&self, x: u8) -> u8;
x = x / base; // Deaccumulate the number.
*byte = self.digit(n.to_u8()); // Store the digit in the buffer.
curr -= 1;
- if x == zero { break }; // No more digits left to accumulate.
+ if x == zero {
+ // No more digits left to accumulate.
+ break
+ };
}
} else {
// Do the same as above, but accounting for two's complement.
x = x / base; // Deaccumulate the number.
*byte = self.digit(n.to_u8()); // Store the digit in the buffer.
curr -= 1;
- if x == zero { break }; // No more digits left to accumulate.
+ if x == zero {
+ break
+ }; // No more digits left to accumulate.
}
}
let buf = unsafe { str::from_utf8_unchecked(&buf[curr..]) };
impl Radix {
fn new(base: u8) -> Radix {
- assert!(2 <= base && base <= 36, "the base must be in the range of 2..36: {}", base);
+ 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 base(&self) -> u8 {
+ self.base
+ }
fn digit(&self, x: u8) -> u8 {
match x {
x @ 0 ... 9 => b'0' + x,