1 // Copyright 2015 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.
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.
12 use fmt::{self, Write, FlagV1};
14 struct PadAdapter<'a, 'b: 'a> {
15 fmt: &'a mut fmt::Formatter<'b>,
19 impl<'a, 'b: 'a> PadAdapter<'a, 'b> {
20 fn new(fmt: &'a mut fmt::Formatter<'b>) -> PadAdapter<'a, 'b> {
28 impl<'a, 'b: 'a> fmt::Write for PadAdapter<'a, 'b> {
29 fn write_str(&mut self, mut s: &str) -> fmt::Result {
32 try!(self.fmt.write_str(" "));
35 let split = match s.find('\n') {
37 self.on_newline = true;
41 self.on_newline = false;
45 try!(self.fmt.write_str(&s[..split]));
53 /// A struct to help with `fmt::Debug` implementations.
55 /// Constructed by the `Formatter::debug_struct` method.
57 #[stable(feature = "debug_builders", since = "1.2.0")]
58 pub struct DebugStruct<'a, 'b: 'a> {
59 fmt: &'a mut fmt::Formatter<'b>,
64 pub fn debug_struct_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>, name: &str)
65 -> DebugStruct<'a, 'b> {
66 let result = fmt.write_str(name);
74 impl<'a, 'b: 'a> DebugStruct<'a, 'b> {
75 /// Adds a new field to the generated struct output.
76 #[stable(feature = "debug_builders", since = "1.2.0")]
77 pub fn field(&mut self, name: &str, value: &fmt::Debug) -> &mut DebugStruct<'a, 'b> {
78 self.result = self.result.and_then(|_| {
79 let prefix = if self.has_fields {
86 let mut writer = PadAdapter::new(self.fmt);
87 fmt::write(&mut writer, format_args!("{}\n{}: {:#?}", prefix, name, value))
89 write!(self.fmt, "{} {}: {:?}", prefix, name, value)
93 self.has_fields = true;
97 /// Finishes output and returns any error encountered.
98 #[stable(feature = "debug_builders", since = "1.2.0")]
99 pub fn finish(&mut self) -> fmt::Result {
101 self.result = self.result.and_then(|_| {
102 if self.is_pretty() {
103 self.fmt.write_str("\n}")
105 self.fmt.write_str(" }")
112 fn is_pretty(&self) -> bool {
113 self.fmt.flags() & (1 << (FlagV1::Alternate as usize)) != 0
117 /// A struct to help with `fmt::Debug` implementations.
119 /// Constructed by the `Formatter::debug_tuple` method.
121 #[stable(feature = "debug_builders", since = "1.2.0")]
122 pub struct DebugTuple<'a, 'b: 'a> {
123 fmt: &'a mut fmt::Formatter<'b>,
128 pub fn debug_tuple_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>, name: &str) -> DebugTuple<'a, 'b> {
129 let result = fmt.write_str(name);
137 impl<'a, 'b: 'a> DebugTuple<'a, 'b> {
138 /// Adds a new field to the generated tuple struct output.
139 #[stable(feature = "debug_builders", since = "1.2.0")]
140 pub fn field(&mut self, value: &fmt::Debug) -> &mut DebugTuple<'a, 'b> {
141 self.result = self.result.and_then(|_| {
142 let (prefix, space) = if self.has_fields {
148 if self.is_pretty() {
149 let mut writer = PadAdapter::new(self.fmt);
150 fmt::write(&mut writer, format_args!("{}\n{:#?}", prefix, value))
152 write!(self.fmt, "{}{}{:?}", prefix, space, value)
156 self.has_fields = true;
160 /// Finishes output and returns any error encountered.
161 #[stable(feature = "debug_builders", since = "1.2.0")]
162 pub fn finish(&mut self) -> fmt::Result {
164 self.result = self.result.and_then(|_| {
165 if self.is_pretty() {
166 self.fmt.write_str("\n)")
168 self.fmt.write_str(")")
175 fn is_pretty(&self) -> bool {
176 self.fmt.flags() & (1 << (FlagV1::Alternate as usize)) != 0
179 /// Returns the wrapped `Formatter`.
180 #[unstable(feature = "debug_builder_formatter", reason = "recently added",
182 pub fn formatter(&mut self) -> &mut fmt::Formatter<'b> {
187 struct DebugInner<'a, 'b: 'a> {
188 fmt: &'a mut fmt::Formatter<'b>,
193 impl<'a, 'b: 'a> DebugInner<'a, 'b> {
194 fn entry(&mut self, entry: &fmt::Debug) {
195 self.result = self.result.and_then(|_| {
196 if self.is_pretty() {
197 let mut writer = PadAdapter::new(self.fmt);
198 let prefix = if self.has_fields { "," } else { "" };
199 fmt::write(&mut writer, format_args!("{}\n{:#?}", prefix, entry))
201 let prefix = if self.has_fields { ", " } else { "" };
202 write!(self.fmt, "{}{:?}", prefix, entry)
206 self.has_fields = true;
209 pub fn finish(&mut self) {
210 let prefix = if self.is_pretty() && self.has_fields { "\n" } else { "" };
211 self.result = self.result.and_then(|_| self.fmt.write_str(prefix));
214 fn is_pretty(&self) -> bool {
215 self.fmt.flags() & (1 << (FlagV1::Alternate as usize)) != 0
219 /// A struct to help with `fmt::Debug` implementations.
221 /// Constructed by the `Formatter::debug_set` method.
223 #[stable(feature = "debug_builders", since = "1.2.0")]
224 pub struct DebugSet<'a, 'b: 'a> {
225 inner: DebugInner<'a, 'b>,
228 pub fn debug_set_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>) -> DebugSet<'a, 'b> {
229 let result = write!(fmt, "{{");
239 impl<'a, 'b: 'a> DebugSet<'a, 'b> {
240 /// Adds a new entry to the set output.
241 #[stable(feature = "debug_builders", since = "1.2.0")]
242 pub fn entry(&mut self, entry: &fmt::Debug) -> &mut DebugSet<'a, 'b> {
243 self.inner.entry(entry);
247 /// Adds the contents of an iterator of entries to the set output.
248 #[stable(feature = "debug_builders", since = "1.2.0")]
249 pub fn entries<D, I>(&mut self, entries: I) -> &mut DebugSet<'a, 'b>
250 where D: fmt::Debug, I: IntoIterator<Item=D> {
251 for entry in entries {
257 /// Finishes output and returns any error encountered.
258 #[stable(feature = "debug_builders", since = "1.2.0")]
259 pub fn finish(&mut self) -> fmt::Result {
261 self.inner.result.and_then(|_| self.inner.fmt.write_str("}"))
265 /// A struct to help with `fmt::Debug` implementations.
267 /// Constructed by the `Formatter::debug_list` method.
269 #[stable(feature = "debug_builders", since = "1.2.0")]
270 pub struct DebugList<'a, 'b: 'a> {
271 inner: DebugInner<'a, 'b>,
274 pub fn debug_list_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>) -> DebugList<'a, 'b> {
275 let result = write!(fmt, "[");
285 impl<'a, 'b: 'a> DebugList<'a, 'b> {
286 /// Adds a new entry to the list output.
287 #[stable(feature = "debug_builders", since = "1.2.0")]
288 pub fn entry(&mut self, entry: &fmt::Debug) -> &mut DebugList<'a, 'b> {
289 self.inner.entry(entry);
293 /// Adds the contents of an iterator of entries to the list output.
294 #[stable(feature = "debug_builders", since = "1.2.0")]
295 pub fn entries<D, I>(&mut self, entries: I) -> &mut DebugList<'a, 'b>
296 where D: fmt::Debug, I: IntoIterator<Item=D> {
297 for entry in entries {
303 /// Finishes output and returns any error encountered.
304 #[stable(feature = "debug_builders", since = "1.2.0")]
305 pub fn finish(&mut self) -> fmt::Result {
307 self.inner.result.and_then(|_| self.inner.fmt.write_str("]"))
311 /// A struct to help with `fmt::Debug` implementations.
313 /// Constructed by the `Formatter::debug_map` method.
315 #[stable(feature = "debug_builders", since = "1.2.0")]
316 pub struct DebugMap<'a, 'b: 'a> {
317 fmt: &'a mut fmt::Formatter<'b>,
322 pub fn debug_map_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>) -> DebugMap<'a, 'b> {
323 let result = write!(fmt, "{{");
331 impl<'a, 'b: 'a> DebugMap<'a, 'b> {
332 /// Adds a new entry to the map output.
333 #[stable(feature = "debug_builders", since = "1.2.0")]
334 pub fn entry(&mut self, key: &fmt::Debug, value: &fmt::Debug) -> &mut DebugMap<'a, 'b> {
335 self.result = self.result.and_then(|_| {
336 if self.is_pretty() {
337 let mut writer = PadAdapter::new(self.fmt);
338 let prefix = if self.has_fields { "," } else { "" };
339 fmt::write(&mut writer, format_args!("{}\n{:#?}: {:#?}", prefix, key, value))
341 let prefix = if self.has_fields { ", " } else { "" };
342 write!(self.fmt, "{}{:?}: {:?}", prefix, key, value)
346 self.has_fields = true;
350 /// Adds the contents of an iterator of entries to the map output.
351 #[stable(feature = "debug_builders", since = "1.2.0")]
352 pub fn entries<K, V, I>(&mut self, entries: I) -> &mut DebugMap<'a, 'b>
353 where K: fmt::Debug, V: fmt::Debug, I: IntoIterator<Item=(K, V)> {
354 for (k, v) in entries {
360 /// Finishes output and returns any error encountered.
361 #[stable(feature = "debug_builders", since = "1.2.0")]
362 pub fn finish(&mut self) -> fmt::Result {
363 let prefix = if self.is_pretty() && self.has_fields { "\n" } else { "" };
364 self.result.and_then(|_| write!(self.fmt, "{}}}", prefix))
367 fn is_pretty(&self) -> bool {
368 self.fmt.flags() & (1 << (FlagV1::Alternate as usize)) != 0