Trait sanakirja::btree::BTreeMutPage[−][src]

pub trait BTreeMutPage<K, V>: BTreePage<K, V> + Debug where
    K: ?Sized,
    V: ?Sized, {
    type Saved;
    fn init(page: &mut MutPage);

    fn put<T>(
        txn: &mut T, 
        page: CowPage, 
        mutable: bool, 
        replace: bool, 
        c: &Self::Cursor, 
        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;

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

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

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

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

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

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

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

Associated Types

Required methods

Initialise a page.

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

Makes the assumption that k1v1.is_some() implies replace. When k1v1.is_some(), we insert both (k0, v0) (as a replacement), followed by (k1, v1). This is only ever used when deleting, and when the right child of a deleted entry (in an internal node) has split while we were looking for a replacement for the deleted entry.

Since we only look for replacements in the right child, the left child of the insertion isn’t modified, in which case l and r are interpreted as the left and right child of the new entry, k1v1.

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.

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

[src]

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.

Recover the saved value.

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

Merge, rebalance or update a concatenation.

Implementors