Struct shadow_rs::PWrapper

pub struct PWrapper<T>(pub T);

Wrapper for many std types, which implements the const_debug_fmt and/or const_display_fmt methods for them.

The macros from this crate automatically wraps std types in this type, so you only need to use it if you’re manually calling the const_*_fmt methods.

Constructors

Most std types can be wrapped in this type simply by doing PWrapper(value).

To wrap arrays, there is the PWrapper::slice constructor for convenience.

Excluded std types

Note that this type does not implement the formatting methods for std types which wrap non-std types, only for a selection of wrapped std types.

You can use the call_debug_fmt macro to format arrays/slices/Options of any type that can be const debug formatted.

Example

This example demonstrates how you can implement debug formatting for a type using PWrapper to write std types.

#![feature(const_mut_refs)]

use const_format::{Error, Formatter, PWrapper};
use const_format::{impl_fmt, formatc, try_};

use core::num::NonZeroU32;

pub struct Divide(pub u32, pub u32);

impl_fmt!{
    impl Divide;
     
    pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
        let Self(left, right) = *self;
        let divided = self.0 / self.1;

        let mut f = f.debug_struct("Divide");
        try_!(PWrapper(self.0).const_debug_fmt(f.field("numerator")));
        try_!(PWrapper(self.1).const_debug_fmt(f.field("denominator")));
        try_!(PWrapper(divided).const_debug_fmt(f.field("divided")));
        f.finish()
    }
}

const TEXT: &str = formatc!("{:?}", Divide(34, 11));
const T_HEX: &str = formatc!("{:X?}", Divide(34, 11));
const T_BIN: &str = formatc!("{:b?}", Divide(34, 11));

assert_eq!(TEXT, "Divide { numerator: 34, denominator: 11, divided: 3 }");
assert_eq!(T_HEX, "Divide { numerator: 22, denominator: B, divided: 3 }");
assert_eq!(T_BIN, "Divide { numerator: 100010, denominator: 1011, divided: 11 }");

Tuple Fields

0: T

Implementations

impl<'a, T> PWrapper<&'a [T]>

pub const fn slice(x: &'a [T]) -> PWrapper<&'a [T]>

For constructing from a reference to an array.

With slices you can do PWrapper(slice) as well.

impl PWrapper<i8>

pub const fn hexadecimal_len(self, fmt: FormattingFlags) -> usize

Computes how long much space is necessary to write this integer as a hexadecimal literal.

pub const fn binary_len(self, fmt: FormattingFlags) -> usize

Computes how long much space is necessary to write this integer as a binary literal.

impl PWrapper<i8>

pub const fn unsigned_abs(self) -> u8

Returns the absolute value of this integer, as the equivalent unsigned type.

impl PWrapper<i16>

pub const fn hexadecimal_len(self, fmt: FormattingFlags) -> usize

Computes how long much space is necessary to write this integer as a hexadecimal literal.

pub const fn binary_len(self, fmt: FormattingFlags) -> usize

Computes how long much space is necessary to write this integer as a binary literal.

impl PWrapper<i16>

pub const fn unsigned_abs(self) -> u16

Returns the absolute value of this integer, as the equivalent unsigned type.

impl PWrapper<i32>

pub const fn hexadecimal_len(self, fmt: FormattingFlags) -> usize

Computes how long much space is necessary to write this integer as a hexadecimal literal.

pub const fn binary_len(self, fmt: FormattingFlags) -> usize

Computes how long much space is necessary to write this integer as a binary literal.

impl PWrapper<i32>

pub const fn unsigned_abs(self) -> u32

Returns the absolute value of this integer, as the equivalent unsigned type.

impl PWrapper<i64>

pub const fn hexadecimal_len(self, fmt: FormattingFlags) -> usize

Computes how long much space is necessary to write this integer as a hexadecimal literal.

pub const fn binary_len(self, fmt: FormattingFlags) -> usize

Computes how long much space is necessary to write this integer as a binary literal.

impl PWrapper<i64>

pub const fn unsigned_abs(self) -> u64

Returns the absolute value of this integer, as the equivalent unsigned type.

impl PWrapper<i128>

pub const fn hexadecimal_len(self, fmt: FormattingFlags) -> usize

Computes how long much space is necessary to write this integer as a hexadecimal literal.

pub const fn binary_len(self, fmt: FormattingFlags) -> usize

Computes how long much space is necessary to write this integer as a binary literal.

impl PWrapper<i128>

pub const fn unsigned_abs(self) -> u128

Returns the absolute value of this integer, as the equivalent unsigned type.

impl PWrapper<u8>

pub const fn hexadecimal_len(self, fmt: FormattingFlags) -> usize

Computes how long much space is necessary to write this integer as a hexadecimal literal.

pub const fn binary_len(self, fmt: FormattingFlags) -> usize

Computes how long much space is necessary to write this integer as a binary literal.

impl PWrapper<u8>

pub const fn unsigned_abs(self) -> u8

Returns the absolute value of this integer, as the equivalent unsigned type.

impl PWrapper<u16>

pub const fn hexadecimal_len(self, fmt: FormattingFlags) -> usize

Computes how long much space is necessary to write this integer as a hexadecimal literal.

pub const fn binary_len(self, fmt: FormattingFlags) -> usize

Computes how long much space is necessary to write this integer as a binary literal.

impl PWrapper<u16>

pub const fn unsigned_abs(self) -> u16

Returns the absolute value of this integer, as the equivalent unsigned type.

impl PWrapper<u32>

pub const fn hexadecimal_len(self, fmt: FormattingFlags) -> usize

Computes how long much space is necessary to write this integer as a hexadecimal literal.

pub const fn binary_len(self, fmt: FormattingFlags) -> usize

Computes how long much space is necessary to write this integer as a binary literal.

impl PWrapper<u32>

pub const fn unsigned_abs(self) -> u32

Returns the absolute value of this integer, as the equivalent unsigned type.

impl PWrapper<u64>

pub const fn hexadecimal_len(self, fmt: FormattingFlags) -> usize

Computes how long much space is necessary to write this integer as a hexadecimal literal.

pub const fn binary_len(self, fmt: FormattingFlags) -> usize

Computes how long much space is necessary to write this integer as a binary literal.

impl PWrapper<u64>

pub const fn unsigned_abs(self) -> u64

Returns the absolute value of this integer, as the equivalent unsigned type.

impl PWrapper<u128>

pub const fn hexadecimal_len(self, fmt: FormattingFlags) -> usize

Computes how long much space is necessary to write this integer as a hexadecimal literal.

pub const fn binary_len(self, fmt: FormattingFlags) -> usize

Computes how long much space is necessary to write this integer as a binary literal.

impl PWrapper<u128>

pub const fn unsigned_abs(self) -> u128

Returns the absolute value of this integer, as the equivalent unsigned type.

impl PWrapper<usize>

pub const fn compute_display_len(self, fmt: FormattingFlags) -> usize

Computes how long much space is necessary to write this integer as a literal.

pub const fn compute_debug_len(self, fmt: FormattingFlags) -> usize

Computes how long much space is necessary to write this integer as a literal.

pub const fn hexadecimal_len(self, fmt: FormattingFlags) -> usize

Computes how long much space is necessary to write this integer as a hexadecimal literal.

pub const fn binary_len(self, fmt: FormattingFlags) -> usize

Computes how long much space is necessary to write this integer as a binary literal.

impl PWrapper<isize>

pub const fn compute_display_len(self, fmt: FormattingFlags) -> usize

Computes how long much space is necessary to write this integer as a literal.

pub const fn compute_debug_len(self, fmt: FormattingFlags) -> usize

Computes how long much space is necessary to write this integer as a literal.

pub const fn hexadecimal_len(self, fmt: FormattingFlags) -> usize

Computes how long much space is necessary to write this integer as a hexadecimal literal.

pub const fn binary_len(self, fmt: FormattingFlags) -> usize

Computes how long much space is necessary to write this integer as a binary literal.

impl PWrapper<usize>

pub const fn unsigned_abs(self) -> usize

Returns the absolute value of this integer.

impl PWrapper<isize>

pub const fn unsigned_abs(self) -> usize

Returns the absolute value of this integer, as the equivalent unsigned type.

impl PWrapper<&[u8]>

pub const fn compute_utf8_debug_len(self) -> usize

Computes how much space is necessary to write the wrapped &[u8] as a utf8 string, with debug formatting

pub const fn compute_utf8_debug_len_in_range(self, range: Range<usize>) -> usize

Computes how much space is necessary to write &self.0[range] as a utf8 string, with debug formatting

Trait Implementations

impl<T> Clone for PWrapper<T>

where T: Clone,

fn clone(&self) -> PWrapper<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Copy for PWrapper<T>

where T: Copy,