1.0.0[−][src]Trait nom::lib::std::fmt::Pointer

pub trait Pointer {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
}
[−]

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!("{:p}", x); // 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: {:p}", l);

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

Required methods

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>[−]

Formats the value using the given formatter.

Implementations on Foreign Types

impl<Ret, A, B, C, D, E, F> Pointer for extern "C" fn(A, B, C, D, E, F, ...) -> Ret[src][−]

impl<Ret, A, B, C, D, E> Pointer for fn(A, B, C, D, E) -> Ret[src][−]

impl<Ret, A, B, C, D> Pointer for extern "C" fn(A, B, C, D) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G, H> Pointer for extern "C" fn(A, B, C, D, E, F, G, H) -> Ret[src][−]

impl<Ret, A, B, C, D, E> Pointer for unsafe fn(A, B, C, D, E) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G> Pointer for unsafe fn(A, B, C, D, E, F, G) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G, H, I, J> Pointer for fn(A, B, C, D, E, F, G, H, I, J) -> Ret[src][−]

impl<'_, T> Pointer for &'_ mut T where
    T: ?Sized, [src][−]

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Pointer for fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret[src][−]

impl<Ret, A, B, C> Pointer for fn(A, B, C) -> Ret[src][−]

impl<T> Pointer for *const T where
    T: ?Sized, [src][−]

impl<Ret, A, B, C, D, E, F, G, H> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, ...) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G, H, I> Pointer for extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret[src][−]

impl<Ret, A> Pointer for unsafe extern "C" fn(A, ...) -> Ret[src][−]

impl<Ret, A, B, C> Pointer for unsafe fn(A, B, C) -> Ret[src][−]

impl<Ret, A> Pointer for fn(A) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F> Pointer for unsafe fn(A, B, C, D, E, F) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F> Pointer for unsafe extern "C" fn(A, B, C, D, E, F) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G, H> Pointer for fn(A, B, C, D, E, F, G, H) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G, H> Pointer for extern "C" fn(A, B, C, D, E, F, G, H, ...) -> Ret[src][−]

impl<Ret, A, B, C> Pointer for extern "C" fn(A, B, C) -> Ret[src][−]

impl<Ret> Pointer for unsafe fn() -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Pointer for unsafe fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Pointer for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Pointer for fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret[src][−]

impl<Ret, A, B> Pointer for fn(A, B) -> Ret[src][−]

impl<Ret, A, B> Pointer for unsafe extern "C" fn(A, B, ...) -> Ret[src][−]

impl<T> Pointer for NonNull<T> where
    T: ?Sized, [src][−]

impl<Ret, A, B> Pointer for extern "C" fn(A, B, ...) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Pointer for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret[src][−]

impl<Ret, A, B, C, D, E> Pointer for extern "C" fn(A, B, C, D, E, ...) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G, H, I> Pointer for extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Pointer for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret[src][−]

impl<Ret, A, B, C, D> Pointer for unsafe fn(A, B, C, D) -> Ret[src][−]

impl<T> Pointer for AtomicPtr<T>[src][−]

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Pointer for unsafe fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Pointer for extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G, H, I> Pointer for fn(A, B, C, D, E, F, G, H, I) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G, H, I, J> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G, H> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H) -> Ret[src][−]

impl<Ret, A, B, C, D> Pointer for unsafe extern "C" fn(A, B, C, D) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F> Pointer for fn(A, B, C, D, E, F) -> Ret[src][−]

impl<T> Pointer for *mut T where
    T: ?Sized, [src][−]

impl<Ret> Pointer for unsafe extern "C" fn() -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G> Pointer for extern "C" fn(A, B, C, D, E, F, G) -> Ret[src][−]

impl<Ret, A, B, C, D> Pointer for fn(A, B, C, D) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G, H, I, J> Pointer for unsafe fn(A, B, C, D, E, F, G, H, I, J) -> Ret[src][−]

impl<Ret, A, B> Pointer for unsafe extern "C" fn(A, B) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K) -> Ret[src][−]

impl<'_, T> Pointer for &'_ T where
    T: ?Sized, [src][−]

impl<Ret, A, B> Pointer for unsafe fn(A, B) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G, H, I> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L) -> Ret[src][−]

impl<Ret, A, B, C> Pointer for unsafe extern "C" fn(A, B, C, ...) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G> Pointer for extern "C" fn(A, B, C, D, E, F, G, ...) -> Ret[src][−]

impl<Ret, A, B, C, D> Pointer for unsafe extern "C" fn(A, B, C, D, ...) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G, H, I, J, K> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, ...) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G) -> Ret[src][−]

impl<Ret, A, B, C> Pointer for extern "C" fn(A, B, C, ...) -> Ret[src][−]

impl<Ret, A, B, C> Pointer for unsafe extern "C" fn(A, B, C) -> Ret[src][−]

impl<Ret, A, B, C, D, E> Pointer for extern "C" fn(A, B, C, D, E) -> Ret[src][−]

impl<Ret, A> Pointer for extern "C" fn(A) -> Ret[src][−]

impl<Ret, A> Pointer for unsafe extern "C" fn(A) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G, H, I> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, ...) -> Ret[src][−]

impl<Ret, A, B> Pointer for extern "C" fn(A, B) -> Ret[src][−]

impl<Ret, A, B, C, D, E> Pointer for unsafe extern "C" fn(A, B, C, D, E, ...) -> Ret[src][−]

impl<P> Pointer for Pin<P> where
    P: Pointer, [src][−]

impl<Ret, A, B, C, D> Pointer for extern "C" fn(A, B, C, D, ...) -> Ret[src][−]

impl<Ret> Pointer for fn() -> Ret[src][−]

impl<Ret> Pointer for extern "C" fn() -> Ret[src][−]

impl<Ret, A> Pointer for unsafe fn(A) -> Ret[src][−]

impl<Ret, A> Pointer for extern "C" fn(A, ...) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G, H, I, J> Pointer for extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F> Pointer for extern "C" fn(A, B, C, D, E, F) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G, H> Pointer for unsafe fn(A, B, C, D, E, F, G, H) -> Ret[src][−]

impl<Ret, A, B, C, D, E> Pointer for unsafe extern "C" fn(A, B, C, D, E) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G, H, I> Pointer for unsafe fn(A, B, C, D, E, F, G, H, I) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G, H, I, J> Pointer for extern "C" fn(A, B, C, D, E, F, G, H, I, J) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G, H, I, J, K, L> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, K, L, ...) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G> Pointer for fn(A, B, C, D, E, F, G) -> Ret[src][−]

impl<Ret, A, B, C, D, E, F, G, H, I, J> Pointer for unsafe extern "C" fn(A, B, C, D, E, F, G, H, I, J, ...) -> Ret[src][−]

impl<T> Pointer for Arc<T> where
    T: ?Sized, [src][−]

impl<T> Pointer for Rc<T> where
    T: ?Sized, [src][−]

Implementors

impl<T> Pointer for Box<T> where
    T: ?Sized, [src][+]

impl Pointer for Instance

impl Pointer for PhysicalDevice

impl Pointer for Device

impl Pointer for Queue

impl Pointer for CommandBuffer

impl Pointer for DeviceMemory

impl Pointer for CommandPool

impl Pointer for Buffer

impl Pointer for BufferView

impl Pointer for Image

impl Pointer for ImageView

impl Pointer for ShaderModule

impl Pointer for Pipeline

impl Pointer for PipelineLayout

impl Pointer for Sampler

impl Pointer for DescriptorSet

impl Pointer for DescriptorSetLayout

impl Pointer for DescriptorPool

impl Pointer for Fence

impl Pointer for Semaphore

impl Pointer for Event

impl Pointer for QueryPool

impl Pointer for Framebuffer

impl Pointer for RenderPass

impl Pointer for PipelineCache

impl Pointer for IndirectCommandsLayoutNV

impl Pointer for DescriptorUpdateTemplate

impl Pointer for SamplerYcbcrConversion

impl Pointer for ValidationCacheEXT

impl Pointer for AccelerationStructureKHR

impl Pointer for PerformanceConfigurationINTEL

impl Pointer for DeferredOperationKHR

impl Pointer for DisplayKHR

impl Pointer for DisplayModeKHR

impl Pointer for SurfaceKHR

impl Pointer for SwapchainKHR

impl Pointer for DebugReportCallbackEXT

impl Pointer for DebugUtilsMessengerEXT

impl Pointer for GpaSessionAmd

impl<T> Pointer for Atomic<T>

impl<'g, T> Pointer for Shared<'g, T>