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>,
66 -> DebugStruct<'a, 'b> {
67 let result = fmt.write_str(name);
75 impl<'a, 'b: 'a> DebugStruct<'a, 'b> {
76 /// Adds a new field to the generated struct output.
77 #[stable(feature = "debug_builders", since = "1.2.0")]
78 pub fn field(&mut self, name: &str, value: &fmt::Debug) -> &mut DebugStruct<'a, 'b> {
79 self.result = self.result.and_then(|_| {
80 let prefix = if self.has_fields {
87 let mut writer = PadAdapter::new(self.fmt);
88 fmt::write(&mut writer,
89 format_args!("{}\n{}: {:#?}", prefix, name, value))
91 write!(self.fmt, "{} {}: {:?}", prefix, name, value)
95 self.has_fields = true;
99 /// Finishes output and returns any error encountered.
100 #[stable(feature = "debug_builders", since = "1.2.0")]
101 pub fn finish(&mut self) -> fmt::Result {
103 self.result = self.result.and_then(|_| {
104 if self.is_pretty() {
105 self.fmt.write_str("\n}")
107 self.fmt.write_str(" }")
114 fn is_pretty(&self) -> bool {
115 self.fmt.flags() & (1 << (FlagV1::Alternate as usize)) != 0
119 /// A struct to help with `fmt::Debug` implementations.
121 /// Constructed by the `Formatter::debug_tuple` method.
123 #[stable(feature = "debug_builders", since = "1.2.0")]
124 pub struct DebugTuple<'a, 'b: 'a> {
125 fmt: &'a mut fmt::Formatter<'b>,
130 pub fn debug_tuple_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>, name: &str) -> DebugTuple<'a, 'b> {
131 let result = fmt.write_str(name);
139 impl<'a, 'b: 'a> DebugTuple<'a, 'b> {
140 /// Adds a new field to the generated tuple struct output.
141 #[stable(feature = "debug_builders", since = "1.2.0")]
142 pub fn field(&mut self, value: &fmt::Debug) -> &mut DebugTuple<'a, 'b> {
143 self.result = self.result.and_then(|_| {
144 let (prefix, space) = if self.has_fields {
150 if self.is_pretty() {
151 let mut writer = PadAdapter::new(self.fmt);
152 fmt::write(&mut writer, format_args!("{}\n{:#?}", prefix, value))
154 write!(self.fmt, "{}{}{:?}", prefix, space, value)
158 self.has_fields = true;
162 /// Finishes output and returns any error encountered.
163 #[stable(feature = "debug_builders", since = "1.2.0")]
164 pub fn finish(&mut self) -> fmt::Result {
166 self.result = self.result.and_then(|_| {
167 if self.is_pretty() {
168 self.fmt.write_str("\n)")
170 self.fmt.write_str(")")
177 fn is_pretty(&self) -> bool {
178 self.fmt.flags() & (1 << (FlagV1::Alternate as usize)) != 0
181 /// Returns the wrapped `Formatter`.
182 #[unstable(feature = "debug_builder_formatter", reason = "recently added",
184 pub fn formatter(&mut self) -> &mut fmt::Formatter<'b> {
189 struct DebugInner<'a, 'b: 'a> {
190 fmt: &'a mut fmt::Formatter<'b>,
195 impl<'a, 'b: 'a> DebugInner<'a, 'b> {
196 fn entry(&mut self, entry: &fmt::Debug) {
197 self.result = self.result.and_then(|_| {
198 if self.is_pretty() {
199 let mut writer = PadAdapter::new(self.fmt);
200 let prefix = if self.has_fields {
205 fmt::write(&mut writer, format_args!("{}\n{:#?}", prefix, entry))
207 let prefix = if self.has_fields {
212 write!(self.fmt, "{}{:?}", prefix, entry)
216 self.has_fields = true;
219 pub fn finish(&mut self) {
220 let prefix = if self.is_pretty() && self.has_fields {
225 self.result = self.result.and_then(|_| self.fmt.write_str(prefix));
228 fn is_pretty(&self) -> bool {
229 self.fmt.flags() & (1 << (FlagV1::Alternate as usize)) != 0
233 /// A struct to help with `fmt::Debug` implementations.
235 /// Constructed by the `Formatter::debug_set` method.
237 #[stable(feature = "debug_builders", since = "1.2.0")]
238 pub struct DebugSet<'a, 'b: 'a> {
239 inner: DebugInner<'a, 'b>,
242 pub fn debug_set_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>) -> DebugSet<'a, 'b> {
243 let result = write!(fmt, "{{");
253 impl<'a, 'b: 'a> DebugSet<'a, 'b> {
254 /// Adds a new entry to the set output.
255 #[stable(feature = "debug_builders", since = "1.2.0")]
256 pub fn entry(&mut self, entry: &fmt::Debug) -> &mut DebugSet<'a, 'b> {
257 self.inner.entry(entry);
261 /// Adds the contents of an iterator of entries to the set output.
262 #[stable(feature = "debug_builders", since = "1.2.0")]
263 pub fn entries<D, I>(&mut self, entries: I) -> &mut DebugSet<'a, 'b>
265 I: IntoIterator<Item = D>
267 for entry in entries {
273 /// Finishes output and returns any error encountered.
274 #[stable(feature = "debug_builders", since = "1.2.0")]
275 pub fn finish(&mut self) -> fmt::Result {
277 self.inner.result.and_then(|_| self.inner.fmt.write_str("}"))
281 /// A struct to help with `fmt::Debug` implementations.
283 /// Constructed by the `Formatter::debug_list` method.
285 #[stable(feature = "debug_builders", since = "1.2.0")]
286 pub struct DebugList<'a, 'b: 'a> {
287 inner: DebugInner<'a, 'b>,
290 pub fn debug_list_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>) -> DebugList<'a, 'b> {
291 let result = write!(fmt, "[");
301 impl<'a, 'b: 'a> DebugList<'a, 'b> {
302 /// Adds a new entry to the list output.
303 #[stable(feature = "debug_builders", since = "1.2.0")]
304 pub fn entry(&mut self, entry: &fmt::Debug) -> &mut DebugList<'a, 'b> {
305 self.inner.entry(entry);
309 /// Adds the contents of an iterator of entries to the list output.
310 #[stable(feature = "debug_builders", since = "1.2.0")]
311 pub fn entries<D, I>(&mut self, entries: I) -> &mut DebugList<'a, 'b>
313 I: IntoIterator<Item = D>
315 for entry in entries {
321 /// Finishes output and returns any error encountered.
322 #[stable(feature = "debug_builders", since = "1.2.0")]
323 pub fn finish(&mut self) -> fmt::Result {
325 self.inner.result.and_then(|_| self.inner.fmt.write_str("]"))
329 /// A struct to help with `fmt::Debug` implementations.
331 /// Constructed by the `Formatter::debug_map` method.
333 #[stable(feature = "debug_builders", since = "1.2.0")]
334 pub struct DebugMap<'a, 'b: 'a> {
335 fmt: &'a mut fmt::Formatter<'b>,
340 pub fn debug_map_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>) -> DebugMap<'a, 'b> {
341 let result = write!(fmt, "{{");
349 impl<'a, 'b: 'a> DebugMap<'a, 'b> {
350 /// Adds a new entry to the map output.
351 #[stable(feature = "debug_builders", since = "1.2.0")]
352 pub fn entry(&mut self, key: &fmt::Debug, value: &fmt::Debug) -> &mut DebugMap<'a, 'b> {
353 self.result = self.result.and_then(|_| {
354 if self.is_pretty() {
355 let mut writer = PadAdapter::new(self.fmt);
356 let prefix = if self.has_fields {
361 fmt::write(&mut writer,
362 format_args!("{}\n{:#?}: {:#?}", prefix, key, value))
364 let prefix = if self.has_fields {
369 write!(self.fmt, "{}{:?}: {:?}", prefix, key, value)
373 self.has_fields = true;
377 /// Adds the contents of an iterator of entries to the map output.
378 #[stable(feature = "debug_builders", since = "1.2.0")]
379 pub fn entries<K, V, I>(&mut self, entries: I) -> &mut DebugMap<'a, 'b>
382 I: IntoIterator<Item = (K, V)>
384 for (k, v) in entries {
390 /// Finishes output and returns any error encountered.
391 #[stable(feature = "debug_builders", since = "1.2.0")]
392 pub fn finish(&mut self) -> fmt::Result {
393 let prefix = if self.is_pretty() && self.has_fields {
398 self.result.and_then(|_| write!(self.fmt, "{}}}", prefix))
401 fn is_pretty(&self) -> bool {
402 self.fmt.flags() & (1 << (FlagV1::Alternate as usize)) != 0