Struct pages::Page

#[repr(transparent)]
pub struct Page<H, T> { /* fields omitted */ }

A dynamically-sized heap-backed data page. Comprises a user-chosen header and data array packed into a single allocation. It is an owned object and the internal representation is a NonNull.

Example

use pages::Page;
// A really crappy replacement for Box<Option<usize>>
struct Maybe(Page::<bool, usize>);
impl Maybe {
    fn new() -> Self { Maybe(Page::new(false, 1)) }
    fn put(&mut self, value: usize) {
        *self.0.header_mut() = true; // occupied
        let item: *mut usize = self.0.data_mut()[0].as_mut_ptr();
        unsafe { item.write(value); }
    }
    fn get(&mut self) -> Option<usize> {
        if !(*self.0.header()) { return None; }
        let item: *mut usize = self.0.data_mut()[0].as_mut_ptr();
        *self.0.header_mut() = false; // free
        Some(unsafe { *item })
    }
}

let mut maybe = Maybe::new();
assert_eq!(maybe.get(), None);
maybe.put(42);
assert_eq!(maybe.get(), Some(42));

Notes

Data is exposed as a MaybeUninit slice for maximum flexibility. Unfortunately this means we’re unable to automatically drop the data for you in our destructor. You could cause a memory leak if you don’t.

Implementations

impl<H, T> Page<H, T>

pub fn new(header: H, items: u32) -> Self

Creates a new Page with the capacity for the provided number of items on the heap and a header.

Notes

Will panic if the header plus padding is extremely large (around 2^32 bytes)

pub fn capacity(&self) -> u32

The capacity of our data array.

pub fn header(&self) -> &H

Access to the header by reference.

pub fn header_mut(&mut self) -> &mut H

Access to the header by mut reference.

pub fn data(&self) -> &[MaybeUninit<T>]

Access to the raw data as a slice.

pub fn data_mut(&mut self) -> &mut [MaybeUninit<T>]

Access to the raw data as a mut slice.

Trait Implementations

impl<H, T> Debug for Page<H, T>

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

Formats the value using the given formatter.

impl<H, T> Drop for Page<H, T>

fn drop(&mut self)

Executes the destructor for this type.

impl<H: Send, T: Send> Send for Page<H, T>

impl<H: Sync, T: Sync> Sync for Page<H, T>