Trait sp_std::fmt::Pointer

1.0.0 · source ·
pub trait Pointer {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
}
Expand description

p formatting.

The Pointer trait should format its output as a memory location. This is commonly presented as hexadecimal.

For more information on formatters, see the module-level documentation.

Examples

Basic usage with &i32:

let x = &42;

let address = format!("{x:p}"); // this produces something like '0x7f06092ac6d0'

Implementing Pointer on a type:

use std::fmt;

struct Length(i32);

impl fmt::Pointer for Length {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        // use `as` to convert to a `*const T`, which implements Pointer, which we can use

        let ptr = self as *const Self;
        fmt::Pointer::fmt(&ptr, f)
    }
}

let l = Length(42);

println!("l is in memory here: {l:p}");

let l_ptr = format!("{l:018p}");
assert_eq!(l_ptr.len(), 18);
assert_eq!(&l_ptr[..2], "0x");

Required Methods§

Formats the value using the given formatter.

Implementors§

This trait is implemented for function pointers with up to twelve arguments.

This trait is implemented for function pointers with up to twelve arguments.

This trait is implemented for function pointers with up to twelve arguments.

This trait is implemented for function pointers with up to twelve arguments.

This trait is implemented for function pointers with up to twelve arguments.

This trait is implemented for function pointers with up to twelve arguments.

This trait is implemented for function pointers with up to twelve arguments.

This trait is implemented for function pointers with up to twelve arguments.

This trait is implemented for function pointers with up to twelve arguments.

This trait is implemented for function pointers with up to twelve arguments.

impl<T, O> Pointer for BitBox<T, O>where
    O: BitOrder,
    T: BitStore,

impl<M, T, O> Pointer for BitRef<'_, M, T, O>where
    M: Mutability,
    T: BitStore,
    O: BitOrder,

impl<M, T, O> Pointer for BitPtr<M, T, O>where
    M: Mutability,
    T: BitStore,
    O: BitOrder,

impl<T, O> Pointer for BitSlice<T, O>where
    T: BitStore,
    O: BitOrder,

impl<T, O> Pointer for BitVec<T, O>where
    O: BitOrder,
    T: BitStore,

impl<T: ?Sized + Pointable> Pointer for Atomic<T>

impl<T: ?Sized + Pointable> Pointer for Shared<'_, T>

impl<'a, T: Pointer> Pointer for StyledValue<'a, T>

impl<'a, I> Pointer for Format<'a, I>where
    I: Iterator,
    I::Item: Pointer,

impl<T, R: Dim, C: Dim, S> Pointer for Matrix<T, R, C, S>where
    T: Scalar + Pointer,
    S: Storage<T, R, C>,
    DefaultAllocator: Allocator<usize, R, C>,

impl<A: Array> Pointer for ArrayVec<A>where
    A::Item: Pointer,

impl<'s, T> Pointer for SliceVec<'s, T>where
    T: Pointer,

impl<A: Array> Pointer for TinyVec<A>where
    A::Item: Pointer,

impl<M, T> Pointer for Address<M, T>where
    M: Mutability,
    T: ?Sized,

impl<T: Binary + Pointer> Pointer for FmtBinary<T>

impl<T: Display + Pointer> Pointer for FmtDisplay<T>

impl<T: LowerExp + Pointer> Pointer for FmtLowerExp<T>

impl<T: LowerHex + Pointer> Pointer for FmtLowerHex<T>

impl<T: Octal + Pointer> Pointer for FmtOctal<T>

impl<T: Pointer> Pointer for FmtPointer<T>

impl<T: UpperExp + Pointer> Pointer for FmtUpperExp<T>

impl<T: UpperHex + Pointer> Pointer for FmtUpperHex<T>