Struct accessor::single::Single

pub struct Single<T, M> where
    T: Copy,
    M: Mapper,  { /* fields omitted */ }

An accessor to read, modify, and write a single value of memory.

Examples

use accessor::mapper::Mapper;
use core::num::NonZeroUsize;

struct M;
impl Mapper for M {
    unsafe fn map(&mut self, phys_start: usize, bytes: usize) -> NonZeroUsize {
        unimplemented!()
    }

    fn unmap(&mut self, phys_start: usize, bytes: usize) {
        unimplemented!()
    }
}

let mapper = M;

// Create an accessor to the i32 value at the physical address 0x1000.
let mut a = unsafe { accessor::Single::<i32, M>::new(0x1000, mapper) };

// Read a value.
a.read();

// Write 42.
a.write(42);

// Update the value.
a.update(|v| {
    *v *= 2;
});

Implementations

impl<T, M> Single<T, M> where
    T: Copy,
    M: Mapper, 

pub unsafe fn new(phys_base: usize, mut mapper: M) -> Self

Creates a new accessor to an element of type T at the physical address phys_base.

Safety

The caller must ensure the following conditions:

• The value at the physical address phys_base is valid.
• Any other accessors except the one returned by this method must not access the value while the returned one lives.

Panics

This method panics if phys_base is not aligned as the type T requires.

pub unsafe fn try_new(phys_base: usize, mapper: M) -> Result<Self, Error>

Creates a new accessor to an element of type T at the physical address phys_base.

Safety

The caller must ensure the following conditions:

• The value at the physical address phys_base is valid.
• Any other accessors except the one returned by this method must not access the value while the returned one lives.

Errors

This method may return a Error::NotAligned error if phys_base is not aligned as the type T requires.

pub fn read(&self) -> T

Reads a value from the address that the accessor points to.

pub fn write(&mut self, v: T)

Writes a value to the address that the accessor points to.

pub fn update<U>(&mut self, f: U) where
    U: FnOnce(&mut T), 

Updates a value that the accessor points by reading it, modifying it, and writing it.

Note that some MMIO regions (e.g. the Command Ring Pointer field of the Command Ring Control Register of the xHCI) may return 0 regardless of the actual values of the fields. For these regions, this operation should be called only once.

Trait Implementations

impl<T, M> Debug for Single<T, M> where
    T: Copy + Debug,
    M: Mapper, 

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

Formats the value using the given formatter.

impl<T, M> Drop for Single<T, M> where
    T: Copy,
    M: Mapper, 

fn drop(&mut self)

Executes the destructor for this type.

impl<T, M> Eq for Single<T, M> where
    T: Copy + Eq,
    M: Mapper, 

impl<T, M> Hash for Single<T, M> where
    T: Copy + Hash,
    M: Mapper, 

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<T, M> Ord for Single<T, M> where
    T: Copy + Ord,
    M: Mapper, 

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<T, M> PartialEq<Single<T, M>> for Single<T, M> where
    T: Copy + PartialEq,
    M: Mapper, 

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T, M> PartialOrd<Single<T, M>> for Single<T, M> where
    T: Copy + PartialOrd,
    M: Mapper, 

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.