Cleanup, formatting, and fixing the Git feature

[?]

Feb 25, 2021, 10:29 PM

IIV3EL2XYI2X7HZWKXEXQFAE3R3KC2Q7SGOT3Q332HSENMYVF32QC

Dependencies

[2] YN63NUZO Sanakirja 1.0
[3] G65S7FAW Version bump and cleanup
[4] 23LVKATN Use pager crate for log output
[5] 3S4DR77Z Version updates
[6] 3WIQYEIS Fixing conflicts in Cargo.lock
[7] CXM5CBS2 Fixing `pijul remove` when files are not deleted
[8] HSVGP2G4 Version bump + formatting
[9] EQLDTLXV Fixing a bug with empty new files, and another one with empty replacements
[10] JACZWIJ6 Version bump
[11] GHO6DWPI Refactoring iterators
[12] JL4WKA5P Implement the Sanakirja concurrency model in a cross-process way
[13] N35L72XV Versions in Cargo.lock
[14] HR3WK6A7 When lock times out, check that there are no more clients before quitting
[15] PJ7T2VFL Do not hang on locked repositories
[16] BXD3IQYN Fixing --features git
[17] I52XSRUH Massive cleanup, and simplification
[18] OUWD436A Version bump
[19] XWETQ4DE Upgrading versions
[20] SXEYMYF7 Fixing the bad changes in history (unfortunately, by rebooting).
[21] A3DMBJJA Upgrading the `git` subcommand to the latest Sanakirja and Libpijul
[22] V2MDXX62 Channel rename: do not leave the old name behind
[23] UFCZKKLX Upgrading to the latest Sanakirja/Rand
[24] JRENVH5D Reqwest 0.11
[25] 5YDI33C4 Fixing pager on OSX
[26] HW5Q7GGY Version bump
[27] ZTVNGFNT Version bump
[28] BZSC7VMY address clippy lints
[29] HKEOO4QJ Version bump
[30] CCFJ7VO3 Renaming "Record" to "Hunk" in the changes
[31] H565UUPC Use correct pattern for workspace interdependencies
[32] SPA2OL5I keep-changes feature (default) to avoid deleting problematic changes
[33] CCLLB7OI Upgrading to Sanakirja 0.15 + version bump
[34] XL6Y64UP Fixing a panic when iterating over the basenames of a file
[35] WIORLB47 Version bump
[36] GMGTWOWO Fixing a corruption error in channel rename (the channel was being deallocated in Sanakirja, but still referenced by the transaction)
[37] 5BRU2RRW Cleanup (debugging a crash related to trees/inodes)
[38] WI5BS6BS New published versions
[39] QMTANHVN Reset: only output changed files
[40] IYJZVLET Cleaning up the literate programming bits
[41] L2LPPKD4 Fixing the Git feature
[42] 3YDPHBAN address non-controversial clippy lints
[43] 7MNTFTDF Exit with an error when a change could not be signed
[44] NX5I5H53 New published versions
[45] 3M7WBE24 Re-adding anyhow in the tests of libpijul
[46] VO5OQW4W Removing anyhow in libpijul
[47] B3QWIGDE Fixing the Git features with the latest Pijul (+ conflicts in Cargo.toml)
[48] WZVCLZKY address clippy lints
[49] 3AMEP2Y5 More convenient interface for channels
[50] CT6FBU57 SDPX license + version bump
[51] 65S67T3E Parsing \\ for empty additions (rare problem)
[52] OCBM7IFE New release: pijul-1.0.0-alpha.8
[53] SN7AGY6S Making `pijul lock` robust to kill signals
[54] WKX5S4Z4 remove unneccesary explicit lifetimes
[55] CUHXXBDZ Fixing a bug in replacements, recently introduced during a fix of a graph corruption bug
[56] KUMJITTF Version bump in the lockfiles
[57] 6YMDOZIB Refactoring apply
[58] NO2QPRFL Adding rollback test
[59] B5Z4IMEU Generating Cargo.nix for pijul 1.0.0-alpha.6
[60] XAY4DYRR Version bump
[61] UCQD3JDH Fix build errors caused by sanakirja 0.14
[62] 6DOXSHWG Cleanup, and version bump
[63] ZAEUSICJ File deletions were not shown with their names in the metadata during record
[64] YX3VCEOM Version bump
[65] H23LO7U7 a few more clippy lints addressed
[66] ZQXP3HNA Version bump
[67] 7A2TSC4P Conflict solving code (FOLDER edges)
[68] 6RVT5X4L Current state: return zero instead of an Option if there is no change on the channel
[69] VYHHOEYH Versions and formatting
[70] BT2ZHPY4 Version bumps
[71] BJOZ25EU Deterministic Git import
[72] R3H7D42U Debugging `pijul git`: proper error reporting
[73] HQ56ADNS Formatting, and version bump
[74] 2BKYJ2JM Fixing a bug introduced by the recent refactoring
[75] TPEH2XNB 1.0.0-alpha.28, with Tokio 1.0
[76] G6YZ7U65 Version bump
[77] Q45QHPO4 Feedback on network stuff
[78] SAGSYAPX Various version bumps

Change contents

replacement in pijul-macros/src/lib.rs at line 177

[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.21091]→[3.0:18](∅→∅)

version = "0.4.0"

[4.21091]

[4.21109]

version = "0.3.0"
edit in pijul/src/commands/record.rs at line 148

[4.105115]→[2.10167:10252](∅→∅)

::sanakirja::debug::debug(&txn.txn, &[&txn.internal], "internal", true);
edit in pijul/src/commands/mod.rs at line 54

[4.134253]

[4.134253]

// mod tag;
// pub use tag::*;
edit in pijul/src/commands/git.rs at line 36

[4.138034]

[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.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.139643]→[4.0:64](∅→∅)

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

[4.139643]

[4.139683]

env_git: &mut ::sanakirja::Env,
edit in pijul/src/commands/git.rs at line 93

[4.139722]→[4.139722:139760](∅→∅)

use ::sanakirja::Transaction;
replacement in pijul/src/commands/git.rs at line 102

[4.140110]→[4.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]

[4.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.86]→[4.19:63](∅→∅)

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

[4.86]

[4.63]

for x in ::sanakirja::btree::iter(&txn_git, &db, None)? {
replacement in pijul/src/commands/git.rs at line 111

[4.100]→[4.140419:140459](∅→∅),[4.140419]→[4.140419:140459](∅→∅)

state.insert(commit, merk);

[4.100]

[4.140459]

state.insert(commit, merk.clone());
replacement in pijul/src/commands/git.rs at line 115

[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.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.143869]→[4.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.162]→[4.144297:144337](∅→∅),[4.144297]→[4.144297:144337](∅→∅)

let (_, (_, merkle_)) = txn

[4.162]

[4.163]

let (_, p) = txn
edit in pijul/src/commands/git.rs at line 244

[4.256]

[4.144447]

let merkle_: libpijul::Merkle = (&p.b).into();
edit in pijul/src/commands/git.rs at line 320

[4.147539]→[4.14525:14569](∅→∅)

repo.repo.lock.commit().await?;
replacement in pijul/src/commands/git.rs at line 327

[4.147614]→[4.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.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.147840]→[4.3716:3867](∅→∅),[4.3867]→[4.148025:148111](∅→∅),[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.632]→[4.632:692](∅→∅)

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

[4.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.887]→[4.150389:150456](∅→∅),[4.150389]→[4.150389:150456](∅→∅)

txn.apply_change_ws(&repo.repo.changes, channel, *h, ws)?;

[4.887]

[4.150456]

txn.apply_change_ws(&repo.repo.changes, channel, h, ws)?;
replacement in pijul/src/commands/git.rs at line 527

[4.154693]→[4.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.161721]→[4.161721:161804](∅→∅)

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

[4.161721]

[4.169]

let (_, m) = txn.apply_local_change(channel, &change, &hash, &rec.updatables)?;
replacement in pijul/Cargo.toml at line 4

[4.196462]→[3.19:46](∅→∅)

version = "1.0.0-alpha.39"

[4.196462]

[4.196488]

version = "1.0.0-alpha.41"
edit in pijul/Cargo.toml at line 32

[4.197171]

[2.14538]

"src/commands/lock.rs",
edit in pijul/Cargo.toml at line 36

[4.197209]

[4.197209]

"src/repository/unix_lock.rs",
"src/repository/basic_lock.rs",
replacement in pijul/Cargo.toml at line 54

[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.7110]→[2.15053:15146](∅→∅)

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

[4.7110]

[4.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.3349]→[2.18859:18961](∅→∅)

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

[4.3349]

[4.3447]

if !(e.introduced_by() == change_id || e.flag() & EdgeFlags::bp() == EdgeFlags::PARENT)
{
replacement in libpijul/src/tests/unrecord.rs at line 138

[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

[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

[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

[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

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

[4.820]→[2.22561:22578](∅→∅)

}).unwrap();

[4.820]

[2.22578]

})
.unwrap();
replacement in libpijul/src/tests/rollback.rs at line 34

[4.1015]→[2.22708:22725](∅→∅)

}).unwrap();

[4.1015]

[2.22725]

})
.unwrap();
replacement in libpijul/src/tests/rollback.rs at line 44

[4.1345]→[2.23088:23201](∅→∅)

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

[4.1345]

[4.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

[4.1845]→[2.23375:23392](∅→∅)

}).unwrap();

[4.1845]

[4.1854]

})
.unwrap();
replacement in libpijul/src/tests/rollback.rs at line 127

[4.3860]→[2.23922:24027](∅→∅)

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

[4.3860]

[4.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

[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,
);
edit in libpijul/src/tests/performance.rs at line 125

[4.281709]→[2.24954:24955](∅→∅)
replacement in libpijul/src/tests/filesystem.rs at line 27

[2.26979]→[2.26979:27081](∅→∅),[2.27081]→[4.301466:301485](∅→∅),[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

[2.27225]→[2.27225:27327](∅→∅),[2.27327]→[4.302796:302815](∅→∅),[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

[2.27471]→[2.27471:27573](∅→∅),[2.27573]→[4.304059:304078](∅→∅),[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

[2.27717]→[2.27717:27819](∅→∅),[2.27819]→[4.305425:305444](∅→∅),[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

[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

[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

[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.3977]→[2.44275:44380](∅→∅)

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

[4.3977]

[4.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

[2.45486]→[2.45486:45501](∅→∅)

_str: [u8]

[2.45486]

[4.480895]

_str: [u8],
replacement in libpijul/src/small_string.rs at line 41

[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

[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

[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

[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

[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

[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.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.11892]→[2.50045:50149](∅→∅)

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

[4.11892]

[4.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.281]→[2.50704:50812](∅→∅)

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

[4.281]

[4.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.35616]→[2.50949:51051](∅→∅)

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

[4.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.36364]→[2.51420:51496](∅→∅)

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

[4.36364]

[4.36438]

if !parent
.flag()
.contains(EdgeFlags::FOLDER | EdgeFlags::PARENT)
{
replacement in libpijul/src/record.rs at line 994

[2.54032]→[4.3965:4030](∅→∅),[4.3965]→[4.3965:4030](∅→∅),[4.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 },
);
edit in libpijul/src/pristine/vertex.rs at line 1

[4.525242]→[2.55896:55912](∅→∅)

use super::L64;
edit in libpijul/src/pristine/vertex.rs at line 2

[4.525323]

[4.525323]

use super::L64;
replacement in libpijul/src/pristine/vertex.rs at line 19

[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
)
edit in libpijul/src/pristine/sanakirja.rs at line 190

[4.536203]→[4.536203:536204](∅→∅)
replacement in libpijul/src/pristine/sanakirja.rs at line 265

[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.36940]→[2.65385:65489](∅→∅)

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

[4.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

[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

[2.71161]→[2.71161:71176](∅→∅)

},

[2.71161]

[2.71176]

}
replacement in libpijul/src/pristine/sanakirja.rs at line 778

[2.74103]→[2.74103:74129](∅→∅)

_ => Ok(None)

[2.74103]

[2.74129]

_ => Ok(None),
replacement in libpijul/src/pristine/sanakirja.rs at line 873

[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

[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.550501]→[4.550501:550535](∅→∅),[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

[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

[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.551179]→[4.551179:551193](∅→∅)

}

[4.551179]

[4.45322]

_ => return Ok(None),
},
edit in libpijul/src/pristine/sanakirja.rs at line 1119

[4.940]→[4.115:115](∅→∅),[4.940]→[4.115:115](∅→∅)
replacement in libpijul/src/pristine/sanakirja.rs at line 1170

[4.555427]→[4.555427:555461](∅→∅),[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.556105]→[4.556105:556119](∅→∅)

}

[4.556105]

[4.556119]

_ => return Ok(None),
},
replacement in libpijul/src/pristine/sanakirja.rs at line 1225

[2.82118]→[2.82118:82145](∅→∅)

_ => Ok(false)

[2.82118]

[2.82145]

_ => Ok(false),
replacement in libpijul/src/pristine/sanakirja.rs at line 1235

[2.82311]→[2.82311:82338](∅→∅)

_ => Ok(false)

[2.82311]

[2.82338]

_ => Ok(false),
replacement in libpijul/src/pristine/sanakirja.rs at line 1521

[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

[2.88532]→[4.564757:564780](∅→∅),[4.564757]→[4.564757:564780](∅→∅)

};

[2.88532]

[4.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.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.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.16014]→[2.90143:90204](∅→∅)

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

[4.16014]

[2.90204]

.map_err(|e| ForkError::Txn(e.into()))?;
replacement in libpijul/src/pristine/sanakirja.rs at line 1623

[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.568289]→[2.90803:92083](∅→∅),[2.92083]→[4.569194:569217](∅→∅),[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

[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

[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

[2.93884]→[2.93884:93910](∅→∅)

_ => Ok(None)

[2.93884]

[4.572745]

_ => Ok(None),
replacement in libpijul/src/pristine/sanakirja.rs at line 1771

[2.93981]→[2.93981:94087](∅→∅),[2.94087]→[4.573831:573861](∅→∅),[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

[2.94395]→[2.94395:94442](∅→∅),[2.94442]→[4.574049:574081](∅→∅),[4.574049]→[4.574049:574081](∅→∅),[4.574081]→[2.94443:94487](∅→∅),[2.94487]→[4.574393:574405](∅→∅),[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.53791]→[2.94560:94664](∅→∅),[2.94664]→[4.575336:575366](∅→∅),[4.575336]→[4.575336:575366](∅→∅)

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

[4.53791]

[2.94665]

btree::del(&mut self.txn, &mut self.remotes, &remote.name, None)?;
replacement in libpijul/src/pristine/sanakirja.rs at line 1804

[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

[2.96056]→[2.96056:96109](∅→∅)

basename: SmallString::from_str("blablabla")

[2.96056]

[2.96109]

basename: SmallString::from_str("blablabla"),
edit in libpijul/src/pristine/sanakirja.rs at line 1873

[4.581112]→[4.581112:581113](∅→∅),[4.581991]→[4.581991:581992](∅→∅)
replacement in libpijul/src/pristine/sanakirja.rs at line 1886

[2.96887]→[2.96887:96910](∅→∅)

ord => ord

[2.96887]

[4.583598]

ord => ord,
edit in libpijul/src/pristine/sanakirja.rs at line 1915

[2.97813]→[2.97813:97814](∅→∅)
replacement in libpijul/src/pristine/path_id.rs at line 47

[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

[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

[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) }
edit in libpijul/src/pristine/mod.rs at line 116

[2.100688]→[2.100688:100689](∅→∅)
edit in libpijul/src/pristine/mod.rs at line 124

[2.100887]→[2.100887:100888](∅→∅)
edit in libpijul/src/pristine/mod.rs at line 131

[4.587268]→[2.101016:101017](∅→∅)
replacement in libpijul/src/pristine/mod.rs at line 224

[4.54628]→[2.101082:101185](∅→∅)

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

[4.54628]

[4.54719]

fn get_external(
&self,
p: &ChangeId,
) -> Result<Option<&SerializedHash>, TxnErr<Self::GraphError>>;
replacement in libpijul/src/pristine/mod.rs at line 231

[4.54836]→[2.101186:101289](∅→∅)

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

[4.54836]

[4.48878]

fn get_internal(
&self,
p: &SerializedHash,
) -> Result<Option<&ChangeId>, TxnErr<Self::GraphError>>;
replacement in libpijul/src/pristine/mod.rs at line 321

[4.51355]→[2.102192:102294](∅→∅)

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

[4.51355]

[4.51443]

RevCursor<
Self,
&'txn Self,
Self::RevchangesetCursor,
L64,
Pair<ChangeId, SerializedMerkle>,
>,
replacement in libpijul/src/pristine/mod.rs at line 517

[4.59143]→[2.103426:103528](∅→∅)

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

[4.59143]

[4.59221]

RevCursor<
Self,
&'txn Self,
Self::RemoteCursor,
L64,
Pair<SerializedHash, SerializedMerkle>,
>,
replacement in libpijul/src/pristine/mod.rs at line 683

[2.104012]→[2.104012:104129](∅→∅),[2.104129]→[4.62542:62544](∅→∅),[4.62542]→[4.62542:62544](∅→∅)

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

[2.104012]

[4.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.63629]→[2.104276:104380](∅→∅)

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

[4.63629]

[4.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.63962]→[2.104381:104481](∅→∅)

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

[4.63962]

[4.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.620373]→[2.107460:107551](∅→∅)

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

[4.620373]

[4.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.620582]→[2.107673:107767](∅→∅)

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

[4.620582]

[4.54879]

pub struct RevCursor<T: Sized, RT: std::ops::Deref<Target = T>, Cursor, K: ?Sized, V: ?Sized> {
edit in libpijul/src/pristine/mod.rs at line 1225

[4.68241]

[4.68241]

initialized_cursor!(partials, SmallStr, Position<ChangeId>, TreeTxnT, TreeError);
edit in libpijul/src/pristine/mod.rs at line 1227

[4.68262]→[4.68262:68276](∅→∅),[4.68276]→[2.108188:108202](∅→∅),[2.108202]→[4.68293:68369](∅→∅),[4.68293]→[4.68293:68369](∅→∅)

partials,
SmallStr,
Position<ChangeId>,
TreeTxnT,
TreeError
);
initialized_cursor!(
replacement in libpijul/src/pristine/mod.rs at line 1302

[2.108947]→[2.108947:109061](∅→∅)

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

[2.108947]

[4.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

[2.109358]→[2.109358:109470](∅→∅)

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

[2.109358]

[4.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

[2.110178]→[2.110178:110256](∅→∅)

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

[2.110178]

[4.52831]

Some(&SerializedEdge::new(
flag,
k1.change,
k1.start,
introduced_by,
)),
replacement in libpijul/src/pristine/mod.rs at line 1648

[2.110270]→[2.110270:110366](∅→∅)

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

[2.110270]

[4.53117]

Some(&SerializedEdge::new(
flag | EdgeFlags::PARENT,
k0.change,
k0.end,
introduced_by,
)),
replacement in libpijul/src/pristine/mod.rs at line 1656

[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

[2.110514]→[2.110514:110585](∅→∅)

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

[2.110514]

[4.53969]

&SerializedEdge::new(flag, k1.change, k1.start, introduced_by),
replacement in libpijul/src/pristine/mod.rs at line 1777

[4.3974]→[2.111693:111724](∅→∅)

let (&b, state) = e?;

[4.3974]

[2.111724]

let (&b, state) = e?;
replacement in libpijul/src/pristine/merkle.rs at line 100

[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

[2.114941]→[2.114941:114950](∅→∅)

h: H

[2.114941]

[2.114950]

h: H,
replacement in libpijul/src/pristine/hash.rs at line 191

[2.115671]→[2.115671:115690](∅→∅)

o => o

[2.115671]

[2.115690]

o => o,
replacement in libpijul/src/pristine/hash.rs at line 249

[2.117119]→[2.117119:117133](∅→∅)

}

[2.117119]

[2.117133]

},
replacement in libpijul/src/pristine/edge.rs at line 89

[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

[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

[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

[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]→[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

[2.120919]→[2.120919:120981](∅→∅),[2.120981]→[4.4834:4886](∅→∅),[4.4834]→[4.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.24856]→[2.122090:122198](∅→∅)

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

[4.24856]

[4.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.12667]→[2.123506:123614](∅→∅)

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

[4.12667]

[4.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

[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.99689]→[2.128510:128624](∅→∅)

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

[4.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.100355]→[2.128945:129059](∅→∅)

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

[4.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.748566]→[4.748566:748631](∅→∅),[4.748631]→[2.131139:131159](∅→∅),[2.131159]→[4.748664:748693](∅→∅),[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.109779]→[2.131957:132058](∅→∅)

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

[4.109779]

[4.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.111342]→[2.132151:132238](∅→∅)

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

[4.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.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.111529]→[2.132369:132470](∅→∅)

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

[4.111529]

[4.111628]

Some(Ok(grandparent)) => {
return Some(Ok((grandparent.dest(), perms, basename)))
}
replacement in libpijul/src/fs.rs at line 796

[4.32131]→[2.132797:132907](∅→∅)

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

[4.32131]

[4.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.114694]→[2.133674:133779](∅→∅)

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

[4.114694]

[4.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.771983]→[4.771983:772005](∅→∅),[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.772185]→[4.772185:772205](∅→∅),[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.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.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.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.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.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.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

[4.48973]→[4.48973:49025](∅→∅),[4.49025]→[2.140484:140560](∅→∅),[2.140560]→[4.49113:49166](∅→∅),[4.49113]→[4.49113:49166](∅→∅)

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

[4.48973]

[4.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

[4.51864]→[4.51864:51916](∅→∅),[4.51916]→[2.140640:140712](∅→∅),[2.140712]→[4.52000:52053](∅→∅),[4.52000]→[4.52000:52053](∅→∅)

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

[4.51864]

[4.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

[4.216]→[2.141630:141703](∅→∅)

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

[4.216]

[2.141703]

if contents_[c.end.us() - 1] == b'\n' {
replacement in libpijul/src/change/text_changes.rs at line 921

[4.73938]→[4.175:232](∅→∅),[4.232]→[2.141869:141944](∅→∅)

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

[4.73938]

[4.313]

if change.end > change.start && contents_[change.end.us() - 1] == b'\n'
replacement in libpijul/src/change/text_changes.rs at line 958

[4.75755]→[2.142110:142204](∅→∅),[2.142204]→[4.444:474](∅→∅),[4.444]→[4.444:474](∅→∅)

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

[4.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

[2.142457]→[4.78688:78733](∅→∅),[4.78688]→[4.78688:78733](∅→∅),[4.78733]→[2.142458:142565](∅→∅)

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

[2.142457]

[4.78831]

change.end = ChangePosition(
(contents_.len() as u64 + new_end - new_start).into(),
);
replacement in libpijul/src/apply.rs at line 388

[4.3531]→[4.955011:955037](∅→∅),[4.955011]→[4.955011:955037](∅→∅),[4.955037]→[2.144768:144842](∅→∅),[2.144842]→[4.127980:127996](∅→∅),[4.955259]→[4.127980:127996](∅→∅)

txn.del_tree(
&OwnedPathId::inode(inode),
Some(&inode),
)?;

[4.3531]

[2.144843]

txn.del_tree(&OwnedPathId::inode(inode), Some(&inode))?;
replacement in libpijul/src/apply.rs at line 498

[4.129170]→[2.145086:145189](∅→∅)

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

[4.129170]

[4.68579]

is_non_folder |=
parent.flag() & (EdgeFlags::PARENT | EdgeFlags::FOLDER) == EdgeFlags::PARENT;
replacement in libpijul/src/apply.rs at line 542

[4.129585]→[2.145475:145559](∅→∅)

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

[4.129585]

[2.145559]

is_folder |= parent
.flag()
.contains(EdgeFlags::PARENT | EdgeFlags::FOLDER);
replacement in libpijul/src/apply.rs at line 828

[4.230]→[2.147261:147307](∅→∅)

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

[4.230]

[4.272]

a,
b,
p.introduced_by(),
p.flag()
replacement in libpijul/src/alive/retrieve.rs at line 121

[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.100647]→[2.149121:149217](∅→∅)

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

[4.100647]

[4.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.1003461]→[2.149798:149827](∅→∅),[2.149827]→[4.1003489:1003598](∅→∅),[4.1003489]→[4.1003489:1003598](∅→∅),[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.101031]→[2.150096:150202](∅→∅)

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

[4.101031]

[4.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.1020894]→[3.138:165](∅→∅)

version = "1.0.0-alpha.35"

[4.1020894]

[4.27]

version = "1.0.0-alpha.34"
edit in libpijul/Cargo.toml at line 59

[4.1022139]

[4.1022139]

"src/tag.rs",
replacement in libpijul/Cargo.toml at line 108

[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.560]→[3.230:257](∅→∅)

version = "1.0.0-alpha.35"

[4.560]

[4.729]

version = "1.0.0-alpha.34"
replacement in Cargo.lock at line 1310

[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.1064574]→[3.286:304](∅→∅)

version = "0.4.0"

[4.1064574]

[4.1064592]

version = "0.3.0"