Struct VolatileRef 

pub struct VolatileRef<'a, T>
where
    T: 'a + DataInit,
{ /* private fields */ }

A memory location that supports volatile access of a T.

Examples

  let mut v = 5u32;
  assert_eq!(v, 5);
  let v_ref = unsafe { VolatileRef::new(&mut v as *mut u32) };
  assert_eq!(v_ref.load(), 5);
  v_ref.store(500);
  assert_eq!(v, 500);

Implementations

impl<'a, T: DataInit> VolatileRef<'a, T>

pub unsafe fn new(addr: *mut T) -> VolatileRef<'a, T>

Creates a reference to raw memory that must support volatile access of T sized chunks.

Safety

To use this safely, the caller must guarantee that the memory at addr is big enough for a T and is available for the duration of the lifetime of the new VolatileRef. The caller must also guarantee that all other users of the given chunk of memory are using volatile accesses.

pub fn as_mut_ptr(&self) -> *mut T

Gets the address of this slice’s memory.

pub fn size(&self) -> usize

Gets the size of this slice.

Examples

  let v_ref = unsafe { VolatileRef::new(0 as *mut u32) };
  assert_eq!(v_ref.size(), size_of::<u32>());

pub fn store(&self, v: T)

Does a volatile write of the value v to the address of this ref.

pub fn load(&self) -> T

Does a volatile read of the value at the address of this ref.

pub fn to_slice(&self) -> VolatileSlice<'a>

Converts this T reference to a raw slice with the same size and address.

Trait Implementations

impl<'a, T> Debug for VolatileRef<'a, T>

where T: 'a + Debug + DataInit,

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

Formats the value using the given formatter.