Struct zerovec::flexzerovec::slice::FlexZeroSlice

#[repr(packed)]
pub struct FlexZeroSlice {
    width: u8,
    data: [u8],
}

A zero-copy “slice” that efficiently represents [usize].

Fields

width: u8

data: [u8]

Implementations

impl FlexZeroSlice

pub const fn new_empty() -> &'static Self

Constructs a new empty FlexZeroSlice.

use zerovec::vecs::FlexZeroSlice;

const EMPTY_SLICE: &FlexZeroSlice = FlexZeroSlice::new_empty();

assert!(EMPTY_SLICE.is_empty());
assert_eq!(EMPTY_SLICE.len(), 0);
assert_eq!(EMPTY_SLICE.first(), None);

pub const fn parse_byte_slice(bytes: &[u8]) -> Result<&Self, ZeroVecError>

Safely constructs a FlexZeroSlice from a byte array.

Examples

use zerovec::vecs::FlexZeroSlice;

const FZS: &FlexZeroSlice = match FlexZeroSlice::parse_byte_slice(&[
    2, // width
    0x42, 0x00, // first value
    0x07, 0x09, // second value
    0xFF, 0xFF, // third value
]) {
    Ok(v) => v,
    Err(_) => panic!("invalid bytes"),
};

assert!(!FZS.is_empty());
assert_eq!(FZS.len(), 3);
assert_eq!(FZS.first(), Some(0x0042));
assert_eq!(FZS.get(0), Some(0x0042));
assert_eq!(FZS.get(1), Some(0x0907));
assert_eq!(FZS.get(2), Some(0xFFFF));
assert_eq!(FZS.get(3), None);
assert_eq!(FZS.last(), Some(0xFFFF));

pub const unsafe fn from_byte_slice_unchecked(bytes: &[u8]) -> &Self

Constructs a FlexZeroSlice without checking invariants.

Panics

Panics if bytes is empty.

Safety

Must be called on a valid FlexZeroSlice byte array.

pub(crate) unsafe fn from_byte_slice_mut_unchecked( bytes: &mut [u8] ) -> &mut Self

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

Returns this slice as its underlying &[u8] byte buffer representation.

Useful for serialization.

Example

use zerovec::vecs::FlexZeroSlice;

let bytes: &[u8] = &[2, 0xD3, 0x00, 0x19, 0x01, 0xA5, 0x01, 0xCD, 0x80];
let fzv = FlexZeroSlice::parse_byte_slice(bytes).expect("valid bytes");

assert_eq!(bytes, fzv.as_bytes());

pub const fn as_flexzerovec(&self) -> FlexZeroVec<'_>

Borrows this FlexZeroSlice as a FlexZeroVec::Borrowed.

pub fn len(&self) -> usize

Returns the number of elements in the FlexZeroSlice.

pub(crate) fn get_width(&self) -> usize

pub fn is_empty(&self) -> bool

Returns whether there are zero elements in the FlexZeroSlice.

pub fn get(&self, index: usize) -> Option<usize>

Gets the element at index, or None if index >= self.len().

Examples

use zerovec::vecs::FlexZeroVec;

let fzv: FlexZeroVec = [22, 33].iter().copied().collect();
assert_eq!(fzv.get(0), Some(22));
assert_eq!(fzv.get(1), Some(33));
assert_eq!(fzv.get(2), None);

pub(crate) fn get_chunk(&self, index: usize) -> Option<&[u8]>

Gets the element at index as a chunk of bytes, or None if index >= self.len().

pub unsafe fn get_unchecked(&self, index: usize) -> usize

Gets the element at index without checking bounds.

Safety

index must be in-range.

pub fn first(&self) -> Option<usize>

Gets the first element of the slice, or None if the slice is empty.

pub fn last(&self) -> Option<usize>

Gets the last element of the slice, or None if the slice is empty.

pub fn iter( &self ) -> impl DoubleEndedIterator<Item = usize> + '_ + ExactSizeIterator<Item = usize>

Gets an iterator over the elements of the slice as usize.

pub fn iter_pairs(&self) -> impl Iterator<Item = (usize, Option<usize>)> + '_

Gets an iterator over pairs of elements.

The second element of the final pair is None.

Examples

use zerovec::vecs::FlexZeroVec;

let nums: &[usize] = &[211, 281, 421, 461];
let fzv: FlexZeroVec = nums.iter().copied().collect();

let mut pairs_it = fzv.iter_pairs();

assert_eq!(pairs_it.next(), Some((211, Some(281))));
assert_eq!(pairs_it.next(), Some((281, Some(421))));
assert_eq!(pairs_it.next(), Some((421, Some(461))));
assert_eq!(pairs_it.next(), Some((461, None)));
assert_eq!(pairs_it.next(), None);

pub fn to_vec(&self) -> Vec<usize>

Creates a Vec<usize> from a FlexZeroSlice (or FlexZeroVec).

Examples

use zerovec::vecs::FlexZeroVec;

let nums: &[usize] = &[211, 281, 421, 461];
let fzv: FlexZeroVec = nums.iter().copied().collect();
let vec: Vec<usize> = fzv.to_vec();

assert_eq!(nums, vec.as_slice());

pub fn binary_search(&self, needle: usize) -> Result<usize, usize>

Binary searches a sorted FlexZeroSlice for the given usize value.

Examples

use zerovec::vecs::FlexZeroVec;

let nums: &[usize] = &[211, 281, 421, 461];
let fzv: FlexZeroVec = nums.iter().copied().collect();

assert_eq!(fzv.binary_search(0), Err(0));
assert_eq!(fzv.binary_search(211), Ok(0));
assert_eq!(fzv.binary_search(250), Err(1));
assert_eq!(fzv.binary_search(281), Ok(1));
assert_eq!(fzv.binary_search(300), Err(2));
assert_eq!(fzv.binary_search(421), Ok(2));
assert_eq!(fzv.binary_search(450), Err(3));
assert_eq!(fzv.binary_search(461), Ok(3));
assert_eq!(fzv.binary_search(462), Err(4));

pub fn binary_search_in_range( &self, needle: usize, range: Range<usize> ) -> Option<Result<usize, usize>>

Binary searches a sorted range of a FlexZeroSlice for the given usize value.

The indices in the return value are relative to the start of the range.

Examples

use zerovec::vecs::FlexZeroVec;

// Make a FlexZeroVec with two sorted ranges: 0..3 and 3..5
let nums: &[usize] = &[111, 222, 444, 333, 555];
let fzv: FlexZeroVec = nums.iter().copied().collect();

// Search in the first range:
assert_eq!(fzv.binary_search_in_range(0, 0..3), Some(Err(0)));
assert_eq!(fzv.binary_search_in_range(111, 0..3), Some(Ok(0)));
assert_eq!(fzv.binary_search_in_range(199, 0..3), Some(Err(1)));
assert_eq!(fzv.binary_search_in_range(222, 0..3), Some(Ok(1)));
assert_eq!(fzv.binary_search_in_range(399, 0..3), Some(Err(2)));
assert_eq!(fzv.binary_search_in_range(444, 0..3), Some(Ok(2)));
assert_eq!(fzv.binary_search_in_range(999, 0..3), Some(Err(3)));

// Search in the second range:
assert_eq!(fzv.binary_search_in_range(0, 3..5), Some(Err(0)));
assert_eq!(fzv.binary_search_in_range(333, 3..5), Some(Ok(0)));
assert_eq!(fzv.binary_search_in_range(399, 3..5), Some(Err(1)));
assert_eq!(fzv.binary_search_in_range(555, 3..5), Some(Ok(1)));
assert_eq!(fzv.binary_search_in_range(999, 3..5), Some(Err(2)));

// Out-of-bounds range:
assert_eq!(fzv.binary_search_in_range(0, 4..6), None);

pub fn binary_search_by( &self, predicate: impl FnMut(usize) -> Ordering ) -> Result<usize, usize>

Binary searches a sorted FlexZeroSlice according to a predicate function.

pub fn binary_search_in_range_by( &self, predicate: impl FnMut(usize) -> Ordering, range: Range<usize> ) -> Option<Result<usize, usize>>

Binary searches a sorted range of a FlexZeroSlice according to a predicate function.

The indices in the return value are relative to the start of the range.

pub fn binary_search_with_index( &self, predicate: impl FnMut(usize) -> Ordering ) -> Result<usize, usize>

Binary searches a FlexZeroSlice by its indices.

The predicate function is passed in-bounds indices into the FlexZeroSlice.

pub fn binary_search_in_range_with_index( &self, predicate: impl FnMut(usize) -> Ordering, range: Range<usize> ) -> Option<Result<usize, usize>>

Binary searches a range of a FlexZeroSlice by its indices.

The predicate function is passed in-bounds indices into the FlexZeroSlice, which are relative to the start of the entire slice.

The indices in the return value are relative to the start of the range.

fn binary_search_impl( &self, predicate: impl FnMut(usize) -> Ordering, scaled_slice: &[u8] ) -> Result<usize, usize>

Safety

scaled_slice must be a subslice of self.data

fn binary_search_with_index_impl( &self, predicate: impl FnMut(usize) -> Ordering, scaled_slice: &[u8] ) -> Result<usize, usize>

predicate is passed a valid index as an argument.

Safety

scaled_slice must be a subslice of self.data

impl FlexZeroSlice

pub(crate) fn get_insert_info(&self, new_item: usize) -> InsertInfo

Compute the InsertInfo for inserting the specified item anywhere into the vector.

Panics

Panics if inserting the element would require allocating more than usize::MAX bytes.

pub(crate) fn insert_impl( &mut self, insert_info: InsertInfo, insert_index: usize )

This function should be called on a slice with a data array new_data_len long which previously held new_count - 1 elements.

After calling this function, all bytes in the slice will have been written.

impl FlexZeroSlice

pub(crate) fn get_remove_info(&self, remove_index: usize) -> RemoveInfo

Compute the RemoveInfo for removing the item at the specified index.

pub(crate) fn get_sorted_pop_info(&self) -> RemoveInfo

Returns the RemoveInfo for removing the last element. Should be called on a slice sorted in ascending order.

This is more efficient than get_remove_info() because it doesn’t require a linear traversal of the vector in order to calculate new_width.

pub(crate) fn remove_impl(&mut self, remove_info: RemoveInfo)

This function should be called on a valid slice.

After calling this function, the slice data should be truncated to new_data_len bytes.

Trait Implementations

impl<'a> AsRef<FlexZeroSlice> for FlexZeroVec<'a>

fn as_ref(&self) -> &FlexZeroSlice

Converts this type into a shared reference of the (usually inferred) input type.

impl Debug for FlexZeroSlice

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

Formats the value using the given formatter.

impl From<&FlexZeroSlice> for FlexZeroVecOwned

fn from(other: &FlexZeroSlice) -> Self

Converts to this type from the input type.

impl PartialEq<FlexZeroSlice> for FlexZeroSlice

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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'zf> ZeroFrom<'zf, FlexZeroSlice> for &'zf FlexZeroSlice

fn zero_from(other: &'zf FlexZeroSlice) -> Self

Clone the other C into a struct that may retain references into C.

impl<'zf> ZeroFrom<'zf, FlexZeroSlice> for FlexZeroVec<'zf>

fn zero_from(other: &'zf FlexZeroSlice) -> Self

Clone the other C into a struct that may retain references into C.

impl ZeroVecLike<usize> for FlexZeroSlice

type GetType = [u8]

The type returned by Self::get()

type SliceVariant = FlexZeroSlice

A fully borrowed version of this

fn zvl_new_borrowed() -> &'static Self::SliceVariant

Create a new, empty borrowed variant

fn zvl_binary_search(&self, k: &usize) -> Result<usize, usize>

Search for a key in a sorted vector, returns Ok(index) if found, returns Err(insert_index) if not found, where insert_index is the index where it should be inserted to maintain sort order.

fn zvl_binary_search_in_range( &self, k: &usize, range: Range<usize> ) -> Option<Result<usize, usize>>

Search for a key within a certain range in a sorted vector. Returns None if the range is out of bounds, and Ok or Err in the same way as zvl_binary_search. Indices are returned relative to the start of the range.

fn zvl_binary_search_by( &self, predicate: impl FnMut(&usize) -> Ordering ) -> Result<usize, usize>

Search for a key in a sorted vector by a predicate, returns Ok(index) if found, returns Err(insert_index) if not found, where insert_index is the index where it should be inserted to maintain sort order.

fn zvl_binary_search_in_range_by( &self, predicate: impl FnMut(&usize) -> Ordering, range: Range<usize> ) -> Option<Result<usize, usize>>

Search for a key within a certain range in a sorted vector by a predicate. Returns None if the range is out of bounds, and Ok or Err in the same way as zvl_binary_search. Indices are returned relative to the start of the range.

fn zvl_get(&self, index: usize) -> Option<&[u8]>

Get element at index

fn zvl_len(&self) -> usize

The length of this vector

fn zvl_as_borrowed(&self) -> &FlexZeroSlice

Construct a borrowed variant by borrowing from &self.

fn zvl_get_as_t<R>(g: &Self::GetType, f: impl FnOnce(&usize) -> R) -> R

Obtain a reference to T, passed to a closure

fn zvl_is_ascending(&self) -> boolwhere T: Ord,

Check if this vector is in ascending order according to Ts Ord impl

fn zvl_is_empty(&self) -> bool

Check if this vector is empty

fn t_cmp_get(t: &T, g: &Self::GetType) -> Orderingwhere T: Ord,

Compare this type with a Self::GetType. This must produce the same result as if g were converted to Self

fn get_cmp_get(a: &Self::GetType, b: &Self::GetType) -> Orderingwhere T: Ord,

Compare two values of Self::GetType. This must produce the same result as if both a and b were converted to Self

impl Eq for FlexZeroSlice