Struct esp_idf_hal::sys::const_format::PWrapper

source ·
pub struct PWrapper<T>(pub T);
Expand description

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§

source§

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

source

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.

source§

impl PWrapper<i8>

source

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

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

source

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

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

source§

impl PWrapper<i8>

source

pub const fn unsigned_abs(self) -> u8

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

source§

impl PWrapper<i16>

source

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

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

source

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

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

source§

impl PWrapper<i16>

source

pub const fn unsigned_abs(self) -> u16

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

source§

impl PWrapper<i32>

source

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

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

source

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

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

source§

impl PWrapper<i32>

source

pub const fn unsigned_abs(self) -> u32

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

source§

impl PWrapper<i64>

source

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

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

source

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

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

source§

impl PWrapper<i64>

source

pub const fn unsigned_abs(self) -> u64

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

source§

impl PWrapper<i128>

source

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

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

source

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

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

source§

impl PWrapper<i128>

source

pub const fn unsigned_abs(self) -> u128

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

source§

impl PWrapper<u8>

source

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

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

source

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

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

source§

impl PWrapper<u8>

source

pub const fn unsigned_abs(self) -> u8

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

source§

impl PWrapper<u16>

source

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

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

source

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

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

source§

impl PWrapper<u16>

source

pub const fn unsigned_abs(self) -> u16

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

source§

impl PWrapper<u32>

source

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

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

source

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

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

source§

impl PWrapper<u32>

source

pub const fn unsigned_abs(self) -> u32

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

source§

impl PWrapper<u64>

source

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

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

source

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

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

source§

impl PWrapper<u64>

source

pub const fn unsigned_abs(self) -> u64

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

source§

impl PWrapper<u128>

source

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

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

source

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

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

source§

impl PWrapper<u128>

source

pub const fn unsigned_abs(self) -> u128

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

source§

impl PWrapper<usize>

source

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

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

source

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

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

source

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

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

source

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

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

source§

impl PWrapper<isize>

source

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

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

source

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

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

source

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

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

source

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

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

source§

impl PWrapper<usize>

source

pub const fn unsigned_abs(self) -> usize

Returns the absolute value of this integer.

source§

impl PWrapper<isize>

source

pub const fn unsigned_abs(self) -> usize

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

source§

impl PWrapper<&[u8]>

source

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

source

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§

source§

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

source§

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

Returns a copy of the value. Read more
1.0.0§

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

Performs copy-assignment from source. Read more
source§

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

Auto Trait Implementations§

§

impl<T> Freeze for PWrapper<T>
where T: Freeze,

§

impl<T> RefUnwindSafe for PWrapper<T>
where T: RefUnwindSafe,

§

impl<T> Send for PWrapper<T>
where T: Send,

§

impl<T> Sync for PWrapper<T>
where T: Sync,

§

impl<T> Unpin for PWrapper<T>
where T: Unpin,

§

impl<T> UnwindSafe for PWrapper<T>
where T: UnwindSafe,

Blanket Implementations§

§

impl<T> Any for T
where T: 'static + ?Sized,

§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
§

impl<T> Borrow<T> for T
where T: ?Sized,

§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
§

impl<T> BorrowMut<T> for T
where T: ?Sized,

§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> CloneToUninit for T
where T: Clone,

§

default unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§

impl<T> CloneToUninit for T
where T: Copy,

§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
§

impl<T> From<T> for T

§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T, U> Into<U> for T
where U: From<T>,

§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.