Struct narrow::Buffer

pub struct Buffer<T, const A: usize> where
    T: Primitive,  { /* fields omitted */ }

A contiguous immutable memory buffer for data.

Generic over the element type T stored in this buffer and the alignment A of the buffer.

• T must implement Copy. The elements of the buffer can’t have destructors.
• A is the exponent of a power-of-two alignment.

An important invariant of a Buffer is its memory Layout.

• The layout’s size is always the length (invariant because buffer is immutable) multiplied with the element size.
• The layout’s alignment is A.
• The layout is based on the size and alignment as described above, with trailing padding to round up to the alignment. Because of this invariant this struct stores just a ptr and a length, and can be used as a slice via a Deref implementation.

This is currently implemented using low-level unsafe code. When the Allocator trait is stabilized a wrapper around a Vec with a custom allocator implementation (for the alignment and padding requirements) can replace most of the code here.

Trait Implementations

impl<T, const A: usize> ArrayData for Buffer<T, A> where
    T: Primitive, 

fn len(&self) -> usize

Returns the number of elements.

fn is_null(&self, index: usize) -> bool

Returns true if the element at position index is null.

fn null_count(&self) -> usize

Returns the number of null elements.

fn is_valid(&self, index: usize) -> bool

fn valid_count(&self) -> usize

Returns the number of valid elements.

fn is_empty(&self) -> bool

Returns true if the number of elements is 0.

impl<T, const A: usize> AsRef<[u8]> for Buffer<T, A> where
    T: Primitive, 

fn as_ref(&self) -> &[u8]

Performs the conversion.

impl<T, const A: usize> AsRef<Buffer<T, A>> for Buffer<T, A> where
    T: Primitive, 

fn as_ref(&self) -> &Buffer<T, A>

Performs the conversion.

impl<T, const A: usize> Borrow<[T]> for Buffer<T, A> where
    T: Primitive, 

fn borrow(&self) -> &[T]

Immutably borrows from an owned value.

impl<T, const A: usize> Clone for Buffer<T, A> where
    T: Primitive, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, const A: usize> Debug for Buffer<T, A> where
    T: Primitive + Debug, 

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

Formats the value using the given formatter.

impl<T, const A: usize> Default for Buffer<T, A> where
    T: Primitive, 

fn default() -> Self

Returns the “default value” for a type.

impl<T, const A: usize> Deref for Buffer<T, A> where
    T: Primitive, 

type Target = [T]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, const A: usize> Drop for Buffer<T, A> where
    T: Primitive, 

fn drop(&mut self)

Executes the destructor for this type.

impl<T, const A: usize> FromIterator<T> for Buffer<T, A> where
    T: Primitive, 

fn from_iter<I>(iter: I) -> Self where
    I: IntoIterator<Item = T>, 

Creates a value from an iterator.

impl<'a, T, const A: usize> IntoIterator for &'a Buffer<T, A> where
    T: Primitive, 

type Item = T

The type of the elements being iterated over.

type IntoIter = Copied<Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, const A: usize> PartialEq<Buffer<T, A>> for Buffer<T, A> where
    T: Primitive,
    for<'a> &'a [T]: PartialEq, 

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

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

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

This method tests for !=.

impl<T, const A: usize> Eq for Buffer<T, A> where
    T: Primitive,
    for<'a> &'a [T]: PartialEq, 

impl<T, const A: usize> Send for Buffer<T, A> where
    T: Primitive, 

Buffer is Send because the buffer is immutable.

impl<T, const A: usize> Sync for Buffer<T, A> where
    T: Primitive, 

Buffer is Sync because the buffer is immutable.