Struct 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.

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 PWrapper<&[&str]>

pub const fn const_eq(&self, other: &[&str]) -> bool

This method is only available with the “assert” feature.

impl PWrapper<&[bool]>

pub const fn const_eq(&self, other: &[bool]) -> bool

This method is only available with the “assert” feature.

impl PWrapper<&[char]>

pub const fn const_eq(&self, other: &[char]) -> bool

This method is only available with the “assert” feature.

impl PWrapper<&[u8]>

pub const fn const_eq(&self, other: &[u8]) -> bool

This method is only available with the “assert” feature.

impl PWrapper<&[i8]>

pub const fn const_eq(&self, other: &[i8]) -> bool

This method is only available with the “assert” feature.

impl PWrapper<&[u16]>

pub const fn const_eq(&self, other: &[u16]) -> bool

This method is only available with the “assert” feature.

impl PWrapper<&[i16]>

pub const fn const_eq(&self, other: &[i16]) -> bool

This method is only available with the “assert” feature.

impl PWrapper<&[u32]>

pub const fn const_eq(&self, other: &[u32]) -> bool

This method is only available with the “assert” feature.

impl PWrapper<&[i32]>

pub const fn const_eq(&self, other: &[i32]) -> bool

This method is only available with the “assert” feature.

impl PWrapper<&[u64]>

pub const fn const_eq(&self, other: &[u64]) -> bool

This method is only available with the “assert” feature.

impl PWrapper<&[i64]>

pub const fn const_eq(&self, other: &[i64]) -> bool

This method is only available with the “assert” feature.

impl PWrapper<&[u128]>

pub const fn const_eq(&self, other: &[u128]) -> bool

This method is only available with the “assert” feature.

impl PWrapper<&[i128]>

pub const fn const_eq(&self, other: &[i128]) -> bool

This method is only available with the “assert” feature.

impl PWrapper<&[usize]>

pub const fn const_eq(&self, other: &[usize]) -> bool

This method is only available with the “assert” feature.

impl PWrapper<&[isize]>

pub const fn const_eq(&self, other: &[isize]) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Option<u8>>

pub const fn const_eq(&self, other: &Option<u8>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Option<i8>>

pub const fn const_eq(&self, other: &Option<i8>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Option<u16>>

pub const fn const_eq(&self, other: &Option<u16>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Option<i16>>

pub const fn const_eq(&self, other: &Option<i16>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Option<u32>>

pub const fn const_eq(&self, other: &Option<u32>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Option<i32>>

pub const fn const_eq(&self, other: &Option<i32>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Option<u64>>

pub const fn const_eq(&self, other: &Option<u64>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Option<i64>>

pub const fn const_eq(&self, other: &Option<i64>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Option<u128>>

pub const fn const_eq(&self, other: &Option<u128>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Option<i128>>

pub const fn const_eq(&self, other: &Option<i128>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Option<usize>>

pub const fn const_eq(&self, other: &Option<usize>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Option<isize>>

pub const fn const_eq(&self, other: &Option<isize>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Option<bool>>

pub const fn const_eq(&self, other: &Option<bool>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Option<char>>

pub const fn const_eq(&self, other: &Option<char>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Option<&str>>

pub const fn const_eq(&self, other: &Option<&str>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<NonZeroU8>

pub const fn const_eq(&self, r: &NonZeroU8) -> bool

This method is only available with the “assert” feature.

impl PWrapper<NonZeroI8>

pub const fn const_eq(&self, r: &NonZeroI8) -> bool

This method is only available with the “assert” feature.

impl PWrapper<NonZeroU16>

pub const fn const_eq(&self, r: &NonZeroU16) -> bool

This method is only available with the “assert” feature.

impl PWrapper<NonZeroI16>

pub const fn const_eq(&self, r: &NonZeroI16) -> bool

This method is only available with the “assert” feature.

impl PWrapper<NonZeroU32>

pub const fn const_eq(&self, r: &NonZeroU32) -> bool

This method is only available with the “assert” feature.

impl PWrapper<NonZeroI32>

pub const fn const_eq(&self, r: &NonZeroI32) -> bool

This method is only available with the “assert” feature.

impl PWrapper<NonZeroU64>

pub const fn const_eq(&self, r: &NonZeroU64) -> bool

This method is only available with the “assert” feature.

impl PWrapper<NonZeroI64>

pub const fn const_eq(&self, r: &NonZeroI64) -> bool

This method is only available with the “assert” feature.

impl PWrapper<NonZeroU128>

pub const fn const_eq(&self, r: &NonZeroU128) -> bool

This method is only available with the “assert” feature.

impl PWrapper<NonZeroI128>

pub const fn const_eq(&self, r: &NonZeroI128) -> bool

This method is only available with the “assert” feature.

impl PWrapper<NonZeroUsize>

pub const fn const_eq(&self, r: &NonZeroUsize) -> bool

This method is only available with the “assert” feature.

impl PWrapper<NonZeroIsize>

pub const fn const_eq(&self, r: &NonZeroIsize) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Option<NonZeroU8>>

pub const fn const_eq(&self, other: &Option<NonZeroU8>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Option<NonZeroI8>>

pub const fn const_eq(&self, other: &Option<NonZeroI8>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Option<NonZeroU16>>

pub const fn const_eq(&self, other: &Option<NonZeroU16>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Option<NonZeroI16>>

pub const fn const_eq(&self, other: &Option<NonZeroI16>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Option<NonZeroU32>>

pub const fn const_eq(&self, other: &Option<NonZeroU32>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Option<NonZeroI32>>

pub const fn const_eq(&self, other: &Option<NonZeroI32>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Option<NonZeroU64>>

pub const fn const_eq(&self, other: &Option<NonZeroU64>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Option<NonZeroI64>>

pub const fn const_eq(&self, other: &Option<NonZeroI64>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Option<NonZeroU128>>

pub const fn const_eq(&self, other: &Option<NonZeroU128>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Option<NonZeroI128>>

pub const fn const_eq(&self, other: &Option<NonZeroI128>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Option<NonZeroUsize>>

pub const fn const_eq(&self, other: &Option<NonZeroUsize>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Option<NonZeroIsize>>

pub const fn const_eq(&self, other: &Option<NonZeroIsize>) -> bool

This method is only available with the “assert” feature.

impl<T: ?Sized> PWrapper<PhantomData<T>>

pub const fn const_eq(&self, r: &PhantomData<T>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<PhantomPinned>

pub const fn const_eq(&self, r: &PhantomPinned) -> bool

This method is only available with the “assert” feature.

impl PWrapper<()>

pub const fn const_eq(&self, r: &()) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Ordering>

pub const fn const_eq(&self, r: &Ordering) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Ordering>

pub const fn const_eq(&self, r: &AtomicOrdering) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Range<usize>>

pub const fn const_eq(&self, r: &Range<usize>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<RangeInclusive<usize>>

pub const fn const_eq(&self, r: &RangeInclusive<usize>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<RangeFrom<usize>>

pub const fn const_eq(&self, r: &RangeFrom<usize>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<RangeFull>

pub const fn const_eq(&self, r: &RangeFull) -> bool

This method is only available with the “assert” feature.

impl PWrapper<RangeTo<usize>>

pub const fn const_eq(&self, r: &RangeTo<usize>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<RangeToInclusive<usize>>

pub const fn const_eq(&self, r: &RangeToInclusive<usize>) -> bool

This method is only available with the “assert” feature.

impl PWrapper<Range<usize>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<RangeFrom<usize>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<RangeTo<usize>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<RangeToInclusive<usize>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<RangeInclusive<usize>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<RangeFull>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<&str>

pub const fn const_display_fmt( &self, f: &mut Formatter<'_>, ) -> Result<(), Error>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<bool>

pub const fn const_display_fmt( &self, f: &mut Formatter<'_>, ) -> Result<(), Error>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<char>

pub const fn const_display_fmt( &self, f: &mut Formatter<'_>, ) -> Result<(), Error>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<&[&str]>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<&[bool]>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<&[char]>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<&[u8]>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<&[i8]>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<&[u16]>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<&[i16]>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<&[u32]>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<&[i32]>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<&[u64]>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<&[i64]>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<&[u128]>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<&[i128]>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<&[usize]>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<&[isize]>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> PWrapper<Option<NonNull<T>>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<Option<NonZeroU8>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<Option<NonZeroI8>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<Option<NonZeroU16>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<Option<NonZeroI16>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<Option<NonZeroU32>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<Option<NonZeroI32>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<Option<NonZeroU64>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<Option<NonZeroI64>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<Option<NonZeroU128>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<Option<NonZeroI128>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<Option<NonZeroUsize>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<Option<NonZeroIsize>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<Option<u8>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<Option<i8>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<Option<u16>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<Option<i16>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<Option<u32>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<Option<i32>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<Option<u64>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<Option<i64>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<Option<u128>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<Option<i128>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<Option<usize>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<Option<isize>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<Option<bool>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<Option<char>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a> PWrapper<Option<&'a str>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<NonZeroU8>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

pub const fn const_display_fmt( &self, f: &mut Formatter<'_>, ) -> Result<(), Error>

impl PWrapper<NonZeroI8>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

pub const fn const_display_fmt( &self, f: &mut Formatter<'_>, ) -> Result<(), Error>

impl PWrapper<NonZeroU16>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

pub const fn const_display_fmt( &self, f: &mut Formatter<'_>, ) -> Result<(), Error>

impl PWrapper<NonZeroI16>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

pub const fn const_display_fmt( &self, f: &mut Formatter<'_>, ) -> Result<(), Error>

impl PWrapper<NonZeroU32>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

pub const fn const_display_fmt( &self, f: &mut Formatter<'_>, ) -> Result<(), Error>

impl PWrapper<NonZeroI32>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

pub const fn const_display_fmt( &self, f: &mut Formatter<'_>, ) -> Result<(), Error>

impl PWrapper<NonZeroU64>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

pub const fn const_display_fmt( &self, f: &mut Formatter<'_>, ) -> Result<(), Error>

impl PWrapper<NonZeroI64>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

pub const fn const_display_fmt( &self, f: &mut Formatter<'_>, ) -> Result<(), Error>

impl PWrapper<NonZeroU128>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

pub const fn const_display_fmt( &self, f: &mut Formatter<'_>, ) -> Result<(), Error>

impl PWrapper<NonZeroI128>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

pub const fn const_display_fmt( &self, f: &mut Formatter<'_>, ) -> Result<(), Error>

impl PWrapper<NonZeroUsize>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

pub const fn const_display_fmt( &self, f: &mut Formatter<'_>, ) -> Result<(), Error>

impl PWrapper<NonZeroIsize>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

pub const fn const_display_fmt( &self, f: &mut Formatter<'_>, ) -> Result<(), Error>

impl<T> PWrapper<*mut T>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> PWrapper<*const T>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T> PWrapper<NonNull<T>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl<T: ?Sized> PWrapper<PhantomData<T>>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<PhantomPinned>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<()>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<Ordering>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<Ordering>

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

impl PWrapper<u8>

pub const fn const_display_fmt( &self, f: &mut Formatter<'_>, ) -> Result<(), Error>

Writes a u8 with Display formatting.

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Writes a u8 with Debug formatting.

impl PWrapper<u16>

pub const fn const_display_fmt( &self, f: &mut Formatter<'_>, ) -> Result<(), Error>

Writes a u16 with Display formatting.

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Writes a u16 with Debug formatting.

impl PWrapper<u32>

pub const fn const_display_fmt( &self, f: &mut Formatter<'_>, ) -> Result<(), Error>

Writes a u32 with Display formatting.

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Writes a u32 with Debug formatting.

impl PWrapper<u64>

pub const fn const_display_fmt( &self, f: &mut Formatter<'_>, ) -> Result<(), Error>

Writes a u64 with Display formatting.

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Writes a u64 with Debug formatting.

impl PWrapper<u128>

pub const fn const_display_fmt( &self, f: &mut Formatter<'_>, ) -> Result<(), Error>

Writes a u128 with Display formatting.

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Writes a u128 with Debug formatting.

impl PWrapper<usize>

pub const fn const_display_fmt( &self, f: &mut Formatter<'_>, ) -> Result<(), Error>

Writes a usize with Display formatting.

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Writes a usize with Debug formatting.

impl PWrapper<i8>

pub const fn const_display_fmt( &self, f: &mut Formatter<'_>, ) -> Result<(), Error>

Writes a i8 with Display formatting.

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Writes a i8 with Debug formatting.

impl PWrapper<i16>

pub const fn const_display_fmt( &self, f: &mut Formatter<'_>, ) -> Result<(), Error>

Writes a i16 with Display formatting.

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Writes a i16 with Debug formatting.

impl PWrapper<i32>

pub const fn const_display_fmt( &self, f: &mut Formatter<'_>, ) -> Result<(), Error>

Writes a i32 with Display formatting.

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Writes a i32 with Debug formatting.

impl PWrapper<i64>

pub const fn const_display_fmt( &self, f: &mut Formatter<'_>, ) -> Result<(), Error>

Writes a i64 with Display formatting.

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Writes a i64 with Debug formatting.

impl PWrapper<i128>

pub const fn const_display_fmt( &self, f: &mut Formatter<'_>, ) -> Result<(), Error>

Writes a i128 with Display formatting.

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Writes a i128 with Debug formatting.

impl PWrapper<isize>

pub const fn const_display_fmt( &self, f: &mut Formatter<'_>, ) -> Result<(), Error>

Writes a isize with Display formatting.

pub const fn const_debug_fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Writes a isize with Debug formatting.

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

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

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

impl PWrapper<u8>

pub const fn const_eq(&self, r: &u8) -> bool

This method is only available with the “assert” feature.

impl PWrapper<i8>

pub const fn const_eq(&self, r: &i8) -> bool

This method is only available with the “assert” feature.

impl PWrapper<u16>

pub const fn const_eq(&self, r: &u16) -> bool

This method is only available with the “assert” feature.

impl PWrapper<i16>

pub const fn const_eq(&self, r: &i16) -> bool

This method is only available with the “assert” feature.

impl PWrapper<u32>

pub const fn const_eq(&self, r: &u32) -> bool

This method is only available with the “assert” feature.

impl PWrapper<i32>

pub const fn const_eq(&self, r: &i32) -> bool

This method is only available with the “assert” feature.

impl PWrapper<u64>

pub const fn const_eq(&self, r: &u64) -> bool

This method is only available with the “assert” feature.

impl PWrapper<i64>

pub const fn const_eq(&self, r: &i64) -> bool

This method is only available with the “assert” feature.

impl PWrapper<u128>

pub const fn const_eq(&self, r: &u128) -> bool

This method is only available with the “assert” feature.

impl PWrapper<i128>

pub const fn const_eq(&self, r: &i128) -> bool

This method is only available with the “assert” feature.

impl PWrapper<usize>

pub const fn const_eq(&self, r: &usize) -> bool

This method is only available with the “assert” feature.

impl PWrapper<isize>

pub const fn const_eq(&self, r: &isize) -> bool

This method is only available with the “assert” feature.

impl PWrapper<bool>

pub const fn const_eq(&self, r: &bool) -> bool

This method is only available with the “assert” feature.

impl PWrapper<char>

pub const fn const_eq(&self, r: &char) -> bool

This method is only available with the “assert” feature.

impl PWrapper<&str>

pub const fn const_eq(&self, r: &&str) -> bool

This method is only available with the “assert” feature.

Trait Implementations

impl<T: Clone> Clone for PWrapper<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P> FormatMarker for PWrapper<P>

type Kind = IsNotStdKind

What kind of type this is, this can be one of:

type This = PWrapper<P>

The type after dereferencing, implemented as type This = Self; for all non-reference types

impl<T: Copy> Copy for PWrapper<T>

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.