Struct pages::Page[][src]

pub struct Page<H, T>(_);
Expand description

An owned, heap-backed, dynamically-sized data page comprising a user-chosen header and data array packed into a single allocation. It is an owned object and the internal representation is a [NonNull].


use pages::Page;
use core::mem::MaybeUninit;
// 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
        unsafe { };
    fn get(&mut self) -> Option<usize> {
        if !(*self.0.header()) { return None; }
        *self.0.header_mut() = false; // free
        Some(unsafe { })

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


Data is exposed as a MaybeUninit pointer 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.


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


Will panic if items is 0 or the header plus padding is extremely large (u32::MAX - 8 bytes)

The capacity of this page’s data array.

Access to this page’s header by reference.

Access to this page’s header by mut reference.

Access to the start of the data array as a mut pointer.

Returns the PageLayout describing the memory layout of this Page

Creates a new Page from a pointer to uninitialised memory, a header and a PageLayout.


You must ensure:

  • The pointer was allocated according to the provided PageLayout.
    • Synchronise all reads and writes to
    • Suppress the destructor of all but one of them (e.g. by wrapping in [ManuallyDrop]).
  • If the pointer did not originate from the global allocator, you must suppress the destructor (e.g. by wrapping in [ManuallyDrop]).

Creates an owned Page from a PageRef.


use pages::Page;
let page = Page::<bool, usize>::new(false, 1);
let page_ref = page.to_ref();
let page = unsafe { Page::<bool, usize>::from_ref(page_ref) };


You must only have one live Page per page.

Converts this Page to a PageRef, a mutable pointer structure, effectively leaking it.

Trait Implementations

Formats the value using the given formatter. Read more

Executes the destructor for this type. Read more

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Performs the conversion.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.