| buf.rs |
A buffer for constructing a string while avoiding heap allocation. |
6187 |
| ext.rs |
Extension traits. |
1831 |
| lib.rs |
`powerfmt` is a library that provides utilities for formatting values. Specifically, it makes it
significantly easier to support filling to a minimum width with alignment, avoid heap
allocation, and avoid repetitive calculations. |
530 |
| smart_display.rs |
Definition of [`SmartDisplay`] and its related items.
[`SmartDisplay`] is a trait that allows authors to provide additional information to both the
formatter and other users. This information is provided in the form of a metadata type. The only
required piece of metadata is the width of the value. This is _before_ it is passed to the
formatter (i.e. it does not include any padding added by the formatter). Other information
can be stored in a custom metadata type as needed. This information may be made available to
downstream users, but it is not required.
This module contains the [`SmartDisplay`] and associated items.
# Example
```rust
use std::fmt;
use powerfmt::ext::FormatterExt as _;
use powerfmt::smart_display::{self, FormatterOptions, Metadata, SmartDisplay};
#[derive(Debug)]
struct User {
id: usize,
}
// If you try to use `UserMetadata` in the `SmartDisplay` implementation, you will get a
// compiler error about a private type being used publicly. To avoid this, use this attribute to
// declare a private metadata type. You shouldn't need to worry about how this works, but be
// aware that any public fields or methods remain usable by downstream users.
#[smart_display::private_metadata]
struct UserMetadata {
username: String,
legal_name: String,
}
// This attribute can be applied to `SmartDisplay` implementations. It will generate an
// implementation of `Display` that delegates to `SmartDisplay`, avoiding the need to write
// boilerplate.
#[smart_display::delegate]
impl SmartDisplay for User {
type Metadata = UserMetadata;
fn metadata(&self, _: FormatterOptions) -> Metadata<'_, Self> {
// This could be obtained from a database, for example.
let legal_name = "John Doe".to_owned();
let username = "jdoe".to_owned();
// Note that this must be kept in sync with the implementation of `fmt_with_metadata`.
let width = smart_display::padded_width_of!(username, " (", legal_name, ")",);
Metadata::new(
width,
self,
UserMetadata {
username,
legal_name,
},
)
}
// Use the now-generated metadata to format the value. Here we use the `pad_with_width`
// method to use the alignment and desired width from the formatter.
fn fmt_with_metadata(
&self,
f: &mut fmt::Formatter<'_>,
metadata: Metadata<Self>,
) -> fmt::Result {
f.pad_with_width(
metadata.unpadded_width(),
format_args!("{} ({})", metadata.username, metadata.legal_name),
)
}
}
let user = User { id: 42 };
assert_eq!(user.to_string(), "jdoe (John Doe)");
assert_eq!(format!("{user:>20}"), " jdoe (John Doe)");
``` |
24289 |
| smart_display_impls.rs |
Implementation of [`SmartDisplay`] for various types. |
7157 |