Struct Array

#[repr(C)]
pub struct Array<T> {
    pub index: u32,
    pub len: u32,
    /* private fields */
}

A pointer to contiguous T elements in a slab.

use crabslab::{Array, CpuSlab, GrowableSlab, Id, Slab, SlabItem};

let ints = [1, 2, 3, 4, 5u32];
let mut slab = CpuSlab::new(vec![]);
let array = slab.append_array(&ints);
for (i, id) in array.iter().enumerate() {
    let value = slab.read(id);
    assert_eq!(ints[i], value);
}

Fields

index: u32

len: u32

Implementations

impl<T> Array<T>

pub const NONE: Array<T>

pub const fn new(index: u32, len: u32) -> Array<T>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn is_null(&self) -> bool

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

pub fn at(&self, index: usize) -> Id<T>

where T: SlabItem,

pub fn starting_index(&self) -> usize

pub fn iter(&self) -> ArrayIter<T>

pub fn into_u32_array(self) -> Array<u32>

where T: SlabItem,

Convert this array into a u32 array.

pub fn sub_slab<'a>(&'a self, slab: &'a [u32]) -> &'a [u32]

where T: SlabItem,

Return the slice of the slab that this array represents.

impl Array<u32>

pub fn union(&mut self, other: &Array<u32>)

Trait Implementations

impl<T> Clone for Array<T>

fn clone(&self) -> Array<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Array<T>

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

Formats the value using the given formatter.

impl<T> Default for Array<T>

where T: SlabItem,

fn default() -> Array<T>

Returns the “default value” for a type.

impl<T> From<Id<T>> for Array<T>

An Id<T> is an Array<T> with a length of 1.

fn from(id: Id<T>) -> Array<T>

Converts to this type from the input type.

impl<T> PartialEq for Array<T>

fn eq(&self, other: &Array<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T> SlabItem for Array<T>

where T: SlabItem,

const SLAB_SIZE: usize = 2usize

The number of u32s this type occupies in a slab of &[u32].

fn write_slab(&self, index: usize, slab: &mut [u32]) -> usize

Write the type into the slab at starting index and return the new index.

fn read_slab(index: usize, slab: &[u32]) -> Array<T>

Read the type out of the slab at index.

impl<T> Copy for Array<T>