pijul/sanakirja - Change QYDGYIZRNFRIQD7RUCY5YAN3F2THZA74E5UOHPIFWSULEJFAFVJQC

Split trait Representable into its mandatory part and an optional part

Created by pmeunier on February 14, 2021

QYDGYIZRNFRIQD7RUCY5YAN3F2THZA74E5UOHPIFWSULEJFAFVJQC

Dependencies

In channels

main

Change contents

Replacement in sanakirja-core/src/lib.rs at line 36 [4.91]

∅:D[2.303] → [3.0:44]

B:BD[4.119] → [3.0:44]

B:BD[4.506] → [4.506:701]

B:BD[4.701] → [2.304:593]

∅:D[2.593] → [4.701:732]

B:BD[4.701] → [4.701:732]

B:BD[4.732] → [2.594:724]

∅:D[2.724] → [5.0:64]

B:BD[4.732] → [5.0:64]

B:BD[5.64] → [2.725:894]

∅:D[2.894] → [6.116:196]

B:BD[5.64] → [6.116:196]

B:BD[6.196] → [2.895:1004]

∅:D[2.1004] → [5.65:150]

∅:D[6.196] → [5.65:150]

B:BD[7.166] → [5.65:150]

B:BD[5.150] → [2.1005:1129]

∅:D[2.1129] → [8.50:98]

∅:D[5.150] → [8.50:98]

B:BD[8.50] → [8.50:98]

B:BD[8.98] → [2.1130:1131]

pub trait Representable: core::fmt::Debug {
    /// If this value is an offset to another page at offset `offset`,
    /// return `Some(offset)`. Return `None` else.
    fn page_offsets(&self) -> Self::PageOffsets;
    const ALIGN: usize;
    /// Some datastructures expect this to be at least the memory size
    /// of `Self` (as returned by `core::mem::size_of::<Self>()`). For
    /// example, the sized implementation of B trees sometimes
    /// allocates an instance of `Self` on the stack, and copy it from
    /// the
    const SIZE: Option<usize>;
    /// If `Self::SIZE.is_some()`, this must return the same
    /// value. The default implementation is `Self;:SIZE.unwrap()`.
    fn size(&self) -> usize {
        Self::SIZE.unwrap()
    }
    /// Form a pointer to `Self` from a raw pointer. The purpose of
    /// this function is that the output can be a slim or a fat
    /// pointer (like for `&[u8]`).
    unsafe fn from_raw_ptr<'a, T: LoadPage>(txn: &T, p: *const u8) -> &'a Self;
    /// Read the size from an on-page entry. If `Self::SIZE.is_some()`
    /// this must be the same value.
    unsafe fn onpage_size(_: *const u8) -> usize {
        Self::SIZE.unwrap()
    }
    /// Write to a page. Must not overwrite the allocated size, but
    /// this isn't checkde (which is why it's unsafe).
    unsafe fn write_to_page(&self, p: *mut u8);

[2.303]

[2.1131]

pub trait Storable: core::fmt::Debug {

Insertion in sanakirja-core/src/lib.rs at line 43 [4.91]

[2.1363]

    /// If this value is an offset to another page at offset `offset`,
    /// return `Some(offset)`. Return `None` else.
    fn page_offsets(&self) -> Self::PageOffsets;

Replacement in sanakirja-core/src/lib.rs at line 60 [4.91]
B:BD[4.809] → [7.167:203]
```
        impl Representable for $t {
```
[4.809]
[4.851]
```
        impl Storable for $t {
```

Deletion in sanakirja-core/src/lib.rs at line 65 [4.91]

B:BD[4.1014] → [4.1014:1154]

            const ALIGN: usize = core::mem::align_of::<Self>();
            const SIZE: Option<usize> = Some(core::mem::size_of::<Self>());

Replacement in sanakirja-core/src/lib.rs at line 68 [4.91]

B:BD[4.1364] → [7.280:357]

B:BD[7.357] → [7.357:394]

            unsafe fn from_raw_ptr<'a, T>(_: &T, p: *const u8) -> &'a Self {
                &*(p as *const Self)

[4.1267]

[8.99]

        }
        impl UnsizedStorable for $t {
            const ALIGN: usize = core::mem::align_of::<$t>();
            /// If `Self::SIZE.is_some()`, this must return the same
            /// value. The default implementation is `Self;:SIZE.unwrap()`.
            fn size(&self) -> usize {
                core::mem::size_of::<Self>()

Insertion in sanakirja-core/src/lib.rs at line 77 [4.91]

[8.113]

[8.231]


            /// Read the size from an on-page entry.
            unsafe fn onpage_size(_: *const u8) -> usize {
                core::mem::size_of::<Self>()
            }
            /// Write to a page. Must not overwrite the allocated size, but
            /// this isn't checked (which is why it's unsafe).

Insertion in sanakirja-core/src/lib.rs at line 88 [4.91]

[7.408]

[4.1364]


            unsafe fn from_raw_ptr<'a, T>(_: &T, p: *const u8) -> &'a Self {
                &*(p as *const Self)
            }

Replacement in sanakirja-core/src/lib.rs at line 107 [4.91]

B:BD[8.362] → [8.362:392]

impl Representable for [u8] {

[8.362]

[8.392]

/// Types that can be stored on disk.
pub trait UnsizedStorable: Storable {
    const ALIGN: usize;
    /// If `Self::SIZE.is_some()`, this must return the same
    /// value. The default implementation is `Self;:SIZE.unwrap()`.
    fn size(&self) -> usize;
    /// Read the size from an on-page entry. If `Self::SIZE.is_some()`
    /// this must be the same value.
    unsafe fn onpage_size(_: *const u8) -> usize;
    /// Write to a page. Must not overwrite the allocated size, but
    /// this isn't checked (which is why it's unsafe).
    unsafe fn write_to_page(&self, p: *mut u8);
    unsafe fn from_raw_ptr<'a, T>(_: &T, p: *const u8) -> &'a Self;
}
impl Storable for [u8] {

Deletion in sanakirja-core/src/lib.rs at line 131 [4.91]
B:BD[8.523] → [8.523:589]
```
    const ALIGN: usize = 2;
    const SIZE: Option<usize> = None;
```
Insertion in sanakirja-core/src/lib.rs at line 134 [4.91]
[8.682]
[8.682]
```
}
impl UnsizedStorable for [u8] {
    const ALIGN: usize = 2;
```

Replacement in sanakirja-core/src/lib.rs at line 158 [4.91]

B:BD[7.469] → [6.197:280]

unsafe fn read<T: LoadPage, K: Representable + ?Sized, V: Representable + ?Sized>(

[7.469]

[2.1659]

unsafe fn read<T: LoadPage, K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized>(

Replacement in sanakirja-core/src/lib.rs at line 169 [4.91]

B:BD[4.1749] → [9.135:228]

fn alloc_size<K: Representable + ?Sized, V: Representable + ?Sized>(k: &K, v: &V) -> usize {

[4.1749]

[4.1833]

fn alloc_size<K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized>(k: &K, v: &V) -> usize {

Replacement in sanakirja-core/src/lib.rs at line 175 [4.91]

B:BD[4.1972] → [9.229:329]

unsafe fn entry_size<K: Representable + ?Sized, V: Representable + ?Sized>(k: *const u8) -> usize {

[4.1972]

[8.1663]

unsafe fn entry_size<K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized>(
    k: *const u8,
) -> usize {

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

B:BD[9.360] → [9.360:460]

    K: Representable + ?Sized + core::fmt::Debug,
    V: Representable + ?Sized + core::fmt::Debug,

[9.360]

[9.460]

    K: Storable + ?Sized + core::fmt::Debug,
    V: Storable + ?Sized + core::fmt::Debug,

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

B:BD[9.525] → [9.525:625]

    K: Representable + ?Sized + core::fmt::Debug,
    V: Representable + ?Sized + core::fmt::Debug,

[9.525]

[9.625]

    K: Storable + ?Sized + core::fmt::Debug,
    V: Storable + ?Sized + core::fmt::Debug,

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

B:BD[4.7489] → [9.787:849]

    K: Representable + ?Sized,
    V: Representable + ?Sized,

[4.7489]

[7.1076]

    K: Storable + ?Sized,
    V: Storable + ?Sized,

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

B:BD[8.2334] → [9.1081:1189]

        K: Representable + ?Sized + core::fmt::Debug,
        V: Representable + ?Sized + core::fmt::Debug,

[8.2334]

[8.2438]

        K: UnsizedStorable + ?Sized + core::fmt::Debug,
        V: UnsizedStorable + ?Sized + core::fmt::Debug,

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 270 [8.2014]

B:BD[8.11586] → [10.584:647]

fn size<K: Representable + ?Sized, V: Representable + ?Sized>(

[8.11586]

[10.647]

fn size<K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized>(

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 291 [8.2014]

∅:D[10.1234] → [9.1341:1440]

B:BD[8.11586] → [9.1341:1440]

impl<K: Representable + ?Sized, V: Representable + ?Sized> super::BTreePage<K, V> for Page<K, V> {

[10.1234]

[11.2467]

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

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 438 [8.2014]

B:BD[8.16540] → [6.1474:1559]

unsafe fn lookup<T: LoadPage, K: Representable + ?Sized, V: Representable + ?Sized>(

[8.16540]

[8.16615]

unsafe fn lookup<T: LoadPage, K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized>(

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 542 [8.2014]

B:BD[8.19008] → [8.19008:19108]

    K: Representable + ?Sized + core::fmt::Debug,
    V: Representable + ?Sized + core::fmt::Debug,

[8.19008]

[8.19108]

    K: UnsizedStorable + ?Sized + core::fmt::Debug,
    V: UnsizedStorable + ?Sized + core::fmt::Debug,

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 580 [8.2014]

B:BD[8.20093] → [8.20093:20193]

    K: Representable + ?Sized + core::fmt::Debug,
    V: Representable + ?Sized + core::fmt::Debug,

[8.20093]

[8.20193]

    K: UnsizedStorable + ?Sized + core::fmt::Debug,
    V: UnsizedStorable + ?Sized + core::fmt::Debug,

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 609 [8.2014]

B:BD[8.21214] → [8.21214:21288]

fn clone<K: Representable + ?Sized, V: Representable + ?Sized, L: Alloc>(

[8.21213]

[8.21288]

fn clone<K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized, L: Alloc>(

Replacement in sanakirja-core/src/btree/page_unsized.rs at line 637 [8.2014]

B:BD[8.22308] → [8.22308:22382]

fn alloc<K: Representable + ?Sized, V: Representable + ?Sized, L: Alloc>(

[8.22308]

[8.22382]

fn alloc<K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized, L: Alloc>(

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

B:BD[8.22998] → [8.22998:23098]

    K: Representable + ?Sized + core::fmt::Debug,
    V: Representable + ?Sized + core::fmt::Debug,

[8.22998]

[8.23098]

    K: UnsizedStorable + ?Sized + core::fmt::Debug,
    V: UnsizedStorable + ?Sized + core::fmt::Debug,

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

B:BD[8.25027] → [8.25027:25127]

    K: Representable + ?Sized + core::fmt::Debug,
    V: Representable + ?Sized + core::fmt::Debug,

[8.25027]

[8.25127]

    K: UnsizedStorable + ?Sized + core::fmt::Debug,
    V: UnsizedStorable + ?Sized + core::fmt::Debug,

Replacement in sanakirja-core/src/btree/page_unsized/put.rs at line 7 [8.27023]

B:BD[8.27084] → [8.27084:27184]

    K: Representable + ?Sized + core::fmt::Debug,
    V: Representable + ?Sized + core::fmt::Debug,

[8.27084]

[8.27184]

    K: UnsizedStorable + ?Sized + core::fmt::Debug,
    V: UnsizedStorable + ?Sized + core::fmt::Debug,

Replacement in sanakirja-core/src/btree/page_unsized/put.rs at line 95 [8.27023]

B:BD[8.29277] → [8.29277:29377]

    K: Representable + ?Sized + core::fmt::Debug,
    V: Representable + ?Sized + core::fmt::Debug,

[8.29277]

[8.29377]

    K: UnsizedStorable + ?Sized + core::fmt::Debug,
    V: UnsizedStorable + ?Sized + core::fmt::Debug,

Replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 6 [8.33822]

B:BD[9.2975] → [12.4328:4403]

    fn current_size<K: Representable + ?Sized, V: Representable + ?Sized>(

[9.2975]

[12.4403]

    fn current_size<K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized>(

Replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 15 [8.33822]

B:BD[8.34317] → [8.34317:34396]

    fn truncate_left<T, K: Representable + ?Sized, V: Representable + ?Sized>(

[8.34317]

[8.34396]

    fn truncate_left<T, K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized>(

Replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 21 [8.33822]

B:BD[8.34499] → [8.34499:34574]

    fn alloc_insert<K: Representable + ?Sized, V: Representable + ?Sized>(

[8.34499]

[8.34574]

    fn alloc_insert<K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized>(

Replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 30 [8.33822]

B:BD[8.34865] → [8.34865:34944]

    fn offset_slice<'a, K: Representable + ?Sized, V: Representable + ?Sized>(

[8.34865]

[8.34944]

    fn offset_slice<'a, K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized>(

Replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 33 [8.33822]

B:BD[8.35011] → [6.2933:3015]

    fn kv<'a, T: LoadPage, K: Representable + ?Sized, V: Representable + ?Sized>(

[8.35011]

[8.35083]

    fn kv<'a, T: LoadPage, K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized>(

Replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 68 [8.33822]

B:BD[8.35961] → [12.4523:4598]

    fn current_size<K: Representable + ?Sized, V: Representable + ?Sized>(

[8.35961]

[12.4598]

    fn current_size<K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized>(

Replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 99 [8.33822]

B:BD[8.36469] → [8.36469:36548]

    fn truncate_left<T, K: Representable + ?Sized, V: Representable + ?Sized>(

[8.36469]

[8.36548]

    fn truncate_left<T, K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized>(

Replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 133 [8.33822]

B:BD[8.37823] → [8.37823:37898]

    fn alloc_insert<K: Representable + ?Sized, V: Representable + ?Sized>(

[8.37823]

[8.37898]

    fn alloc_insert<K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized>(

Replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 166 [8.33822]

B:BD[8.38879] → [8.38879:38958]

    fn offset_slice<'a, K: Representable + ?Sized, V: Representable + ?Sized>(

[8.38879]

[8.38958]

    fn offset_slice<'a, K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized>(

Replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 177 [8.33822]

B:BD[8.39262] → [6.3042:3124]

    fn kv<'a, T: LoadPage, K: Representable + ?Sized, V: Representable + ?Sized>(

[8.39262]

[8.39334]

    fn kv<'a, T: LoadPage, K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized>(

Replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 193 [8.33822]

B:BD[12.5064] → [12.5064:5139]

    fn current_size<K: Representable + ?Sized, V: Representable + ?Sized>(

[12.5064]

[12.5139]

    fn current_size<K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized>(

Replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 226 [8.33822]

∅:D[9.4588] → [8.40209:40288]

B:BD[8.40209] → [8.40209:40288]

    fn truncate_left<T, K: Representable + ?Sized, V: Representable + ?Sized>(

[9.4588]

[8.40288]

    fn truncate_left<T, K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized>(

Replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 268 [8.33822]

B:BD[8.41747] → [8.41747:41822]

    fn alloc_insert<K: Representable + ?Sized, V: Representable + ?Sized>(

[8.41747]

[8.41822]

    fn alloc_insert<K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized>(

Replacement in sanakirja-core/src/btree/page_unsized/alloc.rs at line 306 [8.33822]

B:BD[8.42983] → [8.42983:43062]

    fn offset_slice<'a, K: Representable + ?Sized, V: Representable + ?Sized>(

[8.42983]

[8.43062]

    fn offset_slice<'a, K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized>(

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

B:BD[8.43370] → [6.3151:3233]

    fn kv<'a, T: LoadPage, K: Representable + ?Sized, V: Representable + ?Sized>(

[8.43370]

[8.43442]

    fn kv<'a, T: LoadPage, K: UnsizedStorable + ?Sized, V: UnsizedStorable + ?Sized>(

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

B:BD[10.2146] → [10.2146:2227]

impl<K: Representable, V: Representable> super::BTreePage<K, V> for Page<K, V> {

[10.2146]

[10.2311]

impl<K: Storable, V: Storable> super::BTreePage<K, V> for Page<K, V> {

Replacement in sanakirja-core/src/btree/page.rs at line 48 [4.8623]
B:BD[10.2742] → [10.2742:2759]
```
        txn: &T,
```
[10.2742]
[10.2759]
```
        _txn: &T,
```

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

B:BD[10.3020] → [10.3020:3069]

                let al = K::ALIGN.max(V::ALIGN);

[10.3020]

[10.3069]

                let al = core::mem::align_of::<Tuple<K, V>>();

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

B:BD[10.3200] → [10.3200:3289]

B:BD[10.3289] → [10.3289:3312]

B:BD[10.3312] → [10.3312:3428]

B:BD[10.3428] → [10.3428:3470]

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

[10.3200]

[10.3470]

                let kv = &*(page.data.as_ptr().add(off as usize) as *const Tuple<K, V>);
                Some((&kv.k, &kv.v, 0))

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

B:BD[10.3648] → [10.3648:3747]

B:BD[10.3747] → [10.3747:3770]

B:BD[10.3770] → [10.3770:3886]

B:BD[10.3886] → [10.3886:3939]

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

[10.3648]

[10.3939]

                let kv = &*(page.data.as_ptr().add((off as usize) & 0xfff) as *const Tuple<K, V>);
                Some((&kv.k, &kv.v, off & !0xfff))

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

B:BD[10.3970] → [10.3970:4038]

    fn current_size(page: crate::Page, c: &Self::Cursor) -> usize {

[10.3970]

[10.4038]

    fn current_size(_page: crate::Page, c: &Self::Cursor) -> usize {

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

B:BD[10.4095] → [10.4095:4139]

B:BD[10.4139] → [2.7161:7213]

∅:D[2.7213] → [10.4176:4436]

B:BD[10.4176] → [10.4176:4436]

        unsafe {
            if c.is_leaf {
                core::mem::size_of::<Tuple<K, V>>()
            } else {
                8 + entry_size::<K, V>(page.data.as_ptr().add(
                    (u64::from_le(*(page.data.as_ptr().add(HDR) as *const u64).add(c.cur as usize))
                        & 0xfff) as usize,
                ))
            }

[10.4095]

[10.4436]

        if c.is_leaf {
            core::mem::size_of::<Tuple<K, V>>()
        } else {
            8 + core::mem::size_of::<Tuple<K, V>>()

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

B:BD[10.5965] → [10.5965:6026]

                            let al = K::ALIGN.max(V::ALIGN);

[10.5965]

[10.6026]

                            let al = core::mem::align_of::<Tuple<K, V>>();

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

∅:D[10.7092] → [9.5036:5160]

B:BD[4.8770] → [9.5036:5160]

impl<K: Representable + core::fmt::Debug, V: Representable + core::fmt::Debug>
    super::BTreeMutPage<K, V> for Page<K, V>

[10.7092]

[4.9832]

impl<K: Storable + core::fmt::Debug, V: Storable + core::fmt::Debug> super::BTreeMutPage<K, V>
    for Page<K, V>

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

B:BD[13.1301] → [14.555:609]

        <super::page_unsized::Page<K, V>>::init(page)

[13.1301]

[4.9926]

        let h = header_mut(page);
        h.init();

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

B:BD[8.44673] → [8.44673:44726]

                    let al = K::ALIGN.max(V::ALIGN);

[15.1770]

[8.44726]

                    let al = core::mem::align_of::<Tuple<K, V>>();

Replacement in sanakirja-core/src/btree/page.rs at line 352 [4.8623]
∅:D[2.7652] → [8.45058:45103]
∅:D[14.1528] → [8.45058:45103]
B:BD[8.45058] → [8.45058:45103]
```
            let al = K::ALIGN.max(V::ALIGN);
```
[2.7652]
[8.45103]
```
            let al = core::mem::align_of::<Tuple<K, V>>();
```

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

B:BD[4.16210] → [7.2743:2796]

            8 + alloc_size::<K, V>(m.mid.0, m.mid.1)

[4.16210]

[4.16281]

            8 + core::mem::size_of::<Tuple<K, V>>()

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

B:BD[4.18476] → [10.7608:7699]

fn size<K: Representable, V: Representable>(m: &ModifiedPage<K, V, Page<K, V>>) -> usize {

[4.18476]

[10.7699]

fn size<K: Storable, V: Storable>(m: &ModifiedPage<K, V, Page<K, V>>) -> usize {

Replacement in sanakirja-core/src/btree/page.rs at line 434 [4.8623]
B:BD[10.7837] → [10.7837:7878]
```
        let al = K::ALIGN.max(V::ALIGN);
```
[10.7837]
[10.7878]
```
        let al = core::mem::align_of::<Tuple<K, V>>();
```
Replacement in sanakirja-core/src/btree/page.rs at line 439 [4.8623]
B:BD[10.7964] → [10.7964:7998]
```
    if let Some((k, v)) = m.ins {
```
[10.7964]
[10.7998]
```
    if m.ins.is_some() {
```

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

B:BD[10.8052] → [10.8052:8213]

        total += extra + crate::alloc_size(k, v) as usize;
        if let Some((k, v)) = m.ins2 {
            total += extra + crate::alloc_size(k, v) as usize;

[10.8052]

[4.20159]

        total += extra + core::mem::size_of::<Tuple<K, V>>();
        if m.ins2.is_some() {
            total += extra + core::mem::size_of::<Tuple<K, V>>()

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

B:BD[13.9543] → [6.4379:4451]

fn leaf_linear_search<T: LoadPage, K: Representable, V: Representable>(

[13.9543]

[16.111]

fn leaf_linear_search<T: LoadPage, K: Storable, V: Storable>(

Replacement in sanakirja-core/src/btree/page.rs at line 479 [4.8623]
B:BD[11.4487] → [11.4487:4551]
```
unsafe fn cmp<T: LoadPage, K: Representable, V: Representable>(
```
[11.4487]
[11.4551]
```
unsafe fn cmp<T: LoadPage, K: Storable, V: Storable>(
```

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

B:BD[11.4687] → [11.4687:4804]

B:BD[11.4804] → [11.4804:4835]

    let (k, v) = read::<T, K, V>(txn, p.as_ptr().offset(off as isize & 0xfff));
    let k = K::from_raw_ptr(txn, k);
    match k.compare(txn, k0) {

[11.4687]

[11.4835]

    let tup = &*(p.as_ptr().offset(off as isize & 0xfff) as *const Tuple<K, V>);
    match tup.k.compare(txn, k0) {

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

B:BD[11.4899] → [11.4899:4948]

B:BD[11.4948] → [11.4948:4983]

                let v = V::from_raw_ptr(txn, v);
                v.compare(txn, v0)

[11.4899]

[11.4983]

                tup.v.compare(txn, v0)

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

B:BD[11.5085] → [11.5085:5161]

unsafe fn internal_search<T: LoadPage, K: Representable, V: Representable>(

[11.5085]

[11.5161]

unsafe fn internal_search<T: LoadPage, K: Storable, V: Storable>(

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

B:BD[16.429] → [6.4452:4519]

unsafe fn lookup<T: LoadPage, K: Representable, V: Representable>(

[16.429]

[13.9608]

unsafe fn lookup<T: LoadPage, K: Storable, V: Storable>(

Replacement in sanakirja-core/src/btree/page.rs at line 539 [4.8623]
B:BD[13.9834] → [8.45591:45632]
```
        let al = K::ALIGN.max(V::ALIGN);
```
[13.9834]
[8.45632]
```
        let al = core::mem::align_of::<Tuple<K, V>>();
```
Replacement in sanakirja-core/src/btree/page.rs at line 555 [4.8623]
B:BD[13.12021] → [10.8346:8357]
∅:D[10.8357] → [7.5384:5483]
B:BD[15.8349] → [7.5384:5483]
∅:D[7.5483] → [15.8473:8487]
B:BD[15.8473] → [15.8473:8487]
B:BD[15.8487] → [9.6046:6049]
```
fn modify<
    T: LoadPage,
    K: Representable + core::fmt::Debug,
    V: Representable + core::fmt::Debug,
    L: Alloc,
>(
```
[13.12021]
[7.5491]
```
fn modify<T: LoadPage, K: Storable + core::fmt::Debug, V: Storable + core::fmt::Debug, L: Alloc>(
```
Replacement in sanakirja-core/src/btree/page.rs at line 587 [4.8623]
B:BD[4.35449] → [10.8358:8368]
∅:D[10.8368] → [7.5982:6081]
B:BD[15.8746] → [7.5982:6081]
∅:D[7.6081] → [15.8870:8884]
B:BD[15.8870] → [15.8870:8884]
B:BD[15.8884] → [9.6097:6100]
```
fn merge<
    T: LoadPage,
    K: Representable + core::fmt::Debug,
    V: Representable + core::fmt::Debug,
    L: Alloc,
>(
```
[4.35449]
[7.6089]
```
fn merge<T: LoadPage, K: Storable + core::fmt::Debug, V: Storable + core::fmt::Debug, L: Alloc>(
```
Replacement in sanakirja-core/src/btree/page.rs at line 613 [4.8623]
B:BD[4.36872] → [7.6692:6748]
```
fn clone<K: Representable, V: Representable, L: Alloc>(
```
[4.36508]
[4.38741]
```
fn clone<K: Storable, V: Storable, L: Alloc>(
```

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

B:BD[13.22697] → [7.6749:6805]

                    let size = entry_size::<K, V>(ptr);

[13.22697]

[13.22804]

                    let size = core::mem::size_of::<Tuple<K, V>>();

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

B:BD[13.22851] → [15.10071:10150]

                    let off_new = L::alloc(hdr, size, K::ALIGN.max(V::ALIGN));

[13.22851]

[13.22970]

                    let off_new = L::alloc(hdr, size, core::mem::align_of::<Tuple<K, V>>());

Replacement in sanakirja-core/src/btree/page.rs at line 636 [4.8623]
∅:D[8.46159] → [4.39476:39520]
∅:D[2.8856] → [4.39476:39520]
∅:D[14.1753] → [4.39476:39520]
∅:D[7.6860] → [4.39476:39520]
B:BD[4.39476] → [4.39476:39520]
```
            let a = K::ALIGN.max(V::ALIGN);
```
[2.8856]
[4.39520]
```
            let a = core::mem::size_of::<Tuple<K, V>>();
```
Replacement in sanakirja-core/src/btree/page.rs at line 654 [4.8623]
B:BD[4.39991] → [7.6861:6917]
```
fn alloc<K: Representable, V: Representable, L: Alloc>(
```
[4.39991]
[13.23686]
```
fn alloc<K: Storable, V: Storable, L: Alloc>(
```

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

B:BD[4.40174] → [4.40174:40209]

B:BD[4.40209] → [7.6918:6978]

    let size = alloc_size(k0, v0);
    let off_new = L::alloc_insert::<K, V>(new, n, size, r);

[4.40174]

[13.23773]

    let off_new = L::alloc_insert::<K, V>(new, n, r);

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

B:BD[13.23786] → [13.23786:24072]

        let new_ptr = new.0.data.add(off_new as usize);
        core::ptr::copy_nonoverlapping(k0, new_ptr as *mut K, 1);
        let ks = k0.size();
        let v_ptr = new_ptr.add((ks + V::ALIGN - 1) & !(V::ALIGN - 1));
        core::ptr::copy_nonoverlapping(v0, v_ptr as *mut V, 1);

[13.23786]

[13.24072]

        let new_ptr = &mut *(new.0.data.add(off_new as usize) as *mut Tuple<K, V>);
        core::ptr::copy_nonoverlapping(k0, &mut new_ptr.k, 1);
        core::ptr::copy_nonoverlapping(v0, &mut new_ptr.v, 1);
        debug!("allocated {:?} {:?} {:?}", new_ptr, l, r);

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

B:BD[7.6997] → [7.6997:7079]

    K: Representable + core::fmt::Debug,
    V: Representable + core::fmt::Debug,

[7.6997]

[17.594]

    K: Storable + core::fmt::Debug,
    V: Storable + core::fmt::Debug,

Replacement in sanakirja-core/src/btree/page/rebalance.rs at line 78 [17.387]
B:BD[8.46506] → [8.46506:46547]
```
        let al = K::ALIGN.max(V::ALIGN);
```
[8.46506]
[8.46547]
```
        let al = core::mem::align_of::<Tuple<K, V>>();
```

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

B:BD[7.7364] → [7.7364:7446]

    K: Representable + core::fmt::Debug,
    V: Representable + core::fmt::Debug,

[7.7364]

[17.4035]

    K: Storable + core::fmt::Debug,
    V: Storable + core::fmt::Debug,

Replacement in sanakirja-core/src/btree/page/put.rs at line 6 [17.5929]

B:BD[7.7605] → [7.7605:7687]

    K: Representable + core::fmt::Debug,
    V: Representable + core::fmt::Debug,

[7.7605]

[17.6097]

    K: Storable + core::fmt::Debug,
    V: Storable + core::fmt::Debug,

Replacement in sanakirja-core/src/btree/page/put.rs at line 21 [17.5929]

B:BD[17.6310] → [17.6310:6416]

    let size = alloc_size(k0, v0)
        + if let Some((k1, v1)) = k1v1 {
            alloc_size(k1, v1)

[17.6310]

[17.6416]

    let size = core::mem::size_of::<Tuple<K, V>>()
        + if k1v1.is_some() {
            core::mem::size_of::<Tuple<K, V>>()

Insertion in sanakirja-core/src/btree/page/put.rs at line 27 [17.5929]
[17.6458]
[2.10589]
```
    debug!("put {:?} {:?} {:?}", k0, v0, k1v1);
```

Replacement in sanakirja-core/src/btree/page/put.rs at line 39 [17.5929]

B:BD[12.9326] → [12.9326:9487]

                let off = (u64::from_le(*ptr) & 0xfff) as usize;
                let kv_ptr = p.add(off);
                let size = entry_size::<K, V>(kv_ptr);

[12.9326]

[12.9487]

                let size = core::mem::size_of::<Tuple<K, V>>();

Replacement in sanakirja-core/src/btree/page/put.rs at line 49 [17.5929]

B:BD[17.6984] → [18.8367:8414]

            debug!("{:?} {:?} {:?}", l, r, n);

[17.6984]

[7.7815]

            debug!("lrn = {:?} {:?} {:?}", l, r, n);

Replacement in sanakirja-core/src/btree/page/put.rs at line 90 [17.5929]

B:BD[7.8325] → [7.8325:8407]

    K: Representable + core::fmt::Debug,
    V: Representable + core::fmt::Debug,

[7.8325]

[17.8524]

    K: Storable + core::fmt::Debug,
    V: Storable + core::fmt::Debug,

Insertion in sanakirja-core/src/btree/page/put.rs at line 123 [17.5929]
[17.9502]
[17.9502]
```
    debug!("u = {:?} k = {:?}", u, k);
```

Replacement in sanakirja-core/src/btree/page/put.rs at line 186 [17.5929]

B:BD[17.12114] → [7.9150:9247]

            if let Some((k, v)) = L::truncate_left::<T, K, V>(txn, &mut right, k as usize + 1) {

[17.12114]

[17.12206]

            if let Some((k, v)) = L::truncate_left::<K, V>(&mut right, k as usize + 1) {

Replacement in sanakirja-core/src/btree/page/put.rs at line 188 [17.5929]

B:BD[17.12231] → [7.9248:9390]

                    split_key = K::from_raw_ptr(txn, k as *const u8);
                    split_value = V::from_raw_ptr(txn, v as *const u8);

[17.12231]

[17.12307]

                    split_key = &*k;
                    split_value = &*v;

Replacement in sanakirja-core/src/btree/page/alloc.rs at line 4 [17.17232]

B:BD[17.17273] → [9.6276:6456]

    fn can_alloc<K: Representable, V: Representable>(hdr: &Header, size: usize) -> bool;
    fn can_compact<K: Representable, V: Representable>(hdr: &Header, size: usize) -> bool;

[17.17273]

[17.17546]

    fn can_alloc<K: Storable, V: Storable>(hdr: &Header, size: usize) -> bool;
    fn can_compact<K: Storable, V: Storable>(hdr: &Header, size: usize) -> bool;

Replacement in sanakirja-core/src/btree/page/alloc.rs at line 9 [17.17232]
B:BD[17.17650] → [6.5023:5094]
∅:D[6.5094] → [7.10630:10647]
B:BD[7.10630] → [7.10630:10647]
```
    fn truncate_left<T: LoadPage, K: Representable, V: Representable>(
        txn: &T,
```
[17.17650]
[17.17717]
```
    fn truncate_left<K: Storable, V: Storable>(
```

Replacement in sanakirja-core/src/btree/page/alloc.rs at line 14 [17.17232]

B:BD[17.17803] → [7.10648:10705]

∅:D[7.10705] → [17.17869:17972]

B:BD[17.17869] → [17.17869:17972]

    fn alloc_insert<K: Representable, V: Representable>(
        new: &mut MutPage,
        n: &mut isize,
        size: usize,
        r: u64,
    ) -> usize;

[17.17803]

[17.17972]

    fn alloc_insert<K: Storable, V: Storable>(new: &mut MutPage, n: &mut isize, r: u64) -> usize;

Replacement in sanakirja-core/src/btree/page/alloc.rs at line 18 [17.17232]

B:BD[17.18160] → [6.5095:5169]

    fn offset_slice<'a, T: LoadPage, K: Representable, V: Representable>(

[17.18160]

[17.18230]

    fn offset_slice<'a, T: LoadPage, K: Storable, V: Storable>(

Replacement in sanakirja-core/src/btree/page/alloc.rs at line 21 [17.17232]
B:BD[17.18297] → [6.5170:5234]
```
    fn kv<'a, T: LoadPage, K: Representable, V: Representable>(
```
[17.18297]
[7.10825]
```
    fn kv<'a, T: LoadPage, K: Storable, V: Storable>(
```

Replacement in sanakirja-core/src/btree/page/alloc.rs at line 52 [17.17232]

B:BD[17.19245] → [7.10843:10922]

    pub fn first<T, K: Representable, V: Representable>(&self) -> (u64, u16) {

[17.19245]

[17.19330]

    pub fn first<T, K: Storable, V: Storable>(&self) -> (u64, u16) {

Replacement in sanakirja-core/src/btree/page/alloc.rs at line 57 [17.17232]
∅:D[8.47654] → [17.19493:19542]
∅:D[2.12454] → [17.19493:19542]
∅:D[14.1877] → [17.19493:19542]
∅:D[7.10981] → [17.19493:19542]
B:BD[17.19493] → [17.19493:19542]
```
                let al = K::ALIGN.max(V::ALIGN);
```
[2.12454]
[17.19542]
```
                let al = core::mem::align_of::<Tuple<K, V>>();
```

Replacement in sanakirja-core/src/btree/page/alloc.rs at line 69 [17.17232]

B:BD[17.19755] → [9.6457:6547]

    fn can_alloc<K: Representable, V: Representable>(hdr: &Header, size: usize) -> bool {

[17.19755]

[2.12455]

    fn can_alloc<K: Storable, V: Storable>(hdr: &Header, size: usize) -> bool {

Replacement in sanakirja-core/src/btree/page/alloc.rs at line 71 [17.17232]
∅:D[2.12508] → [8.47719:47760]
∅:D[14.1916] → [8.47719:47760]
B:BD[8.47719] → [8.47719:47760]
```
        let al = K::ALIGN.max(V::ALIGN);
```
[2.12508]
[9.6548]
```
        let al = core::mem::align_of::<Tuple<K, V>>();
```

Replacement in sanakirja-core/src/btree/page/alloc.rs at line 76 [17.17232]

B:BD[17.20377] → [9.6649:6741]

∅:D[9.6741] → [8.47889:47930]

B:BD[7.11334] → [8.47889:47930]

    fn can_compact<K: Representable, V: Representable>(hdr: &Header, size: usize) -> bool {
        let al = K::ALIGN.max(V::ALIGN);

[17.20377]

[9.6742]

    fn can_compact<K: Storable, V: Storable>(hdr: &Header, size: usize) -> bool {
        let al = core::mem::align_of::<Tuple<K, V>>();

Replacement in sanakirja-core/src/btree/page/alloc.rs at line 88 [17.17232]
B:BD[17.20842] → [6.5235:5306]
∅:D[6.5306] → [7.11440:11457]
B:BD[7.11440] → [7.11440:11457]
```
    fn truncate_left<T: LoadPage, K: Representable, V: Representable>(
        txn: &T,
```
[17.20842]
[17.20909]
```
    fn truncate_left<K: Storable, V: Storable>(
```
Replacement in sanakirja-core/src/btree/page/alloc.rs at line 94 [17.17232]
∅:D[2.12562] → [8.48138:48179]
∅:D[14.1955] → [8.48138:48179]
B:BD[8.48138] → [8.48138:48179]
```
        let al = K::ALIGN.max(V::ALIGN);
```
[2.12562]
[8.48179]
```
        let al = core::mem::align_of::<Tuple<K, V>>();
```

Replacement in sanakirja-core/src/btree/page/alloc.rs at line 124 [17.17232]

B:BD[8.49146] → [9.7111:7212]

∅:D[9.7212] → [8.49294:49363]

B:BD[8.49294] → [8.49294:49363]

            let (k, v) = read::<T, K, V>(txn, page.0.data.add(hdr_size + (hdr_n as usize - n) * f));
            Some((K::from_raw_ptr(txn, k), V::from_raw_ptr(txn, v)))

[8.49146]

[17.23188]

            let tup =
                &*(page.0.data.add(hdr_size + (hdr_n as usize - n) * f) as *const Tuple<K, V>);
            Some((&tup.k, &tup.v))

Replacement in sanakirja-core/src/btree/page/alloc.rs at line 135 [17.17232]
B:BD[17.23462] → [7.11765:11822]
∅:D[7.11822] → [17.23528:23578]
B:BD[17.23528] → [17.23528:23578]
B:BD[17.23578] → [9.7262:7283]
∅:D[8.49386] → [17.23599:23632]
∅:D[9.7283] → [17.23599:23632]
B:BD[17.23599] → [17.23599:23632]
```
    fn alloc_insert<K: Representable, V: Representable>(
        new: &mut MutPage,
        n: &mut isize,
        size: usize,
        _: u64,
    ) -> usize {
```
[17.23462]
[2.12678]
```
    fn alloc_insert<K: Storable, V: Storable>(new: &mut MutPage, n: &mut isize, _: u64) -> usize {
```
Replacement in sanakirja-core/src/btree/page/alloc.rs at line 137 [17.17232]
∅:D[2.12731] → [9.7284:7313]
∅:D[14.1994] → [9.7284:7313]
B:BD[8.49440] → [9.7284:7313]
∅:D[9.7313] → [8.49440:49481]
B:BD[8.49440] → [8.49440:49481]
```
        assert_eq!(f, size);
        let al = K::ALIGN.max(V::ALIGN);
```
[2.12731]
[8.49481]
```
        let al = core::mem::align_of::<Tuple<K, V>>();
```
Deletion in sanakirja-core/src/btree/page/alloc.rs at line 139 [17.17232]
B:BD[8.49532] → [8.49532:49587]
```
        // debug!("{:?} {:?} {:?}", new, hdr.n(), *n);
```

Replacement in sanakirja-core/src/btree/page/alloc.rs at line 161 [17.17232]

B:BD[17.25230] → [6.5307:5381]

    fn offset_slice<'a, T: LoadPage, K: Representable, V: Representable>(

[17.25230]

[17.25300]

    fn offset_slice<'a, T: LoadPage, K: Storable, V: Storable>(

Replacement in sanakirja-core/src/btree/page/alloc.rs at line 167 [17.17232]
B:BD[17.25752] → [6.5382:5446]
∅:D[6.5446] → [7.12036:12053]
B:BD[7.12036] → [7.12036:12053]
```
    fn kv<'a, T: LoadPage, K: Representable, V: Representable>(
        txn: &T,
```
[17.25752]
[17.25812]
```
    fn kv<'a, T: LoadPage, K: Storable, V: Storable>(
        _txn: &T,
```

Replacement in sanakirja-core/src/btree/page/alloc.rs at line 173 [17.17232]

B:BD[17.25917] → [7.12054:12205]

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

[17.25917]

[17.26023]

            let tup = &*(page.data.as_ptr().add(off as usize) as *const Tuple<K, V>);
            debug!(">>>>>>>> kv {:?} {:?}", off, tup);
            (&tup.k, &tup.v, 0)

Replacement in sanakirja-core/src/btree/page/alloc.rs at line 181 [17.17232]

B:BD[17.26068] → [9.7314:7404]

    fn can_alloc<K: Representable, V: Representable>(hdr: &Header, size: usize) -> bool {

[17.26068]

[12.10176]

    fn can_alloc<K: Storable, V: Storable>(hdr: &Header, size: usize) -> bool {

Replacement in sanakirja-core/src/btree/page/alloc.rs at line 185 [17.17232]

B:BD[17.26346] → [9.7405:7497]

    fn can_compact<K: Representable, V: Representable>(hdr: &Header, size: usize) -> bool {

[17.26346]

[9.7497]

    fn can_compact<K: Storable, V: Storable>(hdr: &Header, size: usize) -> bool {

Replacement in sanakirja-core/src/btree/page/alloc.rs at line 195 [17.17232]

B:BD[17.26533] → [7.12467:12546]

    fn truncate_left<T, K: Representable, V: Representable>(
        _txn: &T,

[17.26533]

[17.26600]

    fn truncate_left<K: Storable, V: Storable>(

Replacement in sanakirja-core/src/btree/page/alloc.rs at line 225 [17.17232]

B:BD[17.28075] → [7.12700:12757]

∅:D[7.12757] → [17.28141:28245]

B:BD[17.28141] → [17.28141:28245]

    fn alloc_insert<K: Representable, V: Representable>(
        new: &mut MutPage,
        n: &mut isize,
        size: usize,
        r: u64,
    ) -> usize {

[17.28075]

[17.28245]

    fn alloc_insert<K: Storable, V: Storable>(new: &mut MutPage, n: &mut isize, r: u64) -> usize {
        let size = core::mem::size_of::<Tuple<K, V>>();
        debug!("alloc internal {:?} {:?}", n, size);

Replacement in sanakirja-core/src/btree/page/alloc.rs at line 232 [17.17232]

B:BD[17.28356] → [17.28356:28426]

                Self::alloc(&mut *hdr, size, K::ALIGN.max(V::ALIGN)),

[17.28356]

[17.28426]

                Self::alloc(&mut *hdr, size, core::mem::align_of::<Tuple<K, V>>()),

Insertion in sanakirja-core/src/btree/page/alloc.rs at line 235 [17.17232]
[17.28451]
[17.28451]
```
        debug!("off_new = {:?}", off_new);
```
Replacement in sanakirja-core/src/btree/page/alloc.rs at line 261 [17.17232]
B:BD[17.29294] → [7.12758:12822]
```
    fn offset_slice<'a, T, K: Representable, V: Representable>(
```
[17.29294]
[17.29364]
```
    fn offset_slice<'a, T, K: Storable, V: Storable>(
```
Replacement in sanakirja-core/src/btree/page/alloc.rs at line 272 [17.17232]
B:BD[17.29672] → [6.5473:5537]
∅:D[6.5537] → [7.12877:12894]
B:BD[7.12877] → [7.12877:12894]
```
    fn kv<'a, T: LoadPage, K: Representable, V: Representable>(
        txn: &T,
```
[17.29672]
[17.29732]
```
    fn kv<'a, T: LoadPage, K: Storable, V: Storable>(
        _txn: &T,
```

Replacement in sanakirja-core/src/btree/page/alloc.rs at line 278 [17.17232]

B:BD[17.29837] → [7.12895:13046]

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

[17.29837]

[17.29943]

            let tup = &*(page.data.as_ptr().add(off as usize) as *const Tuple<K, V>);
            (&tup.k, &tup.v, r)

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

B:BD[4.46099] → [9.7971:8054]

pub trait BTreePage<K: Representable + ?Sized, V: Representable + ?Sized>: Sized {

[4.46099]

[10.8900]

pub trait BTreePage<K: ?Sized, V: ?Sized>: Sized {

Replacement in sanakirja-core/src/btree/mod.rs at line 135 [4.45735]
B:BD[4.47601] → [4.47601:47634]
B:BD[4.47634] → [4.47634:47651]
B:BD[4.47651] → [9.8723:8785]
∅:D[8.50323] → [7.13884:13908]
∅:D[9.8785] → [7.13884:13908]
B:BD[7.13884] → [7.13884:13908]
∅:D[7.13908] → [4.47728:47732]
B:BD[4.47728] → [4.47728:47732]
```
pub struct PageIterator<
    'a,
    T: LoadPage,
    K: Representable + ?Sized,
    V: Representable + ?Sized,
    P: BTreePage<K, V>,
> {
```
[4.47601]
[4.47732]
```
pub struct PageIterator<'a, T: LoadPage, K: ?Sized, V: ?Sized, P: BTreePage<K, V>> {
```

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

B:BD[4.47778] → [4.47778:47817]

B:BD[4.47817] → [9.8786:8866]

∅:D[8.50400] → [7.13988:14016]

∅:D[9.8866] → [7.13988:14016]

B:BD[7.13988] → [7.13988:14016]

∅:D[7.14016] → [4.47916:47964]

B:BD[4.47916] → [4.47916:47964]

impl<
        'a,
        T: LoadPage,
        K: Representable + ?Sized + 'a,
        V: Representable + ?Sized + 'a,
        P: BTreePage<K, V>,
    > Iterator for PageIterator<'a, T, K, V, P>

[4.47778]

[4.47964]

impl<'a, T: LoadPage, K: ?Sized + 'a, V: ?Sized + 'a, P: BTreePage<K, V>> Iterator
    for PageIterator<'a, T, K, V, P>

Replacement in sanakirja-core/src/btree/mod.rs at line 150 [4.45735]
B:BD[4.48112] → [9.8867:8945]
B:BD[9.8945] → [12.10223:10262]
∅:D[8.50495] → [4.48223:48225]
∅:D[12.10262] → [4.48223:48225]
∅:D[7.14161] → [4.48223:48225]
B:BD[4.48223] → [4.48223:48225]
```
pub trait BTreeMutPage<K: Representable + ?Sized, V: Representable + ?Sized>:
    BTreePage<K, V> + core::fmt::Debug
{
```
[4.48112]
[10.10873]
```
pub trait BTreeMutPage<K: ?Sized, V: ?Sized>: BTreePage<K, V> + core::fmt::Debug {
```

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

B:BD[19.3885] → [9.9353:9428]

pub enum Op<'a, T, K: Representable + ?Sized, V: Representable + ?Sized> {

[19.3885]

[4.50267]

pub enum Op<'a, T, K: ?Sized, V: ?Sized> {

Replacement in sanakirja-core/src/btree/mod.rs at line 237 [4.45735]
∅:D[11.6378] → [4.50557:50582]
B:BD[4.50557] → [4.50557:50582]
B:BD[4.50582] → [9.9429:9499]
∅:D[8.50626] → [7.14709:14733]
∅:D[9.9499] → [7.14709:14733]
B:BD[7.14709] → [7.14709:14733]
∅:D[7.14733] → [4.50676:50680]
B:BD[4.50676] → [4.50676:50680]
```
pub struct ModifiedPage<
    'a,
    K: Representable + ?Sized,
    V: Representable + ?Sized,
    P: BTreePage<K, V>,
> {
```
[11.6378]
[13.30668]
```
pub struct ModifiedPage<'a, K: ?Sized, V: ?Sized, P: BTreePage<K, V>> {
```

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

B:BD[4.51677] → [9.9736:9834]

pub struct Concat<'a, K: Representable + ?Sized, V: Representable + ?Sized, P: BTreePage<K, V>> {

[4.51677]

[20.699]

pub struct Concat<'a, K: ?Sized, V: ?Sized, P: BTreePage<K, V>> {

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

B:BD[4.52016] → [9.9835:9926]

pub struct Db_<K: Representable + ?Sized, V: Representable + ?Sized, P: BTreePage<K, V>> {

[4.52016]

[18.9162]

pub struct Db_<K: ?Sized, V: ?Sized, P: BTreePage<K, V>> {

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

∅:D[20.1322] → [21.127:221]

B:BD[4.52188] → [21.127:221]

impl<K: Representable + ?Sized, V: Representable + ?Sized, P: BTreePage<K, V>> Db_<K, V, P> {

[20.1322]

[20.1323]

impl<K: ?Sized, V: ?Sized, P: BTreePage<K, V>> Db_<K, V, P> {

Replacement in sanakirja-core/src/btree/mod.rs at line 305 [4.45735]
∅:D[20.1429] → [22.183:202]
B:BD[22.183] → [22.183:202]
∅:D[22.202] → [4.52206:52224]
B:BD[4.52206] → [4.52206:52224]
B:BD[4.52224] → [9.9927:9989]
∅:D[8.51070] → [7.15178:15205]
∅:D[9.9989] → [7.15178:15205]
B:BD[7.15178] → [7.15178:15205]
∅:D[7.15205] → [4.52304:52307]
B:BD[4.52304] → [4.52304:52307]
```
pub fn create_db_<
    T: AllocPage,
    K: Representable + ?Sized,
    V: Representable + ?Sized,
    P: BTreeMutPage<K, V>,
>(
```
[20.1429]
[4.52307]
```
pub fn create_db_<T: AllocPage, K: ?Sized, V: ?Sized, P: BTreeMutPage<K, V>>(
```
Replacement in sanakirja-core/src/btree/mod.rs at line 319 [4.45735]
∅:D[20.1479] → [22.259:314]
B:BD[19.3887] → [22.259:314]
B:BD[22.314] → [7.15245:15327]
∅:D[7.15327] → [22.402:405]
B:BD[22.402] → [22.402:405]
```
pub fn create_db<
    T: AllocPage + core::fmt::Debug,
    K: Representable + core::fmt::Debug,
    V: Representable + core::fmt::Debug,
>(
```
[20.1479]
[22.405]
```
pub fn create_db<T: AllocPage, K: Storable, V: Storable>(
```
Replacement in sanakirja-core/src/btree/mod.rs at line 326 [4.45735]
B:BD[20.1501] → [20.1501:1517]
∅:D[20.1517] → [19.3903:3921]
∅:D[22.518] → [19.3903:3921]
B:BD[19.3903] → [19.3903:3921]
B:BD[19.3921] → [9.9990:10052]
∅:D[8.51244] → [7.15426:15453]
∅:D[9.10052] → [7.15426:15453]
B:BD[7.15426] → [7.15426:15453]
∅:D[7.15453] → [19.4001:4004]
B:BD[19.4001] → [19.4001:4004]
```
pub fn fork_db<
    T: AllocPage,
    K: Representable + ?Sized,
    V: Representable + ?Sized,
    P: BTreeMutPage<K, V>,
>(
```
[20.1501]
[19.4004]
```
pub fn fork_db<T: AllocPage, K: Storable + ?Sized, V: Storable + ?Sized, P: BTreeMutPage<K, V>>(
```

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

∅:D[20.1624] → [9.10053:10179]

B:BD[23.407] → [9.10053:10179]

pub fn get<
    'a,
    T: LoadPage,
    K: Representable + ?Sized,
    V: Representable + ?Sized,
    P: BTreePage<K, V>,
>(

[20.1624]

[23.502]

pub fn get<'a, T: LoadPage, K: Storable + ?Sized, V: Storable + ?Sized, P: BTreePage<K, V>>(

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

∅:D[20.1743] → [24.650:770]

B:BD[25.318] → [24.650:770]

pub fn drop<
    T: AllocPage,
    K: Representable + ?Sized,
    V: Representable + ?Sized,
    P: BTreePage<K, V>,
>(

[20.1743]

[24.770]

pub fn drop<T: AllocPage, K: Storable + ?Sized, V: Storable + ?Sized, P: BTreePage<K, V>>(

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

B:BD[13.31281] → [14.2179:2279]

    K: Representable + ?Sized + core::fmt::Debug,
    V: Representable + ?Sized + core::fmt::Debug,

[13.31281]

[7.15929]

    K: Storable + ?Sized + core::fmt::Debug,
    V: Storable + ?Sized + core::fmt::Debug,

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

B:BD[13.31418] → [14.2280:2380]

    K: Representable + ?Sized + core::fmt::Debug,
    V: Representable + ?Sized + core::fmt::Debug,

[13.31418]

[7.16086]

    K: Storable + ?Sized + core::fmt::Debug,
    V: Storable + ?Sized + core::fmt::Debug,

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

B:BD[17.31607] → [14.2655:2755]

    K: Representable + ?Sized + core::fmt::Debug,
    V: Representable + ?Sized + core::fmt::Debug,

[17.31607]

[7.18370]

    K: Storable + ?Sized + core::fmt::Debug,
    V: Storable + ?Sized + core::fmt::Debug,

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

B:BD[4.61838] → [14.2890:2952]

    K: Representable + ?Sized,
    V: Representable + ?Sized,

[4.61838]

[7.19335]

    K: Storable + ?Sized,
    V: Storable + ?Sized,

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

B:BD[17.34015] → [14.3072:3134]

    K: Representable + ?Sized,
    V: Representable + ?Sized,

[17.34015]

[7.20078]

    K: Storable + ?Sized,
    V: Storable + ?Sized,

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

B:BD[14.3600] → [14.3600:3662]

    K: Representable + ?Sized,
    V: Representable + ?Sized,

[14.3600]

[14.3662]

    K: Storable + ?Sized,
    V: Storable + ?Sized,

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

B:BD[17.38259] → [14.3690:3790]

    K: Representable + ?Sized + core::fmt::Debug,
    V: Representable + ?Sized + core::fmt::Debug,

[17.38259]

[7.23454]

    K: Storable + ?Sized + core::fmt::Debug,
    V: Storable + ?Sized + core::fmt::Debug,

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

B:BD[10.12290] → [11.12649:12743]

fn single_child<K: Representable + ?Sized, V: Representable + ?Sized, P: BTreeMutPage<K, V>>(

[10.12290]

[11.12743]

fn single_child<K: Storable + ?Sized, V: Storable + ?Sized, P: BTreeMutPage<K, V>>(

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

∅:D[11.13028] → [10.12329:12458]

B:BD[10.12329] → [10.12329:12458]

fn modify<
    'a,
    T: AllocPage,
    K: Representable + ?Sized,
    V: Representable + ?Sized,
    P: BTreeMutPage<K, V>,
>(

[11.13028]

[10.12458]

fn modify<'a, T: AllocPage, K: Storable + ?Sized, V: Storable + ?Sized, P: BTreeMutPage<K, V>>(

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

B:BD[4.63799] → [6.7238:7358]

pub(super) struct PageCursor<
    K: Representable + ?Sized,
    V: Representable + ?Sized,
    P: BTreePage<K, V>,
> {

[4.63799]

[13.33799]

pub(super) struct PageCursor<K: ?Sized, V: ?Sized, P: BTreePage<K, V>> {

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

B:BD[4.64963] → [9.10916:11010]

pub struct Cursor<K: Representable + ?Sized, V: Representable + ?Sized, P: BTreePage<K, V>> {

[4.64963]

[24.2475]

pub struct Cursor<K: ?Sized, V: ?Sized, P: BTreePage<K, V>> {

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

B:BD[4.65195] → [9.11011:11112]

impl<'a, K: Representable + ?Sized, V: Representable + ?Sized, P: BTreePage<K, V>> Cursor<K, V, P> {

[4.65195]

[18.10823]

impl<'a, K: ?Sized, V: ?Sized, P: BTreePage<K, V>> Cursor<K, V, P> {

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

B:BD[4.65654] → [9.11113:11210]

impl<K: Representable + ?Sized, V: Representable + ?Sized, P: BTreePage<K, V>> Cursor<K, V, P> {

[4.65654]

[6.7485]

impl<K: ?Sized, V: ?Sized, P: BTreePage<K, V>> Cursor<K, V, P> {

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

∅:D[18.11929] → [26.3459:3567]

B:BD[26.3459] → [26.3459:3567]

        K: Representable + ?Sized + core::fmt::Debug,
        V: Representable + ?Sized + core::fmt::Debug,

[18.11929]

[18.11930]

        K: Storable + ?Sized + core::fmt::Debug,
        V: Storable + ?Sized + core::fmt::Debug,

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

B:BD[18.14497] → [6.8580:8712]

pub struct Iter<
    'a,
    T: LoadPage,
    K: Representable + ?Sized,
    V: Representable + ?Sized,
    P: BTreePage<K, V>,
> {

[18.14497]

[27.3256]

pub struct Iter<'a, T: LoadPage, K: Storable + ?Sized, V: Storable + ?Sized, P: BTreePage<K, V>> {

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

B:BD[6.8775] → [6.8775:8837]

    K: Representable + ?Sized,
    V: Representable + ?Sized,

[6.8775]

[6.8837]

    K: Storable + ?Sized,
    V: Storable + ?Sized,

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

B:BD[6.8933] → [6.8933:9013]

        K: Representable + ?Sized + 'a,
        V: Representable + ?Sized + 'a,

[6.8933]

[6.9013]

        K: Storable + ?Sized + 'a,
        V: Storable + ?Sized + 'a,

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

B:BD[27.3980] → [6.9089:9224]

pub struct RevIter<
    'a,
    T: LoadPage,
    K: Representable + ?Sized,
    V: Representable + ?Sized,
    P: BTreePage<K, V>,
> {

[27.3980]

[27.4092]

pub struct RevIter<'a, T: LoadPage, K: Storable + ?Sized, V: Storable + ?Sized, P: BTreePage<K, V>>
{

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

B:BD[6.9287] → [6.9287:9349]

    K: Representable + ?Sized,
    V: Representable + ?Sized,

[6.9287]

[6.9349]

    K: Storable + ?Sized,
    V: Storable + ?Sized,

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

B:BD[6.9448] → [6.9448:9528]

        K: Representable + ?Sized + 'a,
        V: Representable + ?Sized + 'a,

[6.9448]

[6.9528]

        K: Storable + ?Sized + 'a,
        V: Storable + ?Sized + 'a,

Replacement in sanakirja/src/tests.rs at line 189 [28.11]
B:BD[12.11504] → [12.11504:11528]
```
    let n = 300 as u64;
```
[12.11504]
[12.11528]
```
    let n = 256 as u64;
```

Deletion in sanakirja/src/tests.rs at line 198 [28.11]

B:BD[29.677] → [29.677:724]

B:BD[29.724] → [2.20895:20955]

    let db2 = fork_db(&mut txn, &db).unwrap();
    crate::debug::debug(&txn, &[&db, &db2], "debug", true);

Insertion in sanakirja/src/tests.rs at line 199 [28.11]

[12.11639]

[29.724]

    crate::debug::debug(&txn, &[&db], "debug", true);
    let db2 = fork_db(&mut txn, &db).unwrap();

Replacement in sanakirja/src/tests.rs at line 336 [28.11]

B:BD[28.7872] → [7.26969:27051]

fn add_refs<T: LoadPage, K: Representable, V: Representable, P: BTreePage<K, V>>(

[28.7872]

[28.7963]

fn add_refs<T: LoadPage, K: Storable, V: Storable, P: BTreePage<K, V>>(

Replacement in sanakirja/src/tests.rs at line 689 [28.11]

B:BD[30.388] → [30.388:486]

    K: Representable + ?Sized + std::fmt::Debug,
    V: Representable + ?Sized + std::fmt::Debug,

[30.388]

[30.486]

    K: Storable + ?Sized + std::fmt::Debug,
    V: Storable + ?Sized + std::fmt::Debug,

Replacement in sanakirja/src/lib.rs at line 5 [4.79574]

B:BD[5.217] → [5.217:312]

pub use sanakirja_core::{btree, direct_repr, CowPage, LoadPage, MutPage, Page, Representable};

[5.217]

[5.312]

pub use sanakirja_core::{btree, direct_repr, CowPage, LoadPage, MutPage, Page, Storable};

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

B:BD[22.4442] → [18.16513:16648]

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

[22.4442]

[22.4529]

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

Replacement in sanakirja/src/environment/mod.rs at line 7 [4.91606]
B:BD[4.91734] → [22.5575:5621]
```
use sanakirja_core::{CowPage, Representable};
```
[4.91734]
[31.1300]
```
use sanakirja_core::{CowPage, Storable};
```

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

B:BD[18.16945] → [18.16945:17080]

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

[18.16945]

[18.17080]

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

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

B:BD[18.17211] → [18.17211:17346]

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

[18.17211]

[22.6257]

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

Replacement in sanakirja/src/debug.rs at line 12 [32.11]

B:BD[32.248] → [32.248:346]

    K: Representable + ?Sized + std::fmt::Debug,
    V: Representable + ?Sized + std::fmt::Debug,

[32.248]

[32.346]

    K: Storable + ?Sized + std::fmt::Debug,
    V: Storable + ?Sized + std::fmt::Debug,

Replacement in sanakirja/src/debug.rs at line 35 [32.11]

B:BD[32.826] → [32.826:924]

    K: Representable + ?Sized + std::fmt::Debug,
    V: Representable + ?Sized + std::fmt::Debug,

[32.826]

[32.924]

    K: Storable + ?Sized + std::fmt::Debug,
    V: Storable + ?Sized + std::fmt::Debug,

Replacement in sanakirja/src/debug.rs at line 77 [32.11]

B:BD[32.1898] → [32.1898:1996]

    K: Representable + ?Sized + std::fmt::Debug,
    V: Representable + ?Sized + std::fmt::Debug,

[32.1898]

[32.1996]

    K: Storable + ?Sized + std::fmt::Debug,
    V: Storable + ?Sized + std::fmt::Debug,