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.
11 use fmt::{self, FlagV1};
13 struct PadAdapter<'a, 'b: 'a> {
14 fmt: &'a mut fmt::Formatter<'b>,
18 impl<'a, 'b: 'a> PadAdapter<'a, 'b> {
19 fn new(fmt: &'a mut fmt::Formatter<'b>) -> PadAdapter<'a, 'b> {
27 impl<'a, 'b: 'a> fmt::Write for PadAdapter<'a, 'b> {
28 fn write_str(&mut self, mut s: &str) -> fmt::Result {
31 self.fmt.write_str(" ")?;
34 let split = match s.find('\n') {
36 self.on_newline = true;
40 self.on_newline = false;
44 self.fmt.write_str(&s[..split])?;
52 /// A struct to help with `fmt::Debug` implementations.
54 /// Constructed by the `Formatter::debug_struct` method.
56 #[allow(missing_debug_implementations)]
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 #[allow(missing_debug_implementations)]
124 #[stable(feature = "debug_builders", since = "1.2.0")]
125 pub struct DebugTuple<'a, 'b: 'a> {
126 fmt: &'a mut fmt::Formatter<'b>,
132 pub fn debug_tuple_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>, name: &str) -> DebugTuple<'a, 'b> {
133 let result = fmt.write_str(name);
138 empty_name: name.is_empty(),
142 impl<'a, 'b: 'a> DebugTuple<'a, 'b> {
143 /// Adds a new field to the generated tuple struct output.
144 #[stable(feature = "debug_builders", since = "1.2.0")]
145 pub fn field(&mut self, value: &fmt::Debug) -> &mut DebugTuple<'a, 'b> {
146 self.result = self.result.and_then(|_| {
147 let (prefix, space) = if self.fields > 0 {
153 if self.is_pretty() {
154 let mut writer = PadAdapter::new(self.fmt);
155 fmt::write(&mut writer, format_args!("{}\n{:#?}", prefix, value))
157 write!(self.fmt, "{}{}{:?}", prefix, space, value)
165 /// Finishes output and returns any error encountered.
166 #[stable(feature = "debug_builders", since = "1.2.0")]
167 pub fn finish(&mut self) -> fmt::Result {
169 self.result = self.result.and_then(|_| {
170 if self.is_pretty() {
171 self.fmt.write_str("\n")?;
173 if self.fields == 1 && self.empty_name {
174 self.fmt.write_str(",")?;
176 self.fmt.write_str(")")
182 fn is_pretty(&self) -> bool {
183 self.fmt.flags() & (1 << (FlagV1::Alternate as usize)) != 0
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 {
203 fmt::write(&mut writer, format_args!("{}\n{:#?}", prefix, entry))
205 let prefix = if self.has_fields {
210 write!(self.fmt, "{}{:?}", prefix, entry)
214 self.has_fields = true;
217 pub fn finish(&mut self) {
218 let prefix = if self.is_pretty() && self.has_fields {
223 self.result = self.result.and_then(|_| self.fmt.write_str(prefix));
226 fn is_pretty(&self) -> bool {
227 self.fmt.flags() & (1 << (FlagV1::Alternate as usize)) != 0
231 /// A struct to help with `fmt::Debug` implementations.
233 /// Constructed by the `Formatter::debug_set` method.
235 #[allow(missing_debug_implementations)]
236 #[stable(feature = "debug_builders", since = "1.2.0")]
237 pub struct DebugSet<'a, 'b: 'a> {
238 inner: DebugInner<'a, 'b>,
241 pub fn debug_set_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>) -> DebugSet<'a, 'b> {
242 let result = write!(fmt, "{{");
252 impl<'a, 'b: 'a> DebugSet<'a, 'b> {
253 /// Adds a new entry to the set output.
254 #[stable(feature = "debug_builders", since = "1.2.0")]
255 pub fn entry(&mut self, entry: &fmt::Debug) -> &mut DebugSet<'a, 'b> {
256 self.inner.entry(entry);
260 /// Adds the contents of an iterator of entries to the set output.
261 #[stable(feature = "debug_builders", since = "1.2.0")]
262 pub fn entries<D, I>(&mut self, entries: I) -> &mut DebugSet<'a, 'b>
264 I: IntoIterator<Item = D>
266 for entry in entries {
272 /// Finishes output and returns any error encountered.
273 #[stable(feature = "debug_builders", since = "1.2.0")]
274 pub fn finish(&mut self) -> fmt::Result {
276 self.inner.result.and_then(|_| self.inner.fmt.write_str("}"))
280 /// A struct to help with `fmt::Debug` implementations.
282 /// Constructed by the `Formatter::debug_list` method.
284 #[allow(missing_debug_implementations)]
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 #[allow(missing_debug_implementations)]
334 #[stable(feature = "debug_builders", since = "1.2.0")]
335 pub struct DebugMap<'a, 'b: 'a> {
336 fmt: &'a mut fmt::Formatter<'b>,
341 pub fn debug_map_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>) -> DebugMap<'a, 'b> {
342 let result = write!(fmt, "{{");
350 impl<'a, 'b: 'a> DebugMap<'a, 'b> {
351 /// Adds a new entry to the map output.
352 #[stable(feature = "debug_builders", since = "1.2.0")]
353 pub fn entry(&mut self, key: &fmt::Debug, value: &fmt::Debug) -> &mut DebugMap<'a, 'b> {
354 self.result = self.result.and_then(|_| {
355 if self.is_pretty() {
356 let mut writer = PadAdapter::new(self.fmt);
357 let prefix = if self.has_fields {
362 fmt::write(&mut writer,
363 format_args!("{}\n{:#?}: {:#?}", prefix, key, value))
365 let prefix = if self.has_fields {
370 write!(self.fmt, "{}{:?}: {:?}", prefix, key, value)
374 self.has_fields = true;
378 /// Adds the contents of an iterator of entries to the map output.
379 #[stable(feature = "debug_builders", since = "1.2.0")]
380 pub fn entries<K, V, I>(&mut self, entries: I) -> &mut DebugMap<'a, 'b>
383 I: IntoIterator<Item = (K, V)>
385 for (k, v) in entries {
391 /// Finishes output and returns any error encountered.
392 #[stable(feature = "debug_builders", since = "1.2.0")]
393 pub fn finish(&mut self) -> fmt::Result {
394 let prefix = if self.is_pretty() && self.has_fields {
399 self.result.and_then(|_| write!(self.fmt, "{}}}", prefix))
402 fn is_pretty(&self) -> bool {
403 self.fmt.flags() & (1 << (FlagV1::Alternate as usize)) != 0