Struct BufMut 

pub struct BufMut<T: PackedElement, const DIM: usize>(/* private fields */);

A buffer of packed values that is statically the only reference to its storage, like a Vec: it is written without ever checking whether its storage is shared, it grows along one dimension, and it turns into a Buf to be shared, see Self::freeze. A Buf turns into one with copy-on-write, see Buf::make_mut and Buf::into_mut.

It cannot be sliced, which would share its storage, and cloning it copies its values into a storage of their own, like a Vec. An empty one may have no storage of its own, see Self::new, until it first grows.

Implementations

impl<T: PackedElement, const DIM: usize> BufMut<T, DIM>

pub fn zeroed(dim: [usize; DIM]) -> Self

A buffer of zeroes with those dimensions, held in place for a scalar.

Panics

If the dimensions are too large for a storage.

pub fn from_slice(values: &[T], dim: [usize; DIM]) -> Option<Self>

A buffer of these values, see Buf::from_slice.

pub fn dim(&self) -> [usize; DIM]

The dimensions of this buffer, see Buf::dim.

pub fn len(&self) -> usize

The number of values of this buffer, 1 for a scalar.

pub fn is_empty(&self) -> bool

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

Where the values of this buffer start.

pub fn as_slice(&self) -> &[T]

pub fn as_mut_slice(&mut self) -> &mut [T]

pub fn as_bytes(&self) -> &[u8]

pub fn freeze(self) -> Buf<T, DIM>

Share this buffer, which cannot be written anymore unless it is the only reference to its storage again, see Buf::try_into_mut.

impl<T: PackedElement> BufMut<T, 1>

pub const fn new() -> Self

An empty buffer, which allocates nothing until it grows, see Buf::new.

pub fn with_capacity(capacity: usize) -> Self

An empty buffer that can grow to at least that many values without reallocating.

pub fn capacity(&self) -> usize

How many values this buffer can hold without reallocating.

pub fn reserve(&mut self, additional: usize)

Make room for at least that many more values, growing the storage if it lacks room.

pub fn try_reserve(&mut self, additional: usize) -> Result<(), Error>

Self::reserve, failing rather than aborting when the allocation does, which leaves the buffer as it was: for a length that comes off the wire.

pub fn push(&mut self, value: T)

Append that value.

pub fn extend_from_slice(&mut self, values: &[T])

Append these values.

pub fn resize(&mut self, len: usize, value: T)

Grow or shrink to that many values, the added ones being that value.

Zeroes are only written up to the capacity this buffer had before growing: what a storage grows by is already zeroed.

pub fn truncate(&mut self, len: usize)

Keep only the first values, no more than that many.

pub fn clear(&mut self)

Empty this buffer, keeping its storage, and so its capacity, and freeing what the buffers cast from it had attached to it.

impl BufMut<u8, 1>

pub fn from_hex(s: &str) -> Option<Self>

Parse plain hexadecimal octets, in either case, which is what UpperHex and LowerHex give, absent if they are not.

pub fn set_len(&mut self, len: usize)

Grow or shrink to that many octets, the added ones being left as they are, which saves zeroing octets that are about to be written: they are zeroes, unless this buffer held something there before it was shrunk or cleared.

This is only for octets, every one of which is valid, unlike what was left there for other types.

Trait Implementations

impl<T: PackedElement, const DIM: usize> Clone for BufMut<T, DIM>

fn clone(&self) -> Self

A copy of the values of this buffer, in a storage of their own, the capacity past them not being kept.

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

Performs copy-assignment from source.

impl<T: PackedElement, const DIM: usize> Debug for BufMut<T, DIM>

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

Its dimensions and values, row by row, see Element::fmt_row.

impl<T: PackedElement> Default for BufMut<T, 1>

fn default() -> Self

Returns the “default value” for a type.

impl<T: PackedElement + Eq, const DIM: usize> Eq for BufMut<T, DIM>

impl<T: PackedElement> From<&[T]> for BufMut<T, 1>

fn from(values: &[T]) -> Self

Converts to this type from the input type.

impl<T: PackedElement, const DIM: usize> From<BufMut<T, DIM>> for Buf<T, DIM>

fn from(buf: BufMut<T, DIM>) -> Self

Converts to this type from the input type.

impl<T: PackedElement> From<Vec<T>> for BufMut<T, 1>

fn from(values: Vec<T>) -> Self

Converts to this type from the input type.

impl<T: PackedElement> LowerHex for BufMut<T, 1>

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

The octets of the values as hexadecimal, in the order they are stored, each value’s grouped and separated by a space, octets being a single run that BufMut::from_hex parses back.

impl<T: PackedElement + PartialEq, const DIM: usize> PartialEq for BufMut<T, DIM>

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

Equality operator ==.

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

Inequality operator !=.

impl<T: PackedElement> UpperHex for BufMut<T, 1>

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

The octets of the values as hexadecimal, in the order they are stored, each value’s grouped and separated by a space, octets being a single run that BufMut::from_hex parses back.