pijul/sanakirja - Change OFINGD26ZWCRDVVDI2ZIBLMHXKEMJA6MRNLANJYUHQPIJLPA7J2AC

implementing prev() on cursors (+ some cleanup)

Created by pmeunier on February 7, 2021

OFINGD26ZWCRDVVDI2ZIBLMHXKEMJA6MRNLANJYUHQPIJLPA7J2AC

Dependencies

In channels

main

Change contents

Replacement in sanakirja-core/src/btree/put.rs at line 29 [4.3448]
B:BD[4.4317] → [4.4317:4355]
```
    let mut cursor = Cursor::new(db);
```
[4.4317]
[4.4355]
```
    let mut cursor = Cursor::new(txn, db)?;
```
Replacement in sanakirja-core/src/btree/put.rs at line 38 [4.3448]
∅:D[5.50] → [4.4587:4625]
∅:D[6.118] → [4.4587:4625]
B:BD[4.4587] → [4.4587:4625]
```
        cur.cursor.as_ref().unwrap(),
```
[5.50]
[4.4625]
```
        &cur.cursor,
```

Replacement in sanakirja-core/src/btree/put.rs at line 46 [4.3448]

B:BD[4.4718] → [4.4718:4780]

    db.db = put_cascade(txn, &mut cursor, put, &mut free)?.0;

[4.4718]

[7.45]

    db.db = put_cascade(txn, &mut cursor, put, &mut free)?.0.offset;

Replacement in sanakirja-core/src/btree/put.rs at line 88 [4.3448]

∅:D[5.190] → [8.279:333]

B:BD[8.279] → [8.279:333]

                        cur.cursor.as_ref().unwrap(),

[5.190]

[8.333]

                        &cur.cursor,

Replacement in sanakirja-core/src/btree/put.rs at line 105 [4.3448]

B:BD[4.5879] → [9.921:978]

                        &P::first_cursor(p.0.as_page()),

[4.5879]

[4.5927]

                        &P::cursor_first(p.0.as_page()),

Replacement in sanakirja-core/src/btree/put.rs at line 125 [4.3448]

∅:D[5.330] → [8.810:865]

B:BD[8.810] → [8.810:865]

                        curs.cursor.as_ref().unwrap(),

[5.330]

[8.865]

                        &curs.cursor,

Replacement in sanakirja-core/src/btree/put.rs at line 171 [4.3448]

B:BD[4.8159] → [9.1010:1067]

        let mut c = P::first_cursor(cur.page.as_page());

[4.8159]

[9.1067]

        let mut c = P::cursor_before(cur.page.as_page());
        P::move_next(cur.page.as_page(), &mut c);

Insertion in sanakirja-core/src/btree/page_unsized.rs at line 75 [10.2014]
[10.3909]
[10.3909]
```
        assert!(c.cur >= 0);
```

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 77 [10.2014]

B:BD[10.3929] → [10.3929:4014]

            put::put::<_, _, _, Leaf>(txn, page, mutable, c.cur, k0, v0, k1v1, 0, 0)

[10.3929]

[10.4014]

            put::put::<_, _, _, Leaf>(txn, page, mutable, c.cur as usize, k0, v0, k1v1, 0, 0)

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 79 [10.2014]

B:BD[10.4031] → [10.4031:4120]

            put::put::<_, _, _, Internal>(txn, page, mutable, c.cur, k0, v0, k1v1, l, r)

[10.4031]

[10.4120]

            put::put::<_, _, _, Internal>(txn, page, mutable, c.cur as usize, k0, v0, k1v1, l, r)

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 124 [10.2014]
B:BD[10.5716] → [10.5716:5754]
```
        assert!(c.cur < c.total + 1);
```
[10.5716]
[10.5754]
```
        assert!(c.cur < c.total as isize + 1);
```
Replacement in sanakirja-core/src/btree/page_unsized.rs at line 138 [10.2014]
B:BD[10.6121] → [10.6121:6155]
```
        assert!(c.cur < c.total);
```
[11.1340]
[10.6155]
```
        assert!(c.cur >= 0 && c.cur < c.total as isize);
```

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 146 [10.2014]

B:BD[10.6448] → [10.6448:6514]

                    let ptr = p.add(HDR + c.cur * 2) as *mut u16;

[10.6448]

[10.6514]

                    let ptr = p.add(HDR + c.cur as usize * 2) as *mut u16;

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 149 [10.2014]

B:BD[10.6630] → [10.6630:6698]

                    core::ptr::copy(ptr.offset(1), ptr, n - c.cur);

[10.6630]

[10.6698]

                    core::ptr::copy(ptr.offset(1), ptr, n - c.cur as usize);

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 152 [10.2014]

B:BD[10.6759] → [10.6759:6825]

                    let ptr = p.add(HDR + c.cur * 8) as *mut u64;

[10.6759]

[10.6825]

                    let ptr = p.add(HDR + c.cur as usize * 8) as *mut u64;

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 156 [10.2014]

B:BD[10.6998] → [10.6998:7081]

                    core::ptr::copy(ptr.offset(1), ptr, hdr.n() as usize - c.cur);

[10.6998]

[10.7081]

                    core::ptr::copy(ptr.offset(1), ptr, hdr.n() as usize - c.cur as usize);

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 176 [10.2014]

B:BD[10.7800] → [10.7800:7854]

                    let (s0, s1) = s.split_at(c.cur);

[10.7800]

[10.7854]

                    let (s0, s1) = s.split_at(c.cur as usize);

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 182 [10.2014]

B:BD[10.8148] → [10.8148:8202]

                    let (s0, s1) = s.split_at(c.cur);

[10.8148]

[10.8202]

                    let (s0, s1) = s.split_at(c.cur as usize);

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 241 [10.2014]
B:BD[10.10222] → [10.10222:10286]
```
        let rc = <Page<K, V>>::first_cursor(m.other.as_page());
```
[10.10222]
[10.10286]
```
        let rc = Cursor::new(m.other.as_page(), 0);
```
Replacement in sanakirja-core/src/btree/page_unsized.rs at line 286 [10.2014]
B:BD[10.11833] → [10.11833:11858]
```
        c.cur >= c.total
```
[10.11833]
[10.11858]
```
        c.cur >= c.total as isize
```

Insertion in sanakirja-core/src/btree/page_unsized.rs at line 288 [10.2014]

[10.11864]


    fn is_init(_: crate::Page, c: &Self::Cursor) -> bool {
        c.cur < 0
    }

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 293 [10.2014]

B:BD[10.11890] → [10.11890:12093]

    fn first_cursor(p: crate::Page) -> Self::Cursor {
        let hdr = header(p);
        Cursor {
            cur: 0,
            total: hdr.n() as usize,
            is_leaf: hdr.is_leaf(),
        }

[10.11890]

[10.12093]

    fn cursor_before(p: crate::Page) -> Self::Cursor {
        Cursor::new(p, -1)

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 296 [10.2014]

B:BD[10.12099] → [10.12099:12329]

    fn last_cursor(p: crate::Page) -> Self::Cursor {
        let hdr = header(p);
        let total = hdr.n() as usize;
        Cursor {
            cur: total - 1,
            total,
            is_leaf: hdr.is_leaf(),
        }

[10.12099]

[10.12329]

    fn cursor_after(p: crate::Page) -> Self::Cursor {
        Cursor::after(p)

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 299 [10.2014]
B:BD[10.12335] → [10.12335:12385]
```
    unsafe fn unchecked_current<'a, T: LoadPage>(
```
[10.12335]
[10.12385]
```
    fn current<'a, T: LoadPage>(
```

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 303 [10.2014]

B:BD[10.12459] → [10.12459:12513]

B:BD[10.12513] → [11.1441:1564]

∅:D[11.1564] → [10.12648:12733]

B:BD[10.12648] → [10.12648:12733]

B:BD[10.12733] → [11.1565:1720]

    ) -> (&'a K, &'a V, u64) {
        if c.is_leaf {
            let off =
                { u16::from_le(*(page.data.as_ptr().add(HDR + c.cur * 2) as *const u16)) as usize };
            let (k, v) = read::<T, K, V>(txn, page.data.as_ptr().add(off as usize));
            (
                K::from_raw_ptr(txn, k as *const u8),
                V::from_raw_ptr(txn, v as *const u8),
                0,
            )

[10.12459]

[10.12825]

    ) -> Option<(&'a K, &'a V, u64)> {
        if c.cur < 0 || c.cur >= c.total as isize {
            None
        } else if c.is_leaf {
            unsafe {
                let off =
                { u16::from_le(*(page.data.as_ptr().add(HDR + c.cur as usize * 2) as *const u16)) as usize };
                let (k, v) = read::<T, K, V>(txn, page.data.as_ptr().add(off));
                Some((
                    K::from_raw_ptr(txn, k as *const u8),
                    V::from_raw_ptr(txn, v as *const u8),
                    0,
                ))
            }

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 318 [10.2014]

B:BD[10.12842] → [10.12842:13030]

B:BD[10.13030] → [11.1721:1887]

            let off = u64::from_le(*(page.data.as_ptr().add(HDR) as *const u64).add(c.cur));
            let (k, v) = read::<T, K, V>(txn, page.data.as_ptr().add((off & 0xfff) as usize));
            (
                K::from_raw_ptr(txn, k as *const u8),
                V::from_raw_ptr(txn, v as *const u8),
                off & !0xfff,
            )

[10.12842]

[10.13133]

            unsafe {
                let off = u64::from_le(*(page.data.as_ptr().add(HDR) as *const u64).offset(c.cur));
                let (k, v) = read::<T, K, V>(txn, page.data.as_ptr().add((off & 0xfff) as usize));
                Some((
                    K::from_raw_ptr(txn, k as *const u8),
                    V::from_raw_ptr(txn, v as *const u8),
                    off & !0xfff,
                ))
            }

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 331 [10.2014]

B:BD[10.13283] → [10.13283:13375]

            u16::from_le(*(page.data.as_ptr().add(HDR + c.cur * 2) as *const u16)) as usize

[10.13283]

[10.13375]

            u16::from_le(*(page.data.as_ptr().add(HDR + c.cur as usize * 2) as *const u16)) as usize

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 333 [10.2014]

B:BD[10.13392] → [10.13392:13485]

            (u64::from_le(*(page.data.as_ptr().add(HDR + c.cur * 8) as *const u64)) & 0xfff)

[10.13392]

[10.13485]

            (u64::from_le(*(page.data.as_ptr().add(HDR + c.cur as usize * 8) as *const u64)) & 0xfff)

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 341 [10.2014]

B:BD[10.13715] → [10.13715:13792]

                    *(page.data.as_ptr().add(HDR) as *const u16).add(c.cur),

[10.13715]

[11.1888]

                    *(page.data.as_ptr().add(HDR) as *const u16).offset(c.cur),

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 345 [10.2014]

B:BD[10.13967] → [10.13967:14067]

                    (u64::from_le(*(page.data.as_ptr().add(HDR) as *const u64).add(c.cur)) & 0xfff)

[10.13967]

[10.14067]

                    (u64::from_le(*(page.data.as_ptr().add(HDR) as *const u64).offset(c.cur)) & 0xfff)

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 352 [10.2014]
B:BD[10.14219] → [10.14219:14248]
```
        if c.cur < c.total {
```
[10.14219]
[10.14248]
```
        if c.cur < c.total as isize {
```
Insertion in sanakirja-core/src/btree/page_unsized.rs at line 364 [10.2014]
[10.14490]
[10.14490]
```
            c.cur = -1;
```
Insertion in sanakirja-core/src/btree/page_unsized.rs at line 369 [10.2014]
[10.14588]
[10.14588]
```
        assert!(c.cur >= 0);
```

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 373 [10.2014]

B:BD[10.14642] → [10.14642:14739]

            let off = unsafe { *(page.data.as_ptr().add((HDR + c.cur * 8) - 8) as *const u64) };

[10.14642]

[10.14739]

            let off = unsafe { *(page.data.as_ptr().add((HDR + c.cur as usize * 8) - 8) as *const u64) };

Insertion in sanakirja-core/src/btree/page_unsized.rs at line 378 [10.2014]
[10.14859]
[10.14859]
```
        assert!(c.cur < c.total as isize);
```

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 382 [10.2014]

B:BD[10.14913] → [10.14913:15004]

            let off = unsafe { *(page.data.as_ptr().add(HDR + c.cur * 8) as *const u64) };

[10.14913]

[10.15004]

            let off = unsafe { *(page.data.as_ptr().add(HDR + c.cur as usize * 8) as *const u64) };

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 414 [10.2014]
B:BD[10.16089] → [10.16089:16111]
```
                    n
```
[10.16089]
[10.16111]
```
                    n as isize
```
Replacement in sanakirja-core/src/btree/page_unsized.rs at line 418 [10.2014]
B:BD[10.16194] → [10.16194:16216]
```
                    n
```
[10.16194]
[10.16216]
```
                    n as isize
```
Replacement in sanakirja-core/src/btree/page_unsized.rs at line 429 [10.2014]
B:BD[10.16424] → [10.16424:16454]
```
                total: c.cur,
```
[10.16424]
[10.16454]
```
                total: c.cur.max(0) as usize,
```

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 504 [10.2014]

B:BD[10.18917] → [10.18917:18970]

    cur: usize,
    total: usize,
    is_leaf: bool,

[10.18917]

[10.18970]

    pub(in super) cur: isize,
    pub(in super) total: usize,
    pub(in super) is_leaf: bool,
}
impl Cursor {
    pub(in super) fn new(p: crate::Page, cur: isize) -> Cursor {
        let hdr = header(p);
        assert!(cur < hdr.n() as isize);
        Cursor {
            cur,
            total: hdr.n() as usize,
            is_leaf: hdr.is_leaf(),
        }
    }
    pub(in super) fn after(p: crate::Page) -> Cursor {
        let hdr = header(p);
        let total = hdr.n();
        Cursor {
            cur: total as isize,
            total: total as usize,
            is_leaf: hdr.is_leaf(),
        }
    }
    pub(in super) fn last(p: crate::Page) -> Cursor {
        let hdr = header(p);
        let total = hdr.n();
        Cursor {
            cur: (total - 1) as isize,
            total: total as usize,
            is_leaf: hdr.is_leaf(),
        }
    }

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 590 [10.2014]

B:BD[10.20399] → [10.20399:20467]

        let mut rc = <Page<K, V>>::first_cursor(m.other.as_page());

[10.20399]

[10.20467]

        let mut rc = Cursor::new(m.other.as_page(), 0);

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 597 [10.2014]

B:BD[10.20764] → [10.20764:20832]

        let mut rc = <Page<K, V>>::first_cursor(m.other.as_page());

[10.20764]

[10.20832]

        let mut rc = Cursor::new(m.other.as_page(), 0);

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 647 [10.2014]
B:BD[10.22584] → [10.22584:22640]
```
        let new_ptr = new.0.data.add(off_new as usize);
```
[10.22584]
[10.22640]
```
        let new_ptr = new.0.data.add(off_new);
```
Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 18 [10.22926]
B:BD[10.23324] → [10.23324:23384]
```
    let rc = <Page<K, V>>::first_cursor(m.other.as_page());
```
[10.23324]
[10.23384]
```
    let rc = super::Cursor::new(m.other.as_page(), 0);
```

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 20 [10.22926]

B:BD[10.23447] → [10.23447:23540]

    let (k, v, r) = unsafe { <Page<K, V>>::unchecked_current(txn, m.other.as_page(), &rc) };

[10.23447]

[10.23540]

    let (k, v, r) = <Page<K, V>>::current(txn, m.other.as_page(), &rc).unwrap();

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 51 [10.22926]

B:BD[12.520] → [12.520:656]

    let mut lc = <Page<K, V>>::last_cursor(m.modified.page.as_page());
    <Page<K, V>>::move_next(m.modified.page.as_page(), &mut lc);

[10.24242]

[12.656]

    let lc = Cursor::after(m.modified.page.as_page());

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 101 [10.22926]

B:BD[10.25320] → [10.25320:25475]

    let lc = <Page<K, V>>::last_cursor(m.other.as_page());
    let (k0, v0, r0) = unsafe { <Page<K, V>>::unchecked_current(txn, m.other.as_page(), &lc) };

[10.25320]

[10.25475]

    let lc = super::Cursor::last(m.other.as_page());
    let (k0, v0, r0) = <Page<K, V>>::current(txn, m.other.as_page(), &lc).unwrap();

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 105 [10.22926]
B:BD[10.25516] → [10.25516:25584]
```
    let rc = <Page<K, V>>::first_cursor(m.modified.page.as_page());
```
[10.25516]
[10.25584]
```
    let rc = super::Cursor::new(m.modified.page.as_page(), 0);
```
Insertion in sanakirja-core/src/btree/page.rs at line 12 [4.8623]
[13.94]
[13.94]
```
pub use super::page_unsized::Cursor;
```
Insertion in sanakirja-core/src/btree/page.rs at line 93 [4.8623]
[4.11143]
[9.1824]
```
        assert!(c.cur >= 0);
```

Replacement in sanakirja-core/src/btree/page.rs at line 95 [4.8623]

B:BD[9.1844] → [13.118:203]

            put::put::<_, _, _, Leaf>(txn, page, mutable, c.cur, k0, v0, k1v1, 0, 0)

[9.1844]

[9.1918]

            put::put::<_, _, _, Leaf>(txn, page, mutable, c.cur as usize, k0, v0, k1v1, 0, 0)

Replacement in sanakirja-core/src/btree/page.rs at line 97 [4.8623]

B:BD[9.1935] → [13.204:293]

            put::put::<_, _, _, Internal>(txn, page, mutable, c.cur, k0, v0, k1v1, l, r)

[9.1935]

[4.11455]

            put::put::<_, _, _, Internal>(txn, page, mutable, c.cur as usize, k0, v0, k1v1, l, r)

Replacement in sanakirja-core/src/btree/page.rs at line 141 [4.8623]

B:BD[4.12313] → [14.13:51]

        assert!(c.cur < c.total + 1);

[4.12313]

[4.12351]

        assert!(c.cur >= 0 && (c.cur as usize) < c.total + 1);

Replacement in sanakirja-core/src/btree/page.rs at line 155 [4.8623]
∅:D[9.2758] → [4.12658:12692]
∅:D[15.191] → [4.12658:12692]
B:BD[4.12658] → [4.12658:12692]
```
        assert!(c.cur < c.total);
```
[11.5311]
[9.2759]
```
        assert!(c.cur >= 0 && (c.cur as usize) < c.total);
```

Replacement in sanakirja-core/src/btree/page.rs at line 166 [4.8623]

B:BD[10.44789] → [10.44789:44830]

                    let off = c.cur * f;

[10.44789]

[10.44830]

                    let off = c.cur as usize * f;

Replacement in sanakirja-core/src/btree/page.rs at line 168 [4.8623]

B:BD[10.44886] → [10.44886:44967]

                    core::ptr::copy(kv_ptr.add(f), kv_ptr, f * (n - c.cur - 1));

[10.44886]

[10.44967]

                    core::ptr::copy(kv_ptr.add(f), kv_ptr, f * (n - c.cur as usize - 1));

Replacement in sanakirja-core/src/btree/page.rs at line 171 [4.8623]

B:BD[16.2569] → [16.2569:2635]

B:BD[17.2065] → [17.2065:2148]

                    let ptr = p.add(HDR + c.cur * 8) as *mut u64;
                    core::ptr::copy(ptr.offset(1), ptr, hdr.n() as usize - c.cur);

[16.2569]

[11.5374]

                    let ptr = p.add(HDR + c.cur as usize * 8) as *mut u64;
                    core::ptr::copy(ptr.offset(1), ptr, hdr.n() as usize - c.cur as usize);

Replacement in sanakirja-core/src/btree/page.rs at line 192 [4.8623]

∅:D[9.4646] → [4.14825:14879]

B:BD[4.14825] → [4.14825:14879]

                    let (s0, s1) = s.split_at(c.cur);

[9.4646]

[4.14932]

                    let (s0, s1) = s.split_at(c.cur as usize);

Replacement in sanakirja-core/src/btree/page.rs at line 198 [4.8623]

∅:D[9.4891] → [4.15205:15259]

B:BD[4.15205] → [4.15205:15259]

                    let (s0, s1) = s.split_at(c.cur);

[9.4891]

[4.15312]

                    let (s0, s1) = s.split_at(c.cur as usize);

Replacement in sanakirja-core/src/btree/page.rs at line 256 [4.8623]

B:BD[4.17328] → [9.5779:5843]

        let rc = <Page<K, V>>::first_cursor(m.other.as_page());

[4.17328]

[9.5843]

        let rc = Cursor::new(m.other.as_page(), 0);

Replacement in sanakirja-core/src/btree/page.rs at line 301 [4.8623]

∅:D[9.6739] → [4.18794:18819]

B:BD[4.18794] → [4.18794:18819]

        c.cur >= c.total

[9.6739]

[4.18819]

        c.cur >= c.total as isize
    }
    fn is_init(_: crate::Page, c: &Self::Cursor) -> bool {
        c.cur < 0

Replacement in sanakirja-core/src/btree/page.rs at line 308 [4.8623]

B:BD[4.18851] → [9.6740:6933]

∅:D[9.6933] → [4.19098:19108]

B:BD[4.19098] → [4.19098:19108]

    fn first_cursor(p: crate::Page) -> Self::Cursor {
        let hdr = header(p);
        Cursor {
            cur: 0,
            total: hdr.n() as usize,
            is_leaf: hdr.is_leaf(),
        }

[4.18851]

[4.19108]

    fn cursor_before(p: crate::Page) -> Self::Cursor {
        Cursor::new(p, -1)

Replacement in sanakirja-core/src/btree/page.rs at line 311 [4.8623]

B:BD[4.19114] → [9.6934:7154]

∅:D[9.7154] → [4.19392:19402]

B:BD[4.19392] → [4.19392:19402]

    fn last_cursor(p: crate::Page) -> Self::Cursor {
        let hdr = header(p);
        let total = hdr.n() as usize;
        Cursor {
            cur: total - 1,
            total,
            is_leaf: hdr.is_leaf(),
        }

[4.19114]

[4.19402]

    fn cursor_after(p: crate::Page) -> Self::Cursor {
        Cursor::after(p)

Replacement in sanakirja-core/src/btree/page.rs at line 314 [4.8623]
B:BD[4.19408] → [17.3055:3105]
```
    unsafe fn unchecked_current<'a, T: LoadPage>(
```
[4.19408]
[17.3105]
```
    fn current<'a, T: LoadPage>(
```

Replacement in sanakirja-core/src/btree/page.rs at line 318 [4.8623]

B:BD[16.3872] → [16.3872:3903]

∅:D[16.3903] → [4.19505:19528]

∅:D[9.7257] → [4.19505:19528]

B:BD[4.19505] → [4.19505:19528]

    ) -> (&'a K, &'a V, u64) {
        if c.is_leaf {

[16.3872]

[18.1529]

    ) -> Option<(&'a K, &'a V, u64)> {
        if c.cur < 0 || c.cur >= c.total as isize {
            None
        } else if c.is_leaf {

Replacement in sanakirja-core/src/btree/page.rs at line 326 [4.8623]
B:BD[4.19696] → [4.19696:19728]
```
                hdr + c.cur * f
```
[4.19696]
[4.19836]
```
                hdr + c.cur as usize * f
```

Replacement in sanakirja-core/src/btree/page.rs at line 328 [4.8623]

B:BD[4.19851] → [17.3186:3271]

B:BD[17.3271] → [11.5498:5653]

            let (k, v) = read::<T, K, V>(txn, page.data.as_ptr().add(off as usize));
            (
                K::from_raw_ptr(txn, k as *const u8),
                V::from_raw_ptr(txn, v as *const u8),
                0,
            )

[4.19851]

[4.19944]

            debug!("current {:?}", off);
            unsafe {
                let (k, v) = read::<T, K, V>(txn, page.data.as_ptr().add(off as usize));
                debug!("k {:?}", K::from_raw_ptr(txn, k as *const u8));
                Some((
                    K::from_raw_ptr(txn, k as *const u8),
                    V::from_raw_ptr(txn, v as *const u8),
                    0,
                ))
            }

Replacement in sanakirja-core/src/btree/page.rs at line 339 [4.8623]

B:BD[4.19961] → [9.7462:7555]

B:BD[9.7555] → [17.3364:3459]

B:BD[17.3459] → [11.5654:5820]

            let off = u64::from_le(*(page.data.as_ptr().add(HDR) as *const u64).add(c.cur));
            let (k, v) = read::<T, K, V>(txn, page.data.as_ptr().add((off & 0xfff) as usize));
            (
                K::from_raw_ptr(txn, k as *const u8),
                V::from_raw_ptr(txn, v as *const u8),
                off & !0xfff,
            )

[4.19961]

[4.20159]

            unsafe {
                let off = u64::from_le(*(page.data.as_ptr().add(HDR) as *const u64).add(c.cur as usize));
                let (k, v) = read::<T, K, V>(txn, page.data.as_ptr().add((off & 0xfff) as usize));
                Some((
                    K::from_raw_ptr(txn, k as *const u8),
                    V::from_raw_ptr(txn, v as *const u8),
                    off & !0xfff,
                ))
            }

Insertion in sanakirja-core/src/btree/page.rs at line 351 [4.8623]
[9.7771]
[9.7771]
```
        assert!(c.cur >= 0 && c.cur < c.total as isize);
```
Replacement in sanakirja-core/src/btree/page.rs at line 356 [4.8623]
B:BD[10.45403] → [10.45403:45431]
```
            hdr + c.cur * f
```
[10.45403]
[4.20611]
```
            hdr + c.cur as usize * f
```

Replacement in sanakirja-core/src/btree/page.rs at line 358 [4.8623]

B:BD[4.20628] → [16.3904:3997]

            (u64::from_le(*(page.data.as_ptr().add(HDR + c.cur * 8) as *const u64)) & 0xfff)

[4.20628]

[16.3997]

            (u64::from_le(*(page.data.as_ptr().add(HDR + c.cur as usize * 8) as *const u64)) & 0xfff)

Insertion in sanakirja-core/src/btree/page.rs at line 363 [4.8623]
[9.8086]
[4.20807]
```
        assert!(c.cur >= 0 && c.cur < c.total as isize);
```

Replacement in sanakirja-core/src/btree/page.rs at line 369 [4.8623]

∅:D[17.3817] → [16.4224:4324]

B:BD[9.8295] → [16.4224:4324]

                    (u64::from_le(*(page.data.as_ptr().add(HDR) as *const u64).add(c.cur)) & 0xfff)

[17.3817]

[16.4324]

                    (u64::from_le(*(page.data.as_ptr().add(HDR) as *const u64).add(c.cur as usize)) & 0xfff)

Replacement in sanakirja-core/src/btree/page.rs at line 376 [4.8623]
∅:D[9.8475] → [4.21513:21542]
B:BD[4.21513] → [4.21513:21542]
```
        if c.cur < c.total {
```
[9.8475]
[4.21542]
```
        if c.cur < c.total as isize {
```
Insertion in sanakirja-core/src/btree/page.rs at line 388 [4.8623]
[9.8626]
[9.8626]
```
            c.cur = -1;
```
Insertion in sanakirja-core/src/btree/page.rs at line 393 [4.8623]
[9.8724]
[4.21699]
```
        assert!(c.cur >= 0);
```

Replacement in sanakirja-core/src/btree/page.rs at line 397 [4.8623]

B:BD[4.21753] → [9.8725:8822]

            let off = unsafe { *(page.data.as_ptr().add((HDR + c.cur * 8) - 8) as *const u64) };

[4.21753]

[4.21841]

            let off = unsafe { *(page.data.as_ptr().add((HDR + c.cur as usize * 8) - 8) as *const u64) };

Insertion in sanakirja-core/src/btree/page.rs at line 402 [4.8623]
[9.8888]
[4.21962]
```
        assert!(c.cur < c.total as isize);
```

Replacement in sanakirja-core/src/btree/page.rs at line 406 [4.8623]

B:BD[4.22016] → [9.8889:8980]

            let off = unsafe { *(page.data.as_ptr().add(HDR + c.cur * 8) as *const u64) };

[4.22016]

[4.22098]

            let off = unsafe { *(page.data.as_ptr().offset(HDR as isize + c.cur * 8) as *const u64) };

Replacement in sanakirja-core/src/btree/page.rs at line 439 [4.8623]
B:BD[4.25430] → [4.25430:25452]
```
                    n
```
[4.25430]
[4.25452]
```
                    n as isize
```
Replacement in sanakirja-core/src/btree/page.rs at line 443 [4.8623]
B:BD[4.25535] → [4.25535:25557]
```
                    n
```
[4.25535]
[4.25557]
```
                    n as isize
```
Replacement in sanakirja-core/src/btree/page.rs at line 454 [4.8623]
B:BD[4.25765] → [4.25765:25795]
```
                total: c.cur,
```
[4.25765]
[4.25795]
```
                total: c.cur.max(0) as usize,
```
Deletion in sanakirja-core/src/btree/page.rs at line 533 [4.8623]
∅:D[9.12029] → [4.26193:26296]
B:BD[4.26193] → [4.26193:26296]
B:BD[4.34628] → [4.34628:34631]
```
#[derive(Debug, Clone, Copy)]
pub struct Cursor {
    cur: usize,
    total: usize,
    is_leaf: bool,
}
```
Replacement in sanakirja-core/src/btree/page.rs at line 583 [4.8623]
∅:D[17.6207] → [9.20589:20657]
B:BD[9.20589] → [9.20589:20657]
```
        let mut rc = <Page<K, V>>::first_cursor(m.other.as_page());
```
[17.6207]
[9.20657]
```
        let mut rc = Cursor::new(m.other.as_page(), 0);
```

Replacement in sanakirja-core/src/btree/page.rs at line 590 [4.8623]

B:BD[4.36081] → [9.20937:21005]

        let mut rc = <Page<K, V>>::first_cursor(m.other.as_page());

[4.36081]

[9.21005]

        let mut rc = Cursor::new(m.other.as_page(), 0);

Replacement in sanakirja-core/src/btree/page/rebalance.rs at line 17 [13.387]

B:BD[13.823] → [13.823:883]

    let rc = <Page<K, V>>::first_cursor(m.other.as_page());

[13.823]

[13.883]

    let rc = super::Cursor::new(m.other.as_page(), 0);

Replacement in sanakirja-core/src/btree/page/rebalance.rs at line 19 [13.387]

B:BD[13.946] → [17.7123:7216]

    let (k, v, r) = unsafe { <Page<K, V>>::unchecked_current(txn, m.other.as_page(), &rc) };

[13.946]

[13.1034]

    let (k, v, r) = <Page<K, V>>::current(txn, m.other.as_page(), &rc).unwrap();

Replacement in sanakirja-core/src/btree/page/rebalance.rs at line 50 [13.387]

B:BD[13.1795] → [12.2256:2392]

    let mut lc = <Page<K, V>>::last_cursor(m.modified.page.as_page());
    <Page<K, V>>::move_next(m.modified.page.as_page(), &mut lc);

[13.1736]

[12.2392]

    let lc = Cursor::after(m.modified.page.as_page());

Replacement in sanakirja-core/src/btree/page/rebalance.rs at line 131 [13.387]

B:BD[13.4231] → [13.4231:4290]

B:BD[13.4290] → [17.7490:7586]

    let lc = <Page<K, V>>::last_cursor(m.other.as_page());
    let (k0, v0, r0) = unsafe { <Page<K, V>>::unchecked_current(txn, m.other.as_page(), &lc) };

[13.4231]

[13.4381]

    let lc = Cursor::last(m.other.as_page());
    let (k0, v0, r0) = <Page<K, V>>::current(txn, m.other.as_page(), &lc).unwrap();

Replacement in sanakirja-core/src/btree/page/rebalance.rs at line 135 [13.387]

B:BD[13.4422] → [13.4422:4490]

    let rc = <Page<K, V>>::first_cursor(m.modified.page.as_page());

[13.4422]

[13.4490]

    let rc = super::Cursor::new(m.modified.page.as_page(), 0);

Insertion in sanakirja-core/src/btree/page/put.rs at line 35 [13.5929]
[13.6984]
[17.7815]
```
            debug!("{:?} {:?} {:?}", l, r, n);
```
Insertion in sanakirja-core/src/btree/mod.rs at line 9 [4.45735]
[10.50142]
[4.45830]
```
use log::*;
```

Replacement in sanakirja-core/src/btree/mod.rs at line 32 [4.45735]

B:BD[4.46263] → [9.28315:28406]

    fn first_cursor(p: Page) -> Self::Cursor;
    fn last_cursor(p: Page) -> Self::Cursor;

[4.46263]

[11.8055]


    /// Returns a cursor set before the first element of the page
    /// (i.e. set to -1).
    fn cursor_before(p: Page) -> Self::Cursor;
    fn cursor_first(p: Page) -> Self::Cursor {
        let mut c = Self::cursor_before(p);
        debug!("cursor_first {:?}", c);
        Self::move_next(p, &mut c);
        debug!("cursor_first {:?}", c);
        c
    }
    /// Returns a cursor set after the last element of the page
    /// (i.e. to element n)
    fn cursor_after(p: Page) -> Self::Cursor;
    fn cursor_last(p: Page) -> Self::Cursor {
        let mut c = Self::cursor_after(p);
        Self::move_prev(p, &mut c);
        c
    }

Deletion in sanakirja-core/src/btree/mod.rs at line 76 [4.45735]

B:BD[9.28958] → [11.8331:8475]

    unsafe fn unchecked_current<'a, T: LoadPage>(
        txn: &T,
        p: Page<'a>,
        c: &Self::Cursor,
    ) -> (&'a K, &'a V, u64);

Replacement in sanakirja-core/src/btree/mod.rs at line 80 [4.45735]
B:BD[11.8572] → [11.8572:8611]
∅:D[9.29132] → [4.46909:46977]
∅:D[11.8611] → [4.46909:46977]
∅:D[17.13744] → [4.46909:46977]
B:BD[4.46909] → [4.46909:46977]
B:BD[4.46977] → [11.8612:8676]
∅:D[9.29220] → [4.47025:47041]
∅:D[11.8676] → [4.47025:47041]
B:BD[4.47025] → [4.47025:47041]
```
    ) -> Option<(&'a K, &'a V, u64)> {
        if Self::is_empty(p, c) {
            None
        } else {
            unsafe { Some(Self::unchecked_current(txn, p, c)) }
        }
    }
```
[11.8572]
[9.29221]
```
    ) -> Option<(&'a K, &'a V, u64)>;
```
Insertion in sanakirja-core/src/btree/mod.rs at line 94 [4.45735]
[9.29659]
[4.47598]
```
    fn is_init(p: Page, c: &Self::Cursor) -> bool;
```
Replacement in sanakirja-core/src/btree/mod.rs at line 288 [4.45735]
∅:D[10.50887] → [9.31135:31156]
∅:D[19.126] → [9.31135:31156]
∅:D[11.9926] → [9.31135:31156]
∅:D[17.15028] → [9.31135:31156]
B:BD[4.52110] → [9.31135:31156]
```
    pub db: CowPage,
```
[11.9926]
[10.50888]
```
    pub db: u64,
```
Insertion in sanakirja-core/src/btree/mod.rs at line 293 [4.45735]
[4.52187]
[4.52187]
```
pub type Db<K, V> = Db_<K, V, page::Page<K, V>>;
```
Replacement in sanakirja-core/src/btree/mod.rs at line 297 [4.45735]
B:BD[20.221] → [20.221:265]
```
    pub fn from_page(db: CowPage) -> Self {
```
[20.221]
[20.265]
```
    pub fn from_page(db: u64) -> Self {
```
Deletion in sanakirja-core/src/btree/mod.rs at line 307 [4.45735]
∅:D[20.440] → [17.15084:15133]
B:BD[4.52188] → [17.15084:15133]
∅:D[17.15133] → [19.182:183]
B:BD[19.182] → [19.182:183]
```
pub type Db<K, V> = Db_<K, V, page::Page<K, V>>;
```
Replacement in sanakirja-core/src/btree/mod.rs at line 318 [4.45735]
∅:D[19.258] → [4.52429:52449]
B:BD[4.52429] → [4.52429:52449]
```
        db: page.0,
```
[19.258]
[10.51071]
```
        db: page.0.offset,
```
Replacement in sanakirja-core/src/btree/mod.rs at line 344 [4.45735]
∅:D[19.586] → [15.4086:4118]
∅:D[17.15515] → [15.4086:4118]
B:BD[15.4086] → [15.4086:4118]
```
    txn.incr_rc(db.db.offset)?;
```
[17.15515]
[19.587]
```
    txn.incr_rc(db.db)?;
```
Replacement in sanakirja-core/src/btree/mod.rs at line 379 [4.45735]
B:BD[6.771] → [6.771:797]
```
    let mut page = db.db;
```
[6.771]
[6.797]
```
    let mut page = txn.load_page(db.db)?;
```

Replacement in sanakirja-core/src/btree/mod.rs at line 381 [4.45735]

B:BD[6.833] → [6.833:891]

        let mut cursor = P::first_cursor(page.as_page());

[6.833]

[6.891]

        let mut cursor = P::cursor_before(page.as_page());

Replacement in sanakirja-core/src/btree/mod.rs at line 409 [4.45735]
∅:D[5.837] → [21.471:517]
B:BD[21.471] → [21.471:517]
```
    drop_::<T, K, V, P>(txn, db.db.as_page())
```
[5.837]
[15.4199]
```
    drop_::<T, K, V, P>(txn, txn.load_page(db.db)?.as_page())
```

Replacement in sanakirja-core/src/btree/mod.rs at line 422 [4.45735]

B:BD[21.798] → [21.798:894]

        let mut cursor = P::first_cursor(p);
        let left_page = P::left_child(p, &cursor);

[21.798]

[21.894]

        let mut cursor = P::cursor_before(p);
        let left_page = P::right_child(p, &cursor);

Replacement in sanakirja-core/src/btree/del.rs at line 29 [4.52511]
B:BD[4.53511] → [4.53511:53549]
```
    let mut cursor = Cursor::new(db);
```
[4.53511]
[4.53549]
```
    let mut cursor = Cursor::new(txn, db)?;
```
Replacement in sanakirja-core/src/btree/del.rs at line 55 [4.52511]
B:BD[17.16452] → [5.1055:1094]
```
        let (delk, delv, _) = unsafe {
```
[17.16452]
[17.16469]
```
        let (delk, delv, _) = {
```

Replacement in sanakirja-core/src/btree/del.rs at line 57 [4.52511]

B:BD[17.16509] → [5.1095:1183]

            P::unchecked_current(txn, cur.page.as_page(), cur.cursor.as_ref().unwrap())

[17.16509]

[5.1183]

            P::current(txn, cur.page.as_page(), &cur.cursor).unwrap()

Replacement in sanakirja-core/src/btree/del.rs at line 137 [4.52511]

B:BD[4.61365] → [9.32373:32463]

    let mut left_page = P::right_child(cur.page.as_page(), cur.cursor.as_ref().unwrap());

[4.61365]

[13.31432]

    let mut left_page = P::right_child(cur.page.as_page(), &cur.cursor);

Replacement in sanakirja-core/src/btree/del.rs at line 146 [4.52511]

B:BD[4.61547] → [9.32464:32516]

        let curs = P::first_cursor(page.as_page());

[4.61547]

[9.32516]

        let curs = P::cursor_first(page.as_page());

Replacement in sanakirja-core/src/btree/del.rs at line 150 [4.52511]
B:BD[4.61726] → [4.61726:61758]
```
            cursor: Some(curs),
```
[4.61726]
[4.61758]
```
            cursor: curs,
```

Replacement in sanakirja-core/src/btree/del.rs at line 171 [4.52511]

∅:D[5.1674] → [13.31983:32069]

∅:D[17.18674] → [13.31983:32069]

B:BD[13.31983] → [13.31983:32069]

    let (c0, c1) = P::split_at(curs0.page.as_page(), curs0.cursor.as_ref().unwrap());

[5.1674]

[5.1675]

    debug!("curs0 = {:?}", curs0);
    let (c0, c1) = P::split_at(curs0.page.as_page(), &curs0.cursor);

Replacement in sanakirja-core/src/btree/del.rs at line 188 [4.52511]

B:BD[13.32866] → [5.1717:1806]

        let (k, v, _) = unsafe { P::unchecked_current(txn, curs0.page.as_page(), &c0) };

[13.32866]

[5.1806]

        debug!("{:?}", c0);
        let (k, v, _) = P::current(txn, curs0.page.as_page(), &c1).unwrap();

Replacement in sanakirja-core/src/btree/del.rs at line 228 [4.52511]
∅:D[13.33791] → [9.32702:32745]
B:BD[4.62136] → [9.32702:32745]
```
    let c = curs.cursor.as_mut().unwrap();
```
[13.33791]
[13.33792]
```
    // let c = curs.cursor.as_mut().unwrap();
```

Replacement in sanakirja-core/src/btree/del.rs at line 232 [4.52511]

∅:D[18.3071] → [17.19576:19655]

B:BD[17.19576] → [17.19576:19655]

            let other = txn.load_page(P::left_child(curs.page.as_page(), c))?;

[18.3071]

[17.19655]

            let other = txn.load_page(P::left_child(curs.page.as_page(), &curs.cursor))?;

Replacement in sanakirja-core/src/btree/del.rs at line 244 [4.52511]

B:BD[9.33071] → [17.19874:19957]

        let (k, v, r) = if let Some(x) = P::current(txn, curs.page.as_page(), c) {

[9.33071]

[22.8793]

        let (k, v, r) = if let Some(x) = P::current(txn, curs.page.as_page(), &curs.cursor) {

Replacement in sanakirja-core/src/btree/del.rs at line 250 [4.52511]

B:BD[9.33213] → [17.19958:20033]

∅:D[17.20033] → [9.33283:33342]

B:BD[9.33283] → [9.33283:33342]

            let (k, v, _) = P::prev(txn, curs.page.as_page(), c).unwrap();
            let l = P::left_child(curs.page.as_page(), c);

[9.33213]

[9.33342]

            let (k, v, _) = P::prev(txn, curs.page.as_page(), &mut curs.cursor).unwrap();
            let l = P::left_child(curs.page.as_page(), &curs.cursor);

Replacement in sanakirja-core/src/btree/del.rs at line 283 [4.52511]

B:BD[13.34502] → [13.34502:34609]

        let c = curs.cursor.as_ref().unwrap();
        let (c0, c1) = P::split_at(curs.page.as_page(), c);

[13.34502]

[13.34609]

        let (c0, c1) = P::split_at(curs.page.as_page(), &curs.cursor);

Replacement in sanakirja-core/src/btree/del.rs at line 503 [4.52511]
B:BD[17.23988] → [17.23988:24023]
```
        db.db = txn.load_page(d)?;
```
[17.23988]
[11.10589]
```
        db.db = d;
```
Replacement in sanakirja-core/src/btree/del.rs at line 513 [4.52511]
B:BD[13.38748] → [13.38748:38775]
```
            db.db = page.0
```
[13.38748]
[13.38775]
```
            db.db = page.0.offset
```

Insertion in sanakirja-core/src/btree/del.rs at line 526 [4.52511]

[13.39035]

            let mut c = P::cursor_before(page.0.as_page());
            P::move_next(page.0.as_page(), &mut c);

Replacement in sanakirja-core/src/btree/del.rs at line 532 [4.52511]
B:BD[13.39122] → [13.39122:39174]
```
                &P::first_cursor(page.0.as_page()),
```
[13.39122]
[13.39174]
```
                &c,
```
Replacement in sanakirja-core/src/btree/del.rs at line 550 [4.52511]
B:BD[13.39551] → [13.39551:39578]
```
            db.db = page.0
```
[13.39551]
[13.39578]
```
            db.db = page.0.offset
```
Replacement in sanakirja-core/src/btree/cursor.rs at line 10 [4.63682]
∅:D[9.33822] → [4.63921:63956]
B:BD[4.63921] → [4.63921:63956]
```
    pub cursor: Option<P::Cursor>,
```
[9.33822]
[4.63956]
```
    pub cursor: P::Cursor,
```
Replacement in sanakirja-core/src/btree/cursor.rs at line 69 [4.63682]
∅:D[11.11112] → [17.24828:24872]
B:BD[4.65307] → [17.24828:24872]
```
    pub fn new(db: &Db_<K, V, P>) -> Self {
```
[11.11112]
[4.65353]
```
    pub fn new<T: LoadPage>(txn: &T, db: &Db_<K, V, P>) -> Result<Self, T::Error> {
```
Insertion in sanakirja-core/src/btree/cursor.rs at line 71 [4.63682]
[4.65424]
[7.597]
```
        let page = txn.load_page(db.db)?;
```
Replacement in sanakirja-core/src/btree/cursor.rs at line 73 [4.63682]
∅:D[7.646] → [4.65473:65498]
B:BD[4.65473] → [4.65473:65498]
B:BD[4.65498] → [5.3301:3327]
```
            page: db.db,
            cursor: None,
```
[7.646]
[5.3327]
```
            page,
            cursor: P::cursor_before(page.as_page()),
```
Replacement in sanakirja-core/src/btree/cursor.rs at line 76 [4.63682]
B:BD[4.65536] → [4.65536:65553]
```
        Cursor {
```
[5.3339]
[4.65553]
```
        Ok(Cursor {
```
Replacement in sanakirja-core/src/btree/cursor.rs at line 80 [4.63682]
∅:D[7.671] → [4.65635:65645]
B:BD[4.65635] → [4.65635:65645]
```
        }
```
[7.671]
[5.3424]
```
        })
```
Replacement in sanakirja-core/src/btree/cursor.rs at line 127 [4.63682]
B:BD[4.66515] → [4.66515:66557]
```
            if current.cursor.is_none() {
```
[4.66515]
[9.34164]
```
            /*if current.cursor.is_none() {
```

Replacement in sanakirja-core/src/btree/cursor.rs at line 129 [4.63682]

∅:D[9.34236] → [4.66620:66693]

B:BD[4.66620] → [4.66620:66693]

            }
            let cursor = current.cursor.as_mut().unwrap();

[9.34236]

[7.811]

            }*/
            let ref mut cursor = current.cursor;

Insertion in sanakirja-core/src/btree/cursor.rs at line 145 [4.63682]
[4.67194]
[7.933]
```
                let page = txn.load_page(next_page)?;
```

Replacement in sanakirja-core/src/btree/cursor.rs at line 147 [4.63682]

∅:D[7.972] → [9.34573:34660]

B:BD[9.34573] → [9.34573:34660]

                    page: txn.load_page(next_page)?,
                    cursor: None,

[7.972]

[9.34660]

                    page,
                    cursor: P::cursor_before(page.as_page()),

Deletion in sanakirja-core/src/btree/cursor.rs at line 166 [4.63682]
∅:D[9.34944] → [4.67731:67858]
∅:D[11.11340] → [4.67731:67858]
∅:D[17.25213] → [4.67731:67858]
B:BD[4.67731] → [4.67731:67858]
```
        // Set the "cursor stack" by setting a skip list cursor in
        // each page from the root to the appropriate leaf.
```

Insertion in sanakirja-core/src/btree/cursor.rs at line 167 [4.63682]

[4.67886]

        assert_eq!(self.pointer, 0);
        let current = unsafe { &mut *self.stack[self.pointer].as_mut_ptr() };
        current.cursor = P::cursor_last(current.page.as_page());

Insertion in sanakirja-core/src/btree/cursor.rs at line 172 [4.63682]
[4.67983]
[4.67983]
```
            debug!("{:?}", current.page);
```

Replacement in sanakirja-core/src/btree/cursor.rs at line 176 [4.63682]

B:BD[4.68135] → [4.68135:68177]

B:BD[4.68177] → [9.34945:35024]

∅:D[9.35024] → [4.68247:68320]

B:BD[4.68247] → [4.68247:68320]

B:BD[4.68320] → [17.25214:25312]

            if current.cursor.is_none() {
                current.cursor = Some(P::last_cursor(current.page.as_page()));
            }
            let cursor = current.cursor.as_mut().unwrap();
            let (k, v, r) = unsafe { P::unchecked_current(txn, current.page.as_page(), cursor) };

[4.68135]

[4.68404]

            debug!("cursor = {:?}", current.cursor);
            let (k, v, r) = P::current(txn, current.page.as_page(), &mut current.cursor).unwrap();

Insertion in sanakirja-core/src/btree/cursor.rs at line 179 [4.63682]
[4.68443]
[4.68443]
```
            debug!("k {:?} v {:?} r = {:?}", k, v, r);
```

Replacement in sanakirja-core/src/btree/cursor.rs at line 181 [4.63682]

B:BD[4.68466] → [4.68466:68653]

                self.pointer += 1;
                self.stack[self.pointer] = MaybeUninit::new(PageCursor {
                    page: txn.load_page(r)?,
                    cursor: None,

[4.68466]

[4.68653]

                let page = txn.load_page(r)?;
                self.push(PageCursor {
                    page,
                    cursor: P::cursor_last(page.as_page()),

Insertion in sanakirja-core/src/btree/cursor.rs at line 194 [4.63682]
[12.3459]
[12.3459]
```
        'a,
```
Replacement in sanakirja-core/src/btree/cursor.rs at line 197 [4.63682]
B:BD[12.3567] → [12.3567:3595]
```
        P: BTreePage<K, V>,
```
[12.3567]
[12.3595]
```
        P: BTreePage<K, V> + 'a,
```

Replacement in sanakirja-core/src/btree/cursor.rs at line 200 [4.63682]

∅:D[12.3619] → [11.11341:11441]

∅:D[7.1155] → [11.11341:11441]

B:BD[4.68806] → [11.11341:11441]

    pub fn next<'a, T: LoadPage>(&mut self, txn: &'a mut T) -> Result<Option<(&K, &V)>, T::Error> {

[12.3619]

[7.1156]

    pub fn next<T: LoadPage>(&mut self, txn: &T) -> Result<Option<(&'a K, &'a V)>, T::Error> {

Replacement in sanakirja-core/src/btree/cursor.rs at line 205 [4.63682]

B:BD[23.82] → [23.82:286]

B:BD[23.286] → [17.25419:25502]

∅:D[17.25502] → [23.364:395]

B:BD[23.364] → [23.364:395]

B:BD[23.395] → [7.1234:1281]

∅:D[7.1281] → [23.396:449]

B:BD[4.70566] → [23.396:449]

∅:D[23.449] → [4.70622:70713]

B:BD[4.70622] → [4.70622:70713]

B:BD[4.70713] → [11.11442:11491]

B:BD[11.11491] → [7.1282:1359]

∅:D[7.1359] → [23.584:646]

B:BD[23.584] → [23.584:646]

            if let Some(ref mut c) = current.cursor {
                // We're inside the page, and have already
                // processed the left child of the current page
                // cursor.
                if let Some((k, v, r)) = P::next(txn, current.page.as_page(), c) {
                    if r > 0 {
                        self.push(PageCursor {
                            page: txn.load_page(r)?,
                            cursor: None,
                        })
                    }
                    return Ok(Some((&*k, &*v)));
                } else if self.pointer > 0 {
                    self.pop();
                } else {
                    return Ok(None);

[23.82]

[23.646]

            if P::is_init(current.page.as_page(), &current.cursor) {
                P::move_next(current.page.as_page(), &mut current.cursor);
                let left = P::left_child(current.page.as_page(), &current.cursor);
                // Then visit the right child (if any), i.e. push.
                if left != 0 {
                    let page = txn.load_page(left)?;
                    self.push(PageCursor {
                        page,
                        cursor: P::cursor_before(page.as_page()),
                    })
                }
            } else if let Some((k, v, r)) = P::current(txn, current.page.as_page(), &current.cursor) {
                P::move_next(current.page.as_page(), &mut current.cursor);
                if r > 0 {
                    let page = txn.load_page(r)?;
                    self.push(PageCursor {
                        page,
                        cursor: P::cursor_before(page.as_page()),
                    })

Insertion in sanakirja-core/src/btree/cursor.rs at line 225 [4.63682]

[23.664]

                return Ok(Some((k, v)));
            } else if self.pointer > 0 {
                self.pop();

Replacement in sanakirja-core/src/btree/cursor.rs at line 229 [4.63682]

B:BD[23.685] → [23.685:1060]

                current.cursor = Some(P::first_cursor(current.page.as_page()));
                // First element of a page (not a binding).
                let cursor = current.cursor.as_ref().unwrap();
                let left = P::left_child(current.page.as_page(), cursor);
                // Then visit the right child (if any), i.e. push.
                if left != 0 {

[23.685]

[7.1360]

                return Ok(None);
            }
        }
    }
    pub fn prev<T: LoadPage>(&mut self, txn: &T) -> Result<Option<(&'a K, &'a V)>, T::Error> {
        loop {
            let current = unsafe { &mut *self.stack[self.pointer].as_mut_ptr() };
            if P::is_empty(current.page.as_page(), &current.cursor) {
                P::move_prev(current.page.as_page(), &mut current.cursor);
                let right = P::right_child(current.page.as_page(), &current.cursor);
                if right != 0 {
                    let page = txn.load_page(right)?;

Replacement in sanakirja-core/src/btree/cursor.rs at line 243 [4.63682]

∅:D[7.1403] → [23.1176:1266]

B:BD[23.1176] → [23.1176:1266]

                        page: txn.load_page(left)?,
                        cursor: None,

[7.1403]

[23.1266]

                        page,
                        cursor: P::cursor_after(page.as_page()),
                    })
                }
            } else if let Some((k, v, _)) = P::current(txn, current.page.as_page(), &current.cursor) {
                P::move_prev(current.page.as_page(), &mut current.cursor);
                let l = P::right_child(current.page.as_page(), &current.cursor);
                if l > 0 {
                    let page = txn.load_page(l)?;
                    self.push(PageCursor {
                        page,
                        cursor: P::cursor_after(page.as_page()),

Insertion in sanakirja-core/src/btree/cursor.rs at line 257 [4.63682]

[4.70731]

                return Ok(Some((k, v,)))
            } else if self.pointer > 0 {
                self.pop();
            } else {
                return Ok(None);

Insertion in sanakirja-core/src/btree/cursor.rs at line 265 [4.63682]
[4.70761]
[4.70761]
Replacement in sanakirja/src/tests.rs at line 29 [24.11]
∅:D[19.1150] → [24.1288:1312]
∅:D[17.25649] → [24.1288:1312]
B:BD[24.1288] → [24.1288:1312]
```
    let n = 100_000u64;
```
[17.25649]
[24.1312]
```
    let n = 1_000u64;
```

Replacement in sanakirja/src/tests.rs at line 45 [24.11]

B:BD[24.1953] → [24.1953:2005]

    let mut curs = btree::cursor::Cursor::new(&db);

[24.1953]

[24.2005]

    let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();

Replacement in sanakirja/src/tests.rs at line 47 [24.11]

B:BD[24.2025] → [24.2025:2086]

    while let Some((k, _v)) = curs.next(&mut txn).unwrap() {

[24.2025]

[24.2148]

    while let Some((k, v)) = curs.next(&mut txn).unwrap() {
        debug!("{:?} {:?}", k, v.0[0]);

Replacement in sanakirja/src/tests.rs at line 57 [24.11]
∅:D[11.11543] → [24.2389:2441]
B:BD[24.2389] → [24.2389:2441]
```
    let mut curs = btree::cursor::Cursor::new(&db);
```
[11.11543]
[24.2441]
```
    let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();
```

Replacement in sanakirja/src/tests.rs at line 65 [24.11]

B:BD[24.2627] → [24.2627:2679]

    let mut curs = btree::cursor::Cursor::new(&db);

[24.2627]

[17.25714]

    let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();

Replacement in sanakirja/src/tests.rs at line 74 [24.11]

B:BD[24.2931] → [24.2931:2983]

    let mut curs = btree::cursor::Cursor::new(&db);

[24.2931]

[24.2983]

    crate::debug::debug(&txn, &[&db], "debug0", true);
    let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();

Replacement in sanakirja/src/tests.rs at line 124 [24.11]
∅:D[25.1517] → [24.5540:5592]
B:BD[24.5540] → [24.5540:5592]
```
    let mut curs = btree::cursor::Cursor::new(&db);
```
[25.1517]
[24.5592]
```
    let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();
```
Replacement in sanakirja/src/tests.rs at line 186 [24.11]
∅:D[26.121] → [24.6625:6677]
∅:D[25.1992] → [24.6625:6677]
B:BD[24.6625] → [24.6625:6677]
```
    let mut curs = btree::cursor::Cursor::new(&db);
```
[24.6528]
[24.6677]
```
    let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();
```

Replacement in sanakirja/src/tests.rs at line 193 [24.11]

B:BD[24.6847] → [24.6847:6899]

    let mut curs = btree::cursor::Cursor::new(&db);

[24.6847]

[17.26151]

    let mut curs = btree::cursor::Cursor::new(&txn, &db).unwrap();

Replacement in sanakirja/src/tests.rs at line 197 [24.11]

B:BD[24.6988] → [24.6988:7041]

    let mut curs = btree::cursor::Cursor::new(&db2);

[24.6988]

[24.7041]

    let mut curs = btree::cursor::Cursor::new(&txn, &db2).unwrap();

Replacement in sanakirja/src/tests.rs at line 247 [24.11]
∅:D[20.615] → [24.7458:7487]
B:BD[24.7458] → [24.7458:7487]
```
    if txn.free.offset > 0 {
```
[20.615]
[24.7487]
```
    if txn.free > 0 {
```

Replacement in sanakirja/src/tests.rs at line 254 [24.11]

B:BD[24.7597] → [17.26875:26968]

        let mut curs: btree::cursor::Cursor<_, _, B> = btree::cursor::Cursor::new(&db_free);

[24.7597]

[24.7693]

        let mut curs: btree::cursor::Cursor<_, _, B> =
            btree::cursor::Cursor::new(txn, &db_free).unwrap();

Replacement in sanakirja/src/tests.rs at line 272 [24.11]
B:BD[24.8067] → [17.27076:27126]
```
    debug!("------ add_refs {:?}", db.db.offset);
```
[24.8067]
[24.8067]
```
    debug!("------ add_refs {:?}", db.db);
```
Replacement in sanakirja/src/tests.rs at line 276 [24.11]
∅:D[17.27161] → [24.8138:8176]
B:BD[24.8138] → [24.8138:8176]
```
        match pages.entry(p.offset) {
```
[17.27161]
[24.8176]
```
        match pages.entry(p) {
```

Replacement in sanakirja/src/tests.rs at line 279 [24.11]

B:BD[24.8239] → [24.8239:8297]

                let mut c = P::first_cursor(p.as_page());

[24.8239]

[24.8297]

                let p = txn.load_page(p)?;
                let mut c = P::cursor_first(p.as_page());

Replacement in sanakirja/src/tests.rs at line 284 [24.11]

B:BD[24.8380] → [24.8380:8431]

                    stack.push(txn.load_page(l)?);

[24.8380]

[17.27202]

                    stack.push(l);

Replacement in sanakirja/src/tests.rs at line 287 [24.11]
∅:D[17.27333] → [24.8510:8564]
B:BD[24.8510] → [24.8510:8564]
```
                        stack.push(txn.load_page(r)?)
```
[17.27333]
[24.8564]
```
                        stack.push(r);
```

Replacement in sanakirja/src/tests.rs at line 317 [24.11]

B:BD[20.1215] → [20.1215:1297]

        debug!("db = {:?}", db.db.offset);
        txn.set_root(0, db.db.offset);

[20.1215]

[20.1297]

        debug!("db = {:?}", db.db);
        txn.set_root(0, db.db);

Replacement in sanakirja/src/tests.rs at line 330 [24.11]

B:BD[20.1915] → [20.1915:1997]

        debug!("db = {:?}", db.db.offset);
        txn.set_root(0, db.db.offset);

[20.1915]

[20.1997]

        debug!("db = {:?}", db.db);
        txn.set_root(0, db.db);

Insertion in sanakirja/src/tests.rs at line 438 [24.11]
[27.1074]
[27.1074]
```
#[ignore]
```
Replacement in sanakirja/src/tests.rs at line 623 [24.11]
B:BD[3.533] → [3.533:553]
```
    mut p: CowPage,
```
[3.533]
[3.553]
```
    mut p: u64,
```

Replacement in sanakirja/src/tests.rs at line 627 [24.11]

B:BD[3.614] → [3.614:718]

        let cursor = P::first_cursor(p.as_page());
        let l = P::left_child(p.as_page(), &cursor);

[3.614]

[3.718]

        let pp = txn.load_page(p)?;
        let cursor = P::cursor_first(pp.as_page());
        let l = P::left_child(pp.as_page(), &cursor);

Replacement in sanakirja/src/tests.rs at line 633 [24.11]
B:BD[3.774] → [3.774:805]
```
        p = txn.load_page(l)?;
```
[3.774]
[3.805]
```
        p = l;
```
Insertion in sanakirja/src/tests.rs at line 661 [24.11]
[3.839]
[3.839]
```
#[ignore]
```
Replacement in sanakirja/src/environment/muttxn.rs at line 17 [4.80166]
∅:D[28.2579] → [23.1290:1320]
B:BD[4.80384] → [23.1290:1320]
```
    pub(crate) free: CowPage,
```
[28.2579]
[17.27437]
```
    pub(crate) free: u64,
```

Replacement in sanakirja/src/environment/muttxn.rs at line 104 [4.80166]

B:BD[4.82918] → [9.37416:37453]

∅:D[9.37453] → [4.82952:83075]

B:BD[4.82952] → [4.82952:83075]

                let free = CowPage {
                    data: env_.find_offset(header.free_db),
                    offset: header.free_db,
                };

[4.82918]

[4.83075]

                let free = header.free_db;

Replacement in sanakirja/src/environment/muttxn.rs at line 109 [4.80166]

B:BD[4.83210] → [9.37454:37492]

∅:D[9.37492] → [4.83245:83388]

B:BD[4.83245] → [4.83245:83388]

                        db: CowPage {
                            offset: header.rc_db,
                            data: env_.find_offset(header.rc_db),
                        },

[4.83210]

[10.52819]

                        db: header.rc_db,

Replacement in sanakirja/src/environment/muttxn.rs at line 139 [4.80166]

B:BD[4.84183] → [20.3092:3232]

            let mut free_db: btree::Db<u64, ()> =
                btree::Db::from_page(std::mem::replace(&mut self.free, CowPage::null()));

[4.84183]

[4.84575]

            let mut free_db: btree::Db<u64, ()> = btree::Db::from_page(self.free);

Replacement in sanakirja/src/environment/muttxn.rs at line 156 [4.80166]

B:BD[4.85441] → [4.85441:85506]

            (&mut *globptr).free_db = free_db.db.offset.to_le();

[4.85441]

[20.3233]

            (&mut *globptr).free_db = free_db.db.to_le();

Replacement in sanakirja/src/environment/muttxn.rs at line 211 [4.80166]
B:BD[4.86463] → [4.86463:86498]
```
        if self.free.offset == 0 {
```
[4.86463]
[4.86498]
```
        if self.free == 0 {
```

Replacement in sanakirja/src/environment/muttxn.rs at line 220 [4.80166]

B:BD[4.86708] → [4.86708:86764]

        let mut curs = btree::cursor::Cursor::new(&db);

[4.86708]

[4.86764]

        let mut curs = btree::cursor::Cursor::new(self, &db)?;

Replacement in sanakirja/src/environment/muttxn.rs at line 267 [4.80166]

B:BD[4.88548] → [4.88548:88609]

            let mut curs = btree::cursor::Cursor::new(&rc_);

[4.88548]

[4.88609]

            let mut curs = btree::cursor::Cursor::new(self, &rc_)?;

Replacement in sanakirja/src/environment/muttxn.rs at line 300 [4.80166]

B:BD[4.89329] → [4.89329:89390]

            let mut curs = btree::cursor::Cursor::new(&rc_);

[4.89329]

[9.38881]

            let mut curs = btree::cursor::Cursor::new(self, &rc_)?;

Replacement in sanakirja/src/environment/muttxn.rs at line 335 [4.80166]

B:BD[4.90170] → [4.90170:90231]

            let mut curs = btree::cursor::Cursor::new(&rc_);

[4.90170]

[9.39392]

            let mut curs = btree::cursor::Cursor::new(self, &rc_)?;

Replacement in sanakirja/src/environment/muttxn.rs at line 388 [4.80166]

B:BD[19.4442] → [11.12893:12945]

    fn root_db<K: Representable, V: Representable>(

[19.4442]

[19.4529]

    fn root_db<
        K: Representable + ?Sized,
        V: Representable + ?Sized,
        P: crate::btree::BTreePage<K, V>,
    >(

Replacement in sanakirja/src/environment/muttxn.rs at line 395 [4.80166]
B:BD[19.4562] → [17.27644:27710]
∅:D[17.27710] → [19.4634:4672]
B:BD[19.4634] → [19.4634:4672]
```
    ) -> Result<Option<sanakirja_core::btree::Db<K, V>>, Error> {
        use sanakirja_core::LoadPage;
```
[19.4562]
[19.4672]
```
    ) -> Option<sanakirja_core::btree::Db_<K, V, P>> {
```

Replacement in sanakirja/src/environment/muttxn.rs at line 397 [4.80166]

B:BD[19.4718] → [19.4718:4808]

            Ok(Some(sanakirja_core::btree::Db {
                db: self.load_page(*db)?,

[19.4718]

[10.53239]

            Some(sanakirja_core::btree::Db_ {
                db: *db,

Replacement in sanakirja/src/environment/muttxn.rs at line 402 [4.80166]
∅:D[10.53374] → [19.4858:4874]
B:BD[19.4858] → [19.4858:4874]
```
            }))
```
[10.53374]
[19.4874]
```
            })
```

Replacement in sanakirja/src/environment/muttxn.rs at line 415 [4.80166]

B:BD[19.5228] → [19.5228:5333]

                    Ok(Some(sanakirja_core::btree::Db {
                        db: self.load_page(db)?,

[19.5228]

[10.53375]

                    Some(sanakirja_core::btree::Db_ {
                        db,

Replacement in sanakirja/src/environment/muttxn.rs at line 420 [4.80166]
∅:D[10.53534] → [19.5391:5415]
B:BD[19.5391] → [19.5391:5415]
```
                    }))
```
[10.53534]
[19.5415]
```
                    })
```
Replacement in sanakirja/src/environment/muttxn.rs at line 422 [4.80166]
B:BD[19.5440] → [19.5440:5469]
```
                    Ok(None)
```
[19.5440]
[19.5469]
```
                    None
```

Replacement in sanakirja/src/environment/mod.rs at line 426 [4.91606]

B:BD[4.106701] → [19.6117:6170]

B:BD[19.6170] → [11.13120:13172]

pub trait RootDb: Sized + sanakirja_core::LoadPage {
    fn root_db<K: Representable, V: Representable>(

[4.106701]

[19.6257]

pub trait RootDb {
    fn root_db<
        K: Representable + ?Sized,
        V: Representable + ?Sized,
        P: crate::btree::BTreePage<K, V>,
    >(
        &self,
        n: usize,
    ) -> Option<sanakirja_core::btree::Db_<K, V, P>>;
}
impl<E: Borrow<Env>> RootDb for Txn<E> {
    fn root_db<
        K: Representable + ?Sized,
        V: Representable + ?Sized,
        P: crate::btree::BTreePage<K, V>,
    >(

Replacement in sanakirja/src/environment/mod.rs at line 445 [4.91606]

B:BD[19.6290] → [17.27764:27835]

    ) -> Result<Option<sanakirja_core::btree::Db<K, V>>, Self::Error>;

[19.6290]

[19.6367]

    ) -> Option<sanakirja_core::btree::Db_<K, V, P>> {
        unsafe {
            let env = self.env.borrow();
            let db = {
                let maps = env.mmaps.lock();
                *(maps[0]
                    .ptr
                    .add(self.root * PAGE_SIZE + GLOBAL_HEADER_SIZE + 8 * n)
                    as *mut u64)
            };
            if db != 0 {
                Some(sanakirja_core::btree::Db_ {
                    db,
                    k: std::marker::PhantomData,
                    v: std::marker::PhantomData,
                    p: std::marker::PhantomData,
                })
            } else {
                None
            }
        }
    }

Replacement in sanakirja/src/debug.rs at line 28 [2.11]

B:BD[2.663] → [2.663:746]

        print_page::<T, K, V, PP>(t, &mut h, &mut buf, &db.db.as_page(), recurse);

[2.663]

[2.746]

        print_page::<T, K, V, PP>(
            t,
            &mut h,
            &mut buf,
            &t.load_page(db.db).unwrap().as_page(),
            recurse,
        );

Replacement in sanakirja/src/debug.rs at line 95 [2.11]
B:BD[2.2191] → [2.2191:2233]
```
    let mut cursor = P::first_cursor(*p);
```
[2.2191]
[2.2233]
```
    let mut cursor = P::cursor_first(*p);
```

implementing prev() on cursors (+ some cleanup)

Dependencies

In channels

Change contents

Replacement in sanakirja-core/src/btree/put.rs at line 29 [4.3448]

Replacement in sanakirja-core/src/btree/put.rs at line 38 [4.3448]

Replacement in sanakirja-core/src/btree/put.rs at line 46 [4.3448]

Replacement in sanakirja-core/src/btree/put.rs at line 88 [4.3448]

Replacement in sanakirja-core/src/btree/put.rs at line 105 [4.3448]

Replacement in sanakirja-core/src/btree/put.rs at line 125 [4.3448]

Replacement in sanakirja-core/src/btree/put.rs at line 171 [4.3448]

Insertion in sanakirja-core/src/btree/page_unsized.rs at line 75 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 77 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 79 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 124 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 138 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 146 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 149 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 152 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 156 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 176 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 182 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 241 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 286 [10.2014]

Insertion in sanakirja-core/src/btree/page_unsized.rs at line 288 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 293 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 296 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 299 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 303 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 318 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 331 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 333 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 341 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 345 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 352 [10.2014]

Insertion in sanakirja-core/src/btree/page_unsized.rs at line 364 [10.2014]

Insertion in sanakirja-core/src/btree/page_unsized.rs at line 369 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 373 [10.2014]

Insertion in sanakirja-core/src/btree/page_unsized.rs at line 378 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 382 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 414 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 418 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 429 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 504 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 590 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 597 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 647 [10.2014]

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 18 [10.22926]

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 20 [10.22926]

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 51 [10.22926]

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 101 [10.22926]

Replacement in sanakirja-core/src/btree/page_unsized/rebalance.rs at line 105 [10.22926]

Insertion in sanakirja-core/src/btree/page.rs at line 12 [4.8623]

Insertion in sanakirja-core/src/btree/page.rs at line 93 [4.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 95 [4.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 97 [4.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 141 [4.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 155 [4.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 166 [4.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 168 [4.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 171 [4.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 192 [4.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 198 [4.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 256 [4.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 301 [4.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 308 [4.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 311 [4.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 314 [4.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 318 [4.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 326 [4.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 328 [4.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 339 [4.8623]

Insertion in sanakirja-core/src/btree/page.rs at line 351 [4.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 356 [4.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 358 [4.8623]

Insertion in sanakirja-core/src/btree/page.rs at line 363 [4.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 369 [4.8623]

Replacement in sanakirja-core/src/btree/page.rs at line 376 [4.8623]

Insertion in sanakirja-core/src/btree/page.rs at line 388 [4.8623]

Insertion in sanakirja-core/src/btree/page.rs at line 393 [4.8623]