Struct sdb::Page

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

Empty type implementing BTreePage and BTreeMutPage.

Trait Implementations

impl<K, V> BTreeMutPage<K, V> for Page<K, V> where
    K: Storable + Debug,
    V: Storable + Debug, 

pub fn init(page: &mut MutPage)

Initialise a page.

type Saved = (K, V)

pub fn save_deleted_leaf_entry(
    k: &K,
    v: &V
) -> <Page<K, V> as BTreeMutPage<K, V>>::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.

pub unsafe fn from_saved<'a>(
    s: &<Page<K, V> as BTreeMutPage<K, V>>::Saved
) -> (&'a K, &'a V)

Recover the saved value.

pub fn put<T>(
    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 as LoadPage>::Error> where
    T: AllocPage, 

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

pub unsafe fn put_mut(
    page: &mut MutPage,
    c: &mut <Page<K, V> as BTreePage<K, V>>::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.

pub unsafe fn set_left_child(
    page: &mut MutPage,
    c: &<Page<K, V> as BTreePage<K, V>>::Cursor,
    l: u64
)

pub fn update_left_child<T>(
    txn: &mut T,
    page: CowPage,
    mutable: bool,
    c: &<Page<K, V> as BTreePage<K, V>>::Cursor,
    l: u64
) -> Result<Ok, <T as LoadPage>::Error> where
    T: AllocPage, 

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

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

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).

pub fn merge_or_rebalance<T>(
    txn: &mut T,
    m: Concat<'a, K, V, Page<K, V>>
) -> Result<Op<'a, T, K, V>, <T as LoadPage>::Error> where
    T: AllocPage, 

Merge, rebalance or update a concatenation.

impl<K, V> BTreePage<K, V> for Page<K, V> where
    K: Storable,
    V: Storable, 

type Cursor = PageCursor

pub fn is_empty(c: &<Page<K, V> as BTreePage<K, V>>::Cursor) -> bool

Whether this cursor is at the end of the page.

pub fn is_init(c: &<Page<K, V> as BTreePage<K, V>>::Cursor) -> bool

Whether this cursor is strictly before the first element.

pub fn cursor_before(p: &CowPage) -> <Page<K, V> as BTreePage<K, V>>::Cursor

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

pub fn cursor_after(p: &CowPage) -> <Page<K, V> as BTreePage<K, V>>::Cursor

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

pub fn split_at(
    c: &<Page<K, V> as BTreePage<K, V>>::Cursor
) -> (<Page<K, V> as BTreePage<K, V>>::Cursor, <Page<K, V> as BTreePage<K, V>>::Cursor)

pub fn move_next(c: &mut <Page<K, V> as BTreePage<K, V>>::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).

pub fn move_prev(c: &mut <Page<K, V> as BTreePage<K, V>>::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).

pub fn current<T>(
    _txn: &T,
    page: Page<'a>,
    c: &<Page<K, V> as BTreePage<K, V>>::Cursor
) -> Option<(&'a K, &'a V, u64)> where
    T: LoadPage, 

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

pub fn left_child(
    page: Page<'_>,
    c: &<Page<K, V> as BTreePage<K, V>>::Cursor
) -> u64

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

pub fn right_child(
    page: Page<'_>,
    c: &<Page<K, V> as BTreePage<K, V>>::Cursor
) -> u64

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

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

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<T>(
    txn: &T,
    p: Page<'b>,
    c: &mut Self::Cursor
) -> Option<(&'b K, &'b V, u64)> where
    T: LoadPage, 

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<T>(
    txn: &T,
    p: Page<'b>,
    c: &mut Self::Cursor
) -> Option<(&'b K, &'b V, u64)> where
    T: LoadPage, 

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

impl<K, V> Debug for Page<K, V> where
    K: Debug,
    V: Debug, 

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

Formats the value using the given formatter.