Struct sanakirja_core::btree::page_unsized::Page

pub struct Page<K: ?Sized, V: ?Sized> { /* fields omitted */ }

Trait Implementations

impl<K: UnsizedStorable + ?Sized + Debug, V: UnsizedStorable + ?Sized + Debug> BTreeMutPage<K, V> for Page<K, V>

fn init(page: &mut MutPage)

Initialise a page.

type Saved = (*const K, *const V)

fn save_deleted_leaf_entry(k: &K, v: &V) -> Self::Saved

Save a leaf entry as a replacement, when we delete at an internal node. This can be a pointer to the leaf if the leaf isn’t mutated, or the actual value, or something else.

unsafe fn from_saved<'a>(s: &Self::Saved) -> (&'a K, &'a V)

Recover the saved value.

fn put<'a, T: AllocPage>(
    txn: &mut T,
    page: CowPage,
    mutable: bool,
    replace: bool,
    c: &PageCursor,
    k0: &'a K,
    v0: &'a V,
    k1v1: Option<(&'a K, &'a V)>,
    l: u64,
    r: u64
) -> Result<Put<'a, K, V>, T::Error>

Add an entry to the page, possibly splitting the page in the process.

unsafe fn put_mut(page: &mut MutPage, c: &Self::Cursor, k0: &K, v0: &V, r: u64)

Add an entry to page, at position c. Does not check whether there is enough space to do so. This method is mostly useful for cloning pages.

unsafe fn set_left_child(page: &mut MutPage, c: &Self::Cursor, l: u64)

fn update_left_child<T: AllocPage>(
    txn: &mut T,
    page: CowPage,
    mutable: bool,
    c: &Self::Cursor,
    l: u64
) -> Result<Ok, T::Error>

Update the left child of the position pointed to by the cursor.

fn del<T: AllocPage>(
    txn: &mut T,
    page: CowPage,
    mutable: bool,
    c: &PageCursor,
    l: u64
) -> Result<(MutPage, u64), T::Error>

Delete an entry on the page, returning the resuting page along with the offset of the freed page (or 0 if no page was freed, i.e. if page is mutable).

fn merge_or_rebalance<'a, T: AllocPage>(
    txn: &mut T,
    m: Concat<'a, K, V, Self>
) -> Result<Op<'a, T, K, V>, T::Error>

Merge, rebalance or update a concatenation.

impl<K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized> BTreePage<K, V> for Page<K, V>

fn is_empty(c: &Self::Cursor) -> bool

Whether this cursor is at the end of the page.

fn is_init(c: &Self::Cursor) -> bool

Whether this cursor is strictly before the first element.

type Cursor = PageCursor

fn cursor_before(p: &CowPage) -> Self::Cursor

Returns a cursor set before the first element of the page (i.e. set to -1).

fn cursor_after(p: &CowPage) -> Self::Cursor

Returns a cursor set after the last element of the page (i.e. to element n)

fn split_at(c: &Self::Cursor) -> (Self::Cursor, Self::Cursor)

fn move_next(c: &mut Self::Cursor) -> bool

Move the cursor to the next position. Returns whether the cursor was actually moved (i.e. true if and only if the cursor isn’t already after the last element).

fn move_prev(c: &mut Self::Cursor) -> bool

Move the cursor to the previous position. Returns whether the cursor was actually moved (i.e. true if and only if the cursor isn’t strictly before the page).

fn current<'a, T: LoadPage>(
    txn: &T,
    page: Page<'a>,
    c: &Self::Cursor
) -> Option<(&'a K, &'a V, u64)>

Returns the current element, if the cursor is pointing at one.

fn left_child(page: Page<'_>, c: &Self::Cursor) -> u64

Returns the left child of the entry pointed to by the cursor.

fn right_child(page: Page<'_>, c: &Self::Cursor) -> u64

Returns the right child of the entry pointed to by the cursor.

fn set_cursor<'a, T: LoadPage>(
    txn: &'a T,
    page: Page<'_>,
    c: &mut PageCursor,
    k0: &K,
    v0: Option<&V>
) -> Result<(&'a K, &'a V, u64), usize>

Sets the cursor to the last element less than or equal to k0 if v0.is_none(), and to (k0, v0) if v0.is_some().

fn cursor_first(p: &CowPage) -> Self::Cursor

Returns a cursor set to the first element of the page (i.e. 0). If the page is empty, the returned cursor might be empty.

fn cursor_last(p: &CowPage) -> Self::Cursor

Returns a cursor set to the last element of the page. If the cursor is empty, this is the same as cursor_before.

fn next<'b, T: LoadPage>(
    txn: &T,
    p: Page<'b>,
    c: &mut Self::Cursor
) -> Option<(&'b K, &'b V, u64)>

Return the element currently pointed to by the cursor (if the cursor is not before or after the elements of the page), and move the cursor to the next element.

fn prev<'b, T: LoadPage>(
    txn: &T,
    p: Page<'b>,
    c: &mut Self::Cursor
) -> Option<(&'b K, &'b V, u64)>

Move the cursor to the previous element, and return that element. In that sense, this is not the symmetric of next.

impl<K: Debug + ?Sized, V: Debug + ?Sized> Debug for Page<K, V>

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

Formats the value using the given formatter.