mx00s/pijul - Change IIV3EL2XYI2X7HZWKXEXQFAE3R3KC2Q7SGOT3Q332HSENMYVF32QC

Cleanup, formatting, and fixing the Git feature

Created by pmeunier on February 25, 2021

IIV3EL2XYI2X7HZWKXEXQFAE3R3KC2Q7SGOT3Q332HSENMYVF32QC

Dependencies

In channels

main

Change contents

Replacement in pijul-macros/src/lib.rs at line 177 [4.445]

B:BD[4.6112] → [2.2306:2377]

            Some(e) => {
                result.push(e)
            },

[4.6112]

[4.6151]

            Some(e) => result.push(e),

Replacement in pijul-macros/Cargo.toml at line 4 [4.21011]
B:BD[4.21091] → [3.0:18]
```
version = "0.4.0"
```
[4.21091]
[4.21109]
```
version = "0.3.0"
```

Deletion in pijul/src/commands/record.rs at line 148 [4.101759]

B:BD[4.105115] → [2.10167:10252]

            ::sanakirja::debug::debug(&txn.txn, &[&txn.internal], "internal", true);

Insertion in pijul/src/commands/mod.rs at line 54 [4.133619]
[4.134253]
[4.134253]
```
// mod tag;
// pub use tag::*;
```

Insertion in pijul/src/commands/git.rs at line 36 [4.137210]

[4.138034]

#[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq)]
struct Oid(git2::Oid);
use ::sanakirja::{Storable, UnsizedStorable};
::sanakirja::direct_repr!(Oid);

Replacement in pijul/src/commands/git.rs at line 57 [4.137210]

B:BD[4.138584] → [4.138584:138654]

        let mut env_git = ::sanakirja::Env::new(&path_git, 1 << 15)?;

[4.138584]

[4.138654]

        let mut env_git = ::sanakirja::Env::new(&path_git, 1 << 15, 2)?;

Replacement in pijul/src/commands/git.rs at line 91 [4.137210]

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

        env_git: &mut ::sanakirja::Env<::sanakirja::Exclusive>,

[4.139643]

[4.139683]

        env_git: &mut ::sanakirja::Env,

Deletion in pijul/src/commands/git.rs at line 93 [4.137210]
B:BD[4.139722] → [4.139722:139760]
```
        use ::sanakirja::Transaction;
```

Replacement in pijul/src/commands/git.rs at line 102 [4.137210]

B:BD[4.140110] → [6.3510:3685]

        let db: ::sanakirja::Db<git2::Oid, libpijul::Merkle> = if let Some(db) = txn_git.root(0) {
            db
        } else {
            txn_git.create_db()?
        };

[4.140110]

[7.45]

        let db: ::sanakirja::btree::UDb<Oid, libpijul::pristine::SerializedMerkle> =
            if let Some(db) = txn_git.root(0) {
                ::sanakirja::btree::UDb::from_page(db)
            } else {
                ::sanakirja::btree::create_db_(&mut txn_git)?
            };

Replacement in pijul/src/commands/git.rs at line 109 [4.137210]

B:BD[7.86] → [8.19:63]

        for x in txn_git.iter(&db, None)? {

[7.86]

[8.63]

        for x in ::sanakirja::btree::iter(&txn_git, &db, None)? {

Replacement in pijul/src/commands/git.rs at line 111 [4.137210]
∅:D[8.100] → [4.140419:140459]
B:BD[4.140419] → [4.140419:140459]
```
            state.insert(commit, merk);
```
[8.100]
[4.140459]
```
            state.insert(commit, merk.clone());
```

Replacement in pijul/src/commands/git.rs at line 115 [4.137210]

B:BD[4.140555] → [4.140555:140674]

            if let Some(state) = state.get(&commit.id()) {
                dag.root.push((commit.id(), Some(*state)));

[4.140555]

[4.140674]

            if let Some(state) = state.get(&Oid(commit.id())) {
                dag.root.push((commit.id(), Some(state.into())));

Replacement in pijul/src/commands/git.rs at line 139 [4.137210]
B:BD[4.141382] → [4.141382:141415]
```
        txn_git.set_root(0, db);
```
[4.141382]
[4.141415]
```
        txn_git.set_root(0, db.db);
```
Replacement in pijul/src/commands/git.rs at line 228 [4.137210]
B:BD[4.143869] → [5.65:125]
```
    env_git: &mut ::sanakirja::Env<::sanakirja::Exclusive>,
```
[4.143869]
[4.143905]
```
    env_git: &mut ::sanakirja::Env,
```
Replacement in pijul/src/commands/git.rs at line 240 [4.137210]
∅:D[8.162] → [4.144297:144337]
B:BD[4.144297] → [4.144297:144337]
```
            let (_, (_, merkle_)) = txn
```
[8.162]
[8.163]
```
            let (_, p) = txn
```
Insertion in pijul/src/commands/git.rs at line 244 [4.137210]
[8.256]
[4.144447]
```
            let merkle_: libpijul::Merkle = (&p.b).into();
```
Deletion in pijul/src/commands/git.rs at line 320 [4.137210]
B:BD[4.147539] → [9.14525:14569]
```
            repo.repo.lock.commit().await?;
```
Replacement in pijul/src/commands/git.rs at line 327 [4.137210]
B:BD[4.147614] → [5.126:182]
```
    git: &mut ::sanakirja::Env<::sanakirja::Exclusive>,
```
[4.147614]
[4.147646]
```
    git: &mut ::sanakirja::Env,
```
Replacement in pijul/src/commands/git.rs at line 331 [4.137210]
B:BD[4.147739] → [4.147739:147783]
```
    use ::sanakirja::{Commit, Transaction};
```
[4.147739]
[4.147783]
```
    use ::sanakirja::Commit;
```

Replacement in pijul/src/commands/git.rs at line 333 [4.137210]

B:BD[4.147840] → [6.3716:3867]

∅:D[6.3867] → [4.148025:148111]

B:BD[4.148025] → [4.148025:148111]

    let mut db: ::sanakirja::Db<git2::Oid, libpijul::Merkle> = if let Some(db) = txn.root(0) {
        db
    } else {
        txn.create_db()?
    };
    txn.put(&mut rand::thread_rng(), &mut db, *oid, state)?;
    txn.set_root(0, db);

[4.147840]

[4.148111]

    let mut db: ::sanakirja::btree::UDb<Oid, libpijul::pristine::SerializedMerkle> =
        if let Some(db) = txn.root(0) {
            ::sanakirja::btree::UDb::from_page(db)
        } else {
            ::sanakirja::btree::create_db_(&mut txn)?
        };
    ::sanakirja::btree::put(&mut txn, &mut db, &Oid(*oid), &state.into())?;
    txn.set_root(0, db.db);

Replacement in pijul/src/commands/git.rs at line 371 [4.137210]

B:BD[8.632] → [8.632:692]

                if txn.has_change(&channel, h)?.is_none() {

[8.632]

[4.149236]

                let h: libpijul::Hash = h.into();
                if txn.has_change(&channel, &h)?.is_none() {

Replacement in pijul/src/commands/git.rs at line 410 [4.137210]
∅:D[8.887] → [4.150389:150456]
B:BD[4.150389] → [4.150389:150456]
```
        txn.apply_change_ws(&repo.repo.changes, channel, *h, ws)?;
```
[8.887]
[4.150456]
```
        txn.apply_change_ws(&repo.repo.changes, channel, h, ws)?;
```

Replacement in pijul/src/commands/git.rs at line 527 [4.137210]

B:BD[4.154693] → [10.675:859]

                            if let Some(inode) = txn.get_revinodes(vertex, None)? {
                                if let Some(old_path) = libpijul::fs::inode_filename(txn, inode)? {

[4.154693]

[4.154875]

                            if let Some(inode) = txn.get_revinodes(&vertex, None)? {
                                if let Some(old_path) = libpijul::fs::inode_filename(txn, *inode)? {

Replacement in pijul/src/commands/git.rs at line 739 [4.137210]

B:BD[4.161721] → [4.161721:161804]

    let (_, m) = txn.apply_local_change(channel, &change, hash, &rec.updatables)?;

[4.161721]

[11.169]

    let (_, m) = txn.apply_local_change(channel, &change, &hash, &rec.updatables)?;

Replacement in pijul/Cargo.toml at line 4 [4.196374]
B:BD[4.196462] → [3.19:46]
```
version = "1.0.0-alpha.39"
```
[4.196462]
[4.196488]
```
version = "1.0.0-alpha.41"
```
Insertion in pijul/Cargo.toml at line 32 [4.196374]
[4.197171]
[2.14538]
```
"src/commands/lock.rs",
```
Insertion in pijul/Cargo.toml at line 36 [4.196374]
[4.197209]
[4.197209]
```
"src/repository/unix_lock.rs",
"src/repository/basic_lock.rs",
```

Replacement in pijul/Cargo.toml at line 54 [4.196374]

B:BD[4.197438] → [3.47:137]

libpijul = { path = "../libpijul", version = "1.0.0-alpha.35", features = [ "tarball" ] }

[4.197438]

[4.197523]

libpijul = { path = "../libpijul", version = "1.0.0-alpha.34", features = [ "tarball" ] }

Replacement in libpijul/src/unrecord/working_copy.rs at line 105 [4.225940]

B:BD[12.7110] → [2.15053:15146]

        .get_file_name(|h| txn.get_external(&h).unwrap().map(From::from), source, &mut name)

[12.7110]

[12.7177]

        .get_file_name(
            |h| txn.get_external(&h).unwrap().map(From::from),
            source,
            &mut name,
        )

Replacement in libpijul/src/unrecord/mod.rs at line 489 [4.231493]

B:BD[13.3349] → [2.18859:18961]

            if !(e.introduced_by() == change_id || e.flag() & EdgeFlags::bp() == EdgeFlags::PARENT) {

[13.3349]

[13.3447]

            if !(e.introduced_by() == change_id || e.flag() & EdgeFlags::bp() == EdgeFlags::PARENT)
            {

Replacement in libpijul/src/tests/unrecord.rs at line 138 [4.248807]

B:BD[4.252788] → [2.19472:19576]

    output::output_repository_no_pending(&mut repo, &changes, &mut txn, &mut channel, "", true, None)?;

[4.252788]

[4.252886]

    output::output_repository_no_pending(
        &mut repo,
        &changes,
        &mut txn,
        &mut channel,
        "",
        true,
        None,
    )?;

Replacement in libpijul/src/tests/unrecord.rs at line 200 [4.248807]

B:BD[2.19841] → [2.19841:19948]

    output::output_repository_no_pending(&mut repo2, &changes, &mut txn2, &mut channel2, "", true, None)?;

[2.19841]

[2.19948]

    output::output_repository_no_pending(
        &mut repo2,
        &changes,
        &mut txn2,
        &mut channel2,
        "",
        true,
        None,
    )?;

Replacement in libpijul/src/tests/unrecord.rs at line 210 [4.248807]

B:BD[2.20015] → [2.20015:20122]

    output::output_repository_no_pending(&mut repo3, &changes, &mut txn3, &mut channel3, "", true, None)?;

[2.20015]

[4.254611]

    output::output_repository_no_pending(
        &mut repo3,
        &changes,
        &mut txn3,
        &mut channel3,
        "",
        true,
        None,
    )?;

Replacement in libpijul/src/tests/unrecord.rs at line 252 [4.248807]

B:BD[2.20253] → [2.20253:20357]

    output::output_repository_no_pending(&mut repo, &changes, &mut txn, &mut channel, "", true, None)?;

[2.20253]

[4.255737]

    output::output_repository_no_pending(
        &mut repo,
        &changes,
        &mut txn,
        &mut channel,
        "",
        true,
        None,
    )?;

Replacement in libpijul/src/tests/unrecord.rs at line 300 [4.248807]

B:BD[2.20425] → [2.20425:20532]

    output::output_repository_no_pending(&mut repo2, &changes, &mut txn2, &mut channel2, "", true, None)?;

[2.20425]

[4.257007]

    output::output_repository_no_pending(
        &mut repo2,
        &changes,
        &mut txn2,
        &mut channel2,
        "",
        true,
        None,
    )?;

Replacement in libpijul/src/tests/unrecord.rs at line 418 [4.248807]

B:BD[4.260186] → [2.20697:20801]

    output::output_repository_no_pending(&mut repo, &changes, &mut txn, &mut channel, "", true, None)?;

[4.260186]

[4.260284]

    output::output_repository_no_pending(
        &mut repo,
        &changes,
        &mut txn,
        &mut channel,
        "",
        true,
        None,
    )?;

Replacement in libpijul/src/tests/unrecord.rs at line 526 [4.248807]

B:BD[4.263374] → [2.20817:20921]

    output::output_repository_no_pending(&mut repo, &changes, &mut txn, &mut channel, "", true, None)?;

[4.263374]

[2.20921]

    output::output_repository_no_pending(
        &mut repo,
        &changes,
        &mut txn,
        &mut channel,
        "",
        true,
        None,
    )?;

Replacement in libpijul/src/tests/rollback.rs at line 27 [14.14]
B:BD[14.820] → [2.22561:22578]
```
    }).unwrap();
```
[14.820]
[2.22578]
```
    })
    .unwrap();
```
Replacement in libpijul/src/tests/rollback.rs at line 34 [14.14]
B:BD[14.1015] → [2.22708:22725]
```
    }).unwrap();
```
[14.1015]
[2.22725]
```
    })
    .unwrap();
```

Replacement in libpijul/src/tests/rollback.rs at line 44 [14.14]

B:BD[14.1345] → [2.23088:23201]

    output::output_repository_no_pending(&mut repo, &changes, &mut txn, &mut channela, "", true, None).unwrap();

[14.1345]

[14.1444]

    output::output_repository_no_pending(
        &mut repo,
        &changes,
        &mut txn,
        &mut channela,
        "",
        true,
        None,
    )
    .unwrap();

Replacement in libpijul/src/tests/rollback.rs at line 65 [14.14]
B:BD[14.1845] → [2.23375:23392]
```
    }).unwrap();
```
[14.1845]
[14.1854]
```
    })
    .unwrap();
```

Replacement in libpijul/src/tests/rollback.rs at line 127 [14.14]

B:BD[14.3860] → [2.23922:24027]

    output::output_repository_no_pending(&mut repo, &changes, &mut txn, &mut channela, "", true, None)?;

[14.3860]

[14.3959]

    output::output_repository_no_pending(
        &mut repo,
        &changes,
        &mut txn,
        &mut channela,
        "",
        true,
        None,
    )?;

Replacement in libpijul/src/tests/performance.rs at line 118 [4.278146]

B:BD[2.24800] → [2.24800:24953]

    ::sanakirja::debug::debug(&txn.txn, &[
        txn.graph(&channel.borrow()),
        txn.graph(&channel2.borrow()),
    ], "debug_sanakirja", true);

[2.24800]

[4.281708]

    ::sanakirja::debug::debug(
        &txn.txn,
        &[txn.graph(&channel.borrow()), txn.graph(&channel2.borrow())],
        "debug_sanakirja",
        true,
    );

Deletion in libpijul/src/tests/performance.rs at line 125 [4.278146]
B:BD[4.281709] → [2.24954:24955]

Replacement in libpijul/src/tests/filesystem.rs at line 27 [4.300430]

B:BD[2.26979] → [2.26979:27081]

∅:D[2.27081] → [4.301466:301485]

B:BD[4.301466] → [4.301466:301485]

    output::output_repository_no_pending(&mut repo, &changes, &mut txn, &mut channel, "", true, None)
        .unwrap();

[2.26979]

[4.301485]

    output::output_repository_no_pending(
        &mut repo,
        &changes,
        &mut txn,
        &mut channel,
        "",
        true,
        None,
    )
    .unwrap();

Replacement in libpijul/src/tests/filesystem.rs at line 73 [4.300430]

B:BD[2.27225] → [2.27225:27327]

∅:D[2.27327] → [4.302796:302815]

B:BD[4.302796] → [4.302796:302815]

    output::output_repository_no_pending(&mut repo, &changes, &mut txn, &mut channel, "", true, None)
        .unwrap();

[2.27225]

[4.302815]

    output::output_repository_no_pending(
        &mut repo,
        &changes,
        &mut txn,
        &mut channel,
        "",
        true,
        None,
    )
    .unwrap();

Replacement in libpijul/src/tests/filesystem.rs at line 116 [4.300430]

B:BD[2.27471] → [2.27471:27573]

∅:D[2.27573] → [4.304059:304078]

B:BD[4.304059] → [4.304059:304078]

    output::output_repository_no_pending(&mut repo, &changes, &mut txn, &mut channel, "", true, None)
        .unwrap();

[2.27471]

[4.304078]

    output::output_repository_no_pending(
        &mut repo,
        &changes,
        &mut txn,
        &mut channel,
        "",
        true,
        None,
    )
    .unwrap();

Replacement in libpijul/src/tests/filesystem.rs at line 162 [4.300430]

B:BD[2.27717] → [2.27717:27819]

∅:D[2.27819] → [4.305425:305444]

B:BD[4.305425] → [4.305425:305444]

    output::output_repository_no_pending(&mut repo, &changes, &mut txn, &mut channel, "", true, None)
        .unwrap();

[2.27717]

[4.305444]

    output::output_repository_no_pending(
        &mut repo,
        &changes,
        &mut txn,
        &mut channel,
        "",
        true,
        None,
    )
    .unwrap();

Replacement in libpijul/src/tests/file_conflicts.rs at line 1223 [4.305506]

B:BD[2.31819] → [2.31819:31916]

    apply::apply_change(&changes, &mut txn_alice, &mut channel_alice, &bob_resolution).unwrap();

[2.31819]

[4.342329]

    apply::apply_change(
        &changes,
        &mut txn_alice,
        &mut channel_alice,
        &bob_resolution,
    )
    .unwrap();

Replacement in libpijul/src/tests/change.rs at line 177 [4.446445]

B:BD[2.42783] → [2.42783:42888]

    output::output_repository_no_pending(&mut repo2, &store, &mut txn2, &mut channel2, "", true, None)?;

[2.42783]

[4.451888]

    output::output_repository_no_pending(
        &mut repo2,
        &store,
        &mut txn2,
        &mut channel2,
        "",
        true,
        None,
    )?;

Replacement in libpijul/src/tests/change.rs at line 191 [4.446445]

B:BD[2.42954] → [2.42954:43059]

    output::output_repository_no_pending(&mut repo2, &store, &mut txn2, &mut channel2, "", true, None)?;

[2.42954]

[4.452206]

    output::output_repository_no_pending(
        &mut repo2,
        &store,
        &mut txn2,
        &mut channel2,
        "",
        true,
        None,
    )?;

Replacement in libpijul/src/tests/add_file.rs at line 181 [4.454125]

B:BD[15.3977] → [2.44275:44380]

    output::output_repository_no_pending(&mut repo2, &changes, &mut txn, &mut channel, "", true, None)?;

[15.3977]

[15.4076]

    output::output_repository_no_pending(
        &mut repo2,
        &changes,
        &mut txn,
        &mut channel,
        "",
        true,
        None,
    )?;

Replacement in libpijul/src/small_string.rs at line 14 [4.480474]
B:BD[2.45486] → [2.45486:45501]
```
    _str: [u8]
```
[2.45486]
[4.480895]
```
    _str: [u8],
```

Replacement in libpijul/src/small_string.rs at line 41 [4.480474]

B:BD[2.45753] → [2.45753:45856]

            std::mem::transmute(std::slice::from_raw_parts(self as *const Self as *const u8, 1 + len))

[2.45753]

[2.45856]

            std::mem::transmute(std::slice::from_raw_parts(
                self as *const Self as *const u8,
                1 + len,
            ))

Replacement in libpijul/src/small_string.rs at line 53 [4.480474]

B:BD[2.46004] → [2.46004:46107]

            std::mem::transmute(std::slice::from_raw_parts(self as *const Self as *const u8, 1 + len))

[2.46004]

[2.46107]

            std::mem::transmute(std::slice::from_raw_parts(
                self as *const Self as *const u8,
                1 + len,
            ))

Replacement in libpijul/src/small_string.rs at line 65 [4.480474]

B:BD[2.46263] → [2.46263:46366]

            std::mem::transmute(std::slice::from_raw_parts_mut(self as *mut Self as *mut u8, 1 + len))

[2.46263]

[2.46366]

            std::mem::transmute(std::slice::from_raw_parts_mut(
                self as *mut Self as *mut u8,
                1 + len,
            ))

Replacement in libpijul/src/small_string.rs at line 77 [4.480474]

B:BD[2.46532] → [2.46532:46635]

            std::mem::transmute(std::slice::from_raw_parts_mut(self as *mut Self as *mut u8, 1 + len))

[2.46532]

[2.46635]

            std::mem::transmute(std::slice::from_raw_parts_mut(
                self as *mut Self as *mut u8,
                1 + len,
            ))

Replacement in libpijul/src/small_string.rs at line 309 [4.480474]

B:BD[2.47657] → [2.47657:47741]

        debug!("writing {:?}", std::slice::from_raw_parts(p, 1+self.len as usize));

[2.47657]

[2.47741]

        debug!(
            "writing {:?}",
            std::slice::from_raw_parts(p, 1 + self.len as usize)
        );

Replacement in libpijul/src/small_string.rs at line 319 [4.480474]

B:BD[2.47937] → [2.47937:48020]

        debug!("onpage_size {:?}", std::slice::from_raw_parts(p, 1+len as usize));

[2.47937]

[2.48020]

        debug!(
            "onpage_size {:?}",
            std::slice::from_raw_parts(p, 1 + len as usize)
        );

Replacement in libpijul/src/record.rs at line 392 [4.488880]

B:BD[4.500452] → [2.49953:50044]

            let name_dest = txn.find_block_end(txn.graph(channel), name_.dest()).unwrap();

[4.500452]

[4.500531]

            let name_dest = txn
                .find_block_end(txn.graph(channel), name_.dest())
                .unwrap();

Replacement in libpijul/src/record.rs at line 397 [4.488880]

B:BD[12.11892] → [2.50045:50149]

                .get_contents(|p| txn.get_external(&p).unwrap().map(From::from), *name_dest, &mut name)

[12.11892]

[12.11969]

                .get_contents(
                    |p| txn.get_external(&p).unwrap().map(From::from),
                    *name_dest,
                    &mut name,
                )

Replacement in libpijul/src/record.rs at line 544 [4.488880]

B:BD[16.281] → [2.50704:50812]

                        .get_contents(|p| txn.get_external(&p).unwrap().map(From::from), *child, &mut name)

[16.281]

[16.371]

                        .get_contents(
                            |p| txn.get_external(&p).unwrap().map(From::from),
                            *child,
                            &mut name,
                        )

Replacement in libpijul/src/record.rs at line 631 [4.488880]

B:BD[17.35616] → [2.50949:51051]

                self.record_deleted_file(txn, txn.graph(channel), working_copy, &full_path, *vertex)?

[17.35616]

[4.506617]

                self.record_deleted_file(
                    txn,
                    txn.graph(channel),
                    working_copy,
                    &full_path,
                    *vertex,
                )?

Replacement in libpijul/src/record.rs at line 791 [4.488880]

B:BD[17.36364] → [2.51420:51496]

        if !parent.flag().contains(EdgeFlags::FOLDER | EdgeFlags::PARENT) {

[17.36364]

[17.36438]

        if !parent
            .flag()
            .contains(EdgeFlags::FOLDER | EdgeFlags::PARENT)
        {

Replacement in libpijul/src/record.rs at line 994 [4.488880]

∅:D[2.54032] → [18.3965:4030]

B:BD[18.3965] → [18.3965:4030]

B:BD[18.4030] → [2.54033:54130]

                    self.rec
                        .updatables
                        .insert(self.rec.actions.len(), InodeUpdate::Deleted { inode: *inode });

[2.54032]

[4.520235]

                    self.rec.updatables.insert(
                        self.rec.actions.len(),
                        InodeUpdate::Deleted { inode: *inode },
                    );

Deletion in libpijul/src/pristine/vertex.rs at line 1 [4.525242]
B:BD[4.525242] → [2.55896:55912]
```
use super::L64;
```
Insertion in libpijul/src/pristine/vertex.rs at line 2 [4.525242]
[4.525323]
[4.525323]
```
use super::L64;
```

Replacement in libpijul/src/pristine/vertex.rs at line 19 [4.525242]

B:BD[2.56127] → [2.56127:56212]

        write!(fmt, "V({:?}[{}:{}])", self.change, (self.start.0).0, (self.end.0).0)

[2.56127]

[2.56212]

        write!(
            fmt,
            "V({:?}[{}:{}])",
            self.change,
            (self.start.0).0,
            (self.end.0).0
        )

Deletion in libpijul/src/pristine/sanakirja.rs at line 190 [4.531056]
B:BD[4.536203] → [4.536203:536204]

Replacement in libpijul/src/pristine/sanakirja.rs at line 265 [4.531056]

B:BD[2.62787] → [2.62787:62893]

            let revchanges: UDb<L64, Pair<ChangeId, SerializedMerkle>> = UDb::from_page(tup.0[2].into());

[2.62787]

[2.62893]

            let revchanges: UDb<L64, Pair<ChangeId, SerializedMerkle>> =
                UDb::from_page(tup.0[2].into());

Replacement in libpijul/src/pristine/sanakirja.rs at line 321 [4.531056]

B:BD[6.36940] → [2.65385:65489]

    fn get_internal(&self, p: &SerializedHash) -> Result<Option<&ChangeId>, TxnErr<Self::GraphError>> {

[6.36940]

[2.65489]

    fn get_internal(
        &self,
        p: &SerializedHash,
    ) -> Result<Option<&ChangeId>, TxnErr<Self::GraphError>> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 430 [4.531056]

B:BD[2.67285] → [2.67285:67393]

    let mut k = if let Some((k, _)) = cursor.set(txn, &key, None).map_err(|x| BlockError::Txn(x.into()))? {

[2.67285]

[2.67393]

    let mut k = if let Some((k, _)) = cursor
        .set(txn, &key, None)
        .map_err(|x| BlockError::Txn(x.into()))?
    {

Replacement in libpijul/src/pristine/sanakirja.rs at line 632 [4.531056]
B:BD[2.71161] → [2.71161:71176]
```
            },
```
[2.71161]
[2.71176]
```
            }
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 778 [4.531056]
B:BD[2.74103] → [2.74103:74129]
```
            _ => Ok(None)
```
[2.74103]
[2.74129]
```
            _ => Ok(None),
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 873 [4.531056]

B:BD[2.74969] → [2.74969:75069]

    type TreeCursor =
        ::sanakirja::btree::cursor::Cursor<PathId, Inode, UP<PathId, Inode>>;

[2.74969]

[2.75069]

    type TreeCursor = ::sanakirja::btree::cursor::Cursor<PathId, Inode, UP<PathId, Inode>>;

Replacement in libpijul/src/pristine/sanakirja.rs at line 875 [4.531056]

B:BD[2.75112] → [2.75112:75215]

    type RevtreeCursor =
        ::sanakirja::btree::cursor::Cursor<Inode, PathId, UP<Inode, PathId>>;

[2.75112]

[2.75215]

    type RevtreeCursor = ::sanakirja::btree::cursor::Cursor<Inode, PathId, UP<Inode, PathId>>;

Replacement in libpijul/src/pristine/sanakirja.rs at line 1058 [4.531056]

B:BD[4.550501] → [4.550501:550535]

B:BD[4.550535] → [2.77511:78508]

            Entry::Vacant(v) => {
                match btree::get(&self.txn, &self.remotes, &name, None)? {
                    Some((name_, remote)) if name.as_ref() == name_ => {
                        debug!("load_remote: {:?} {:?}", name_, remote);
                        let r = Remote {
                            remote: UDb::from_page(remote.0[0].into()),
                            rev: UDb::from_page(remote.0[1].into()),
                            states: UDb::from_page(remote.0[2].into()),
                        };
                        for x in btree::iter(&self.txn, &r.remote, None).unwrap() {
                            debug!("remote -> {:?}", x);
                        }
                        for x in btree::iter(&self.txn, &r.rev, None).unwrap() {
                            debug!("rev -> {:?}", x);
                        }
                        for x in btree::iter(&self.txn, &r.states, None).unwrap() {
                            debug!("states -> {:?}", x);
                        }

[4.550501]

[2.78508]

            Entry::Vacant(v) => match btree::get(&self.txn, &self.remotes, &name, None)? {
                Some((name_, remote)) if name.as_ref() == name_ => {
                    debug!("load_remote: {:?} {:?}", name_, remote);
                    let r = Remote {
                        remote: UDb::from_page(remote.0[0].into()),
                        rev: UDb::from_page(remote.0[1].into()),
                        states: UDb::from_page(remote.0[2].into()),
                    };
                    for x in btree::iter(&self.txn, &r.remote, None).unwrap() {
                        debug!("remote -> {:?}", x);
                    }
                    for x in btree::iter(&self.txn, &r.rev, None).unwrap() {
                        debug!("rev -> {:?}", x);
                    }
                    for x in btree::iter(&self.txn, &r.states, None).unwrap() {
                        debug!("states -> {:?}", x);
                    }

Replacement in libpijul/src/pristine/sanakirja.rs at line 1076 [4.531056]

B:BD[2.78509] → [2.78509:78894]

                        for x in self.iter_remote(&r.remote, 0).unwrap() {
                            debug!("ITER {:?}", x);
                        }
                        let r = RemoteRef {
                            db: Rc::new(RefCell::new(r)),
                            name: name.clone(),
                        };
                        Ok(Some(v.insert(r).clone()))

[2.78509]

[2.78894]

                    for x in self.iter_remote(&r.remote, 0).unwrap() {
                        debug!("ITER {:?}", x);

Replacement in libpijul/src/pristine/sanakirja.rs at line 1079 [4.531056]

B:BD[2.78916] → [2.78916:78957]

                    _ => return Ok(None)

[2.78916]

[4.551161]


                    let r = RemoteRef {
                        db: Rc::new(RefCell::new(r)),
                        name: name.clone(),
                    };
                    Ok(Some(v.insert(r).clone()))

Replacement in libpijul/src/pristine/sanakirja.rs at line 1086 [4.531056]
B:BD[4.551179] → [4.551179:551193]
```
            }
```
[4.551179]
[19.45322]
```
                _ => return Ok(None),
            },
```
Deletion in libpijul/src/pristine/sanakirja.rs at line 1119 [4.531056]
B:BD[20.940] → [21.115:115]
D:D[20.940] → [21.115:115]

Replacement in libpijul/src/pristine/sanakirja.rs at line 1170 [4.531056]

B:BD[4.555427] → [4.555427:555461]

B:BD[4.555461] → [2.80696:81384]

            Entry::Vacant(v) => {
                match btree::get(&self.txn, &self.remotes, &name, None)? {
                    Some((name_, remote)) if name_ == name.as_ref() => {
                        let r = RemoteRef {
                            db: Rc::new(RefCell::new(Remote {
                                remote: UDb::from_page(remote.0[0].into()),
                                rev: UDb::from_page(remote.0[1].into()),
                                states: UDb::from_page(remote.0[2].into()),
                            })),
                            name: name.clone(),
                        };
                        v.insert(r);
                    }
                    _ => return Ok(None),

[4.555427]

[4.556087]

            Entry::Vacant(v) => match btree::get(&self.txn, &self.remotes, &name, None)? {
                Some((name_, remote)) if name_ == name.as_ref() => {
                    let r = RemoteRef {
                        db: Rc::new(RefCell::new(Remote {
                            remote: UDb::from_page(remote.0[0].into()),
                            rev: UDb::from_page(remote.0[1].into()),
                            states: UDb::from_page(remote.0[2].into()),
                        })),
                        name: name.clone(),
                    };
                    v.insert(r);

Replacement in libpijul/src/pristine/sanakirja.rs at line 1182 [4.531056]
B:BD[4.556105] → [4.556105:556119]
```
            }
```
[4.556105]
[4.556119]
```
                _ => return Ok(None),
            },
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 1225 [4.531056]
B:BD[2.82118] → [2.82118:82145]
```
            _ => Ok(false)
```
[2.82118]
[2.82145]
```
            _ => Ok(false),
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 1235 [4.531056]
B:BD[2.82311] → [2.82311:82338]
```
            _ => Ok(false)
```
[2.82311]
[2.82338]
```
            _ => Ok(false),
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1521 [4.531056]

B:BD[4.563385] → [2.86819:88506]

                let r =
                    match btree::get(&self.txn, &self.channels, &name, None)? {
                        Some((name_, b)) => {
                            assert_eq!(name_, name.as_ref());
                            ChannelRef {
                                r: Rc::new(RefCell::new(Channel {
                                    graph: Db::from_page(b.0[0].into()),
                                    changes: Db::from_page(b.0[1].into()),
                                    revchanges: UDb::from_page(b.0[2].into()),
                                    states: UDb::from_page(b.0[3].into()),
                                    apply_counter: b.0[4].into(),
                                    name: name.clone(),
                                    last_modified: b.0[5].into(),
                                })),
                            }
                        }
                        _ => {
                            let br = ChannelRef {
                                r: Rc::new(RefCell::new(Channel {
                                    graph: btree::create_db_(&mut self.txn)?,
                                    changes: btree::create_db_(&mut self.txn)?,
                                    revchanges: btree::create_db_(&mut self.txn)?,
                                    states: btree::create_db_(&mut self.txn)?,
                                    apply_counter: 0,
                                    name: name.clone(),
                                    last_modified: 0,
                                })),
                            };
                            commit = Some(br.clone());
                            br

[4.563385]

[2.88506]

                let r = match btree::get(&self.txn, &self.channels, &name, None)? {
                    Some((name_, b)) => {
                        assert_eq!(name_, name.as_ref());
                        ChannelRef {
                            r: Rc::new(RefCell::new(Channel {
                                graph: Db::from_page(b.0[0].into()),
                                changes: Db::from_page(b.0[1].into()),
                                revchanges: UDb::from_page(b.0[2].into()),
                                states: UDb::from_page(b.0[3].into()),
                                apply_counter: b.0[4].into(),
                                name: name.clone(),
                                last_modified: b.0[5].into(),
                            })),

Replacement in libpijul/src/pristine/sanakirja.rs at line 1535 [4.531056]

∅:D[2.88532] → [4.564757:564780]

B:BD[4.564757] → [4.564757:564780]

};

[2.88532]

[19.48488]

                    }
                    _ => {
                        let br = ChannelRef {
                            r: Rc::new(RefCell::new(Channel {
                                graph: btree::create_db_(&mut self.txn)?,
                                changes: btree::create_db_(&mut self.txn)?,
                                revchanges: btree::create_db_(&mut self.txn)?,
                                states: btree::create_db_(&mut self.txn)?,
                                apply_counter: 0,
                                name: name.clone(),
                                last_modified: 0,
                            })),
                        };
                        commit = Some(br.clone());
                        br
                    }
                };

Replacement in libpijul/src/pristine/sanakirja.rs at line 1572 [4.531056]

B:BD[4.565588] → [2.88599:88737]

            Some((name_, _)) if name_ == name.as_ref() =>
                Err(super::ForkError::ChannelNameExists(new_name.to_string())),

[4.565588]

[2.88737]

            Some((name_, _)) if name_ == name.as_ref() => {
                Err(super::ForkError::ChannelNameExists(new_name.to_string()))
            }

Replacement in libpijul/src/pristine/sanakirja.rs at line 1606 [4.531056]

B:BD[4.566888] → [2.89838:89976]

            Some((name_, _)) if name_ == name.as_ref() =>
                Err(super::ForkError::ChannelNameExists(new_name.to_string())),

[4.566888]

[2.89976]

            Some((name_, _)) if name_ == name.as_ref() => {
                Err(super::ForkError::ChannelNameExists(new_name.to_string()))
            }

Replacement in libpijul/src/pristine/sanakirja.rs at line 1616 [4.531056]

B:BD[12.16014] → [2.90143:90204]

                    .map_err(|e| ForkError::Txn(e.into()))?;

[12.16014]

[2.90204]

                .map_err(|e| ForkError::Txn(e.into()))?;

Replacement in libpijul/src/pristine/sanakirja.rs at line 1623 [4.531056]

B:BD[2.90423] → [2.90423:90559]

                std::cell::RefCell::borrow_mut(&std::rc::Rc::get_mut(&mut channel.r).unwrap()).name =
                    name.clone();

[2.90423]

[4.566916]

                std::cell::RefCell::borrow_mut(&std::rc::Rc::get_mut(&mut channel.r).unwrap())
                    .name = name.clone();

Replacement in libpijul/src/pristine/sanakirja.rs at line 1647 [4.531056]

B:BD[4.568289] → [2.90803:92083]

∅:D[2.92083] → [4.569194:569217]

B:BD[4.569194] → [4.569194:569217]

                let r =
                    match btree::get(&self.txn, &self.remotes, &name, None)? {
                        Some((name_, remote)) if name_ == name.as_ref() => {
                            RemoteRef {
                                db: Rc::new(RefCell::new(Remote {
                                    remote: UDb::from_page(remote.0[0].into()),
                                    rev: UDb::from_page(remote.0[1].into()),
                                    states: UDb::from_page(remote.0[2].into()),
                                })),
                                name: name.clone(),
                            }
                        }
                        _ => {
                            let br = RemoteRef {
                                db: Rc::new(RefCell::new(Remote {
                                    remote: btree::create_db_(&mut self.txn)?,
                                    rev: btree::create_db_(&mut self.txn)?,
                                    states: btree::create_db_(&mut self.txn)?,
                                })),
                                name: name.clone(),
                            };
                            commit = Some(br.clone());
                            br
                        }
                    };

[4.568289]

[4.569306]

                let r = match btree::get(&self.txn, &self.remotes, &name, None)? {
                    Some((name_, remote)) if name_ == name.as_ref() => RemoteRef {
                        db: Rc::new(RefCell::new(Remote {
                            remote: UDb::from_page(remote.0[0].into()),
                            rev: UDb::from_page(remote.0[1].into()),
                            states: UDb::from_page(remote.0[2].into()),
                        })),
                        name: name.clone(),
                    },
                    _ => {
                        let br = RemoteRef {
                            db: Rc::new(RefCell::new(Remote {
                                remote: btree::create_db_(&mut self.txn)?,
                                rev: btree::create_db_(&mut self.txn)?,
                                states: btree::create_db_(&mut self.txn)?,
                            })),
                            name: name.clone(),
                        };
                        commit = Some(br.clone());
                        br
                    }
                };

Replacement in libpijul/src/pristine/sanakirja.rs at line 1716 [4.531056]

B:BD[2.92526] → [2.92526:92598]

        self.txn.set_root(Root::RevInodes as usize, self.revinodes.db);

[2.92526]

[2.92598]

        self.txn
            .set_root(Root::RevInodes as usize, self.revinodes.db);

Replacement in libpijul/src/pristine/sanakirja.rs at line 1741 [4.531056]

B:BD[2.93384] → [2.93384:93452]

                debug!("load_const_channel = {:?} {:?}", name_ ,c);

[2.93384]

[2.93452]

                debug!("load_const_channel = {:?} {:?}", name_, c);

Replacement in libpijul/src/pristine/sanakirja.rs at line 1752 [4.531056]
B:BD[2.93884] → [2.93884:93910]
```
            _ => Ok(None)
```
[2.93884]
[4.572745]
```
            _ => Ok(None),
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1771 [4.531056]

B:BD[2.93981] → [2.93981:94087]

∅:D[2.94087] → [4.573831:573861]

B:BD[4.573831] → [4.573831:573861]

        btree::del(
            &mut self.txn,
            &mut self.channels,
            &channel.name,
            None,
        )?;

[2.93981]

[2.94088]

        btree::del(&mut self.txn, &mut self.channels, &channel.name, None)?;

Replacement in libpijul/src/pristine/sanakirja.rs at line 1781 [4.531056]
B:BD[2.94395] → [2.94395:94442]
∅:D[2.94442] → [4.574049:574081]
B:BD[4.574049] → [4.574049:574081]
B:BD[4.574081] → [2.94443:94487]
∅:D[2.94487] → [4.574393:574405]
B:BD[4.574393] → [4.574393:574405]
```
        btree::put(
            &mut self.txn,
            &mut self.channels,
            &channel.name,
            &t6,
        )?;
```
[2.94395]
[2.94488]
```
        btree::put(&mut self.txn, &mut self.channels, &channel.name, &t6)?;
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1797 [4.531056]

B:BD[17.53791] → [2.94560:94664]

∅:D[2.94664] → [4.575336:575366]

B:BD[4.575336] → [4.575336:575366]

        btree::del(
            &mut self.txn,
            &mut self.remotes,
            &remote.name,
            None,
        )?;

[17.53791]

[2.94665]

        btree::del(&mut self.txn, &mut self.remotes, &remote.name, None)?;

Replacement in libpijul/src/pristine/sanakirja.rs at line 1804 [4.531056]

B:BD[2.94807] → [2.94807:94945]

            &T3([
                r.remote.db.into(),
                r.rev.db.into(),
                r.states.db.into()
            ]),

[2.94807]

[4.575729]

            &T3([r.remote.db.into(), r.rev.db.into(), r.states.db.into()]),

Replacement in libpijul/src/pristine/sanakirja.rs at line 1862 [4.531056]
B:BD[2.96056] → [2.96056:96109]
```
        basename: SmallString::from_str("blablabla")
```
[2.96056]
[2.96109]
```
        basename: SmallString::from_str("blablabla"),
```
Deletion in libpijul/src/pristine/sanakirja.rs at line 1873 [4.531056]
B:BD[4.581112] → [4.581112:581113]
B:BD[4.581991] → [4.581991:581992]
Replacement in libpijul/src/pristine/sanakirja.rs at line 1886 [4.531056]
B:BD[2.96887] → [2.96887:96910]
```
            ord => ord
```
[2.96887]
[4.583598]
```
            ord => ord,
```
Deletion in libpijul/src/pristine/sanakirja.rs at line 1915 [4.531056]
B:BD[2.97813] → [2.97813:97814]

Replacement in libpijul/src/pristine/path_id.rs at line 47 [4.584967]

B:BD[2.98295] → [2.98295:98394]

            std::mem::transmute(std::slice::from_raw_parts(self as *const Self as *const u8, len))

[2.98295]

[4.586065]

            std::mem::transmute(std::slice::from_raw_parts(
                self as *const Self as *const u8,
                len,
            ))

Replacement in libpijul/src/pristine/path_id.rs at line 59 [4.584967]

B:BD[2.98481] → [2.98481:98534]

        basename: SmallString::from_str("blablabla")

[2.98481]

[2.98534]

        basename: SmallString::from_str("blablabla"),

Replacement in libpijul/src/pristine/mod.rs at line 105 [4.586748]

B:BD[2.100342] → [2.100342:100457]

        unsafe {
            std::ptr::copy_nonoverlapping(s.as_ptr(), &mut u as *mut u64 as *mut u8, 8)
        }

[2.100342]

[2.100457]

        unsafe { std::ptr::copy_nonoverlapping(s.as_ptr(), &mut u as *mut u64 as *mut u8, 8) }

Deletion in libpijul/src/pristine/mod.rs at line 116 [4.586748]
B:BD[2.100688] → [2.100688:100689]
Deletion in libpijul/src/pristine/mod.rs at line 124 [4.586748]
B:BD[2.100887] → [2.100887:100888]
Deletion in libpijul/src/pristine/mod.rs at line 131 [4.586748]
B:BD[4.587268] → [2.101016:101017]

Replacement in libpijul/src/pristine/mod.rs at line 224 [4.586748]

B:BD[17.54628] → [2.101082:101185]

    fn get_external(&self, p: &ChangeId) -> Result<Option<&SerializedHash>, TxnErr<Self::GraphError>>;

[17.54628]

[17.54719]

    fn get_external(
        &self,
        p: &ChangeId,
    ) -> Result<Option<&SerializedHash>, TxnErr<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 231 [4.586748]

B:BD[17.54836] → [2.101186:101289]

    fn get_internal(&self, p: &SerializedHash) -> Result<Option<&ChangeId>, TxnErr<Self::GraphError>>;

[17.54836]

[19.48878]

    fn get_internal(
        &self,
        p: &SerializedHash,
    ) -> Result<Option<&ChangeId>, TxnErr<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 321 [4.586748]

B:BD[19.51355] → [2.102192:102294]

        RevCursor<Self, &'txn Self, Self::RevchangesetCursor, L64, Pair<ChangeId, SerializedMerkle>>,

[19.51355]

[19.51443]

        RevCursor<
            Self,
            &'txn Self,
            Self::RevchangesetCursor,
            L64,
            Pair<ChangeId, SerializedMerkle>,
        >,

Replacement in libpijul/src/pristine/mod.rs at line 517 [4.586748]

B:BD[17.59143] → [2.103426:103528]

        RevCursor<Self, &'txn Self, Self::RemoteCursor, L64, Pair<SerializedHash, SerializedMerkle>>,

[17.59143]

[17.59221]

        RevCursor<
            Self,
            &'txn Self,
            Self::RemoteCursor,
            L64,
            Pair<SerializedHash, SerializedMerkle>,
        >,

Replacement in libpijul/src/pristine/mod.rs at line 683 [4.586748]

B:BD[2.104012] → [2.104012:104129]

∅:D[2.104129] → [17.62542:62544]

B:BD[17.62542] → [17.62542:62544]

) -> Result<Cursor<T, &'txn T, T::RevchangesetCursor, L64, Pair<ChangeId, SerializedMerkle>>, TxnErr<T::GraphError>>
{

[2.104012]

[22.2878]

) -> Result<
    Cursor<T, &'txn T, T::RevchangesetCursor, L64, Pair<ChangeId, SerializedMerkle>>,
    TxnErr<T::GraphError>,
> {

Replacement in libpijul/src/pristine/mod.rs at line 726 [4.586748]

B:BD[17.63629] → [2.104276:104380]

        iter: T::cursor_revchangeset_ref(txn, txn.rev_changes(&channel), Some(from_timestamp.into()))?,

[17.63629]

[6.41239]

        iter: T::cursor_revchangeset_ref(
            txn,
            txn.rev_changes(&channel),
            Some(from_timestamp.into()),
        )?,

Replacement in libpijul/src/pristine/mod.rs at line 748 [4.586748]

B:BD[17.63962] → [2.104381:104481]

        iter: txn.rev_cursor_revchangeset(txn.rev_changes(&channel), Some(from_timestamp.into()))?,

[17.63962]

[6.41610]

        iter: txn
            .rev_cursor_revchangeset(txn.rev_changes(&channel), Some(from_timestamp.into()))?,

Replacement in libpijul/src/pristine/mod.rs at line 1191 [4.586748]

B:BD[4.620373] → [2.107460:107551]

pub struct Cursor<T: Sized, RT: std::ops::Deref<Target = T>, Cursor, K:?Sized, V:?Sized> {

[4.620373]

[19.54784]

pub struct Cursor<T: Sized, RT: std::ops::Deref<Target = T>, Cursor, K: ?Sized, V: ?Sized> {

Replacement in libpijul/src/pristine/mod.rs at line 1199 [4.586748]

B:BD[4.620582] → [2.107673:107767]

pub struct RevCursor<T: Sized, RT: std::ops::Deref<Target = T>, Cursor, K:?Sized, V:?Sized> {

[4.620582]

[19.54879]

pub struct RevCursor<T: Sized, RT: std::ops::Deref<Target = T>, Cursor, K: ?Sized, V: ?Sized> {

Insertion in libpijul/src/pristine/mod.rs at line 1225 [4.586748]
[17.68241]
[17.68241]
```
initialized_cursor!(partials, SmallStr, Position<ChangeId>, TreeTxnT, TreeError);
```
Deletion in libpijul/src/pristine/mod.rs at line 1227 [4.586748]
B:BD[17.68262] → [17.68262:68276]
B:BD[17.68276] → [2.108188:108202]
∅:D[2.108202] → [17.68293:68369]
B:BD[17.68293] → [17.68293:68369]
```
    partials,
    SmallStr,
    Position<ChangeId>,
    TreeTxnT,
    TreeError
);
initialized_cursor!(
```

Replacement in libpijul/src/pristine/mod.rs at line 1302 [4.586748]

B:BD[2.108947] → [2.108947:109061]

                    Ok(true) => return self.txn.get_external(&changeid).transpose().map(|x| x.map(|x| x.into())),

[2.108947]

[17.70696]

                    Ok(true) => {
                        return self
                            .txn
                            .get_external(&changeid)
                            .transpose()
                            .map(|x| x.map(|x| x.into()))
                    }

Replacement in libpijul/src/pristine/mod.rs at line 1346 [4.586748]

B:BD[2.109358] → [2.109358:109470]

                    Ok(true) => return self.txn.get_external(&changeid).transpose().map(|x| x.map(From::from)),

[2.109358]

[17.71726]

                    Ok(true) => {
                        return self
                            .txn
                            .get_external(&changeid)
                            .transpose()
                            .map(|x| x.map(From::from))
                    }

Replacement in libpijul/src/pristine/mod.rs at line 1638 [4.586748]

B:BD[2.110178] → [2.110178:110256]

        Some(&SerializedEdge::new(flag, k1.change, k1.start, introduced_by)),

[2.110178]

[6.52831]

        Some(&SerializedEdge::new(
            flag,
            k1.change,
            k1.start,
            introduced_by,
        )),

Replacement in libpijul/src/pristine/mod.rs at line 1648 [4.586748]

B:BD[2.110270] → [2.110270:110366]

        Some(&SerializedEdge::new(flag | EdgeFlags::PARENT, k0.change, k0.end, introduced_by)),

[2.110270]

[6.53117]

        Some(&SerializedEdge::new(
            flag | EdgeFlags::PARENT,
            k0.change,
            k0.end,
            introduced_by,
        )),

Replacement in libpijul/src/pristine/mod.rs at line 1656 [4.586748]

B:BD[2.110399] → [2.110399:110494]

        panic!("Failed: {:?} {:?} for {:?} {:?} {:?} {:?}", a, b, flag, k0, k1, introduced_by)

[2.110399]

[2.110494]

        panic!(
            "Failed: {:?} {:?} for {:?} {:?} {:?} {:?}",
            a, b, flag, k0, k1, introduced_by
        )

Replacement in libpijul/src/pristine/mod.rs at line 1683 [4.586748]

B:BD[2.110514] → [2.110514:110585]

        &SerializedEdge::new(flag, k1.change, k1.start, introduced_by)

[2.110514]

[6.53969]

        &SerializedEdge::new(flag, k1.change, k1.start, introduced_by),

Replacement in libpijul/src/pristine/mod.rs at line 1777 [4.586748]
B:BD[23.3974] → [2.111693:111724]
```
        let (&b,  state) = e?;
```
[23.3974]
[2.111724]
```
        let (&b, state) = e?;
```

Replacement in libpijul/src/pristine/merkle.rs at line 100 [4.638683]

B:BD[2.112756] → [2.112756:112966]

                (self.0)[0] == MerkleAlgorithm::Ed25519 as u8
                    && {
                        let q = q.compress();
                        q.as_bytes() == &(self.0)[1..]
                    }

[2.112756]

[2.112966]

                (self.0)[0] == MerkleAlgorithm::Ed25519 as u8 && {
                    let q = q.compress();
                    q.as_bytes() == &(self.0)[1..]
                }

Replacement in libpijul/src/pristine/hash.rs at line 159 [4.644439]
B:BD[2.114941] → [2.114941:114950]
```
    h: H
```
[2.114941]
[2.114950]
```
    h: H,
```
Replacement in libpijul/src/pristine/hash.rs at line 191 [4.644439]
B:BD[2.115671] → [2.115671:115690]
```
            o => o
```
[2.115671]
[2.115690]
```
            o => o,
```
Replacement in libpijul/src/pristine/hash.rs at line 249 [4.644439]
B:BD[2.117119] → [2.117119:117133]
```
            }
```
[2.117119]
[2.117133]
```
            },
```

Replacement in libpijul/src/pristine/edge.rs at line 89 [4.648958]

B:BD[2.117505] → [2.117505:117634]

        write!(fmt, "E({:?}, {}[{}], {})", self.flag(), pos.change.to_base32(), (pos.pos.0).0, self.introduced_by().to_base32())

[2.117505]

[2.117634]

        write!(
            fmt,
            "E({:?}, {}[{}], {})",
            self.flag(),
            pos.change.to_base32(),
            (pos.pos.0).0,
            self.introduced_by().to_base32()
        )

Replacement in libpijul/src/pristine/edge.rs at line 116 [4.648958]

B:BD[2.118186] → [2.118186:118257]

            pos: ChangePosition(L64((pos & 0xffffffffffffff).to_le()))

[2.118186]

[2.118257]

            pos: ChangePosition(L64((pos & 0xffffffffffffff).to_le())),

Replacement in libpijul/src/pristine/edge.rs at line 141 [4.648958]
B:BD[2.118845] → [2.118845:118875]
```
            s.introduced_by.0
```
[2.118845]
[2.118875]
```
            s.introduced_by.0,
```

Replacement in libpijul/src/pristine/edge.rs at line 162 [4.648958]

B:BD[2.119421] → [2.119421:119541]

        assert!(pos < 1 <<56);
        SerializedEdge([(pos | ((flag.bits() as u64) << 56)).into(), change.0, intro.0])

[2.119421]

[2.119541]

        assert!(pos < 1 << 56);
        SerializedEdge([
            (pos | ((flag.bits() as u64) << 56)).into(),
            change.0,
            intro.0,
        ])

Replacement in libpijul/src/pristine/change_id.rs at line 1 [4.666427]
B:BD[4.666427] → [2.119548:119574]
```
use super::{L64, Base32};
```
[4.666427]
[4.666544]
```
use super::{Base32, L64};
```

Replacement in libpijul/src/output/output.rs at line 311 [4.671807]

B:BD[2.120919] → [2.120919:120981]

∅:D[2.120981] → [22.4834:4886]

B:BD[22.4834] → [22.4834:4886]

            crate::fs::rec_delete(txn, &file_id, inode, true)
                .map_err(PristineOutputError::Fs)?;

[2.120919]

[4.682528]

            crate::fs::rec_delete(txn, &file_id, inode, true).map_err(PristineOutputError::Fs)?;

Replacement in libpijul/src/output/mod.rs at line 124 [4.686190]

B:BD[12.24856] → [2.122090:122198]

            .get_contents(|h| txn.get_external(&h).unwrap().map(|x| x.into()), *name_vertex, &mut name_buf)

[12.24856]

[17.86543]

            .get_contents(
                |h| txn.get_external(&h).unwrap().map(|x| x.into()),
                *name_vertex,
                &mut name_buf,
            )

Replacement in libpijul/src/missing_context.rs at line 229 [4.696460]

B:BD[13.12667] → [2.123506:123614]

        if v.introduced_by() == change_id || known(txn.get_external(&v.introduced_by())?.unwrap().into()) {

[13.12667]

[13.12762]

        if v.introduced_by() == change_id
            || known(txn.get_external(&v.introduced_by())?.unwrap().into())
        {

Replacement in libpijul/src/missing_context.rs at line 529 [4.696460]

B:BD[2.125543] → [2.125543:125614]

        ws.unknown_parents.push((dest_vertex, p, inode, edge.flag()));

[2.125543]

[4.715147]

        ws.unknown_parents
            .push((dest_vertex, p, inode, edge.flag()));

Replacement in libpijul/src/lib.rs at line 646 [4.717381]

B:BD[17.99689] → [2.128510:128624]

    type Item = Result<(u64, (&'txn pristine::SerializedHash, &'txn pristine::SerializedMerkle)), T::GraphError>;

[17.99689]

[4.734553]

    type Item = Result<
        (
            u64,
            (
                &'txn pristine::SerializedHash,
                &'txn pristine::SerializedMerkle,
            ),
        ),
        T::GraphError,
    >;

Replacement in libpijul/src/lib.rs at line 684 [4.717381]

B:BD[17.100355] → [2.128945:129059]

    type Item = Result<(u64, (&'txn pristine::SerializedHash, &'txn pristine::SerializedMerkle)), T::GraphError>;

[17.100355]

[4.735067]

    type Item = Result<
        (
            u64,
            (
                &'txn pristine::SerializedHash,
                &'txn pristine::SerializedMerkle,
            ),
        ),
        T::GraphError,
    >;

Replacement in libpijul/src/fs.rs at line 331 [4.737429]

B:BD[4.748566] → [4.748566:748631]

B:BD[4.748631] → [2.131139:131159]

∅:D[2.131159] → [4.748664:748693]

B:BD[4.748664] → [4.748664:748693]

        debug!(
            "rec_delete: {:?} {:?} not present",
            parent,
            inode
        );

[4.748566]

[4.748693]

        debug!("rec_delete: {:?} {:?} not present", parent, inode);

Replacement in libpijul/src/fs.rs at line 569 [4.737429]

B:BD[17.109779] → [2.131957:132058]

            .get_contents(|p| self.txn.get_external(&p).unwrap().map(|x| x.into()), *dest, &mut buf)

[17.109779]

[17.109860]

            .get_contents(
                |p| self.txn.get_external(&p).unwrap().map(|x| x.into()),
                *dest,
                &mut buf,
            )

Replacement in libpijul/src/fs.rs at line 653 [4.737429]

B:BD[17.111342] → [2.132151:132238]

            let dest = self.txn.find_block_end(&self.channel, parent.dest()).unwrap();

[17.111342]

[4.755231]

            let dest = self
                .txn
                .find_block_end(&self.channel, parent.dest())
                .unwrap();

Replacement in libpijul/src/fs.rs at line 659 [4.737429]

B:BD[4.755328] → [2.132239:132344]

                .get_contents(|p| self.txn.get_external(&p).unwrap().map(|x| x.into()), *dest, &mut buf)

[4.755328]

[4.755404]

                .get_contents(
                    |p| self.txn.get_external(&p).unwrap().map(|x| x.into()),
                    *dest,
                    &mut buf,
                )

Replacement in libpijul/src/fs.rs at line 677 [4.737429]

B:BD[17.111529] → [2.132369:132470]

                    Some(Ok(grandparent)) => return Some(Ok((grandparent.dest(), perms, basename))),

[17.111529]

[17.111628]

                    Some(Ok(grandparent)) => {
                        return Some(Ok((grandparent.dest(), perms, basename)))
                    }

Replacement in libpijul/src/fs.rs at line 796 [4.737429]

B:BD[12.32131] → [2.132797:132907]

                .get_contents(|h| txn.get_external(&h).unwrap().map(|x| x.into()), *name_dest, &mut name_buf)

[12.32131]

[17.113593]

                .get_contents(
                    |h| txn.get_external(&h).unwrap().map(|x| x.into()),
                    *name_dest,
                    &mut name_buf,
                )

Replacement in libpijul/src/fs.rs at line 890 [4.737429]

B:BD[17.114694] → [2.133674:133779]

                .get_contents(|h| txn.get_external(&h).unwrap().map(|x| x.into()), *name, &mut name_buf)

[17.114694]

[17.114779]

                .get_contents(
                    |h| txn.get_external(&h).unwrap().map(|x| x.into()),
                    *name,
                    &mut name_buf,
                )

Replacement in libpijul/src/diff/vertex_buffer.rs at line 97 [4.768903]

B:BD[4.771983] → [4.771983:772005]

B:BD[4.772005] → [2.135510:135599]

            v.start =
                ChangePosition(self.pos_a[i].vertex.start.0 + (pos - self.pos_a[i].pos))

[4.771983]

[4.772101]

            v.start = ChangePosition(self.pos_a[i].vertex.start.0 + (pos - self.pos_a[i].pos))

Replacement in libpijul/src/diff/vertex_buffer.rs at line 100 [4.768903]

B:BD[4.772185] → [4.772185:772205]

B:BD[4.772205] → [2.135600:135693]

            v.end =
                ChangePosition(self.pos_a[i].vertex.start.0 + (end_pos - self.pos_a[i].pos))

[4.772185]

[4.772305]

            v.end = ChangePosition(self.pos_a[i].vertex.start.0 + (end_pos - self.pos_a[i].pos))

Replacement in libpijul/src/change.rs at line 966 [4.831311]

B:BD[4.860639] → [2.139573:139684]

                        change: up.change.as_ref().and_then(|a| txn.get_external(a).unwrap().map(Into::into)),

[4.860639]

[4.860716]

                        change: up
                            .change
                            .as_ref()
                            .and_then(|a| txn.get_external(a).unwrap().map(Into::into)),

Replacement in libpijul/src/change.rs at line 976 [4.831311]

B:BD[4.860923] → [2.139685:139798]

                        change: down.change.as_ref().and_then(|a| txn.get_external(a).unwrap().map(Into::into)),

[4.860923]

[4.861002]

                        change: down
                            .change
                            .as_ref()
                            .and_then(|a| txn.get_external(a).unwrap().map(Into::into)),

Replacement in libpijul/src/change.rs at line 987 [4.831311]

B:BD[4.861217] → [2.139799:139909]

                    change: inode.change.as_ref().and_then(|a| txn.get_external(a).unwrap().map(Into::into)),

[4.861217]

[4.861293]

                    change: inode
                        .change
                        .as_ref()
                        .and_then(|a| txn.get_external(a).unwrap().map(Into::into)),

Replacement in libpijul/src/change.rs at line 1001 [4.831311]

B:BD[4.861673] → [2.139910:140032]

                            change: edge.from.change.as_ref().and_then(|a| txn.get_external(a).unwrap().map(Into::into)),

[4.861673]

[4.861761]

                            change: edge
                                .from
                                .change
                                .as_ref()
                                .and_then(|a| txn.get_external(a).unwrap().map(Into::into)),

Replacement in libpijul/src/change.rs at line 1009 [4.831311]

B:BD[4.861873] → [2.140033:140153]

                            change: edge.to.change.as_ref().and_then(|a| txn.get_external(a).unwrap().map(Into::into)),

[4.861873]

[4.861959]

                            change: edge
                                .to
                                .change
                                .as_ref()
                                .and_then(|a| txn.get_external(a).unwrap().map(Into::into)),

Replacement in libpijul/src/change.rs at line 1027 [4.831311]

B:BD[4.862500] → [2.140274:140384]

                    change: inode.change.as_ref().and_then(|a| txn.get_external(a).unwrap().map(Into::into)),

[4.862500]

[4.862576]

                    change: inode
                        .change
                        .as_ref()
                        .and_then(|a| txn.get_external(a).unwrap().map(Into::into)),

Replacement in libpijul/src/change/text_changes.rs at line 325 [12.37976]

B:BD[12.48973] → [12.48973:49025]

B:BD[12.49025] → [2.140484:140560]

∅:D[2.140560] → [12.49113:49166]

B:BD[12.49113] → [12.49113:49166]

                    let name = std::str::from_utf8(
                        &change_contents[add.start.us() + 2..add.end.us()],
                    )
                    .unwrap();

[12.48973]

[12.49166]

                    let name =
                        std::str::from_utf8(&change_contents[add.start.us() + 2..add.end.us()])
                            .unwrap();

Replacement in libpijul/src/change/text_changes.rs at line 399 [12.37976]

B:BD[12.51864] → [12.51864:51916]

B:BD[12.51916] → [2.140640:140712]

∅:D[2.140712] → [12.52000:52053]

B:BD[12.52000] → [12.52000:52053]

                    let name = std::str::from_utf8(
                        &change_contents[n.start.us() + 2..n.end.us()],
                    )
                    .unwrap();

[12.51864]

[12.52053]

                    let name = std::str::from_utf8(&change_contents[n.start.us() + 2..n.end.us()])
                        .unwrap();

Replacement in libpijul/src/change/text_changes.rs at line 811 [12.37976]

B:BD[24.216] → [2.141630:141703]

                                if  contents_[c.end.us() - 1] == b'\n' {

[24.216]

[2.141703]

                                if contents_[c.end.us() - 1] == b'\n' {

Replacement in libpijul/src/change/text_changes.rs at line 921 [12.37976]

B:BD[12.73938] → [25.175:232]

B:BD[25.232] → [2.141869:141944]

                            if change.end > change.start
                                && contents_[change.end.us() - 1] == b'\n'

[12.73938]

[25.313]

                            if change.end > change.start && contents_[change.end.us() - 1] == b'\n'

Replacement in libpijul/src/change/text_changes.rs at line 958 [12.37976]

B:BD[12.75755] → [2.142110:142204]

∅:D[2.142204] → [25.444:474]

B:BD[25.444] → [25.444:474]

                            if repl.end > repl.start && contents_[repl.end.us() - 1] == b'\n'
                            {

[12.75755]

[2.142205]

                            if repl.end > repl.start && contents_[repl.end.us() - 1] == b'\n' {

Replacement in libpijul/src/change/text_changes.rs at line 1010 [12.37976]

∅:D[2.142457] → [12.78688:78733]

B:BD[12.78688] → [12.78688:78733]

B:BD[12.78733] → [2.142458:142565]

                                change.end =
                                    ChangePosition((contents_.len() as u64 + new_end - new_start).into());

[2.142457]

[12.78831]

                                change.end = ChangePosition(
                                    (contents_.len() as u64 + new_end - new_start).into(),
                                );

Replacement in libpijul/src/apply.rs at line 388 [4.944089]
∅:D[20.3531] → [4.955011:955037]
B:BD[4.955011] → [4.955011:955037]
B:BD[4.955037] → [2.144768:144842]
∅:D[2.144842] → [17.127980:127996]
B:BD[4.955259] → [17.127980:127996]
```
            txn.del_tree(
                &OwnedPathId::inode(inode),
                Some(&inode),
            )?;
```
[20.3531]
[2.144843]
```
            txn.del_tree(&OwnedPathId::inode(inode), Some(&inode))?;
```

Replacement in libpijul/src/apply.rs at line 498 [4.944089]

B:BD[17.129170] → [2.145086:145189]

        is_non_folder |= parent.flag() & (EdgeFlags::PARENT | EdgeFlags::FOLDER) == EdgeFlags::PARENT;

[17.129170]

[6.68579]

        is_non_folder |=
            parent.flag() & (EdgeFlags::PARENT | EdgeFlags::FOLDER) == EdgeFlags::PARENT;

Replacement in libpijul/src/apply.rs at line 542 [4.944089]

B:BD[17.129585] → [2.145475:145559]

        is_folder |= parent.flag().contains(EdgeFlags::PARENT | EdgeFlags::FOLDER);

[17.129585]

[2.145559]

        is_folder |= parent
            .flag()
            .contains(EdgeFlags::PARENT | EdgeFlags::FOLDER);

Replacement in libpijul/src/apply.rs at line 828 [4.944089]

B:BD[26.230] → [2.147261:147307]

            a, b, p.introduced_by(), p.flag()

[26.230]

[26.272]

            a,
            b,
            p.introduced_by(),
            p.flag()

Replacement in libpijul/src/alive/retrieve.rs at line 121 [4.984582]

B:BD[4.988306] → [2.148744:148836]

        del_graph_with_rev(txn, channel, edge.flag(), vertex, dest, edge.introduced_by())?;

[4.988306]

[4.988393]

        del_graph_with_rev(
            txn,
            channel,
            edge.flag(),
            vertex,
            dest,
            edge.introduced_by(),
        )?;

Replacement in libpijul/src/alive/output.rs at line 163 [4.988425]

B:BD[12.100647] → [2.149121:149217]

                .get_contents(|p| txn.get_external(&p).unwrap().map(|x| x.into()), vertex, buf)

[12.100647]

[12.100715]

                .get_contents(
                    |p| txn.get_external(&p).unwrap().map(|x| x.into()),
                    vertex,
                    buf,
                )

Replacement in libpijul/src/alive/dfs.rs at line 120 [4.1000429]

B:BD[4.1003461] → [2.149798:149827]

∅:D[2.149827] → [4.1003489:1003598]

B:BD[4.1003489] → [4.1003489:1003598]

B:BD[4.1003598] → [2.149828:149917]

                Some((Edge {
                    dest: graph.lines[chi].vertex.start_pos(),
                    flag: EdgeFlags::empty(),
                    introduced_by: ChangeId(4165u64.into()),
                }).into()),

[4.1003461]

[4.1003669]

                Some(
                    (Edge {
                        dest: graph.lines[chi].vertex.start_pos(),
                        flag: EdgeFlags::empty(),
                        introduced_by: ChangeId(4165u64.into()),
                    })
                    .into(),
                ),

Replacement in libpijul/src/alive/debug.rs at line 36 [4.1014531]

B:BD[12.101031] → [2.150096:150202]

                .get_contents(|h| txn.get_external(&h).unwrap().map(|x| x.into()), line.vertex, &mut buf)

[12.101031]

[12.101109]

                .get_contents(
                    |h| txn.get_external(&h).unwrap().map(|x| x.into()),
                    line.vertex,
                    &mut buf,
                )

Replacement in libpijul/Cargo.toml at line 4 [4.1020742]
B:BD[4.1020894] → [3.138:165]
```
version = "1.0.0-alpha.35"
```
[4.1020894]
[27.27]
```
version = "1.0.0-alpha.34"
```
Insertion in libpijul/Cargo.toml at line 59 [4.1020742]
[4.1022139]
[4.1022139]
```
"src/tag.rs",
```

Replacement in libpijul/Cargo.toml at line 108 [4.1020742]

B:BD[4.1023195] → [3.166:229]

pijul-macros = { path = "../pijul-macros", version = "0.4.0" }

[4.1023195]

[4.1023218]

pijul-macros = { path = "../pijul-macros", version = "0.3.0" }

Replacement in Cargo.lock at line 948 [4.1030385]
B:BD[28.560] → [3.230:257]
```
version = "1.0.0-alpha.35"
```
[28.560]
[28.729]
```
version = "1.0.0-alpha.34"
```
Replacement in Cargo.lock at line 1310 [4.1030385]
B:BD[4.1064071] → [3.258:285]
```
version = "1.0.0-alpha.39"
```
[4.1064071]
[4.1064097]
```
version = "1.0.0-alpha.41"
```
Replacement in Cargo.lock at line 1355 [4.1030385]
B:BD[4.1064574] → [3.286:304]
```
version = "0.4.0"
```
[4.1064574]
[4.1064592]
```
version = "0.3.0"
```

Cleanup, formatting, and fixing the Git feature

Dependencies

In channels

Change contents

Replacement in pijul-macros/src/lib.rs at line 177 [4.445]

Replacement in pijul-macros/Cargo.toml at line 4 [4.21011]

Deletion in pijul/src/commands/record.rs at line 148 [4.101759]

Insertion in pijul/src/commands/mod.rs at line 54 [4.133619]

Insertion in pijul/src/commands/git.rs at line 36 [4.137210]

Replacement in pijul/src/commands/git.rs at line 57 [4.137210]

Replacement in pijul/src/commands/git.rs at line 91 [4.137210]

Deletion in pijul/src/commands/git.rs at line 93 [4.137210]

Replacement in pijul/src/commands/git.rs at line 102 [4.137210]

Replacement in pijul/src/commands/git.rs at line 109 [4.137210]

Replacement in pijul/src/commands/git.rs at line 111 [4.137210]

Replacement in pijul/src/commands/git.rs at line 115 [4.137210]

Replacement in pijul/src/commands/git.rs at line 139 [4.137210]

Replacement in pijul/src/commands/git.rs at line 228 [4.137210]

Replacement in pijul/src/commands/git.rs at line 240 [4.137210]

Insertion in pijul/src/commands/git.rs at line 244 [4.137210]

Deletion in pijul/src/commands/git.rs at line 320 [4.137210]

Replacement in pijul/src/commands/git.rs at line 327 [4.137210]

Replacement in pijul/src/commands/git.rs at line 331 [4.137210]