Struct voladdress::VolBlock

#[repr(transparent)]
pub struct VolBlock<T, R, W, const C: usize> { /* private fields */ }

A volatile memory block.

This is intended to model when a portion of memory is an array of identical values in a row, such as a block of 256 u16 values in a row.

Generic Parameters

• T / R / W: These parameters are applied to the VolAddress type returned when accessing the block in any way (indexing, iteration, etc).
• C: the count of elements in the block.

Safety

• This type stores a base VolAddress internally, and so you must follow all of those safety rules. Notably, the base address must never be zero.
• The address space must legally contain C contiguous values of the T type, starting from the base address.
• The memory block must not wrap around past the end of the address space.

Implementations

impl<T, R, W, const C: usize> VolBlock<T, R, W, C>

pub const unsafe fn new(base: usize) -> Self

Constructs the value.

Safety

• As per the type docs.

pub const fn len(self) -> usize

The length of this block (in elements).

pub const fn as_usize(self) -> usize

Converts the VolBlock the usize for the start of the block.

pub const fn as_ptr(self) -> *const T

Converts the VolBlock into an individual const pointer.

This should usually only be used when you need to call a foreign function that expects a pointer.

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

Converts the VolBlock into an individual mut pointer.

This should usually only be used when you need to call a foreign function that expects a pointer.

pub fn as_slice_ptr(self) -> *const [T]

Converts the VolBlock into a const slice pointer.

This should usually only be used when you need to call a foreign function that expects a pointer.

pub fn as_slice_mut_ptr(self) -> *mut [T]

Converts the VolBlock into an individual mut pointer.

This should usually only be used when you need to call a foreign function that expects a pointer.

pub const fn index(self, i: usize) -> VolAddress<T, R, W>

Indexes to the ith position of the memory block.

Panics

• If the index is out of bounds this will panic.

pub const fn get(self, i: usize) -> Option<VolAddress<T, R, W>>

Gets the address of the ith position, if it’s in bounds.

pub const fn iter(self) -> VolBlockIter<T, R, W>

Creates an iterator over the addresses of the memory block.

pub fn iter_range<RB: RangeBounds<usize>>(self, r: RB) -> VolBlockIter<T, R, W>

Makes an iterator over the range bounds given.

If the range given is empty then your iterator will be empty.

Panics

• If the start or end of the range are out of bounds for the block.

pub const unsafe fn as_voladdress(self) -> VolAddress<[T; C], R, W>

Casts a block to an address to an equivalent sized array.

Safety

• As per the general VolAddress construction rules.
• It is highly likely that on any device this is safe, but because of possible strangeness with volatile side effects this is marked as an unsafe method.

Trait Implementations

impl<T, R, W, const C: usize> Clone for VolBlock<T, R, W, C>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, R, W, const C: usize> Debug for VolBlock<T, R, W, C>

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

Formats the value using the given formatter.

impl<T: Hash, R: Hash, W: Hash, const C: usize> Hash for VolBlock<T, R, W, C>

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<T: Ord, R: Ord, W: Ord, const C: usize> Ord for VolBlock<T, R, W, C>

fn cmp(&self, other: &VolBlock<T, R, W, C>) -> Ordering

This method returns an Ordering between self and other.

const fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

const fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

const fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: PartialOrd<Self>,

Restrict a value to a certain interval.

impl<T: PartialEq, R: PartialEq, W: PartialEq, const C: usize> PartialEq<VolBlock<T, R, W, C>> for VolBlock<T, R, W, C>

fn eq(&self, other: &VolBlock<T, R, W, C>) -> bool

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

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialOrd, R: PartialOrd, W: PartialOrd, const C: usize> PartialOrd<VolBlock<T, R, W, C>> for VolBlock<T, R, W, C>

fn partial_cmp(&self, other: &VolBlock<T, R, W, C>) -> Option<Ordering>

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

const fn lt(&self, other: &Rhs) -> bool

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

const fn le(&self, other: &Rhs) -> bool

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

const fn gt(&self, other: &Rhs) -> bool

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

const fn ge(&self, other: &Rhs) -> bool

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

impl<T, R, W, const C: usize> Pointer for VolBlock<T, R, W, C>

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

Formats the value using the given formatter.

impl<T, R, W, const C: usize> Copy for VolBlock<T, R, W, C>

impl<T: Eq, R: Eq, W: Eq, const C: usize> Eq for VolBlock<T, R, W, C>

impl<T, R, W, const C: usize> StructuralEq for VolBlock<T, R, W, C>

impl<T, R, W, const C: usize> StructuralPartialEq for VolBlock<T, R, W, C>