Upgrading to Sanakirja 0.15 + version bump

[?]

Dec 31, 2020, 12:20 PM

CCLLB7OIFNFYJZTG3UCI7536TOCWSCSXR67VELSB466R24WLJSDAC

Dependencies

[2] MF3WAHBI commands/record: amend current change if unspecified
[3] 7PM25EXL Recursive apply was written a little too fast…
[4] SNZ3OAMC use native external subcommand support instead of hand-rolled one
[5] VXZNQQHC If an existing file is moved to a new directory that is deleted before the record, record the deletion
[6] KD4JIMAE Listing the working copy in alphabetical order (instead of reverse alphabetical)
[7] IUGP6ZGB Add support for ~/.config/pijul even on macos
[8] WKX5S4Z4 remove unneccesary explicit lifetimes
[9] PH7B6I3U Fixing log --hash-only
[10] 7T5STZYB Now you can `pijul remove` the root of a repository
[11] A7NTQINQ pijul channel delete: error if channel doesn't exist
[12] A6R6SGCP Fixing a panic in `pijul change`
[13] IM6UFPOZ Fixing a test related to the tree/revtree tables
[14] PSKXR4QE Do not load the entire change in memory in log
[15] BE7GUCI2 Completing dependencies only with changes the remote does not have
[16] 6RVT5X4L Current state: return zero instead of an Option if there is no change on the channel
[17] 4VWXL6KQ Correct handling of ignore files
[18] Y7YAFMFF Fix path prefix striping on Windows.
[19] 6DOXSHWG Cleanup, and version bump
[20] VBMXB443 Retrying if the HTTP connection drops while reading the body
[21] 6YMDOZIB Refactoring apply
[22] VZL5OHF5 Remove the obsolete `remote list` command
[23] 62XVBWPY remove redundant Clap attributes
[24] NA5I4WYN Fixing the inverse of conflict resolutions
[25] NX5I5H53 New published versions
[26] 737IBW6O Fixing a warning in record
[27] VQPAUKBQ channel switch as an alias to reset
[28] WIORLB47 Version bump
[29] YAJAXIV5 Unrecording changes atomically
[30] 23LVKATN Use pager crate for log output
[31] 6T5ULULM Fixing conflicts with the changes from discussion #143
[32] KQTD46KV Unrecord: restore files *after* having unapplied the *entire* change
[33] PJ7T2VFL Do not hang on locked repositories
[34] FBXYP7QM Forgot to add remote::http
[35] FXT5FS5W Updating Cargo.nix
[36] WI5BS6BS New published versions
[37] AEPEFS7O Write help for each argument
[38] ZTVNGFNT Version bump
[39] UDHP4ZVB Fixing SSH asynchronicity issues
[40] JACZWIJ6 Version bump
[41] G6YZ7U65 Version bump
[42] X6YFD4WV Do not download changes if we already have them
[43] UFCZKKLX Upgrading to the latest Sanakirja/Rand
[44] I52XSRUH Massive cleanup, and simplification
[45] 7FFFKQZU add 'Default' implementations
[46] 3S4DR77Z Version updates
[47] UNZXTNSJ Change text format: order dependencies in the order they were on the channel at record time
[48] DNQHXWRZ address clippy hard errors
[49] CFNFIUJV Parsing the correct flags for new vertices
[50] ERV3644Q Adding the block module
[51] XL6Y64UP Fixing a panic when iterating over the basenames of a file
[52] QE64ATLZ Fixing asynchronicity problems in SSH
[53] FE5ES6Q4 Stop pushing/pulling if the remote returns an error
[54] NLGQAH4H Credit and reset relative to current directory instead of the root
[55] 7UPL3Y2A Unrecord: don't restore the same unrecorded file deletion twice in the inodes and tree tables
[56] LCERQSWM Cleanup
[57] SZWBLWZ4 Reading ~/.ssh/config
[58] 4OCC6D42 Recursive add
[59] RR65HCKO Thrussh versions
[60] MWKDNWZW Version bump
[61] N35L72XV Versions in Cargo.lock
[62] MU5GSJAW Partial push and pull (WARNING: breaks the existing protocol)
[63] 4H2XTVJ2 Fix some mistakes in the docs
[64] O4DNWMPD Cleaunp and proofreading of libpijul::record
[65] VO5OQW4W Removing anyhow in libpijul
[66] IYJZVLET Cleaning up the literate programming bits
[67] 3YDPHBAN address non-controversial clippy lints
[68] HMMMKONL Fixing alive vertices
[69] SXEYMYF7 Fixing the bad changes in history (unfortunately, by rebooting).
[70] 76PCXGML Pushing to, and pulling from the local repository
[71] SLJ3OHD4 unrecord: show list of changes if none were given as arguments
[72] L5IUD2DS Fixing the regular expression parsing the protocol lines
[73] ZHABNS3S Canonicalize all paths
[74] ZXTHL45O address clippy lints
[75] ATZ3BWSE Fixing the double-deletion of repairs for folder edges
[76] SPA2OL5I keep-changes feature (default) to avoid deleting problematic changes
[77] G734WNM6 flake.nix: use crate2nix
[78] QYY37T6Y Fixing a panic with reset --dry-run and no input
[79] Q7CAYX5N Fixing Windows compilation
[80] 3M7WBE24 Re-adding anyhow in the tests of libpijul
[81] OJZWJUF2 MUCH faster `pijul add -r`
[82] UBCBQ5FG Removing pijul/src/commands/checkout.rs (unused file), as well as litorg comments
[83] KTTKF3RW Locking stderr and the progress bar in SSH
[84] 2K7JLB4Z No pager on Windows
[85] K6GWUOD5 Styling progress bars
[86] H23LO7U7 a few more clippy lints addressed
[87] 3WIQYEIS Fixing conflicts in Cargo.lock
[88] KDF6FJRV bigger clippy refactors
[89] 5DVRL6MF Hard-unrecord
[90] XAY4DYRR Version bump
[91] YACC5QR6 Don't delete non-block edges unless they're at the top of a block
[92] M5FK3ABT Complete dependencies when pushing and pulling
[93] B5Z4IMEU Generating Cargo.nix for pijul 1.0.0-alpha.6
[94] BXD3IQYN Fixing --features git
[95] OCBM7IFE New release: pijul-1.0.0-alpha.8
[96] Q45QHPO4 Feedback on network stuff
[97] BZSC7VMY address clippy lints
[98] WZVCLZKY address clippy lints
[99] QNJBR73K don't return Result for infallible functions
[100] BD5PC25A Deleting conflict resolution vertices when the sides are deleted
[101] H62VFFJE Cargo.nix, and solving conflicts
[102] 7A2TSC4P Conflict solving code (FOLDER edges)
[103] L5PHFTIE Minor simplification
[104] GURIBVW6 Fixing the pager
[105] R3H7D42U Debugging `pijul git`: proper error reporting
[106] AN7IDX26 pijul: added ChangesNotFound error variant
[107] L4JXJHWX pijul/*: reorganize imports and remove extern crate
[108] IQ4FCHPZ HTTP connections: pooling + retry on error
[109] GLMOA3PF More edges in "credit"
[110] YX3VCEOM Version bump
[111] 43AJ37IX Getting rid of edge validation, which does not work for zombie conflicts
[112] BT2ZHPY4 Version bumps
[113] SAGSYAPX Various version bumps
[114] 5BRU2RRW Cleanup (debugging a crash related to trees/inodes)
[115] 73NW2X2M Returning a parse error instead of panicking when parsing a text change
[116] 6WFOU7UX Do a DFS on dependencies to complete the list
[117] GVQ7YSED Checking for dependencies even for a local change
[118] XWETQ4DE Upgrading versions
[119] 5YDI33C4 Fixing pager on OSX
[120] VIHXB7SG commands: set up pager for diff, change, and credit
[121] OUWD436A Version bump
[122] 74HX2XZD Cleanup and debugging
[*] FMKKWCFV Better clap attributes

Change contents

edit in pijul-macros/src/lib.rs at line 36

[22.1411]→[22.1411:1434](∅→∅)

#[doc(hidden)]
edit in pijul-macros/src/lib.rs at line 52

[22.2144]

[22.2144]

let error = next(&mut input_iter);
let error = if error.is_empty() {
quote! { Error }
} else {
proc_macro2::TokenStream::from_iter(error.into_iter())
};
replacement in pijul-macros/src/lib.rs at line 69

[22.2496]→[22.2496:2553](∅→∅)

quote! { self.txn.get(&self.#name, key, value) }

[22.2496]

[22.2553]

quote! { if let Ok(x) = self.txn.get(&self.#name, key, value) {
Ok(x)
} else {
Err(TxnErr(SanakirjaError::PristineCorrupt))
}
}
replacement in pijul-macros/src/lib.rs at line 76

[22.2566]→[22.2566:2632](∅→∅)

quote! { self.txn.get(&self.#name, key, value) . #post_ }

[22.2566]

[22.2632]

quote! { if let Ok(x) = self.txn.get(&self.#name, key, value) {
Ok(x . #post_)
} else {
Err(TxnErr(SanakirjaError::PristineCorrupt))
}}
replacement in pijul-macros/src/lib.rs at line 83

[22.2682]→[22.2682:2800](∅→∅)

#[doc(hidden)]
fn #name_get <'txn> (&'txn self, key: #key, value: Option<#value>) -> Option<#value> {

[22.2682]

[22.2800]

fn #name_get <'txn> (&'txn self, key: #key, value: Option<#value>) -> Result<Option<#value>, TxnErr<Self::#error>> {
edit in pijul-macros/src/lib.rs at line 103

[22.3586]

[22.3586]

let error = next(&mut input_iter);
let error = if error.is_empty() {
quote! { Error }
} else {
proc_macro2::TokenStream::from_iter(error.into_iter())
};
replacement in pijul-macros/src/lib.rs at line 111

[22.3671]→[22.3671:3802](∅→∅)

#[doc(hidden)]
fn #name_get(&self, db: &Self::#name_capital, key: #key, value: Option<#value>) -> Option<#value> {

[22.3671]

[22.3802]

fn #name_get(&self, db: &Self::#name_capital, key: #key, value: Option<#value>) -> Result<Option<#value>, TxnErr<Self::#error>> {
replacement in pijul-macros/src/lib.rs at line 113

[22.3844]→[22.3844:3885](∅→∅)

self.txn.get(db, key, value)

[22.3844]

[22.3885]

if let Ok(x) = self.txn.get(db, key, value) {
Ok(x)
} else {
Err(TxnErr(SanakirjaError::PristineCorrupt))
}
edit in pijul-macros/src/lib.rs at line 133

[22.4509]

[22.4509]

let error = next(&mut input_iter);
let error = if error.is_empty() {
quote! { Error }
} else {
proc_macro2::TokenStream::from_iter(error.into_iter())
};
replacement in pijul-macros/src/lib.rs at line 141

[22.4594]→[22.4594:4709](∅→∅)

#[doc(hidden)]
fn #name_get<'txn>(&'txn self, key: #key, value: Option<#value>) -> Option<#value>;

[22.4594]

[22.4709]

fn #name_get<'txn>(&'txn self, key: #key, value: Option<#value>) -> Result<Option<#value>, TxnErr<Self::#error>>;
edit in pijul-macros/src/lib.rs at line 157

[22.5398]

[22.5398]

let error = next(&mut input_iter);
let error = if error.is_empty() {
quote! { Error }
} else {
proc_macro2::TokenStream::from_iter(error.into_iter())
};
replacement in pijul-macros/src/lib.rs at line 165

[22.5483]→[22.5483:5624](∅→∅)

#[doc(hidden)]
fn #name_get<'txn>(&'txn self, db: &Self::#name_capital, key: #key, value: Option<#value>) -> Option<#value>;

[22.5483]

[22.5624]

fn #name_get<'txn>(&'txn self, db: &Self::#name_capital, key: #key, value: Option<#value>) -> Result<Option<#value>, TxnErr<Self::#error>>;
edit in pijul-macros/src/lib.rs at line 234

[22.8021]

[22.8021]

let error = next(&mut input_iter);
let error = if error.is_empty() {
quote! { GraphError }
} else {
proc_macro2::TokenStream::from_iter(error.into_iter())
};
replacement in pijul-macros/src/lib.rs at line 244

[22.8069]→[22.8069:8160](∅→∅)

crate::pristine::RevCursor<Self, &'txn Self, Self::#cursor_name, #key, #value>

[22.8069]

[22.8160]

Result<crate::pristine::RevCursor<Self, &'txn Self, Self::#cursor_name, #key, #value>, TxnErr<Self::#error>>
replacement in pijul-macros/src/lib.rs at line 248

[22.8200]→[22.8200:8288](∅→∅)

crate::pristine::Cursor<Self, &'txn Self, Self::#cursor_name, #key, #value>

[22.8200]

[22.8288]

Result<crate::pristine::Cursor<Self, &'txn Self, Self::#cursor_name, #key, #value>, TxnErr<Self::#error>>
edit in pijul-macros/src/lib.rs at line 255

[22.8376]→[22.8376:8403](∅→∅)

#[doc(hidden)]
edit in pijul-macros/src/lib.rs at line 256

[22.8434]→[22.8434:8461](∅→∅)

#[doc(hidden)]
replacement in pijul-macros/src/lib.rs at line 259

[22.8573]→[22.8573:8641](∅→∅)

) -> Option<(#key, #value)>;
#[doc(hidden)]

[22.8573]

[22.8641]

) -> Result<Option<(#key, #value)>, TxnErr<Self::#error>>;
replacement in pijul-macros/src/lib.rs at line 263

[22.8753]→[22.8753:8794](∅→∅)

) -> Option<(#key, #value)>;

[22.8753]

[22.8794]

) -> Result<Option<(#key, #value)>, TxnErr<Self::#error>>;
edit in pijul-macros/src/lib.rs at line 268

[22.8857]→[22.8857:8880](∅→∅)

#[doc(hidden)]
replacement in pijul-macros/src/lib.rs at line 272

[22.9053]→[22.9053:9135](∅→∅)

) -> crate::pristine::Cursor<Self, RT, Self::#cursor_name, #key, #value>;

[22.9053]

[22.9135]

) -> Result<crate::pristine::Cursor<Self, RT, Self::#cursor_name, #key, #value>, TxnErr<Self::#error>>;
edit in pijul-macros/src/lib.rs at line 281

[22.9257]→[22.9257:9284](∅→∅)

#[doc(hidden)]
edit in pijul-macros/src/lib.rs at line 291

[22.9552]→[22.9552:9575](∅→∅)

#[doc(hidden)]
edit in pijul-macros/src/lib.rs at line 372

[22.12226]→[22.12226:12253](∅→∅)

#[doc(hidden)]
replacement in pijul-macros/src/lib.rs at line 376

[22.12375]→[22.12375:12460](∅→∅)

) -> super::Cursor<Self, &'txn Self, Self::#cursor_name, #key, #value> {

[22.12375]

[22.12460]

) -> Result<super::Cursor<Self, &'txn Self, Self::#cursor_name, #key, #value>, TxnErr<SanakirjaError>> {
edit in pijul-macros/src/lib.rs at line 386

[22.12630]→[22.12630:12657](∅→∅)

#[doc(hidden)]
replacement in pijul-macros/src/lib.rs at line 390

[22.12848]→[22.12848:12925](∅→∅)

) -> super::Cursor<Self, RT, Self::#cursor_name, #key, #value> {

[22.12848]

[22.12925]

) -> Result<super::Cursor<Self, RT, Self::#cursor_name, #key, #value>, TxnErr<SanakirjaError>> {
replacement in pijul-macros/src/lib.rs at line 392

[22.12951]→[22.12951:13156](∅→∅)

let mut cursor = txn.txn.set_cursors(&db, pos).0;
super::Cursor {
cursor,
txn,
marker: std::marker::PhantomData,

[22.12951]

[22.13156]

if let Ok((cursor, _)) = txn.txn.set_cursors(&db, pos) {
Ok(super::Cursor {
cursor,
txn,
marker: std::marker::PhantomData,
})
} else {
Err(TxnErr(SanakirjaError::PristineCorrupt))
edit in pijul-macros/src/lib.rs at line 409

[22.13310]→[22.13310:13337](∅→∅)

#[doc(hidden)]
replacement in pijul-macros/src/lib.rs at line 413

[22.13495]→[22.13495:13583](∅→∅)

) -> super::RevCursor<Self, &'txn Self, Self::#cursor_name, #key, #value> {

[22.13495]

[22.13583]

) -> Result<super::RevCursor<Self, &'txn Self, Self::#cursor_name, #key, #value>, TxnErr<SanakirjaError>> {
replacement in pijul-macros/src/lib.rs at line 416

[22.13661]→[22.13661:13714](∅→∅)

self.txn.set_cursors(&db, pos).0

[22.13661]

[22.13714]

if let Ok((x, _)) = self.txn.set_cursors(&db, pos) {
x
} else {
return Err(TxnErr(SanakirjaError::PristineCorrupt))
}
} else if let Ok(x) = self.txn.set_cursors_last(&db) {
x
replacement in pijul-macros/src/lib.rs at line 424

[22.13739]→[22.13739:13790](∅→∅)

self.txn.set_cursors_last(&db)

[22.13739]

[22.13790]

return Err(TxnErr(SanakirjaError::PristineCorrupt))
replacement in pijul-macros/src/lib.rs at line 426

[22.13809]→[22.13809:13844](∅→∅)

super::RevCursor {

[22.13809]

[22.13844]

Ok(super::RevCursor {
replacement in pijul-macros/src/lib.rs at line 430

[22.13957]→[22.13957:13975](∅→∅)

}

[22.13957]

[22.13975]

})
edit in pijul-macros/src/lib.rs at line 435

[22.14029]→[22.14029:14056](∅→∅)

#[doc(hidden)]
edit in pijul-macros/src/lib.rs at line 436

[22.14109]→[22.14109:14136](∅→∅)

#[doc(hidden)]
replacement in pijul-macros/src/lib.rs at line 440

[22.14294]→[22.14294:14379](∅→∅)

) -> super::Cursor<Self, &'txn Self, Self::#cursor_name, #key, #value> {

[22.14294]

[22.14379]

) -> Result<super::Cursor<Self, &'txn Self, Self::#cursor_name, #key, #value>, TxnErr<SanakirjaError>> {
replacement in pijul-macros/src/lib.rs at line 442

[22.14405]→[22.14405:14504](∅→∅)

let mut cursor = self.txn.set_cursors(&db, pos).0;
super::Cursor {

[22.14405]

[22.14504]

let mut cursor = if let Ok((x, _)) = self.txn.set_cursors(&db, pos) {
x
} else {
return Err(TxnErr(SanakirjaError::PristineCorrupt))
};
Ok(super::Cursor {
replacement in pijul-macros/src/lib.rs at line 451

[22.14617]→[22.14617:14635](∅→∅)

}

[22.14617]

[22.14635]

})
edit in pijul-macros/src/lib.rs at line 454

[22.14669]→[22.14669:14696](∅→∅)

#[doc(hidden)]
replacement in pijul-macros/src/lib.rs at line 457

[22.14808]→[22.14808:14942](∅→∅)

) -> Option<(#key, #value)> {
(unsafe { ::sanakirja::next(&self.txn, cursor) })
#post

[22.14808]

[22.14942]

) -> Result<Option<(#key, #value)>, TxnErr<SanakirjaError>> {
let x = if let Ok(x) = unsafe { ::sanakirja::next(&self.txn, cursor) } {
x
} else {
return Err(TxnErr(SanakirjaError::PristineCorrupt))
};
Ok(x #post)
edit in pijul-macros/src/lib.rs at line 465

[22.14956]→[22.14956:14983](∅→∅)

#[doc(hidden)]
replacement in pijul-macros/src/lib.rs at line 468

[22.15095]→[22.15095:15229](∅→∅)

) -> Option<(#key, #value)> {
(unsafe { ::sanakirja::prev(&self.txn, cursor) })
#post

[22.15095]

[22.15229]

) -> Result<Option<(#key, #value)>, TxnErr<SanakirjaError>> {
let x = if let Ok(x) = unsafe { ::sanakirja::prev(&self.txn, cursor) } {
x
} else {
return Err(TxnErr(SanakirjaError::PristineCorrupt))
};
Ok(x #post)
edit in pijul-macros/src/lib.rs at line 507

[22.16388]

[22.16388]

let txnt = next(&mut input_iter);
let txnt: proc_macro2::TokenStream = if txnt.is_empty() {
proc_macro2::TokenStream::from(quote! { TxnT })
} else {
proc_macro2::TokenStream::from_iter(txnt.into_iter())
};

let error = next(&mut input_iter);
let error: proc_macro2::TokenStream = if error.is_empty() {
proc_macro2::TokenStream::from(quote! { GraphError })
} else {
proc_macro2::TokenStream::from_iter(error.into_iter())
};
replacement in pijul-macros/src/lib.rs at line 524

[22.16490]→[22.16490:16627](∅→∅)

impl<T: TxnT, RT: std::ops::Deref<Target = T>> Iterator for crate::pristine::RevCursor<T, RT, T::#cursor_name, #key, #value>

[22.16490]

[22.16627]

impl<T: #txnt, RT: std::ops::Deref<Target = T>> Iterator for crate::pristine::RevCursor<T, RT, T::#cursor_name, #key, #value>
replacement in pijul-macros/src/lib.rs at line 526

[22.16641]→[22.16641:16806](∅→∅)

type Item = (#key, #value);
fn next(&mut self) -> Option<(#key, #value)> {
self.txn.#name_prev(&mut self.cursor)

[22.16641]

[22.16806]

type Item = Result<(#key, #value), TxnErr<T::#error>>;
fn next(&mut self) -> Option<Self::Item> {
match self.txn.#name_prev(&mut self.cursor) {
Ok(Some(x)) => Some(Ok(x)),
Ok(None) => None,
Err(e) => Some(Err(e)),
}
replacement in pijul-macros/src/lib.rs at line 539

[22.16910]→[22.16910:16969](∅→∅)

impl<T: TxnT, RT: std::ops::Deref<Target = T>>

[22.16910]

[22.16969]

impl<T: #txnt, RT: std::ops::Deref<Target = T>>
replacement in pijul-macros/src/lib.rs at line 542

[22.17061]→[22.17061:17186](∅→∅)

pub fn prev(&mut self) -> Option<(#key, #value)> {
self.txn.#name_prev(&mut self.cursor)

[22.17061]

[22.17186]

pub fn prev(&mut self) -> Option<Result<(#key, #value), TxnErr<T::#error>>> {
match self.txn.#name_prev(&mut self.cursor) {
Ok(Some(x)) => Some(Ok(x)),
Ok(None) => None,
Err(e) => Some(Err(e)),
}
replacement in pijul-macros/src/lib.rs at line 550

[22.17218]→[22.17218:17352](∅→∅)

impl<T: TxnT, RT: std::ops::Deref<Target = T>> Iterator for crate::pristine::Cursor<T, RT, T::#cursor_name, #key, #value>

[22.17218]

[22.17352]

impl<T: #txnt, RT: std::ops::Deref<Target = T>> Iterator for crate::pristine::Cursor<T, RT, T::#cursor_name, #key, #value>
replacement in pijul-macros/src/lib.rs at line 552

[22.17366]→[22.17366:17531](∅→∅)

type Item = (#key, #value);
fn next(&mut self) -> Option<(#key, #value)> {
self.txn.#name_next(&mut self.cursor)

[22.17366]

[22.17531]

type Item = Result<(#key, #value), TxnErr<T::#error>>;
fn next(&mut self) -> Option<Self::Item> {
match self.txn.#name_next(&mut self.cursor) {
Ok(Some(x)) => Some(Ok(x)),
Ok(None) => None,
Err(e) => Some(Err(e)),
}
edit in pijul-macros/src/lib.rs at line 578

[22.18257]

[22.18257]

let error = next(&mut input_iter);
let error = if error.is_empty() {
quote! { Error }
} else {
proc_macro2::TokenStream::from_iter(error.into_iter())
};
edit in pijul-macros/src/lib.rs at line 587

[22.18342]→[22.18342:18365](∅→∅)

#[doc(hidden)]
replacement in pijul-macros/src/lib.rs at line 591

[22.18449]→[22.0:40](∅→∅),[22.40]→[22.18491:18514](∅→∅),[22.18491]→[22.18491:18514](∅→∅)

) -> Result<bool, Self::Error>;
#[doc(hidden)]

[22.18449]

[22.18514]

) -> Result<bool, TxnErr<Self::#error>>;
replacement in pijul-macros/src/lib.rs at line 596

[22.18606]→[22.41:81](∅→∅)

) -> Result<bool, Self::Error>;

[22.18606]

[22.18648]

) -> Result<bool, TxnErr<Self::#error>>;
edit in pijul-macros/src/lib.rs at line 614

[22.19400]

[22.19400]

let error = next(&mut input_iter);
let error = if error.is_empty() {
quote! { Error }
} else {
proc_macro2::TokenStream::from_iter(error.into_iter())
};
edit in pijul-macros/src/lib.rs at line 624

[22.19583]

[22.19583]
edit in pijul-macros/src/lib.rs at line 626

[22.19625]

[22.19625]
edit in pijul-macros/src/lib.rs at line 629

[22.19700]→[22.19700:19727](∅→∅)

#[doc(hidden)]
replacement in pijul-macros/src/lib.rs at line 633

[22.19827]→[22.82:127](∅→∅),[22.127]→[22.19874:19946](∅→∅),[22.19874]→[22.19874:19946](∅→∅)

) -> Result<bool, Self::Error> {
Ok(self.txn.put(&mut self.rng, &mut self.#name, k, v)?)

[22.19827]

[22.19946]

) -> Result<bool, TxnErr<Self::#error>> {
Ok(self.txn.put(&mut self.rng, &mut self.#name, k, v).map_err(TxnErr)?)
edit in pijul-macros/src/lib.rs at line 636

[22.19960]→[22.19960:19987](∅→∅)

#[doc(hidden)]
replacement in pijul-macros/src/lib.rs at line 640

[22.20095]→[22.128:173](∅→∅),[22.173]→[22.20142:20214](∅→∅),[22.20142]→[22.20142:20214](∅→∅)

) -> Result<bool, Self::Error> {
Ok(self.txn.del(&mut self.rng, &mut self.#name, k, v)?)

[22.20095]

[22.20214]

) -> Result<bool, TxnErr<Self::#error>> {
Ok(self.txn.del(&mut self.rng, &mut self.#name, k, v).map_err(TxnErr)?)
edit in pijul-macros/src/lib.rs at line 646

[22.20299]→[22.20299:20326](∅→∅)

#[doc(hidden)]
replacement in pijul-macros/src/lib.rs at line 650

[22.20426]→[22.174:219](∅→∅)

) -> Result<bool, Self::Error> {

[22.20426]

[22.20473]

) -> Result<bool, TxnErr<Self::#error>> {
replacement in pijul-macros/src/lib.rs at line 653

[22.20543]→[22.20543:20615](∅→∅)

Ok(self.txn.put(&mut self.rng, &mut self.#name, k, v)?)

[22.20543]

[22.20615]

Ok(self.txn.put(&mut self.rng, &mut self.#name, k, v).map_err(TxnErr)?)
edit in pijul-macros/src/lib.rs at line 655

[22.20629]→[22.20629:20656](∅→∅)

#[doc(hidden)]
replacement in pijul-macros/src/lib.rs at line 659

[22.20764]→[22.220:265](∅→∅)

) -> Result<bool, Self::Error> {

[22.20764]

[22.20811]

) -> Result<bool, TxnErr<Self::#error>> {
replacement in pijul-macros/src/lib.rs at line 662

[22.20892]→[22.20892:20964](∅→∅)

Ok(self.txn.del(&mut self.rng, &mut self.#name, k, v)?)

[22.20892]

[22.20964]

Ok(self.txn.del(&mut self.rng, &mut self.#name, k, v).map_err(TxnErr)?)
replacement in pijul-macros/Cargo.toml at line 4

[22.21091]→[22.0:18](∅→∅)

version = "0.2.0"

[22.21091]

[22.21109]

version = "0.3.0"
edit in pijul/src/repository.rs at line 4

[22.21541]

[22.0]

use anyhow::bail;
replacement in pijul/src/repository.rs at line 8

[22.40]→[22.40:81](∅→∅)

use crate::{config, current_dir, Error};

[22.40]

[22.81]

use crate::{config, current_dir};
replacement in pijul/src/repository.rs at line 45

[22.22740]→[22.22740:22798](∅→∅)

return Err(Error::NoRepoRoot.into());

[22.22740]

[22.22798]

bail!("No Pijul repository found")
replacement in pijul/src/repository.rs at line 74

[22.23686]→[22.23686:23779](∅→∅)

return Err((crate::Error::CouldNotReadConfig { path: config_path }).into());

[22.23686]

[22.23779]

bail!("Could not read configuration file at {:?}", config_path)
replacement in pijul/src/repository.rs at line 114

[22.25296]→[22.25296:25342](∅→∅)

Err(Error::AlreadyInARepo.into())

[22.25296]

[22.25342]

bail!("Already in a repository")
edit in pijul/src/remote/ssh.rs at line 21

[22.366]→[22.366:384](∅→∅)

use crate::Error;
replacement in pijul/src/remote/ssh.rs at line 103

[22.28303]→[22.28303:28359](∅→∅)

return Err(Error::NotAuthenticated.into());

[22.28303]

[22.28359]

bail!("Not authenticated")
replacement in pijul/src/remote/ssh.rs at line 561

[22.35811]→[22.35811:35977](∅→∅)

return Err((Error::RemoteExit {
status: exit_status,
})
.into());

[22.35811]

[22.35977]

bail!("Remote exited with status {:?}", exit_status)
replacement in pijul/src/remote/ssh.rs at line 659

[22.41652]→[22.41652:41834](∅→∅)

return Err((Error::RemoteExit {
status: exit_status,
})
.into());

[22.41652]

[22.41834]

bail!("Remote exited with status {:?}", exit_status)
replacement in pijul/src/remote/ssh.rs at line 881

[22.51533]→[22.51533:51588](∅→∅)

let h = txn.get_external(ch).unwrap();

[22.51533]

[22.51716]

let h = txn.get_external(ch)?.unwrap();
replacement in pijul/src/remote/ssh.rs at line 885

[22.51779]→[22.460:515](∅→∅),[22.52027]→[22.52027:52059](∅→∅)

for (_, (h, _)) in txn.log(&channel_, 0) {
hashes.push(h);

[22.51779]

[22.52059]

for h in txn.log(&channel_, 0)? {
hashes.push((h?.1).0);
edit in pijul/src/remote/mod.rs at line 14

[22.483]→[22.483:501](∅→∅)

use crate::Error;
replacement in pijul/src/remote/mod.rs at line 75

[22.54147]→[22.54147:54266](∅→∅)

Err((Error::RemoteNotFound {
remote: name.to_string(),
})
.into())

[22.54147]

[22.395]

bail!("Remote not found: {:?}", name)
replacement in pijul/src/remote/mod.rs at line 106

[22.960]→[22.960:1063](∅→∅)

Err((Error::RemoteNotFound {
remote: name.to_string(),
})
.into())

[22.960]

[22.1063]

bail!("Remote not found: {:?}", name)
replacement in pijul/src/remote/mod.rs at line 181

[22.57166]→[22.57166:57289](∅→∅)

.iter_remote(&remote.borrow().remote, n)
.filter_map(|(k, _)| if k >= n { Some(k) } else { None })

[22.57166]

[22.57289]

.iter_remote(&remote.borrow().remote, n)?
.filter_map(|k| {
let k = k.unwrap().0;
if k >= n {
Some(k)
} else {
None
}
})
replacement in pijul/src/remote/mod.rs at line 212

[22.57695]→[22.57695:57775](∅→∅)

let (mut b, (_, state)) = if let Some(last) = txn.last_remote(remote) {

[22.57695]

[22.57775]

let (mut b, (_, state)) = if let Some(last) = txn.last_remote(remote)? {
replacement in pijul/src/remote/mod.rs at line 229

[22.58358]→[22.58358:58438](∅→∅)

let (mid, (_, state)) = txn.get_remote_state(remote, mid).unwrap();

[22.58358]

[22.1790]

let (mid, (_, state)) = txn.get_remote_state(remote, mid)?.unwrap();
replacement in pijul/src/remote/mod.rs at line 272

[22.59915]→[22.59915:60067](∅→∅)

return Err((crate::Error::Http {
status: res.status(),
})
.into());

[22.59915]

[22.60067]

bail!("HTTP error {:?}", res.status())
replacement in pijul/src/remote/mod.rs at line 288

[22.1981]→[22.1981:2110](∅→∅)

if let Some(channel) = txn.load_channel(&channel) {
Ok(local::get_state(txn, &channel, mid))

[22.1981]

[22.2110]

if let Some(channel) = txn.load_channel(&channel)? {
local::get_state(txn, &channel, mid)
replacement in pijul/src/remote/mod.rs at line 311

[22.61331]→[22.61331:61408](∅→∅)

let mut channel = txn.load_channel(&l.channel).unwrap();

[22.61331]

[22.61408]

let mut channel = txn.load_channel(&l.channel)?.unwrap();
replacement in pijul/src/remote/mod.rs at line 315

[22.61584]→[22.61584:61657](∅→∅)

let channel = txn.load_channel(&l.channel).unwrap();

[22.61584]

[22.61657]

let channel = txn.load_channel(&l.channel)?.unwrap();
replacement in pijul/src/remote/mod.rs at line 338

[22.62677]→[22.62677:62829](∅→∅)

return Err((crate::Error::Http {
status: res.status(),
})
.into());

[22.62677]

[22.62829]

bail!("HTTP error {:?}", res.status())
replacement in pijul/src/remote/mod.rs at line 595

[22.73610]→[22.73610:73694](∅→∅)

for (n, (h, s)) in txn.iter_rev_remote(&remote.borrow().remote, None) {

[22.73610]

[22.73694]

for x in txn.iter_rev_remote(&remote.borrow().remote, None)? {
let (n, (h, s)) = x?;
replacement in pijul/src/remote/mod.rs at line 605

[22.73931]→[22.73931:74000](∅→∅)

return Err((Error::StateNotFound { state }).into());

[22.73931]

[22.74000]

bail!("State not found: {:?}", state)
replacement in pijul/src/remote/mod.rs at line 617

[22.74338]→[22.74338:74411](∅→∅)

for (n, (h, s)) in txn.iter_remote(&remote.borrow().remote, 0) {

[22.74338]

[22.74411]

for x in txn.iter_remote(&remote.borrow().remote, 0)? {
let (n, (h, s)) = x?;
replacement in pijul/src/remote/mod.rs at line 627

[22.74612]→[22.74612:74677](∅→∅)

return Err((Error::StateNotFound { state }).into());

[22.74612]

[22.74677]

bail!("State not found: {:?}", state)
replacement in pijul/src/remote/mod.rs at line 659

[22.76104]→[22.76104:76173](∅→∅)

if repo.changes.has_contents(*c, txn.get_internal(*c)) {

[22.76104]

[22.76173]

if repo.changes.has_contents(*c, txn.get_internal(*c)?) {
replacement in pijul/src/remote/mod.rs at line 669

[22.76443]→[22.76443:76508](∅→∅)

let change = if let Some(i) = txn.get_internal(*c) {

[22.76443]

[22.76508]

let change = if let Some(i) = txn.get_internal(*c)? {
replacement in pijul/src/remote/mod.rs at line 681

[22.76925]→[22.856:899](∅→∅)

if txn.is_alive(&channel, v) {

[22.76925]

[22.899]

if txn.is_alive(&channel, v)? {
replacement in pijul/src/remote/mod.rs at line 710

[22.78339]→[22.78339:78420](∅→∅)

for (_, (h, _)) in txn.iter_remote(&remote_changes.borrow().remote, 0) {

[22.78339]

[22.78420]

for x in txn.iter_remote(&remote_changes.borrow().remote, 0)? {
let (_, (h, _)) = x?;
replacement in pijul/src/remote/local.rs at line 5

[22.535]→[22.4235:4308](∅→∅),[22.4308]→[22.79831:79868](∅→∅),[22.79831]→[22.79831:79868](∅→∅)

use libpijul::pristine::{Base32, Hash, Merkle, MutTxnT, Position, TxnT};
use libpijul::{MutTxnTExt, TxnTExt};

[22.535]

[22.536]

use libpijul::pristine::{Hash, Merkle, MutTxnT, Position, TxnT};
use libpijul::*;
replacement in pijul/src/remote/local.rs at line 24

[22.3106]→[22.3106:3135](∅→∅)

) -> Option<(u64, Merkle)> {

[22.3106]

[22.3135]

) -> Result<Option<(u64, Merkle)>, anyhow::Error> {
replacement in pijul/src/remote/local.rs at line 26

[22.3164]→[22.3164:3226](∅→∅)

txn.get_changes(&channel, mid).map(|(_, m)| (mid, m))

[22.3164]

[22.3226]

Ok(txn.get_changes(&channel, mid)?.map(|(_, m)| (mid, m)))
replacement in pijul/src/remote/local.rs at line 28

[22.3239]→[22.3239:3347](∅→∅)

txn.reverse_log(&channel.borrow(), None)
.next()
.map(|(n, (_, m))| (n, m))

[22.3239]

[22.3347]

Ok(txn.reverse_log(&channel.borrow(), None)?.next().map(|n| {
let (n, (_, m)) = n.unwrap();
(n, m)
}))
replacement in pijul/src/remote/local.rs at line 38

[22.80263]→[22.80263:80327](∅→∅),[22.80327]→[22.3354:3397](∅→∅)

let channel = txn.load_channel(&self.channel).unwrap();
Ok(get_state(&txn, &channel, mid))

[22.80263]

[22.80598]

let channel = txn.load_channel(&self.channel)?.unwrap();
Ok(get_state(&txn, &channel, mid)?)
replacement in pijul/src/remote/local.rs at line 51

[22.80949]→[22.80949:81042](∅→∅)

let remote_channel = if let Some(channel) = remote_txn.load_channel(&self.channel) {

[22.80949]

[22.81042]

let remote_channel = if let Some(channel) = remote_txn.load_channel(&self.channel)? {
replacement in pijul/src/remote/local.rs at line 63

[22.4571]→[22.4571:4643](∅→∅)

change: remote_txn.get_external(p.change).unwrap(),

[22.4571]

[22.4643]

change: remote_txn.get_external(p.change)?.unwrap(),
replacement in pijul/src/remote/local.rs at line 67

[22.4729]→[22.4729:4919](∅→∅)

paths_.extend(libpijul::fs::iter_graph_descendants(
&remote_txn,
&remote_channel.borrow(),
p,
));

[22.4729]

[22.81377]

paths_.extend(
libpijul::fs::iter_graph_descendants(
&remote_txn,
&remote_channel.borrow().graph,
p,
)?
.map(|x| x.unwrap()),
);
replacement in pijul/src/remote/local.rs at line 78

[22.4961]→[22.81401:81477](∅→∅),[22.81401]→[22.81401:81477](∅→∅)

for (n, (h, m)) in remote_txn.log(&remote_channel.borrow(), from) {

[22.4961]

[22.81477]

for x in remote_txn.log(&remote_channel.borrow(), from)? {
let (n, (h, m)) = x?;
replacement in pijul/src/remote/local.rs at line 87

[22.81705]→[22.81705:81770](∅→∅)

let h_int = remote_txn.get_internal(h).unwrap();

[22.81705]

[22.81770]

let h_int = remote_txn.get_internal(h)?.unwrap();
replacement in pijul/src/remote/local.rs at line 89

[22.81807]→[22.81807:81959](∅→∅)

|| paths_
.iter()
.any(|x| remote_txn.get_touched_files(*x, Some(h_int)).is_some())

[22.81807]

[22.81959]

|| paths_.iter().any(|x| {
remote_txn
.get_touched_files(*x, Some(h_int))
.unwrap()
.is_some()
})
edit in pijul/src/remote/http.rs at line 5

[22.1193]

[22.1193]

use anyhow::bail;
replacement in pijul/src/remote/http.rs at line 44

[20.240]→[22.1063:1183](∅→∅),[22.1063]→[22.1063:1183](∅→∅)

return Err((crate::Error::Http {
status: res.status(),
})
.into());

[20.240]

[22.1183]

bail!("HTTP error {:?}", res.status())
replacement in pijul/src/remote/http.rs at line 183

[22.5693]→[22.5693:5813](∅→∅)

return Err((crate::Error::Http {
status: res.status(),
})
.into());

[22.5693]

[22.5813]

bail!("HTTP error {:?}", res.status())
edit in pijul/src/main.rs at line 10

[22.603]

[124.0]

use anyhow::bail;
edit in pijul/src/main.rs at line 13

[22.716]→[22.0:32](∅→∅),[22.32]→[22.1637:1659](∅→∅)

use libpijul::pristine::Base32;
use thiserror::Error;
edit in pijul/src/main.rs at line 125

[4.98]→[22.85867:86849](∅→∅),[22.85867]→[22.85867:86849](∅→∅),[22.86917]→[22.86917:87334](∅→∅),[22.87413]→[22.87413:87666](∅→∅),[22.87666]→[22.867:909](∅→∅),[22.909]→[22.87719:87776](∅→∅),[22.87719]→[22.87719:87776](∅→∅),[22.87776]→[22.0:82](∅→∅),[22.82]→[22.87776:88054](∅→∅),[22.87776]→[22.87776:88054](∅→∅),[22.93]→[22.33:133](∅→∅),[22.133]→[22.1660:1751](∅→∅)

}

#[derive(Debug, Error)]
pub enum Error {
#[error("No Pijul repository found")]
NoRepoRoot,
#[error("Cannot access working directory")]
CannotAccessWorkingDirectory,
#[error("Already in a repository")]
AlreadyInARepo,
#[error("No such channel: {}", channel)]
NoSuchChannel { channel: String },
#[error("Protocol error. Is this the correct URL?")]
ProtocolError { line: Vec<u8> },
#[error("Not authenticated")]
NotAuthenticated,
#[error("No change message")]
NoChangeMessage,
#[error("Incorrect remote: {}", name)]
IncorrectRemote { name: String },
#[error("Unknown host key")]
UnknownHostKey,
#[error("Cannot record a binary change interactively. Use -a")]
RecordBinaryChange,
#[error("Remote not found: {:?}", remote)]
RemoteNotFound { remote: String },
#[error("No global config directory")]
NoGlobalConfigDir,
#[error("Could not parse global config")]
CouldNotParseGlobal,
#[error("Remote error: {}", msg)]
Remote { msg: String },
#[error("Remote exited with status {}", status)]
RemoteExit { status: u32 },
#[error("Missing remote")]
MissingRemote,
#[error("State not found in remote: {:?}", state)]
StateNotFound { state: libpijul::pristine::Merkle },
#[error("Missing dependencies for change {:?}", h)]
MissingDep { h: libpijul::pristine::Hash },
#[error("No prefixes given. Use `.` to record the current directory.")]
NoRecordPrefixes,
#[error("HTTP error: {}", status.as_str())]
Http { status: reqwest::StatusCode },
#[error("Could not parse configuration file at {:?}", path)]
CouldNotReadConfig { path: PathBuf },
#[error("No current channel")]
NoCurrentChannel,
#[error("Cannot delete the current channel")]
CannotDeleteCurrentChannel,
#[error("Channel not found: {:?}", channel)]
ChannelNotFound { channel: String },
#[error("Cannot reset, because there are unrecorded changes")]
UnrecordedChanges,
#[error("Could not infer repository name")]
CouldNotInferRepositoryName { repo: String },
#[error("Cannot unrecord change {}, because change {} depends on it", change, dep.to_base32())]
CannotUnrecord {
change: String,
dep: libpijul::pristine::Hash,
},
replacement in pijul/src/main.rs at line 207

[22.89714]→[22.910:959](∅→∅),[22.959]→[22.89774:89851](∅→∅),[22.89774]→[22.89774:89851](∅→∅)

pub fn current_dir() -> Result<PathBuf, Error> {
std::env::current_dir().map_err(|_| Error::CannotAccessWorkingDirectory)

[22.89714]

[22.89851]

pub fn current_dir() -> Result<PathBuf, anyhow::Error> {
if let Ok(cur) = std::env::current_dir() {
Ok(cur)
} else {
bail!("Cannot access working directory")
}
edit in pijul/src/config.rs at line 1

[22.89866]→[7.0:19](∅→∅)

use crate::Error;
edit in pijul/src/config.rs at line 3

[22.89899]

[22.960]

use anyhow::bail;
replacement in pijul/src/config.rs at line 42

[22.90697]→[7.701:794](∅→∅)

toml::from_slice(&s).map_err(|_| Error::CouldNotReadConfig { path: dir }.into())

[22.90697]

[22.90881]

if let Ok(t) = toml::from_slice(&s) {
Ok(t)
} else {
bail!("Could not read configuration file at {:?}", dir)
}
replacement in pijul/src/config.rs at line 48

[22.90898]→[7.795:844](∅→∅)

Err(Error::NoGlobalConfigDir.into())

[22.90898]

[22.90954]

bail!("Global configuration file missing")
replacement in pijul/src/commands/unrecord.rs at line 7

[22.59]→[22.900:960](∅→∅)

use libpijul::{Base32, MutTxnT, MutTxnTExt, TxnT, TxnTExt};

[22.59]

[22.1235]

use libpijul::*;
replacement in pijul/src/commands/unrecord.rs at line 39

[22.96409]→[22.246:314](∅→∅)

if let Some(mut channel) = txn.load_channel(channel_name) {

[22.96409]

[22.314]

if let Some(mut channel) = txn.load_channel(channel_name)? {
replacement in pijul/src/commands/unrecord.rs at line 63

[22.2290]→[22.2290:2390](∅→∅)

.reverse_log(&channel.borrow(), None)
.map(|(_, (h, _))| h)

[22.2290]

[22.2390]

.reverse_log(&channel.borrow(), None)?
.map(|h| (h.unwrap().1).0)
replacement in pijul/src/commands/unrecord.rs at line 88

[22.96722]→[22.96722:96781](∅→∅)

for (p, d) in txn.iter_revdep(change_id) {

[22.96722]

[22.96781]

for p in txn.iter_revdep(change_id)? {
let (p, d) = p?;
replacement in pijul/src/commands/unrecord.rs at line 95

[22.96953]→[22.96953:97034](∅→∅),[22.97034]→[22.487:551](∅→∅)

if txn.get_changeset(&channel_.changes, d, None).is_some() {
let dep = txn.get_external(d).unwrap();

[22.96953]

[22.551]

if txn.get_changeset(&channel_.changes, d, None)?.is_some() {
let dep = txn.get_external(d)?.unwrap();
edit in pijul/src/commands/reset.rs at line 10

[22.1383]→[22.1383:1401](∅→∅)

use crate::Error;
replacement in pijul/src/commands/reset.rs at line 41

[18.108]→[22.98455:98538](∅→∅),[22.98455]→[22.98455:98538](∅→∅)

let mut channel = if let Some(channel) = txn.load_channel(&channel_name) {

[18.108]

[22.98538]

let mut channel = if let Some(channel) = txn.load_channel(&channel_name)? {
replacement in pijul/src/commands/reset.rs at line 44

[22.98672]→[22.98672:98807](∅→∅)

return Err((Error::NoSuchChannel {
channel: channel_name.to_string(),
})
.into());

[22.98672]

[22.98807]

bail!("No such channel: {:?}", channel_name)
replacement in pijul/src/commands/reset.rs at line 75

[22.934]→[22.99838:99917](∅→∅),[22.99838]→[22.99838:99917](∅→∅)

if let Some(mut channel) = txn.load_channel(current_channel) {

[22.934]

[22.99917]

if let Some(mut channel) = txn.load_channel(current_channel)? {
replacement in pijul/src/commands/reset.rs at line 88

[22.100440]→[22.100440:100509](∅→∅)

return Err(Error::UnrecordedChanges.into());

[22.100440]

[22.100509]

bail!("Cannot change channel, as there are unrecorded changes.")
edit in pijul/src/commands/record.rs at line 5

[22.1486]

[22.25]

use anyhow::bail;
edit in pijul/src/commands/record.rs at line 17

[22.1600]→[22.1600:1618](∅→∅)

use crate::Error;
replacement in pijul/src/commands/record.rs at line 76

[2.174]→[2.174:288](∅→∅)

} else if let Some((_, (h, _))) = txn.reverse_log(&channel.borrow(), None).next() {
h

[2.174]

[2.288]

} else if let Some(h) = txn.reverse_log(&channel.borrow(), None)?.next() {
(h?.1).0
replacement in pijul/src/commands/record.rs at line 200

[22.107689]→[22.107689:107732](∅→∅)

.map(|rec| rec.globalize(txn))

[22.107689]

[22.107732]

.map(|rec| rec.globalize(txn).unwrap())
replacement in pijul/src/commands/record.rs at line 203

[22.107777]→[22.107777:107872](∅→∅)

LocalChange::make_change(txn, channel, actions, rec.contents, header, Vec::new());

[22.107777]

[22.107872]

LocalChange::make_change(txn, channel, actions, rec.contents, header, Vec::new())?;
replacement in pijul/src/commands/record.rs at line 210

[22.108130]→[22.108130:108188](∅→∅)

return Err(Error::RecordBinaryChange.into());

[22.108130]

[22.108188]

bail!("Cannot record a binary change interactively. Please use -a.")
replacement in pijul/src/commands/record.rs at line 243

[22.109346]→[22.109346:109401](∅→∅)

return Err(Error::NoChangeMessage.into());

[22.109346]

[22.109401]

bail!("No change message")
replacement in pijul/src/commands/pushpull.rs at line 10

[22.111707]→[22.2331:2383](∅→∅)

use libpijul::{MutTxnT, MutTxnTExt, TxnT, TxnTExt};

[22.111707]

[22.1743]

use libpijul::*;
replacement in pijul/src/commands/pushpull.rs at line 40

[22.112523]→[22.112523:112571](∅→∅)

for r in txn.iter_remotes("") {

[22.112523]

[22.112571]

for r in txn.iter_remotes("")? {
let r = r?;
replacement in pijul/src/commands/pushpull.rs at line 165

[22.7290]→[22.7290:7445](∅→∅)

paths.extend(libpijul::fs::iter_graph_descendants(
&txn,
&channel.borrow(),
p,
));

[22.7290]

[22.7445]

paths.extend(
libpijul::fs::iter_graph_descendants(&txn, &channel.borrow().graph, p)?
.map(|x| x.unwrap()),
);
replacement in pijul/src/commands/pushpull.rs at line 172

[22.116268]→[22.116268:116338](∅→∅)

for (_, (h, m)) in txn.reverse_log(&channel.borrow(), None) {

[22.116268]

[22.7456]

for x in txn.reverse_log(&channel.borrow(), None)? {
let (_, (h, m)) = x?;
replacement in pijul/src/commands/pushpull.rs at line 175

[22.7524]→[22.4561:4622](∅→∅),[22.4561]→[22.4561:4622](∅→∅)

if txn.remote_has_state(remote_changes, m) {

[22.7524]

[22.4622]

if txn.remote_has_state(remote_changes, m)? {
replacement in pijul/src/commands/pushpull.rs at line 178

[22.4667]→[22.4667:4789](∅→∅)

let h_int = txn.get_internal(h).unwrap();
if !txn.remote_has_change(&remote_changes, h) {

[22.4667]

[22.7525]

let h_int = txn.get_internal(h)?.unwrap();
if !txn.remote_has_change(&remote_changes, h)? {
replacement in pijul/src/commands/pushpull.rs at line 184

[22.7686]→[22.7686:7768](∅→∅)

if txn.get_touched_files(*p, Some(h_int)).is_some() {

[22.7686]

[22.7768]

if txn.get_touched_files(*p, Some(h_int))?.is_some() {
replacement in pijul/src/commands/pushpull.rs at line 192

[22.5132]→[22.5132:5206](∅→∅)

if let Some(channel) = txn.load_channel(remote_channel) {

[22.5132]

[22.5206]

if let Some(channel) = txn.load_channel(remote_channel)? {
replacement in pijul/src/commands/pushpull.rs at line 194

[22.5258]→[22.5258:5404](∅→∅)

let h_int = txn.get_internal(h).unwrap();
if txn.get_changeset(&channel.changes, h_int, None).is_none() {

[22.5258]

[22.7889]

let h_int = txn.get_internal(h)?.unwrap();
if txn.get_changeset(&channel.changes, h_int, None)?.is_none() {
replacement in pijul/src/commands/pushpull.rs at line 200

[22.8066]→[22.8066:8152](∅→∅)

if txn.get_touched_files(*p, Some(h_int)).is_some() {

[22.8066]

[22.8152]

if txn.get_touched_files(*p, Some(h_int))?.is_some() {
replacement in pijul/src/commands/pushpull.rs at line 309

[22.8812]→[22.6267:6416](∅→∅),[22.6267]→[22.6267:6416](∅→∅)

for (_, (h, m)) in txn.iter_remote(&remote_changes.borrow().remote, 0) {
if txn.channel_has_state(&channel, m) {

[22.8812]

[22.6416]

for x in txn.iter_remote(&remote_changes.borrow().remote, 0)? {
let (h, m) = x?.1;
if txn.channel_has_state(&channel, m)? {
replacement in pijul/src/commands/pushpull.rs at line 313

[22.6447]→[22.6447:6521](∅→∅)

} else if txn.get_revchanges(&channel, h).is_none() {

[22.6447]

[22.6521]

} else if txn.get_revchanges(&channel, h)?.is_none() {
replacement in pijul/src/commands/pushpull.rs at line 325

[22.9108]→[22.9108:9305](∅→∅)

inodes_.extend(libpijul::fs::iter_graph_descendants(
&txn,
&channel.borrow(),
p,
));

[22.9108]

[22.9305]

inodes_.extend(
libpijul::fs::iter_graph_descendants(&txn, &channel.borrow().graph, p)?
.map(|x| x.unwrap()),
);
replacement in pijul/src/commands/pushpull.rs at line 331

[22.9407]→[22.9407:9472](∅→∅)

change: txn.get_external(x.change).unwrap(),

[22.9407]

[22.9472]

change: txn.get_external(x.change).unwrap().unwrap(),
replacement in pijul/src/commands/pushpull.rs at line 334

[22.9525]→[22.7112:7193](∅→∅),[22.7112]→[22.7112:7193](∅→∅)

if let Some(remote_channel) = txn.load_channel(remote_channel) {

[22.9525]

[22.7193]

if let Some(remote_channel) = txn.load_channel(remote_channel)? {
replacement in pijul/src/commands/pushpull.rs at line 336

[22.7259]→[22.7259:7403](∅→∅)

for (_, (h, m)) in txn.reverse_log(&remote_channel, None) {
if txn.channel_has_state(&channel, m) {

[22.7259]

[22.7403]

for x in txn.reverse_log(&remote_channel, None)? {
let (h, m) = x?.1;
if txn.channel_has_state(&channel, m)? {
replacement in pijul/src/commands/pushpull.rs at line 341

[22.7464]→[22.7464:7530](∅→∅)

let h_int = txn.get_internal(h).unwrap();

[22.7464]

[22.7530]

let h_int = txn.get_internal(h)?.unwrap();
replacement in pijul/src/commands/pushpull.rs at line 343

[22.7561]→[22.7561:7644](∅→∅)

.get_changeset(&channel.borrow().changes, h_int, None)

[22.7561]

[22.7644]

.get_changeset(&channel.borrow().changes, h_int, None)?
replacement in pijul/src/commands/pushpull.rs at line 348

[22.9641]→[22.9641:9733](∅→∅)

txn.get_rev_touched_files(h_int, Some(inode)).is_some()

[22.9641]

[22.9733]

txn.get_rev_touched_files(h_int, Some(inode))
.unwrap()
.is_some()
replacement in pijul/src/commands/pushpull.rs at line 436

[22.10482]→[22.10482:10557](∅→∅)

let i = if let Some(change) = txn.get_internal(i.change) {

[22.10482]

[22.10557]

let i = if let Some(change) = txn.get_internal(i.change)? {
replacement in pijul/src/commands/pushpull.rs at line 488

[15.350]→[15.350:401](∅→∅)

if txn.remote_has_change(rem, d) {

[15.350]

[15.401]

if txn.remote_has_change(rem, d)? {
edit in pijul/src/commands/protocol.rs at line 6

[22.1914]

[22.123335]

use crate::repository::Repository;
use anyhow::bail;
replacement in pijul/src/commands/protocol.rs at line 11

[22.1961]→[22.3000:3078](∅→∅)

use libpijul::{Base32, ChannelRef, Hash, MutTxnT, MutTxnTExt, TxnT, TxnTExt};

[22.1961]

[22.1962]

use libpijul::*;
edit in pijul/src/commands/protocol.rs at line 15

[22.1989]→[22.1989:2042](∅→∅),[22.2042]→[22.123610:123611](∅→∅),[22.123610]→[22.123610:123611](∅→∅)

use crate::repository::Repository;
use crate::Error;
replacement in pijul/src/commands/protocol.rs at line 38

[22.124435]→[22.3079:3165](∅→∅),[22.3165]→[22.124518:124564](∅→∅),[22.124518]→[22.124518:124564](∅→∅)

fn load_channel<T: MutTxnTExt>(txn: &T, name: &str) -> Result<ChannelRef<T>, Error> {
if let Some(c) = txn.load_channel(name) {

[22.124435]

[22.124564]

fn load_channel<T: MutTxnTExt>(txn: &T, name: &str) -> Result<ChannelRef<T>, anyhow::Error> {
if let Some(c) = txn.load_channel(name)? {
replacement in pijul/src/commands/protocol.rs at line 42

[22.124591]→[22.837:872](∅→∅),[22.872]→[22.124627:124677](∅→∅),[22.124627]→[22.124627:124677](∅→∅)

Err(Error::NoSuchChannel {
channel: name.to_string(),
})

[22.124591]

[22.124694]

bail!("No such channel: {:?}", name)
replacement in pijul/src/commands/protocol.rs at line 72

[22.125737]→[22.125737:125810](∅→∅)

for (n, (_, m)) in txn.log(&channel.borrow(), pos) {

[22.125737]

[22.922]

for x in txn.log(&channel.borrow(), pos)? {
let (n, (_, m)) = x?;
replacement in pijul/src/commands/protocol.rs at line 86

[22.126196]→[22.1415:1515](∅→∅)

} else if let Some((n, (_, m))) = txn.reverse_log(&channel.borrow(), None).next() {

[22.126196]

[22.1515]

} else if let Some(x) = txn.reverse_log(&channel.borrow(), None)?.next() {
let (n, (_, m)) = x?;
replacement in pijul/src/commands/protocol.rs at line 103

[22.127036]→[22.127036:127231](∅→∅)

return Err((Error::ProtocolError {
line: buf.as_bytes().to_vec(),
})
.into());

[22.127036]

[22.127231]

bail!("Ambiguous path")
replacement in pijul/src/commands/protocol.rs at line 105

[22.127257]→[22.11485:11554](∅→∅)

let h = txn.get_external(p.change).unwrap();

[22.127257]

[22.11554]

let h = txn.get_external(p.change)?.unwrap();
replacement in pijul/src/commands/protocol.rs at line 108

[22.11666]→[22.11666:11881](∅→∅)

paths.extend(libpijul::fs::iter_graph_descendants(
&txn,
&channel.borrow(),
p,
));

[22.11666]

[22.127295]

paths.extend(
libpijul::fs::iter_graph_descendants(&txn, &channel.borrow().graph, p)?
.map(|x| x.unwrap()),
);
replacement in pijul/src/commands/protocol.rs at line 113

[22.127324]→[22.127324:127503](∅→∅)

return Err((Error::ProtocolError {
line: buf.as_bytes().to_vec(),
})
.into());

[22.127324]

[22.127503]

debug!("protocol line: {:?}", buf);
bail!("Protocol error")
replacement in pijul/src/commands/protocol.rs at line 118

[22.11929]→[22.127543:127675](∅→∅),[22.127543]→[22.127543:127675](∅→∅)

for (n, (h, m)) in txn.log(&channel.borrow(), from) {
let h_int = txn.get_internal(h).unwrap();

[22.11929]

[22.127675]

for x in txn.log(&channel.borrow(), from)? {
let (n, (h, m)) = x?;
let h_int = txn.get_internal(h)?.unwrap();
replacement in pijul/src/commands/protocol.rs at line 123

[22.11980]→[22.11980:12078](∅→∅)

x.change == h_int || txn.get_touched_files(*x, Some(h_int)).is_some()

[22.11980]

[22.12078]

x.change == h_int
|| txn.get_touched_files(*x, Some(h_int)).unwrap().is_some()
replacement in pijul/src/commands/protocol.rs at line 137

[22.128296]→[22.128296:128459](∅→∅)

return Err((Error::ProtocolError {
line: buf.as_bytes().to_vec(),
})
.into());

[22.128296]

[22.128459]

debug!("protocol error: {:?}", buf);
bail!("Protocol error")
replacement in pijul/src/commands/protocol.rs at line 168

[22.129776]→[22.129776:129939](∅→∅)

return Err((Error::ProtocolError {
line: buf.as_bytes().to_vec(),
})
.into());

[22.129776]

[22.129939]

debug!("protocol error {:?}", buf);
bail!("Protocol error");
replacement in pijul/src/commands/protocol.rs at line 184

[22.130748]→[22.130748:130875](∅→∅)

for d in libpijul::pristine::channel_dump::dump_channel(&txn, channel) {
o.write_all(&d)?;

[22.130748]

[22.130875]

for d in libpijul::pristine::channel_dump::dump_channel(&txn, channel)? {
o.write_all(&d?)?;
replacement in pijul/src/commands/protocol.rs at line 201

[22.131779]→[16.0:91](∅→∅)

if txn.current_state(&channel.borrow()) == state && extra.is_empty() {

[22.131779]

[22.131876]

if txn.current_state(&channel.borrow())? == state && extra.is_empty() {
replacement in pijul/src/commands/mod.rs at line 80

[22.2244]→[22.2244:2283](∅→∅)

.map(|rec| rec.globalize(txn))

[22.2244]

[22.2283]

.map(|rec| rec.globalize(txn).unwrap())
replacement in pijul/src/commands/mod.rs at line 89

[22.2516]→[22.2516:2523](∅→∅)

);

[22.2516]

[22.2523]

)?;
replacement in pijul/src/commands/mod.rs at line 91

[22.2561]→[22.2561:2646](∅→∅)

libpijul::change::dependencies(txn, channel, pending_change.changes.iter());

[22.2561]

[22.2646]

libpijul::change::dependencies(txn, &channel.borrow(), pending_change.changes.iter())?;
edit in pijul/src/commands/log.rs at line 4

[22.2088]

[22.2088]

use anyhow::bail;
edit in pijul/src/commands/log.rs at line 10

[22.2141]→[22.2141:2159](∅→∅)

use crate::Error;
replacement in pijul/src/commands/log.rs at line 35

[22.135173]→[22.135173:135251](∅→∅)

let channel = if let Some(channel) = txn.load_channel(channel_name) {

[22.135173]

[22.135251]

let channel = if let Some(channel) = txn.load_channel(channel_name)? {
replacement in pijul/src/commands/log.rs at line 38

[22.135288]→[22.135288:135423](∅→∅)

return Err((Error::NoSuchChannel {
channel: channel_name.to_string(),
})
.into());

[22.135288]

[22.135423]

bail!("No such channel: {:?}", channel_name)
replacement in pijul/src/commands/log.rs at line 44

[22.135542]→[9.0:74](∅→∅)

for (_, (h, _)) in txn.reverse_log(&channel.borrow(), None) {

[22.135542]

[22.135619]

for h in txn.reverse_log(&channel.borrow(), None)? {
let h = (h?.1).0;
replacement in pijul/src/commands/log.rs at line 50

[22.135743]→[22.135743:135819](∅→∅)

for (_, (h, mrk)) in txn.reverse_log(&channel.borrow(), None) {

[22.135743]

[14.0]

for h in txn.reverse_log(&channel.borrow(), None)? {
let (h, mrk) = h?.1;
replacement in pijul/src/commands/fork.rs at line 35

[22.168851]→[22.168851:168919](∅→∅)

if let Some(channel) = txn.load_channel(channel_name) {

[22.168851]

[22.168919]

if let Some(channel) = txn.load_channel(channel_name)? {
replacement in pijul/src/commands/file_operations.rs at line 81

[22.171069]→[22.171069:171117](∅→∅)

for (_, p) in txn.iter_working_copy() {

[22.171069]

[22.171117]

for p in txn.iter_working_copy() {
let p = p?.1;
replacement in pijul/src/commands/file_operations.rs at line 140

[22.891]→[22.891:939](∅→∅)

if !txn.is_tracked(&path_str) {

[22.891]

[17.660]

if !txn.is_tracked(&path_str)? {
replacement in pijul/src/commands/file_operations.rs at line 184

[22.173382]→[22.173382:173425](∅→∅)

if txn.is_tracked(&path_str) {

[22.173382]

[22.173425]

if txn.is_tracked(&path_str)? {
replacement in pijul/src/commands/diff.rs at line 71

[22.175217]→[22.175217:175261](∅→∅)

.map(|rec| rec.globalize(&txn))

[22.175217]

[22.175261]

.map(|rec| rec.globalize(&txn).unwrap())
replacement in pijul/src/commands/diff.rs at line 80

[22.175484]→[22.175484:175495](∅→∅)

);

[22.175484]

[22.175495]

)?;
replacement in pijul/src/commands/diff.rs at line 83

[22.175552]→[22.175552:175598](∅→∅)

full_dependencies(&txn, &channel)

[22.175552]

[22.175598]

full_dependencies(&txn, &channel)?
replacement in pijul/src/commands/diff.rs at line 85

[22.175615]→[22.175615:175679](∅→∅)

dependencies(&txn, &channel, change.changes.iter())

[22.175615]

[22.175679]

dependencies(&txn, &channel.borrow(), change.changes.iter())?
replacement in pijul/src/commands/debug.rs at line 4

[22.177794]→[22.177794:177812](∅→∅)

use crate::Error;

[22.177794]

[22.0]

use anyhow::bail;
replacement in pijul/src/commands/debug.rs at line 26

[22.178297]→[22.178297:178376](∅→∅)

let channel = if let Some(channel) = txn.load_channel(&channel_name) {

[22.178297]

[22.178376]

let channel = if let Some(channel) = txn.load_channel(&channel_name)? {
replacement in pijul/src/commands/debug.rs at line 29

[22.178413]→[22.178413:178548](∅→∅)

return Err((Error::NoSuchChannel {
channel: channel_name.to_string(),
})
.into());

[22.178413]

[22.178548]

bail!("No such channel: {:?}", channel_name)
replacement in pijul/src/commands/debug.rs at line 37

[22.264]→[22.264:299](∅→∅)

&channel.borrow(),

[22.264]

[22.299]

&channel.borrow().graph,
replacement in pijul/src/commands/debug.rs at line 44

[22.102]→[22.102:177](∅→∅)

libpijul::pristine::debug(&txn, &channel, std::io::stdout())?;

[22.102]

[22.177]

libpijul::pristine::debug(&txn, &channel.graph, std::io::stdout())?;
replacement in pijul/src/commands/debug.rs at line 46

[22.187]→[22.187:269](∅→∅)

libpijul::pristine::check_alive_debug(&repo.changes, &txn, &channel, 0)?;

[22.187]

[19.0]

libpijul::pristine::check_alive_debug(&repo.changes, &txn, &channel.borrow(), 0)?;
edit in pijul/src/commands/credit.rs at line 4

[22.2811]

[18.690]

use anyhow::bail;
replacement in pijul/src/commands/credit.rs at line 8

[22.178851]→[22.5891:5960](∅→∅)

use libpijul::{ChangeId, Channel, EdgeFlags, TxnT, TxnTExt, Vertex};

[22.178851]

[22.2828]

use libpijul::*;
edit in pijul/src/commands/credit.rs at line 12

[22.2880]→[22.2880:2898](∅→∅)

use crate::Error;
replacement in pijul/src/commands/credit.rs at line 31

[22.179431]→[22.179431:179510](∅→∅)

let channel = if let Some(channel) = txn.load_channel(&channel_name) {

[22.179431]

[22.179510]

let channel = if let Some(channel) = txn.load_channel(&channel_name)? {
replacement in pijul/src/commands/credit.rs at line 34

[22.179547]→[22.179547:179682](∅→∅)

return Err((Error::NoSuchChannel {
channel: channel_name.to_string(),
})
.into());

[22.179547]

[22.179682]

bail!("No such channel: {:?}", channel_name)
replacement in pijul/src/commands/credit.rs at line 64

[22.180479]→[22.5961:6018](∅→∅)

pub struct Creditor<'a, W: std::io::Write, T: TxnTExt> {

[22.180479]

[22.180533]

pub struct Creditor<'a, W: std::io::Write, T: ChannelTxnT> {
replacement in pijul/src/commands/credit.rs at line 73

[22.180661]→[22.6019:6080](∅→∅)

impl<'a, W: std::io::Write, T: TxnTExt> Creditor<'a, W, T> {

[22.180661]

[22.180719]

impl<'a, W: std::io::Write, T: ChannelTxnT> Creditor<'a, W, T> {
edit in pijul/src/commands/credit.rs at line 99

[22.181319]→[22.6160:6190](∅→∅)

use libpijul::Base32;
replacement in pijul/src/commands/credit.rs at line 104

[22.181558]→[22.0:56](∅→∅)

.filter(|e| !e.introduced_by.is_root())

[22.181558]

[22.181558]

.unwrap()
edit in pijul/src/commands/credit.rs at line 106

[22.181572]

[22.181572]

let e = e.unwrap();
if e.introduced_by.is_root() {
continue;
}
edit in pijul/src/commands/clone.rs at line 4

[22.2925]

[22.2925]

use crate::repository::*;
use anyhow::bail;
edit in pijul/src/commands/clone.rs at line 10

[22.183024]→[22.2959:2986](∅→∅)

use crate::repository::*;
replacement in pijul/src/commands/clone.rs at line 57

[22.184404]→[22.184404:184502](∅→∅)

return Err((crate::Error::CouldNotInferRepositoryName { repo: self.remote }).into());

[22.184404]

[22.184502]

bail!("Could not infer repository name from {:?}", self.remote)
edit in pijul/src/commands/channel.rs at line 6

[11.20]

[124.147]

use anyhow::bail;
replacement in pijul/src/commands/channel.rs at line 42

[22.187789]→[22.187789:187844](∅→∅)

for channel in txn.iter_channels("") {

[22.187789]

[22.187844]

for channel in txn.iter_channels("")? {
let channel = channel?;
replacement in pijul/src/commands/channel.rs at line 57

[22.1311]→[22.6297:6378](∅→∅)

return Err(crate::Error::CannotDeleteCurrentChannel.into());

[22.1311]

[22.1391]

bail!("Cannot delete current channel")
replacement in pijul/src/commands/channel.rs at line 83

[22.188748]→[22.188748:188819](∅→∅)

return Err(crate::Error::NoCurrentChannel.into());

[22.188748]

[22.188819]

bail!("No current channel")
replacement in pijul/src/commands/channel.rs at line 85

[22.188838]→[22.188838:188920](∅→∅)

let mut channel = if let Some(channel) = txn.load_channel(from) {

[22.188838]

[22.188920]

let mut channel = if let Some(channel) = txn.load_channel(from)? {
replacement in pijul/src/commands/channel.rs at line 88

[22.188973]→[22.188973:189141](∅→∅)

return Err((crate::Error::ChannelNotFound {
channel: from.to_string(),
})
.into());

[22.188973]

[22.189141]

bail!("No such channel: {:?}", from)
replacement in pijul/src/commands/change.rs at line 30

[12.70]→[12.70:152](∅→∅)

let channel = if let Some(channel) = txn.load_channel(channel_name) {

[12.70]

[12.152]

let channel = if let Some(channel) = txn.load_channel(channel_name)? {
replacement in pijul/src/commands/change.rs at line 36

[12.287]→[12.287:385](∅→∅)

if let Some((_, (h, _))) = txn.reverse_log(&channel, None).next() {
h

[12.287]

[12.385]

if let Some(h) = txn.reverse_log(&channel, None)?.next() {
(h?.1).0
replacement in pijul/src/commands/archive.rs at line 90

[22.193497]→[22.193497:193573](∅→∅)

let mut channel = txn.load_channel(&channel_name).unwrap();

[22.193497]

[22.193573]

let mut channel = txn.load_channel(&channel_name)?.unwrap();
replacement in pijul/src/commands/archive.rs at line 100

[22.193869]→[22.193869:193941](∅→∅)

let channel = txn.load_channel(&channel_name).unwrap();

[22.193869]

[22.193941]

let channel = txn.load_channel(&channel_name)?.unwrap();
replacement in pijul/src/commands/apply.rs at line 31

[22.195050]→[22.195050:195133](∅→∅)

let mut channel = if let Some(channel) = txn.load_channel(&channel_name) {

[22.195050]

[22.195133]

let mut channel = if let Some(channel) = txn.load_channel(&channel_name)? {
replacement in pijul/Cargo.toml at line 4

[22.196462]→[19.51:78](∅→∅)

version = "1.0.0-alpha.26"

[22.196462]

[22.196488]

version = "1.0.0-alpha.27"
replacement in pijul/Cargo.toml at line 49

[22.197438]→[22.197438:197456](∅→∅),[22.197456]→[19.79:147](∅→∅)

thiserror = "1.0"
libpijul = { version = "1.0.0-alpha.22", features = [ "tarball" ] }

[22.197438]

[22.197523]

libpijul = { version = "1.0.0-alpha.23", features = [ "tarball" ] }
replacement in pijul/Cargo.toml at line 64

[22.197874]→[22.0:21](∅→∅)

sanakirja = "0.14.2"

[22.197874]

[22.197895]

sanakirja = "0.15.2"
replacement in libpijul/src/working_copy/filesystem.rs at line 107

[22.398]→[22.3775:3824](∅→∅),[22.210434]→[22.3775:3824](∅→∅)

) -> Result<(), Error<C::Error, T::Error>> {

[22.398]

[22.210471]

) -> Result<(), Error<C::Error, T::GraphError>> {
replacement in libpijul/src/working_copy/filesystem.rs at line 140

[22.875]→[22.3825:3867](∅→∅),[22.1792]→[22.3825:3867](∅→∅)

) -> Result<(), AddError<T::Error>> {

[22.875]

[22.1829]

) -> Result<(), AddError<T::GraphError>> {
replacement in libpijul/src/working_copy/filesystem.rs at line 149

[22.1902]→[22.984:1063](∅→∅),[22.984]→[22.984:1063](∅→∅)

let t = std::thread::spawn(move || -> Result<(), AddError<T::Error>> {

[22.1902]

[22.1063]

let t = std::thread::spawn(move || -> Result<(), AddError<T::GraphError>> {
replacement in libpijul/src/working_copy/filesystem.rs at line 219

[22.3130]→[22.3868:3917](∅→∅),[22.211282]→[22.3868:3917](∅→∅)

) -> Result<(), Error<C::Error, T::Error>> {

[22.3130]

[22.2643]

) -> Result<(), Error<C::Error, T::GraphError>> {
replacement in libpijul/src/unrecord/working_copy.rs at line 6

[22.1]→[22.226152:226191](∅→∅),[22.226152]→[22.226152:226191](∅→∅)

pub fn undo_file_addition<T: MutTxnT>(

[22.1]

[22.226191]

pub fn undo_file_addition<
T: GraphMutTxnT + TreeMutTxnT<TreeError = <T as GraphTxnT>::GraphError>,
>(
replacement in libpijul/src/unrecord/working_copy.rs at line 12

[22.226275]→[22.6687:6715](∅→∅)

) -> Result<(), T::Error> {

[22.226275]

[22.226308]

) -> Result<(), TxnErr<T::GraphError>> {
replacement in libpijul/src/unrecord/working_copy.rs at line 18

[22.226458]→[22.226458:226518](∅→∅)

if let Some(inode) = txn.get_revinodes(pos, None) {

[22.226458]

[22.353]

if let Some(inode) = txn.get_revinodes(pos, None)? {
replacement in libpijul/src/unrecord/working_copy.rs at line 25

[22.3]→[22.226729:226784](∅→∅),[22.226729]→[22.226729:226784](∅→∅)

pub fn undo_file_deletion<T: MutTxnT, P: ChangeStore>(

[22.3]

[22.226784]

pub fn undo_file_deletion<
T: ChannelTxnT + TreeMutTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
P: ChangeStore,
>(
replacement in libpijul/src/unrecord/working_copy.rs at line 34

[22.226907]→[22.6716:6776](∅→∅)

) -> Result<(), super::UnrecordError<P::Error, T::Error>> {

[22.226907]

[22.226940]

) -> Result<(), super::UnrecordError<P::Error, T::TreeError>> {
replacement in libpijul/src/unrecord/working_copy.rs at line 37

[22.227037]→[22.6529:6622](∅→∅)

let source = find_block_end(txn, &channel, internal_pos(txn, &e.from, change_id)?)?;

[22.227037]

[22.227128]

let source = find_block_end(txn, &channel.graph, internal_pos(txn, &e.from, change_id)?)?;
replacement in libpijul/src/unrecord/working_copy.rs at line 46

[22.5]→[22.227428:227468](∅→∅),[22.227428]→[22.227428:227468](∅→∅)

fn restore<T: MutTxnT, P: ChangeStore>(

[22.5]

[22.227468]

fn restore<
T: ChannelTxnT + TreeMutTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
P: ChangeStore,
>(
replacement in libpijul/src/unrecord/working_copy.rs at line 55

[22.227588]→[22.6777:6837](∅→∅)

) -> Result<(), super::UnrecordError<P::Error, T::Error>> {

[22.227588]

[22.227621]

) -> Result<(), super::UnrecordError<P::Error, T::TreeError>> {
replacement in libpijul/src/unrecord/working_copy.rs at line 63

[22.227921]→[22.6697:6740](∅→∅)

let source_parent = iter_adjacent(

[22.227921]

[22.6740]

let mut source_parent = None;
for e in iter_adjacent(
replacement in libpijul/src/unrecord/working_copy.rs at line 66

[22.6757]→[22.6757:6779](∅→∅)

&channel,

[22.6757]

[22.6779]

&channel.graph,
replacement in libpijul/src/unrecord/working_copy.rs at line 70

[22.6880]→[22.6880:6890](∅→∅),[22.6890]→[22.1769:1843](∅→∅),[22.1843]→[22.6982:7015](∅→∅),[22.6982]→[22.6982:7015](∅→∅)

)
.find(|e| e.flag.contains(EdgeFlags::PARENT | EdgeFlags::FOLDER))
.unwrap()
.dest;

[22.6880]

[22.6]

)? {
let e = e?;
if e.flag.contains(EdgeFlags::PARENT | EdgeFlags::FOLDER) {
source_parent = Some(e.dest);
break;
}
}
let source_parent = source_parent.unwrap();
replacement in libpijul/src/unrecord/working_copy.rs at line 81

[22.6928]→[22.228471:228548](∅→∅),[22.228471]→[22.228471:228548](∅→∅)

} else if let Some(inode) = txn.get_revinodes(source_parent, None) {

[22.6928]

[22.6929]

} else if let Some(inode) = txn.get_revinodes(source_parent, None)? {
replacement in libpijul/src/unrecord/working_copy.rs at line 92

[22.9]→[22.228923:228969](∅→∅),[22.228923]→[22.228923:228969](∅→∅)

fn restore_inode<T: MutTxnT, P: ChangeStore>(

[22.9]

[22.228969]

fn restore_inode<
T: TreeMutTxnT + GraphTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
P: ChangeStore,
>(
replacement in libpijul/src/unrecord/working_copy.rs at line 101

[22.229088]→[22.7014:7077](∅→∅)

) -> Result<Inode, super::UnrecordError<P::Error, T::Error>> {

[22.229088]

[22.229174]

) -> Result<Inode, super::UnrecordError<P::Error, T::TreeError>> {
replacement in libpijul/src/unrecord/working_copy.rs at line 104

[22.7110]→[22.7110:7177](∅→∅)

.get_file_name(|h| txn.get_external(h), source, &mut name)

[22.7110]

[22.7177]

.get_file_name(|h| txn.get_external(h).unwrap(), source, &mut name)
replacement in libpijul/src/unrecord/working_copy.rs at line 111

[22.229428]→[22.10:67](∅→∅)

if let Some(inode) = txn.get_revinodes(dest, None) {

[22.229428]

[22.67]

if let Some(inode) = txn.get_revinodes(dest, None)? {
replacement in libpijul/src/unrecord/working_copy.rs at line 114

[22.98]→[22.98:152](∅→∅),[22.152]→[22.7232:7412](∅→∅)

let inode = crate::fs::create_new_inode(txn);
put_tree_with_rev(txn, file_id.as_file_id(), inode).map_err(super::UnrecordError::Txn)?;
put_inodes_with_rev(txn, inode, dest).map_err(super::UnrecordError::Txn)?;

[22.98]

[22.338]

let inode = crate::fs::create_new_inode(txn)?;
put_tree_with_rev(txn, file_id.as_file_id(), inode)?;
put_inodes_with_rev(txn, inode, dest)?;
replacement in libpijul/src/unrecord/working_copy.rs at line 121

[22.364]→[22.229677:229711](∅→∅),[22.229677]→[22.229677:229711](∅→∅)

fn find_youngest_parent<T: TxnT>(

[22.364]

[22.229711]

fn find_youngest_parent<T: ChannelTxnT>(
replacement in libpijul/src/unrecord/working_copy.rs at line 125

[22.229781]→[22.7413:7457](∅→∅)

) -> Result<Vertex<ChangeId>, BlockError> {

[22.229781]

[22.229827]

) -> Result<Vertex<ChangeId>, BlockError<T::GraphError>> {
replacement in libpijul/src/unrecord/working_copy.rs at line 129

[22.7057]→[22.7057:7074](∅→∅)

channel,

[22.7057]

[22.7074]

&channel.graph,
replacement in libpijul/src/unrecord/working_copy.rs at line 133

[22.7225]→[22.7225:7303](∅→∅),[22.7303]→[22.230163:230169](∅→∅),[22.230163]→[22.230163:230169](∅→∅)

)
.filter(|e| e.flag.contains(EdgeFlags::FOLDER | EdgeFlags::PARENT))
{

[22.7225]

[22.230169]

)? {
let e = e?;
if !e.flag.contains(EdgeFlags::FOLDER | EdgeFlags::PARENT) {
continue;
}
replacement in libpijul/src/unrecord/working_copy.rs at line 141

[22.230244]→[22.230244:230316](∅→∅)

.get_changeset(&channel.changes, e.introduced_by, None)

[22.230244]

[22.230316]

.get_changeset(&channel.changes, e.introduced_by, None)?
replacement in libpijul/src/unrecord/working_copy.rs at line 156

[22.230687]→[22.7304:7354](∅→∅)

find_block_end(txn, channel, next.unwrap().1)

[22.230687]

[22.230736]

find_block_end(txn, &channel.graph, next.unwrap().1)
replacement in libpijul/src/unrecord/working_copy.rs at line 159

[22.230739]→[22.7458:7516](∅→∅)

pub fn undo_file_reinsertion<P: ChangeStore, T: MutTxnT>(

[22.230739]

[22.230836]

pub fn undo_file_reinsertion<
P: ChangeStore,
T: GraphTxnT + TreeMutTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
>(
replacement in libpijul/src/unrecord/working_copy.rs at line 166

[22.230916]→[22.7517:7577](∅→∅)

) -> Result<(), super::UnrecordError<P::Error, T::Error>> {

[22.230916]

[22.230949]

) -> Result<(), super::UnrecordError<P::Error, T::TreeError>> {
replacement in libpijul/src/unrecord/working_copy.rs at line 171

[22.7432]→[22.231227:231296](∅→∅),[22.231227]→[22.231227:231296](∅→∅),[22.231296]→[22.7578:7673](∅→∅)

if let Some(inode) = txn.get_revinodes(position, None) {
del_inodes_with_rev(txn, inode, position).map_err(super::UnrecordError::Txn)?;

[22.7432]

[22.231440]

if let Some(inode) = txn.get_revinodes(position, None)? {
del_inodes_with_rev(txn, inode, position)?;
replacement in libpijul/src/unrecord/mod.rs at line 21

[22.7965]→[22.7965:8013](∅→∅)

Block(#[from] crate::pristine::BlockError),

[22.7965]

[22.8013]

Block(#[from] crate::pristine::BlockError<TxnError>),
replacement in libpijul/src/unrecord/mod.rs at line 23

[22.8039]→[22.8039:8108](∅→∅)

InconsistentChange(#[from] crate::pristine::InconsistentChange),

[22.8039]

[22.8108]

InconsistentChange(#[from] crate::pristine::InconsistentChange<TxnError>),
edit in libpijul/src/unrecord/mod.rs at line 34

[22.8611]

[22.8611]

}

impl<T: std::error::Error + 'static, C: std::error::Error + 'static> std::convert::From<TxnErr<T>>
for UnrecordError<C, T>
{
fn from(t: TxnErr<T>) -> Self {
UnrecordError::Txn(t.0)
}
replacement in libpijul/src/unrecord/mod.rs at line 49

[22.231881]→[22.8615:8670](∅→∅)

) -> Result<bool, UnrecordError<P::Error, T::Error>> {

[22.231881]

[22.8670]

) -> Result<bool, UnrecordError<P::Error, T::GraphError>> {
replacement in libpijul/src/unrecord/mod.rs at line 53

[22.8768]→[22.231960:232023](∅→∅),[22.231960]→[22.231960:232023](∅→∅)

let change_id = if let Some(h) = txn.get_internal(*hash) {

[22.8768]

[22.232023]

let change_id = if let Some(h) = txn.get_internal(*hash)? {
replacement in libpijul/src/unrecord/mod.rs at line 58

[22.232079]→[22.232079:232148](∅→∅)

let unused = unused_in_other_channels(txn, &channel, change_id);

[22.232079]

[22.232148]

let unused = unused_in_other_channels(txn, &channel, change_id)?;
replacement in libpijul/src/unrecord/mod.rs at line 66

[22.232331]→[22.232331:232391](∅→∅),[22.232391]→[22.8834:9062](∅→∅)

assert!(txn.get_revdep(change_id, None).is_none());
while txn.del_dep(change_id, None).map_err(UnrecordError::Txn)? {}
txn.del_external(change_id, None)
.map_err(UnrecordError::Txn)?;
txn.del_internal(*hash, None).map_err(UnrecordError::Txn)?;

[22.232331]

[22.232522]

assert!(txn.get_revdep(change_id, None)?.is_none());
while txn.del_dep(change_id, None)? {}
txn.del_external(change_id, None)?;
txn.del_internal(*hash, None)?;
replacement in libpijul/src/unrecord/mod.rs at line 71

[22.232570]→[22.232570:232625](∅→∅),[22.232625]→[22.9063:9159](∅→∅)

let dep = txn.get_internal(*dep).unwrap();
txn.del_revdep(dep, Some(change_id))
.map_err(UnrecordError::Txn)?;

[22.232570]

[22.232676]

let dep = txn.get_internal(*dep)?.unwrap();
txn.del_revdep(dep, Some(change_id))?;
replacement in libpijul/src/unrecord/mod.rs at line 80

[22.9161]→[22.9161:9213](∅→∅)

fn del_channel_changes<T: MutTxnT, P: ChangeStore>(

[22.9161]

[22.232833]

fn del_channel_changes<
T: ChannelMutTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>,
P: ChangeStore,
>(
replacement in libpijul/src/unrecord/mod.rs at line 87

[22.232905]→[22.9214:9267](∅→∅),[22.9267]→[22.232938:233031](∅→∅),[22.232938]→[22.232938:233031](∅→∅)

) -> Result<(), UnrecordError<P::Error, T::Error>> {
let timestamp = if let Some(ts) = txn.get_changeset(&channel.changes, change_id, None) {

[22.232905]

[22.233031]

) -> Result<(), UnrecordError<P::Error, T::GraphError>> {
let timestamp = if let Some(ts) = txn.get_changeset(&channel.changes, change_id, None)? {
replacement in libpijul/src/unrecord/mod.rs at line 94

[22.233133]→[22.233133:233180](∅→∅)

for (p, d) in txn.iter_revdep(change_id) {

[22.233133]

[22.233180]

for x in txn.iter_revdep(change_id)? {
let (p, d) = x?;
replacement in libpijul/src/unrecord/mod.rs at line 101

[22.233292]→[22.233292:233360](∅→∅)

if txn.get_changeset(&channel.changes, d, None).is_some() {

[22.233292]

[22.9344]

if txn.get_changeset(&channel.changes, d, None)?.is_some() {
replacement in libpijul/src/unrecord/mod.rs at line 106

[22.233453]→[22.9420:9510](∅→∅)

txn.del_changes(channel, change_id, timestamp)
.map_err(UnrecordError::Txn)?;

[22.233453]

[22.233506]

txn.del_changes(channel, change_id, timestamp)?;
replacement in libpijul/src/unrecord/mod.rs at line 114

[22.233683]→[22.233683:233695](∅→∅)

) -> bool {

[22.233683]

[22.233695]

) -> Result<bool, TxnErr<T::GraphError>> {
replacement in libpijul/src/unrecord/mod.rs at line 116

[22.233731]→[22.233731:233769](∅→∅)

for br in txn.iter_channels("") {

[22.233731]

[22.233769]

for br in txn.iter_channels("")? {
let br = br?;
replacement in libpijul/src/unrecord/mod.rs at line 119

[22.233799]→[22.1844:1968](∅→∅)

if br.name != channel.name && txn.get_changeset(&br.changes, change_id, None).is_some() {
return false;

[22.233799]

[22.233955]

if br.name != channel.name && txn.get_changeset(&br.changes, change_id, None)?.is_some() {
return Ok(false);
replacement in libpijul/src/unrecord/mod.rs at line 123

[22.233971]→[22.233971:233980](∅→∅)

true

[22.233971]

[22.233980]

Ok(true)
replacement in libpijul/src/unrecord/mod.rs at line 126

[22.9514]→[22.234037:234077](∅→∅),[22.234037]→[22.234037:234077](∅→∅)

fn unapply<T: MutTxnT, C: ChangeStore>(

[22.9514]

[22.234077]

fn unapply<
T: ChannelMutTxnT + TreeMutTxnT<TreeError = <T as GraphTxnT>::GraphError>,
C: ChangeStore,
>(
replacement in libpijul/src/unrecord/mod.rs at line 135

[22.234187]→[22.9515:9568](∅→∅)

) -> Result<(), UnrecordError<C::Error, T::Error>> {

[22.234187]

[22.234220]

) -> Result<(), UnrecordError<C::Error, T::GraphError>> {
replacement in libpijul/src/unrecord/mod.rs at line 140

[22.234399]→[22.234399:234542](∅→∅)

Atom::EdgeMap(ref newedges) => {
unapply_edges(changes, txn, channel, change_id, newedges, &mut ws)?
}

[22.234399]

[22.234542]

Atom::EdgeMap(ref newedges) => unapply_edges(
changes,
txn,
&mut channel.graph,
change_id,
newedges,
&mut ws,
)?,
replacement in libpijul/src/unrecord/mod.rs at line 152

[22.234733]→[22.234733:234766](∅→∅)

channel,

[22.234733]

[22.7433]

&mut channel.graph,
replacement in libpijul/src/unrecord/mod.rs at line 154

[22.7506]→[22.9569:9642](∅→∅)

)
.map_err(UnrecordError::Txn)?;

[22.7506]

[22.234862]

)?
replacement in libpijul/src/unrecord/mod.rs at line 156

[22.234880]→[22.9643:9731](∅→∅)

unapply_newvertex::<T, C>(txn, channel, change_id, &mut ws, newvertex)?

[22.234880]

[22.234960]

unapply_newvertex::<T, C>(txn, &mut channel.graph, change_id, &mut ws, newvertex)?
replacement in libpijul/src/unrecord/mod.rs at line 160

[22.234990]→[21.40:114](∅→∅)

repair_newvertex_contexts::<T, C>(txn, channel, &mut ws, change_id)?;

[22.234990]

[22.235104]

repair_newvertex_contexts::<T, C>(txn, &mut channel.graph, &mut ws, change_id)?;
replacement in libpijul/src/unrecord/mod.rs at line 163

[22.2017]→[21.115:189](∅→∅)

remove_zombies::<_, C>(txn, channel, &mut ws, change_id, n)?;

[22.2017]

[22.2074]

remove_zombies::<_, C>(txn, &mut channel.graph, &mut ws, change_id, n)?;
replacement in libpijul/src/unrecord/mod.rs at line 167

[22.2154]→[22.2154:2179](∅→∅)

channel,

[22.2154]

[22.2179]

&mut channel.graph,
replacement in libpijul/src/unrecord/mod.rs at line 188

[22.958]→[22.958:1086](∅→∅)

working_copy::undo_file_addition(txn, change_id, new_vertex)
.map_err(UnrecordError::Txn)?;

[22.958]

[22.1086]

working_copy::undo_file_addition(txn, change_id, new_vertex)?;
replacement in libpijul/src/unrecord/mod.rs at line 194

[22.1137]→[21.190:347](∅→∅)

crate::apply::clean_obsolete_pseudo_edges(txn, channel, &mut ws.apply, change_id)?;
crate::apply::repair_cyclic_paths(txn, channel, &mut ws.apply)?;

[22.1137]

[22.235674]

crate::apply::clean_obsolete_pseudo_edges(txn, &mut channel.graph, &mut ws.apply, change_id)?;
crate::apply::repair_cyclic_paths(txn, &mut channel.graph, &mut ws.apply)?;
replacement in libpijul/src/unrecord/mod.rs at line 211

[22.236205]→[22.9862:9912](∅→∅)

fn unapply_newvertex<T: MutTxnT, C: ChangeStore>(

[22.235980]

[22.236239]

fn unapply_newvertex<T: GraphMutTxnT, C: ChangeStore>(
replacement in libpijul/src/unrecord/mod.rs at line 213

[22.236256]→[22.236256:236286](∅→∅)

channel: &mut Channel<T>,

[22.236256]

[22.236286]

channel: &mut T::Graph,
replacement in libpijul/src/unrecord/mod.rs at line 217

[22.236377]→[22.9913:9966](∅→∅)

) -> Result<(), UnrecordError<C::Error, T::Error>> {

[22.236377]

[22.236410]

) -> Result<(), UnrecordError<C::Error, T::GraphError>> {
replacement in libpijul/src/unrecord/mod.rs at line 225

[22.237225]→[21.611:665](∅→∅)

for e in iter_adj_all(txn, channel, vertex) {

[22.237225]

[22.237317]

for e in iter_adj_all(txn, channel, vertex)? {
let e = e?;
replacement in libpijul/src/unrecord/mod.rs at line 256

[21.1166]→[21.1166:1214](∅→∅)

fn perform_del<C: ChangeStore, T: MutTxnT>(

[21.1166]

[21.1214]

fn perform_del<C: ChangeStore, T: GraphMutTxnT>(
replacement in libpijul/src/unrecord/mod.rs at line 259

[21.1254]→[21.1254:1288](∅→∅)

channel: &mut Channel<T>,

[21.1254]

[21.1288]

channel: &mut T::Graph,
replacement in libpijul/src/unrecord/mod.rs at line 261

[21.1322]→[21.1322:1379](∅→∅)

) -> Result<(), UnrecordError<C::Error, T::Error>> {

[21.1322]

[21.1379]

) -> Result<(), UnrecordError<C::Error, T::GraphError>> {
replacement in libpijul/src/unrecord/mod.rs at line 275

[22.8203]→[22.9967:10024](∅→∅)

)
.map_err(UnrecordError::Txn)?;

[22.8203]

[22.238504]

)?;
replacement in libpijul/src/unrecord/mod.rs at line 281

[22.238934]→[22.10125:10183](∅→∅)

fn repair_newvertex_contexts<T: MutTxnT, C: ChangeStore>(

[22.238934]

[22.238976]

fn repair_newvertex_contexts<T: GraphMutTxnT, C: ChangeStore>(
replacement in libpijul/src/unrecord/mod.rs at line 283

[22.238993]→[22.238993:239023](∅→∅)

channel: &mut Channel<T>,

[22.238993]

[22.239023]

channel: &mut T::Graph,
replacement in libpijul/src/unrecord/mod.rs at line 286

[21.1508]→[22.10184:10237](∅→∅),[22.239047]→[22.10184:10237](∅→∅)

) -> Result<(), UnrecordError<C::Error, T::Error>> {

[21.1508]

[22.239080]

) -> Result<(), UnrecordError<C::Error, T::GraphError>> {
replacement in libpijul/src/unrecord/mod.rs at line 289

[22.239152]→[22.8220:8260](∅→∅)

if is_alive(txn, channel, up) {

[22.239152]

[22.239191]

if is_alive(txn, channel, up)? {
replacement in libpijul/src/unrecord/mod.rs at line 309

[22.239740]→[22.239740:239752](∅→∅)

) {

[22.239740]

[22.8316]

)? {
let parent = parent?;
replacement in libpijul/src/unrecord/mod.rs at line 312

[22.8385]→[22.8385:8434](∅→∅)

if !is_alive(txn, channel, parent) {

[22.8385]

[21.1553]

if !is_alive(txn, channel, parent)? {
replacement in libpijul/src/unrecord/mod.rs at line 332

[22.10239]→[22.240360:240406](∅→∅),[22.240360]→[22.240360:240406](∅→∅)

fn unapply_edges<T: MutTxnT, P: ChangeStore>(

[22.10239]

[22.240406]

fn unapply_edges<T: GraphMutTxnT, P: ChangeStore>(
replacement in libpijul/src/unrecord/mod.rs at line 335

[22.240440]→[22.240440:240470](∅→∅)

channel: &mut Channel<T>,

[22.240440]

[22.240470]

channel: &mut T::Graph,
replacement in libpijul/src/unrecord/mod.rs at line 339

[22.240557]→[22.10240:10293](∅→∅)

) -> Result<(), UnrecordError<P::Error, T::Error>> {

[22.240557]

[22.240590]

) -> Result<(), UnrecordError<P::Error, T::GraphError>> {
replacement in libpijul/src/unrecord/mod.rs at line 341

[22.240632]→[22.240632:240684](∅→∅)

let ext = txn.get_external(change_id).unwrap();

[22.240632]

[22.240757]

let ext = txn.get_external(change_id)?.unwrap();
replacement in libpijul/src/unrecord/mod.rs at line 343

[22.240797]→[21.1710:1786](∅→∅)

let intro = internal(txn, &edge.introduced_by, change_id).unwrap();

[22.240797]

[22.240940]

let intro = internal(txn, &edge.introduced_by, change_id)?.unwrap();
replacement in libpijul/src/unrecord/mod.rs at line 359

[22.241975]→[22.241975:242021](∅→∅)

fn must_reintroduce<T: TxnT, C: ChangeStore>(

[22.241975]

[22.242021]

fn must_reintroduce<T: GraphTxnT, C: ChangeStore>(
replacement in libpijul/src/unrecord/mod.rs at line 361

[22.242034]→[22.242034:242060](∅→∅)

channel: &Channel<T>,

[22.242034]

[22.242060]

channel: &T::Graph,
replacement in libpijul/src/unrecord/mod.rs at line 368

[21.1958]→[22.10378:10444](∅→∅),[22.242168]→[22.10378:10444](∅→∅)

) -> Result<bool, crate::apply::ApplyError<C::Error, T::Error>> {

[21.1958]

[22.242203]

) -> Result<bool, UnrecordError<C::Error, T::GraphError>> {
replacement in libpijul/src/unrecord/mod.rs at line 373

[22.242373]→[22.242373:242417](∅→∅)

change: txn.get_external(b.change),

[22.242373]

[22.242417]

change: txn.get_external(b.change)?,
replacement in libpijul/src/unrecord/mod.rs at line 377

[22.242478]→[21.1959:2185](∅→∅),[21.2185]→[22.8706:8715](∅→∅),[22.8706]→[22.8706:8715](∅→∅)

for e in iter_adj_all(txn, channel, a).filter(|e| {
!e.flag.contains(EdgeFlags::PARENT)
&& e.dest == b.start_pos()
&& !e.introduced_by.is_root()
&& e.introduced_by != current_id
}) {

[22.242478]

[21.2186]

for e in iter_adj_all(txn, channel, a)? {
let e = e?;
if e.flag.contains(EdgeFlags::PARENT)
|| e.dest != b.start_pos()
|| e.introduced_by.is_root()
|| e.introduced_by == current_id
{
continue;
}
edit in libpijul/src/unrecord/mod.rs at line 396

[22.243261]→[22.10445:10501](∅→∅)

.map_err(crate::apply::ApplyError::Changestore)
replacement in libpijul/src/unrecord/mod.rs at line 398

[22.243264]→[22.243264:243312](∅→∅)

fn edge_is_in_channel<T: TxnT, C: ChangeStore>(

[22.243264]

[22.243312]

fn edge_is_in_channel<T: GraphTxnT, C: ChangeStore>(
replacement in libpijul/src/unrecord/mod.rs at line 404

[22.243431]→[22.10502:10532](∅→∅)

) -> Result<bool, C::Error> {

[22.243431]

[22.243466]

) -> Result<bool, UnrecordError<C::Error, T::GraphError>> {
replacement in libpijul/src/unrecord/mod.rs at line 411

[22.243640]→[22.243640:243728](∅→∅)

for next in changes.change_deletes_position(|c| txn.get_external(c), s, pos)? {

[22.243640]

[22.243728]

for next in changes
.change_deletes_position(|c| txn.get_external(c).unwrap(), s, pos)
.map_err(UnrecordError::Changestore)?
{
replacement in libpijul/src/unrecord/mod.rs at line 417

[22.243801]→[22.243801:243862](∅→∅)

} else if let Some(i) = txn.get_internal(next) {

[22.243801]

[22.243862]

} else if let Some(i) = txn.get_internal(next)? {
replacement in libpijul/src/unrecord/mod.rs at line 425

[22.243938]→[22.10533:10580](∅→∅)

fn remove_zombies<T: MutTxnT, C: ChangeStore>(

[22.243938]

[22.243969]

fn remove_zombies<T: GraphMutTxnT, C: ChangeStore>(
replacement in libpijul/src/unrecord/mod.rs at line 427

[22.243986]→[22.243986:244016](∅→∅)

channel: &mut Channel<T>,

[22.243986]

[21.2508]

channel: &mut T::Graph,
replacement in libpijul/src/unrecord/mod.rs at line 431

[22.244079]→[22.10581:10634](∅→∅)

) -> Result<(), UnrecordError<C::Error, T::Error>> {

[22.244079]

[22.244208]

) -> Result<(), UnrecordError<C::Error, T::GraphError>> {
replacement in libpijul/src/unrecord/mod.rs at line 441

[21.2745]→[21.2745:2876](∅→∅)

del_graph_with_rev(txn, channel, e.flag, u, v, e.introduced_by)
.map_err(UnrecordError::Txn)?;

[21.2745]

[22.246602]

del_graph_with_rev(txn, channel, e.flag, u, v, e.introduced_by)?;
replacement in libpijul/src/unrecord/mod.rs at line 444

[22.9860]→[22.10829:10960](∅→∅)

del_graph_with_rev(txn, channel, e.flag, v, w, e.introduced_by)
.map_err(UnrecordError::Txn)?;

[22.9860]

[22.246762]

del_graph_with_rev(txn, channel, e.flag, v, w, e.introduced_by)?;
replacement in libpijul/src/unrecord/mod.rs at line 451

[22.246806]→[21.2877:2953](∅→∅)

fn collect_zombies<T: TxnT>(
txn: &mut T,
channel: &mut Channel<T>,

[22.246806]

[21.2953]

fn collect_zombies<T: GraphTxnT>(
txn: &T,
channel: &T::Graph,
replacement in libpijul/src/unrecord/mod.rs at line 457

[21.3030]→[21.3030:3060](∅→∅)

) -> Result<(), BlockError> {

[21.3030]

[21.3060]

) -> Result<(), BlockError<T::GraphError>> {
replacement in libpijul/src/unrecord/mod.rs at line 464

[21.3265]→[21.3265:3314](∅→∅)

for e in iter_adj_all(txn, channel, v) {

[21.3265]

[21.3314]

for e in iter_adj_all(txn, channel, v)? {
let e = e?;
replacement in libpijul/src/unrecord/mod.rs at line 485

[21.3886]→[22.246861:246914](∅→∅),[22.246861]→[22.246861:246914](∅→∅)

fn repair_edges_context<T: MutTxnT, P: ChangeStore>(

[21.3886]

[22.246914]

fn repair_edges_context<T: GraphMutTxnT, P: ChangeStore>(
replacement in libpijul/src/unrecord/mod.rs at line 488

[22.246948]→[22.246948:246978](∅→∅)

channel: &mut Channel<T>,

[22.246948]

[22.246978]

channel: &mut T::Graph,
replacement in libpijul/src/unrecord/mod.rs at line 492

[22.247082]→[22.10961:11014](∅→∅),[22.11014]→[22.247115:247175](∅→∅),[22.247115]→[22.247115:247175](∅→∅)

) -> Result<(), UnrecordError<P::Error, T::Error>> {
let change_hash = txn.get_external(change_id).unwrap();

[22.247082]

[22.247175]

) -> Result<(), UnrecordError<P::Error, T::GraphError>> {
let change_hash = txn.get_external(change_id)?.unwrap();
replacement in libpijul/src/unrecord/mod.rs at line 496

[22.247259]→[21.3887:3960](∅→∅)

let intro = internal(txn, &e.introduced_by, change_id).unwrap();

[22.247259]

[21.3960]

let intro = internal(txn, &e.introduced_by, change_id)?.unwrap();
replacement in libpijul/src/unrecord/mod.rs at line 511

[22.10222]→[22.10222:10267](∅→∅)

if !is_alive(txn, channel, to) {

[22.10222]

[22.248246]

if !is_alive(txn, channel, to)? {
replacement in libpijul/src/tests/unrecord.rs at line 128

[22.252619]→[22.252619:252654](∅→∅)

.map(|(_, name)| name)

[22.252619]

[22.252654]

.map(|n| n.unwrap().1)
replacement in libpijul/src/tests/unrecord.rs at line 137

[22.252958]→[22.252958:252993](∅→∅)

.map(|(_, name)| name)

[22.252958]

[22.252993]

.map(|n| n.unwrap().1)
replacement in libpijul/src/tests/unrecord.rs at line 314

[22.258535]→[22.10861:10921](∅→∅)

let (alive_, reachable_) = check_alive(&txn, &channel);

[22.258535]

[22.258593]

let (alive_, reachable_) = check_alive(&txn, &channel.borrow().graph);
replacement in libpijul/src/tests/unrecord.rs at line 399

[22.261132]→[22.11125:11185](∅→∅)

let (alive_, reachable_) = check_alive(&txn, &channel);

[22.261132]

[22.261190]

let (alive_, reachable_) = check_alive(&txn, &channel.borrow().graph);
replacement in libpijul/src/tests/unrecord.rs at line 449

[22.262885]→[22.262885:262930](∅→∅)

for p in txn.log(&channel.borrow(), 0) {

[22.262885]

[22.262930]

for p in txn.log(&channel.borrow(), 0).unwrap() {
replacement in libpijul/src/tests/unrecord.rs at line 457

[22.263107]→[22.263107:263152](∅→∅)

for p in txn.log(&channel.borrow(), 0) {

[22.263107]

[22.263152]

for p in txn.log(&channel.borrow(), 0).unwrap() {
replacement in libpijul/src/tests/unrecord.rs at line 938

[22.1754]→[22.1754:1794](∅→∅)

let mut inodes = txn.iter_inodes();

[22.1754]

[22.1794]

let mut inodes = txn.iter_inodes().unwrap();
replacement in libpijul/src/tests/performance.rs at line 53

[22.279859]→[22.279859:279923](∅→∅)

let m = txn.cursor_graph(&channel.graph, None).count();

[22.279859]

[22.279923]

let m = txn.cursor_graph(&channel.graph, None).unwrap().count();
replacement in libpijul/src/tests/performance.rs at line 136

[22.282440]→[22.282440:282504](∅→∅)

let m = txn.cursor_graph(&channel.graph, None).count();

[22.282440]

[22.282504]

let m = txn.cursor_graph(&channel.graph, None).unwrap().count();
replacement in libpijul/src/tests/performance.rs at line 145

[22.282737]→[22.282737:282801](∅→∅)

let m = txn.cursor_graph(&channel.graph, None).count();

[22.282737]

[22.282801]

let m = txn.cursor_graph(&channel.graph, None).unwrap().count();
replacement in libpijul/src/tests/partial.rs at line 35

[22.286507]→[22.286507:286648](∅→∅)

let key = txn.get_inodes(inode, None).unwrap();
let changes: Vec<_> = txn.log_for_path(&channel.borrow(), key, 0).collect();

[22.286507]

[22.286648]

let key = txn.get_inodes(inode, None).unwrap().unwrap();
let changes: Vec<_> = txn
.log_for_path(&channel.borrow(), key, 0)
.unwrap()
.map(|x| x.unwrap())
.collect();
replacement in libpijul/src/tests/mod.rs at line 32

[22.289967]→[22.289967:290043](∅→∅)

state.record(txn, Algorithm::default(), channel, repo, store, prefix)?;

[22.289967]

[22.290043]

state.record(
txn,
Algorithm::default(),
&mut channel.borrow_mut(),
repo,
store,
prefix,
)?;
replacement in libpijul/src/tests/mod.rs at line 45

[22.290134]→[22.290134:290173](∅→∅)

.map(|rec| rec.globalize(txn))

[22.290134]

[22.290173]

.map(|rec| rec.globalize(txn).unwrap())
replacement in libpijul/src/tests/mod.rs at line 62

[22.290724]→[22.290724:290731](∅→∅)

);

[22.290724]

[22.290731]

)
.unwrap();
replacement in libpijul/src/tests/file_conflicts.rs at line 569

[22.322581]→[22.322581:322772](∅→∅)

for x in txn_alice.iter_tree(
OwnedPathId {
parent_inode: Inode::ROOT,
basename: crate::small_string::SmallString::new(),
},
None,
) {

[22.322581]

[22.322772]

for x in txn_alice
.iter_tree(
OwnedPathId {
parent_inode: Inode::ROOT,
basename: crate::small_string::SmallString::new(),
},
None,
)
.unwrap()
{
replacement in libpijul/src/tests/file_conflicts.rs at line 1499

[22.352588]→[22.21701:21771](∅→∅)

let (alive, reachable) = check_alive(&txn_alice, &channel_alice);

[22.352588]

[22.352656]

let (alive, reachable) = check_alive(&txn_alice, &channel_alice.borrow().graph);
replacement in libpijul/src/tests/conflict.rs at line 1124

[22.393790]→[22.393790:393826](∅→∅)

&mut channel_alice,

[22.393790]

[22.393826]

&mut channel_alice.borrow_mut(),
replacement in libpijul/src/tests/conflict.rs at line 2335

[22.30412]→[22.30412:30476](∅→∅)

let (alive_, reachable_) = check_alive(&txn, &channel_bob);

[22.30412]

[22.433556]

let (alive_, reachable_) = check_alive(&txn, &channel_bob.borrow().graph);
replacement in libpijul/src/tests/conflict.rs at line 2352

[22.30539]→[22.30539:30601](∅→∅)

let (alive, reachable) = check_alive(&txn, &channel_bob);

[22.30539]

[22.434046]

let (alive, reachable) = check_alive(&txn, &channel_bob.borrow().graph);
replacement in libpijul/src/tests/conflict.rs at line 2369

[22.30671]→[22.30671:30737](∅→∅)

let (alive, reachable) = check_alive(&txn, &channel_charlie);

[22.30671]

[22.434801]

let (alive, reachable) = check_alive(&txn, &channel_charlie.borrow().graph);
replacement in libpijul/src/tests/conflict.rs at line 2386

[22.435224]→[22.30809:30875](∅→∅)

let (alive, reachable) = check_alive(&txn, &channel_charlie);

[22.435224]

[22.435288]

let (alive, reachable) = check_alive(&txn, &channel_charlie.borrow().graph);
replacement in libpijul/src/tests/conflict.rs at line 2465

[22.437747]→[22.31013:31083](∅→∅)

let (alive, reachable) = check_alive(&txn_alice, &channel_alice);

[22.437747]

[22.437815]

let (alive, reachable) = check_alive(&txn_alice, &channel_alice.borrow().graph);
replacement in libpijul/src/tests/conflict.rs at line 2550

[22.440414]→[22.440414:440461](∅→∅)

for (inode, vertex) in txn.iter_inodes() {

[22.440414]

[22.440461]

for x in txn.iter_inodes().unwrap() {
let (inode, vertex) = x.unwrap();
replacement in libpijul/src/tests/conflict.rs at line 2555

[22.440589]→[22.440589:440653](∅→∅)

if let Some(next) = txn.get_revtree(inode_, None) {

[22.440589]

[22.440653]

if let Some(next) = txn.get_revtree(inode_, None).unwrap() {
replacement in libpijul/src/tests/conflict.rs at line 2562

[22.440857]→[22.31289:31350](∅→∅)

if !is_alive(txn, &channel, vertex.inode_vertex()) {

[22.440857]

[22.31350]

if !is_alive(txn, &channel.graph, vertex.inode_vertex()).unwrap() {
replacement in libpijul/src/tests/conflict.rs at line 2565

[22.31407]→[22.440957:440983](∅→∅),[22.440957]→[22.440957:440983](∅→∅)

&channel,

[22.31407]

[22.440983]

&channel.graph,
replacement in libpijul/src/tests/conflict.rs at line 2569

[22.441092]→[22.441092:441108](∅→∅)

) {

[22.441092]

[22.441108]

)
.unwrap()
{
replacement in libpijul/src/tests/clone.rs at line 37

[22.442660]→[22.442660:442770](∅→∅)

for channel in txn.iter_channels("") {
for (_, (i, _)) in txn.log(&channel.borrow(), 0) {

[22.442660]

[22.442770]

for channel in txn.iter_channels("").unwrap() {
let channel = channel.unwrap();
for x in txn.log(&channel.borrow(), 0).unwrap() {
let (_, (i, _)) = x.unwrap();
replacement in libpijul/src/tests/change.rs at line 48

[22.448033]→[22.448033:448059](∅→∅)

&mut channel,

[22.448033]

[22.448059]

&mut channel.borrow_mut(),
replacement in libpijul/src/tests/change.rs at line 58

[22.448245]→[22.448245:448285](∅→∅)

.map(|rec| rec.globalize(&txn))

[22.448245]

[22.448285]

.map(|rec| rec.globalize(&txn).unwrap())
replacement in libpijul/src/tests/change.rs at line 73

[22.448681]→[22.448681:448688](∅→∅)

);

[22.448681]

[22.448688]

)
.unwrap();
replacement in libpijul/src/tests/change.rs at line 96

[22.449161]→[22.449161:449237](∅→∅)

state.record(txn, Algorithm::default(), channel, repo, store, prefix)?;

[22.449161]

[22.449237]

state.record(
txn,
Algorithm::default(),
&mut channel.borrow_mut(),
repo,
store,
prefix,
)?;
replacement in libpijul/src/tests/change.rs at line 109

[22.449328]→[22.449328:449367](∅→∅)

.map(|rec| rec.globalize(txn))

[22.449328]

[22.449367]

.map(|rec| rec.globalize(txn).unwrap())
replacement in libpijul/src/tests/change.rs at line 126

[22.449926]→[22.449926:449933](∅→∅)

);

[22.449926]

[22.449933]

)
.unwrap();
replacement in libpijul/src/tests/add_file.rs at line 29

[22.455055]→[22.455055:455090](∅→∅)

.map(|(_, name)| name)

[22.455055]

[22.455090]

.map(|n| n.unwrap().1)
replacement in libpijul/src/tests/add_file.rs at line 33

[22.455167]→[22.455167:455225](∅→∅)

let channel_ = txn.load_channel("main").unwrap();

[22.455167]

[22.455225]

let channel_ = txn.load_channel("main").unwrap().unwrap();
replacement in libpijul/src/tests/add_file.rs at line 35

[22.455266]→[22.455266:455413](∅→∅)

let mut it = crate::fs::iter_graph_children(&txn, &changes, &channel, Position::ROOT);
let (key, meta, file) = it.next().unwrap();

[22.455266]

[22.455413]

let mut it =
crate::fs::iter_graph_children(&txn, &changes, &channel.graph, Position::ROOT).unwrap();
let (key, meta, file) = it.next().unwrap().unwrap();
replacement in libpijul/src/tests/add_file.rs at line 41

[22.455516]→[22.455516:455717](∅→∅)

let mut it = crate::fs::iter_graph_children(&txn, &changes, &channel, key);
let (file_key, _, _) = it.next().unwrap();
crate::fs::iter_paths(&txn, &channel_, file_key, |path| {

[22.455516]

[22.455717]

let mut it = crate::fs::iter_graph_children(&txn, &changes, &channel.graph, key).unwrap();
let (file_key, _, _) = it.next().unwrap().unwrap();
crate::fs::iter_paths(&txn, &channel_.borrow().graph, file_key, |path| {
replacement in libpijul/src/tests/add_file.rs at line 50

[22.455890]→[22.455890:455902](∅→∅)

});

[22.455890]

[22.31734]

})
.unwrap();
replacement in libpijul/src/tests/add_file.rs at line 54

[22.455960]→[22.455960:456088](∅→∅)

let mut it = crate::fs::iter_basenames(&txn, &changes, &channel, key);
let (key, _, name) = it.next().unwrap();

[22.455960]

[22.456088]

let mut it = crate::fs::iter_basenames(&txn, &changes, &channel.graph, key).unwrap();
let (key, _, name) = it.next().unwrap().unwrap();
replacement in libpijul/src/tests/add_file.rs at line 59

[22.456200]→[22.456200:456245](∅→∅)

assert!(txn.is_tracked("dir/file"));

[22.456200]

[22.456245]

assert!(txn.is_tracked("dir/file").unwrap());
replacement in libpijul/src/tests/add_file.rs at line 76

[22.456669]→[22.456669:456746](∅→∅)

assert!(txn.is_tracked("dir"));
assert!(txn.is_tracked("dir/file"));

[22.456669]

[22.456746]

assert!(txn.is_tracked("dir").unwrap());
assert!(txn.is_tracked("dir/file").unwrap());
edit in libpijul/src/tests/add_file.rs at line 80

[22.456823]

[22.456823]

.unwrap()
edit in libpijul/src/tests/add_file.rs at line 82

[22.456839]

[22.456839]

.unwrap()
replacement in libpijul/src/tests/add_file.rs at line 85

[22.456896]→[22.456896:456934](∅→∅)

assert!(txn.is_directory(inode));

[22.456896]

[22.456934]

assert!(txn.is_directory(inode).unwrap());
replacement in libpijul/src/tests/add_file.rs at line 88

[22.31831]→[22.457003:457107](∅→∅),[22.457003]→[22.457003:457107](∅→∅)

let mut it = crate::fs::working_copy_children(&txn, inode);
let (name, _) = it.next().unwrap();

[22.31831]

[22.457107]

let mut it = crate::fs::working_copy_children(&txn, inode).unwrap();
let (name, _) = it.next().unwrap().unwrap();
replacement in libpijul/src/tests/add_file.rs at line 114

[22.457925]→[22.457925:457960](∅→∅)

.map(|(_, file)| file)

[22.457925]

[22.457960]

.map(|f| f.unwrap().1)
replacement in libpijul/src/tests/add_file.rs at line 122

[22.458186]→[22.458186:458221](∅→∅)

.map(|(_, name)| name)

[22.458186]

[22.458221]

.map(|n| n.unwrap().1)
replacement in libpijul/src/tests/add_file.rs at line 131

[22.458529]→[22.458529:458564](∅→∅)

.map(|(_, name)| name)

[22.458529]

[22.458564]

.map(|n| n.unwrap().1)
replacement in libpijul/src/tests/add_file.rs at line 139

[22.458778]→[22.458778:458876](∅→∅)

assert!(crate::fs::iter_working_copy(&txn, Inode::ROOT).all(|(_, file)| file != "dir2"));

[22.458778]

[22.458876]

assert!(crate::fs::iter_working_copy(&txn, Inode::ROOT).all(|f| f.unwrap().1 != "dir2"));
replacement in libpijul/src/tests/add_file.rs at line 147

[22.459075]→[22.459075:459110](∅→∅)

.map(|(_, name)| name)

[22.459075]

[22.459110]

.map(|n| n.unwrap().1)
replacement in libpijul/src/tests/add_file.rs at line 172

[22.3597]→[22.3597:3628](∅→∅)

.map(|(_, file)| file)

[22.3597]

[22.3628]

.map(|f| f.unwrap().1)
replacement in libpijul/src/tests/add_file.rs at line 186

[22.4203]→[22.4203:4234](∅→∅)

.map(|(_, name)| name)

[22.4203]

[22.4234]

.map(|n| n.unwrap().1)
replacement in libpijul/src/tests/add_file.rs at line 673

[22.475569]→[22.475569:475591](∅→∅)

&mut channel,

[22.475569]

[22.475591]

&mut channel.borrow_mut(),
replacement in libpijul/src/tests/add_file.rs at line 682

[22.475762]→[22.475762:475784](∅→∅)

&mut channel,

[22.475762]

[22.475784]

&mut channel.borrow_mut(),
replacement in libpijul/src/tests/add_file.rs at line 692

[22.475943]→[22.475943:475989](∅→∅)

.map(|rec| rec.globalize(&txn_alice))

[22.475943]

[22.475989]

.map(|rec| rec.globalize(&txn_alice).unwrap())
replacement in libpijul/src/tests/add_file.rs at line 706

[22.476345]→[22.476345:476352](∅→∅)

);

[22.476345]

[22.476352]

)
.unwrap();
replacement in libpijul/src/tests/add_file.rs at line 720

[22.476642]→[22.33753:33817](∅→∅)

let (alive, reachable) = check_alive(&txn_alice, &channel);

[22.476642]

[22.476704]

let (alive, reachable) = check_alive(&txn_alice, &channel.borrow().graph);
replacement in libpijul/src/tests/add_file.rs at line 774

[22.478478]→[22.478478:478513](∅→∅)

.map(|(_, name)| name)

[22.478478]

[22.478513]

.map(|n| n.unwrap().1)
replacement in libpijul/src/tests/add_file.rs at line 795

[22.479182]→[22.479182:479217](∅→∅)

.map(|(_, name)| name)

[22.479182]

[22.479217]

.map(|n| n.unwrap().1)
replacement in libpijul/src/record.rs at line 28

[22.11461]→[22.11461:11499](∅→∅)

Diff(#[from] diff::DiffError<C>),

[22.11461]

[22.11499]

Diff(#[from] diff::DiffError<C, T>),
edit in libpijul/src/record.rs at line 35

[22.489268]

[22.489268]

impl<
C: std::error::Error + 'static,
W: std::error::Error + 'static,
T: std::error::Error + 'static,
> std::convert::From<TxnErr<T>> for RecordError<C, W, T>
{
fn from(e: TxnErr<T>) -> Self {
RecordError::Txn(e.0)
}
}
replacement in libpijul/src/record.rs at line 150

[22.492241]→[22.492241:492397](∅→∅)

fn get_inodes<T: TxnT>(txn: &T, channel: &Channel<T>, inode: Inode) -> Option<Position<ChangeId>> {
if let Some(vertex) = txn.get_inodes(inode, None) {

[22.492241]

[22.492397]

fn get_inodes<T: ChannelTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>>(
txn: &T,
channel: &Channel<T>,
inode: Inode,
) -> Result<Option<Position<ChangeId>>, TxnErr<T::GraphError>> {
if let Some(vertex) = txn.get_inodes(inode, None)? {
replacement in libpijul/src/record.rs at line 157

[22.492412]→[22.492412:492478](∅→∅)

.get_changeset(&channel.changes, vertex.change, None)

[22.492412]

[22.492478]

.get_changeset(&channel.changes, vertex.change, None)?
replacement in libpijul/src/record.rs at line 160

[22.492511]→[22.492511:492536](∅→∅)

Some(vertex)

[22.492511]

[22.492536]

Ok(Some(vertex))
replacement in libpijul/src/record.rs at line 162

[22.492553]→[22.492553:492570](∅→∅)

None

[22.492553]

[22.492570]

Ok(None)
replacement in libpijul/src/record.rs at line 165

[22.492593]→[22.492593:492606](∅→∅)

None

[22.492593]

[22.492606]

Ok(None)
replacement in libpijul/src/record.rs at line 170

[22.492630]→[22.492630:492700](∅→∅)

pub(crate) fn record<T: MutTxnT, W: WorkingCopy, C: ChangeStore>(

[22.492630]

[22.492700]

pub(crate) fn record<T, W: WorkingCopy, C: ChangeStore>(
replacement in libpijul/src/record.rs at line 174

[22.492781]→[22.492781:492818](∅→∅)

channel: &mut ChannelRef<T>,

[22.492781]

[22.492818]

channel: &mut Channel<T>,
replacement in libpijul/src/record.rs at line 178

[22.492891]→[22.11631:11696](∅→∅)

) -> Result<(), RecordError<C::Error, W::Error, T::Error>> {

[22.492891]

[22.492928]

) -> Result<(), RecordError<C::Error, W::Error, T::GraphError>>
where
T: ChannelTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError> + GraphMutTxnT,
<W as WorkingCopy>::Error: 'static,
{
edit in libpijul/src/record.rs at line 184

[22.492973]→[22.492973:493013](∅→∅)

let channel = channel.borrow();
replacement in libpijul/src/record.rs at line 196

[22.493559]→[22.493559:493589](∅→∅)

&channel,

[22.493559]

[22.493589]

&channel.graph,
replacement in libpijul/src/record.rs at line 200

[22.493696]→[22.493696:493715](∅→∅)

);

[22.493696]

[22.493715]

)?;
replacement in libpijul/src/record.rs at line 202

[22.493753]→[22.493753:493834](∅→∅)

} else if let Some(vertex) = get_inodes(txn, &channel, item.inode) {

[22.493753]

[22.493834]

} else if let Some(vertex) = get_inodes(txn, &channel, item.inode)? {
replacement in libpijul/src/record.rs at line 333

[22.499383]→[22.499383:499456](∅→∅)

fn record_existing_file<T: MutTxnT, W: WorkingCopy, C: ChangeStore>(

[22.499383]

[22.499456]

fn record_existing_file<
T: ChannelTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
W: WorkingCopy,
C: ChangeStore,
>(
replacement in libpijul/src/record.rs at line 346

[22.499681]→[22.11806:11871](∅→∅)

) -> Result<(), RecordError<C::Error, W::Error, T::Error>> {

[22.499681]

[22.499718]

) -> Result<(), RecordError<C::Error, W::Error, T::GraphError>>
where
<W as crate::working_copy::WorkingCopy>::Error: 'static,
{
replacement in libpijul/src/record.rs at line 359

[22.500045]→[22.33988:34069](∅→∅),[22.34069]→[22.500138:500208](∅→∅),[22.500138]→[22.500138:500208](∅→∅)

for name_ in iter_adjacent(txn, &channel, vertex.inode_vertex(), f0, f1)
.filter(|e| e.flag.contains(EdgeFlags::PARENT))
{

[22.500045]

[22.500208]

for name_ in iter_adjacent(txn, &channel.graph, vertex.inode_vertex(), f0, f1)? {
let name_ = name_?;
if !name_.flag.contains(EdgeFlags::PARENT) {
continue;
}
replacement in libpijul/src/record.rs at line 370

[22.500452]→[22.34070:34150](∅→∅)

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

[22.500452]

[22.500531]

let name_dest = find_block_end(txn, &channel.graph, name_.dest).unwrap();
replacement in libpijul/src/record.rs at line 373

[22.11892]→[22.11892:11969](∅→∅)

.get_contents(|p| txn.get_external(p), name_dest, &mut name)

[22.11892]

[22.11969]

.get_contents(|p| txn.get_external(p).unwrap(), name_dest, &mut name)
replacement in libpijul/src/record.rs at line 379

[22.500926]→[22.34151:34242](∅→∅)

if let Some(v_papa) = iter_adjacent(txn, &channel, name_dest, f0, f1).next() {

[22.500926]

[22.501016]

if let Some(v_papa) = iter_adjacent(txn, &channel.graph, name_dest, f0, f1)?.next() {
let v_papa = v_papa?;
replacement in libpijul/src/record.rs at line 404

[22.501992]→[22.501992:502032](∅→∅)

self.record_moved_file(

[22.501992]

[22.502032]

self.record_moved_file::<_, _, W>(
replacement in libpijul/src/record.rs at line 407

[22.502086]→[22.502086:502116](∅→∅)

&channel,

[22.502086]

[22.502116]

&channel.graph,
replacement in libpijul/src/record.rs at line 412

[22.502254]→[22.12023:12093](∅→∅)

)
.map_err(RecordError::Changestore)?

[22.502254]

[22.502273]

)?
replacement in libpijul/src/record.rs at line 418

[22.502466]→[22.502466:502529](∅→∅)

let mut ret = retrieve(txn, &channel, vertex);

[22.502466]

[22.502529]

let mut ret = retrieve(txn, &channel.graph, vertex)?;
replacement in libpijul/src/record.rs at line 443

[22.503210]→[22.503210:503301](∅→∅)

self.record_deleted_file(txn, &channel, working_copy, &item.full_path, vertex)

[22.503210]

[22.503301]

self.record_deleted_file(txn, &channel.graph, working_copy, &item.full_path, vertex)?
replacement in libpijul/src/record.rs at line 448

[22.503333]→[8.383:444](∅→∅)

fn delete_obsolete_children<T: MutTxnT, W: WorkingCopy>(

[22.503333]

[22.503398]

fn delete_obsolete_children<
T: GraphTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
W: WorkingCopy,
>(
replacement in libpijul/src/record.rs at line 454

[22.503434]→[22.503434:503464](∅→∅)

channel: &Channel<T>,

[22.503434]

[22.503464]

channel: &T::Graph,
replacement in libpijul/src/record.rs at line 458

[22.503546]→[22.503546:503554](∅→∅)

) {

[22.503546]

[22.503554]

) -> Result<(), TxnErr<T::GraphError>> {
replacement in libpijul/src/record.rs at line 462

[22.503681]→[22.34243:34469](∅→∅)

for child in iter_adjacent(txn, &channel, v.inode_vertex(), f0, f1) {
let child = find_block(txn, &channel, child.dest).unwrap();
for grandchild in iter_adjacent(txn, &channel, child, f0, f1) {

[22.503681]

[22.503904]

for child in iter_adjacent(txn, channel, v.inode_vertex(), f0, f1)? {
let child = child?;
let child = find_block(txn, channel, child.dest).unwrap();
for grandchild in iter_adjacent(txn, channel, child, f0, f1)? {
let grandchild = grandchild?;
replacement in libpijul/src/record.rs at line 468

[22.503959]→[22.503959:504146](∅→∅),[22.504146]→[5.0:147](∅→∅)

let needs_deletion = if let Some(inode) = txn.get_revinodes(grandchild.dest, None) {
debug!("inode = {:?} {:?}", inode, txn.get_revtree(inode, None));
if let Some(path) = crate::fs::inode_filename(txn, inode) {
working_copy.file_metadata(&path).is_err()

[22.503959]

[5.147]

let needs_deletion =
if let Some(inode) = txn.get_revinodes(grandchild.dest, None)? {
debug!("inode = {:?} {:?}", inode, txn.get_revtree(inode, None));
if let Some(path) = crate::fs::inode_filename(txn, inode)? {
working_copy.file_metadata(&path).is_err()
} else {
true
}
replacement in libpijul/src/record.rs at line 478

[5.205]→[5.205:227](∅→∅),[5.227]→[22.504205:504274](∅→∅),[22.504205]→[22.504205:504274](∅→∅)

}
} else {
true
};

[5.205]

[22.504274]

};
replacement in libpijul/src/record.rs at line 487

[22.504576]→[22.504576:504598](∅→∅)

)

[22.504576]

[22.504598]

)?
edit in libpijul/src/record.rs at line 491

[22.504640]

[22.504640]

Ok(())
replacement in libpijul/src/record.rs at line 494

[22.504647]→[22.12237:12307](∅→∅)

fn push_children<'a, T: MutTxnT, W: WorkingCopy, C: ChangeStore>(

[22.504647]

[22.504701]

fn push_children<
'a,
T: ChannelTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
W: WorkingCopy,
C: ChangeStore,
>(
replacement in libpijul/src/record.rs at line 508

[22.504935]→[22.12308:12373](∅→∅)

) -> Result<(), RecordError<C::Error, W::Error, T::Error>> {

[22.504935]

[22.504972]

) -> Result<(), RecordError<C::Error, W::Error, T::GraphError>>
where
<W as crate::working_copy::WorkingCopy>::Error: 'static,
{
replacement in libpijul/src/record.rs at line 519

[22.505236]→[22.505236:505312](∅→∅)

for (fileid_, child_inode) in txn.iter_tree(fileid.clone(), None) {

[22.505236]

[22.505312]

for x in txn.iter_tree(fileid.clone(), None)? {
let (fileid_, child_inode) = x?;
replacement in libpijul/src/record.rs at line 549

[22.506445]→[22.506445:506617](∅→∅)

} else if let Some(vertex) = get_inodes(txn, &channel, child_inode) {
self.record_deleted_file(txn, &channel, working_copy, &full_path, vertex)

[22.506445]

[22.506617]

} else if let Some(vertex) = get_inodes(txn, &channel, child_inode)? {
self.record_deleted_file(txn, &channel.graph, working_copy, &full_path, vertex)?
replacement in libpijul/src/record.rs at line 561

[22.506910]→[22.506910:506966](∅→∅)

fn modified_since_last_commit<T: TxnT, W: WorkingCopy>(

[22.506855]

[22.506966]

fn modified_since_last_commit<T: ChannelTxnT, W: WorkingCopy>(
replacement in libpijul/src/record.rs at line 585

[22.507625]→[22.507625:507676](∅→∅)

fn record_moved_file<T: TxnT, C: ChangeStore>(

[22.507625]

[22.507676]

fn record_moved_file<T: GraphTxnT, C: ChangeStore, W: WorkingCopy>(
replacement in libpijul/src/record.rs at line 589

[22.507733]→[22.507733:507763](∅→∅)

channel: &Channel<T>,

[22.507733]

[22.507763]

channel: &T::Graph,
replacement in libpijul/src/record.rs at line 594

[22.507905]→[22.12496:12528](∅→∅)

) -> Result<(), C::Error> {

[22.507905]

[22.507942]

) -> Result<(), RecordError<C::Error, W::Error, T::GraphError>>
where
<W as crate::working_copy::WorkingCopy>::Error: 'static,
{
replacement in libpijul/src/record.rs at line 605

[22.508507]→[22.508507:508552](∅→∅)

let mut moved = collect_moved_edges(

[22.508444]

[22.508552]

let mut moved = collect_moved_edges::<_, _, W>(
replacement in libpijul/src/record.rs at line 672

[22.510763]→[22.510763:510812](∅→∅)

fn collect_moved_edges<T: TxnT, C: ChangeStore>(

[22.510763]

[22.510812]

fn collect_moved_edges<T: GraphTxnT, C: ChangeStore, W: WorkingCopy>(
replacement in libpijul/src/record.rs at line 675

[22.510842]→[22.510842:510868](∅→∅)

channel: &Channel<T>,

[22.510842]

[22.510868]

channel: &T::Graph,
replacement in libpijul/src/record.rs at line 681

[22.511024]→[22.12592:12628](∅→∅)

) -> Result<MovedEdges, C::Error> {

[22.511024]

[22.511065]

) -> Result<MovedEdges, RecordError<C::Error, W::Error, T::GraphError>>
where
<W as crate::working_copy::WorkingCopy>::Error: 'static,
{
replacement in libpijul/src/record.rs at line 701

[22.34642]→[22.34642:34720](∅→∅),[22.34720]→[22.511660:511666](∅→∅),[22.511660]→[22.511660:511666](∅→∅)

)
.filter(|e| e.flag.contains(EdgeFlags::FOLDER | EdgeFlags::PARENT))
{

[22.34642]

[22.511729]

)? {
let parent = parent?;
if !parent.flag.contains(EdgeFlags::FOLDER | EdgeFlags::PARENT) {
continue;
}
replacement in libpijul/src/record.rs at line 730

[22.512793]→[22.34721:34800](∅→∅),[22.34800]→[22.512871:512960](∅→∅),[22.512871]→[22.512871:512960](∅→∅)

let parent_dest = find_block_end(txn, &channel, parent.dest).unwrap();
changes.get_contents(|p| txn.get_external(p), parent_dest, &mut previous_name)?;

[22.512793]

[22.512960]

let parent_dest = find_block_end(txn, channel, parent.dest).unwrap();
changes
.get_contents(
|p| txn.get_external(p).unwrap(),
parent_dest,
&mut previous_name,
)
.map_err(RecordError::Changestore)?;
replacement in libpijul/src/record.rs at line 752

[22.34987]→[22.34987:35154](∅→∅)

)
.filter(|e| {
e.flag.contains(EdgeFlags::FOLDER | EdgeFlags::PARENT)
&& !e.flag.contains(EdgeFlags::PSEUDO)
}) {

[22.34987]

[22.513762]

)? {
let grandparent = grandparent?;
if !grandparent
.flag
.contains(EdgeFlags::FOLDER | EdgeFlags::PARENT)
|| grandparent.flag.contains(EdgeFlags::PSEUDO)
{
continue;
}
replacement in libpijul/src/record.rs at line 762

[22.513816]→[22.35155:35248](∅→∅)

let grandparent_dest = find_block_end(txn, &channel, grandparent.dest).unwrap();

[22.513816]

[22.513908]

let grandparent_dest = find_block_end(txn, channel, grandparent.dest).unwrap();
replacement in libpijul/src/record.rs at line 864

[22.518341]→[22.518341:518394](∅→∅)

fn record_deleted_file<T: TxnT, W: WorkingCopy>(

[22.518341]

[22.518394]

fn record_deleted_file<
T: GraphTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
W: WorkingCopy,
>(
replacement in libpijul/src/record.rs at line 870

[22.518430]→[22.518430:518460](∅→∅)

channel: &Channel<T>,

[22.518430]

[22.518460]

channel: &T::Graph,
replacement in libpijul/src/record.rs at line 874

[22.518555]→[22.518555:518563](∅→∅)

) {

[22.518555]

[22.518563]

) -> Result<(), TxnErr<T::GraphError>> {
replacement in libpijul/src/record.rs at line 880

[22.518868]→[22.35249:35318](∅→∅)

if let Some(path) = tree_path(txn, vertex.start_pos()) {

[22.518868]

[22.518936]

if let Some(path) = tree_path(txn, vertex.start_pos())? {
replacement in libpijul/src/record.rs at line 889

[22.519190]→[22.519190:519257](∅→∅)

self.delete_file_edge(txn, channel, vertex, inode)

[22.519190]

[22.3339]

self.delete_file_edge(txn, channel, vertex, inode)?
replacement in libpijul/src/record.rs at line 896

[22.3605]→[22.3605:3688](∅→∅)

if let Some(inode) = txn.get_revinodes(vertex.start_pos(), None) {

[22.3605]

[22.3688]

if let Some(inode) = txn.get_revinodes(vertex.start_pos(), None)? {
replacement in libpijul/src/record.rs at line 907

[22.520253]→[22.4120:4214](∅→∅)

self.delete_inode_vertex(txn, channel, vertex, vertex.start_pos(), full_path)

[22.520253]

[22.520253]

self.delete_inode_vertex(txn, channel, vertex, vertex.start_pos(), full_path)?
replacement in libpijul/src/record.rs at line 917

[22.520514]→[22.520514:520530](∅→∅)

) {

[22.520514]

[22.520530]

)? {
let edge = edge?;
replacement in libpijul/src/record.rs at line 921

[22.35407]→[22.35407:35507](∅→∅)

find_block(txn, &channel, edge.dest).expect("delete_recursively, descendants");

[22.35407]

[22.520742]

find_block(txn, channel, edge.dest).expect("delete_recursively, descendants");
edit in libpijul/src/record.rs at line 936

[22.521259]

[22.521259]

Ok(())
replacement in libpijul/src/record.rs at line 939

[22.521266]→[22.521266:521303](∅→∅)

fn delete_inode_vertex<T: TxnT>(

[22.521266]

[22.521303]

fn delete_inode_vertex<T: GraphTxnT>(
replacement in libpijul/src/record.rs at line 942

[22.521339]→[22.521339:521369](∅→∅)

channel: &Channel<T>,

[22.521339]

[22.521369]

channel: &T::Graph,
replacement in libpijul/src/record.rs at line 946

[22.521458]→[22.521458:521466](∅→∅)

) {

[22.521458]

[22.521466]

) -> Result<(), TxnErr<T::GraphError>> {
replacement in libpijul/src/record.rs at line 954

[22.35684]→[22.35684:35822](∅→∅)

)
.filter(|e| e.flag.contains(EdgeFlags::PARENT))
{
assert!(parent.flag.contains(EdgeFlags::PARENT));

[22.35684]

[22.35822]

)? {
let parent = parent?;
if !parent.flag.contains(EdgeFlags::PARENT) {
continue;
}
replacement in libpijul/src/record.rs at line 960

[22.35884]→[22.35884:35967](∅→∅)

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

[22.35884]

[22.35967]

let parent_dest = find_block_end(txn, channel, parent.dest).unwrap();
replacement in libpijul/src/record.rs at line 967

[22.521694]→[22.521694:521708](∅→∅),[22.521708]→[22.36065:36164](∅→∅),[22.36164]→[22.522371:522385](∅→∅),[22.522371]→[22.522371:522385](∅→∅)

)
.filter(|e| e.flag.contains(EdgeFlags::PARENT) && !e.flag.contains(EdgeFlags::PSEUDO))
{

[22.521694]

[22.522385]

)? {
let grandparent = grandparent?;
if !grandparent.flag.contains(EdgeFlags::PARENT)
|| grandparent.flag.contains(EdgeFlags::PSEUDO)
{
continue;
}
edit in libpijul/src/record.rs at line 1005

[22.523734]

[22.523734]

Ok(())
replacement in libpijul/src/record.rs at line 1008

[22.523741]→[22.523741:523775](∅→∅)

fn delete_file_edge<T: TxnT>(

[22.523741]

[22.523775]

fn delete_file_edge<T: GraphTxnT>(
replacement in libpijul/src/record.rs at line 1011

[22.523811]→[22.523811:523841](∅→∅)

channel: &Channel<T>,

[22.523811]

[22.523841]

channel: &T::Graph,
replacement in libpijul/src/record.rs at line 1014

[22.523906]→[22.523906:523914](∅→∅)

) {

[22.523906]

[22.523914]

) -> Result<(), TxnErr<T::GraphError>> {
replacement in libpijul/src/record.rs at line 1032

[22.36386]→[22.36386:36469](∅→∅),[22.36469]→[22.524640:524658](∅→∅),[22.524640]→[22.524640:524658](∅→∅)

)
.filter(|e| !e.flag.contains(EdgeFlags::PSEUDO))
{

[22.36386]

[22.524658]

)? {
let parent = parent?;
if parent.flag.contains(EdgeFlags::PSEUDO) {
continue;
}
edit in libpijul/src/record.rs at line 1049

[22.525209]

[22.525209]

Ok(())
edit in libpijul/src/pristine/sanakirja.rs at line 28

[22.12924]

[22.12924]

}

impl std::convert::From<::sanakirja::CRCError> for SanakirjaError {
fn from(_: ::sanakirja::CRCError) -> Self {
SanakirjaError::PristineCorrupt
}
}

impl std::convert::From<::sanakirja::CRCError> for TxnErr<SanakirjaError> {
fn from(_: ::sanakirja::CRCError) -> Self {
TxnErr(SanakirjaError::PristineCorrupt)
}
}

impl std::convert::From<::sanakirja::Error> for TxnErr<SanakirjaError> {
fn from(e: ::sanakirja::Error) -> Self {
TxnErr(e.into())
}
}

impl std::convert::From<TxnErr<::sanakirja::Error>> for TxnErr<SanakirjaError> {
fn from(e: TxnErr<::sanakirja::Error>) -> Self {
TxnErr(e.0.into())
}
replacement in libpijul/src/pristine/sanakirja.rs at line 278

[22.539439]→[22.539439:539516](∅→∅)

for (a, (g, c, r, s, _, _)) in self.txn.iter(&self.channels, None) {

[22.539439]

[22.539516]

for x in self.txn.iter(&self.channels, None).unwrap() {
let (a, (g, c, r, s, _, _)) = x.unwrap();
replacement in libpijul/src/pristine/sanakirja.rs at line 292

[22.540004]→[22.540004:540071](∅→∅)

for (a, (u, v, w)) in self.txn.iter(&self.remotes, None) {

[22.540004]

[22.540071]

for x in self.txn.iter(&self.remotes, None).unwrap() {
let (a, (u, v, w)) = x.unwrap();
replacement in libpijul/src/pristine/sanakirja.rs at line 309

[22.540597]→[22.540597:540674](∅→∅)

for (a, (g, c, r, s, _, _)) in self.txn.iter(&self.channels, None) {

[22.540597]

[22.540674]

for x in self.txn.iter(&self.channels, None).unwrap() {
let (a, (g, c, r, s, _, _)) = x.unwrap();
replacement in libpijul/src/pristine/sanakirja.rs at line 356

[22.542222]→[22.542222:542281](∅→∅),[22.542281]→[22.13666:13699](∅→∅)

impl<T: ::sanakirja::Transaction> TxnT for GenericTxn<T> {
type Error = SanakirjaError;

[22.542222]

[22.542300]

impl<T: ::sanakirja::Transaction> GraphTxnT for GenericTxn<T> {
edit in libpijul/src/pristine/sanakirja.rs at line 358

[22.542345]

[22.542345]

type GraphError = SanakirjaError;
replacement in libpijul/src/pristine/sanakirja.rs at line 361

[22.542403]→[22.542403:542455](∅→∅),[22.542474]→[22.542474:542532](∅→∅)

sanakirja_get!(graph, Vertex<ChangeId>, Edge);

fn get_external(&self, p: ChangeId) -> Option<Hash> {

[22.542403]

[22.542532]

sanakirja_get!(graph, Vertex<ChangeId>, Edge, GraphError);
fn get_external(&self, p: ChangeId) -> Result<Option<Hash>, TxnErr<Self::GraphError>> {
replacement in libpijul/src/pristine/sanakirja.rs at line 364

[22.542557]→[22.542557:542586](∅→∅)

Some(Hash::None)

[22.542557]

[22.542586]

Ok(Some(Hash::None))
} else if let Ok(x) = self.txn.get(&self.external, p, None) {
Ok(x)
replacement in libpijul/src/pristine/sanakirja.rs at line 368

[22.542603]→[22.542603:542653](∅→∅)

self.txn.get(&self.external, p, None)

[22.542603]

[22.542653]

Err(TxnErr(SanakirjaError::PristineCorrupt))
replacement in libpijul/src/pristine/sanakirja.rs at line 372

[22.36940]→[22.542688:542746](∅→∅),[22.542688]→[22.542688:542746](∅→∅)

fn get_internal(&self, p: Hash) -> Option<ChangeId> {

[22.36940]

[22.542746]

fn get_internal(&self, p: Hash) -> Result<Option<ChangeId>, TxnErr<Self::GraphError>> {
replacement in libpijul/src/pristine/sanakirja.rs at line 374

[22.542778]→[22.542778:542811](∅→∅)

Some(ChangeId::ROOT)

[22.542778]

[22.542811]

Ok(Some(ChangeId::ROOT))
} else if let Ok(x) = self.txn.get(&self.internal, p, None) {
Ok(x)
replacement in libpijul/src/pristine/sanakirja.rs at line 378

[22.542828]→[22.542828:542878](∅→∅)

self.txn.get(&self.internal, p, None)

[22.542828]

[22.542878]

Err(TxnErr(SanakirjaError::PristineCorrupt))
edit in libpijul/src/pristine/sanakirja.rs at line 381

[22.542894]

[22.542894]

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

[22.542895]→[22.13700:13794](∅→∅),[22.13794]→[22.542980:543067](∅→∅),[22.542980]→[22.542980:543067](∅→∅),[22.543067]→[22.13795:13865](∅→∅),[22.13865]→[22.543147:543716](∅→∅),[22.543147]→[22.543147:543716](∅→∅),[22.543716]→[22.13866:13948](∅→∅),[22.13948]→[22.543884:544005](∅→∅),[22.543884]→[22.543884:544005](∅→∅),[22.544005]→[22.13949:14014](∅→∅),[22.14014]→[22.544126:544136](∅→∅),[22.544126]→[22.544126:544136](∅→∅)

fn hash_from_prefix(&self, s: &str) -> Result<(Hash, ChangeId), super::HashPrefixError> {
let h = if let Some(h) = Hash::from_prefix(s) {
h
} else {
return Err(super::HashPrefixError::Parse(s.to_string()));
};
let mut result = None;
debug!("h = {:?}", h);
for (e, i) in self.txn.iter(&self.internal, Some((h, None))) {
debug!("{:?} {:?}", e, i);
if e < h {
continue;
} else {
let b32 = e.to_base32();
debug!("{:?}", b32);
let (b32, _) = b32.split_at(s.len().min(b32.len()));
if b32 != s {
break;
} else if result.is_none() {
result = Some((e, i))
} else {
return Err(super::HashPrefixError::Ambiguous(s.to_string()));
}
}
}
if let Some(result) = result {
Ok(result)
} else {
Err(super::HashPrefixError::NotFound(s.to_string()))
}

[22.542895]

[22.544136]

impl<T: ::sanakirja::Transaction> ChannelTxnT for GenericTxn<T> {
type Changeset = Db<ChangeId, u64>;

type Revchangeset = Db<u64, (ChangeId, Merkle)>;

type Channelstates = Db<Merkle, u64>;
sanakirja_get!(changeset, ChangeId, u64, GraphError);
sanakirja_get!(revchangeset, u64, (ChangeId, Merkle), GraphError);
sanakirja_cursor!(changeset, ChangeId, u64);
sanakirja_cursor_ref!(revchangeset, u64, (ChangeId, Merkle));
sanakirja_rev_cursor!(revchangeset, u64, (ChangeId, Merkle));
}

impl<T: ::sanakirja::Transaction> DepsTxnT for GenericTxn<T> {
type DepsError = SanakirjaError;
type Dep = Db<ChangeId, ChangeId>;
type Revdep = Db<ChangeId, ChangeId>;

sanakirja_table_get!(dep, ChangeId, ChangeId, DepsError);
sanakirja_table_get!(revdep, ChangeId, ChangeId, DepsError);
sanakirja_cursor_ref!(dep, ChangeId, ChangeId);
fn iter_dep_ref<RT: std::ops::Deref<Target = Self> + Clone>(
txn: RT,
p: ChangeId,
) -> Result<super::Cursor<Self, RT, Self::DepCursor, ChangeId, ChangeId>, TxnErr<Self::DepsError>>
{
Self::cursor_dep_ref(txn.clone(), &txn.dep, Some((p, None)))
edit in libpijul/src/pristine/sanakirja.rs at line 411

[22.544142]

[22.544142]

sanakirja_table_get!(touched_files, Position<ChangeId>, ChangeId, DepsError);
sanakirja_table_get!(rev_touched_files, ChangeId, Position<ChangeId>, DepsError);

type Touched_files = Db<Position<ChangeId>, ChangeId>;
replacement in libpijul/src/pristine/sanakirja.rs at line 417

[22.544143]→[22.544143:544252](∅→∅),[22.544252]→[22.14015:14063](∅→∅),[22.14063]→[22.544291:544416](∅→∅),[22.544291]→[22.544291:544416](∅→∅),[22.544416]→[22.14064:14134](∅→∅),[22.14134]→[22.544496:545049](∅→∅),[22.544496]→[22.544496:545049](∅→∅),[22.545049]→[22.14135:14217](∅→∅),[22.14217]→[22.545217:545338](∅→∅),[22.545217]→[22.545217:545338](∅→∅),[22.545338]→[22.14218:14283](∅→∅),[22.14283]→[22.545459:545469](∅→∅),[22.545459]→[22.545459:545469](∅→∅)

fn hash_from_prefix_remote<'txn>(
&'txn self,
remote: &RemoteRef<Self>,
s: &str,
) -> Result<Hash, super::HashPrefixError> {
let remote = remote.borrow();
let h = if let Some(h) = Hash::from_prefix(s) {
h
} else {
return Err(super::HashPrefixError::Parse(s.to_string()));
};
let mut result = None;
debug!("h = {:?}", h);
for (e, _) in self.txn.iter(&remote.rev, Some((h, None))) {
debug!("{:?}", e);
if e < h {
continue;
} else {
let b32 = e.to_base32();
debug!("{:?}", b32);
let (b32, _) = b32.split_at(s.len().min(b32.len()));
if b32 != s {
break;
} else if result.is_none() {
result = Some(e)
} else {
return Err(super::HashPrefixError::Ambiguous(s.to_string()));
}
}
}
if let Some(result) = result {
Ok(result)
} else {
Err(super::HashPrefixError::NotFound(s.to_string()))
}

[22.544143]

[22.545469]

type Rev_touched_files = Db<ChangeId, Position<ChangeId>>;
sanakirja_iter!(touched_files, Position<ChangeId>, ChangeId);
sanakirja_iter!(rev_touched_files, ChangeId, Position<ChangeId>);
fn iter_revdep(
&self,
k: ChangeId,
) -> Result<
super::Cursor<Self, &Self, Self::DepCursor, ChangeId, ChangeId>,
TxnErr<Self::DepsError>,
> {
self.cursor_dep(&self.revdep, Some((k, None)))
}

fn iter_dep(
&self,
k: ChangeId,
) -> Result<
super::Cursor<Self, &Self, Self::DepCursor, ChangeId, ChangeId>,
TxnErr<Self::DepsError>,
> {
self.cursor_dep(&self.dep, Some((k, None)))
}

fn iter_touched(
&self,
k: Position<ChangeId>,
) -> Result<
super::Cursor<Self, &Self, Self::Touched_filesCursor, Position<ChangeId>, ChangeId>,
TxnErr<Self::DepsError>,
> {
self.cursor_touched_files(&self.touched_files, Some((k, None)))
edit in libpijul/src/pristine/sanakirja.rs at line 450

[22.545476]

[22.545495]

fn iter_rev_touched(
&self,
k: ChangeId,
) -> Result<
super::Cursor<Self, &Self, Self::Rev_touched_filesCursor, ChangeId, Position<ChangeId>>,
TxnErr<Self::DepsError>,
> {
self.cursor_rev_touched_files(&self.rev_touched_files, Some((k, None)))
}
}

impl<T: ::sanakirja::Transaction> TreeTxnT for GenericTxn<T> {
type TreeError = SanakirjaError;
replacement in libpijul/src/pristine/sanakirja.rs at line 465

[22.617]→[22.545544:545669](∅→∅),[22.545544]→[22.545544:545669](∅→∅)

sanakirja_table_get!(inodes, Inode, Position<ChangeId>);
sanakirja_table_get!(revinodes, Position<ChangeId>, Inode);

[22.617]

[22.545701]

sanakirja_table_get!(inodes, Inode, Position<ChangeId>, TreeError);
sanakirja_table_get!(revinodes, Position<ChangeId>, Inode, TreeError);
replacement in libpijul/src/pristine/sanakirja.rs at line 472

[22.545820]→[22.545820:545909](∅→∅)

sanakirja_table_get!(tree, PathId, Inode, (UnsafePathId::from_fileid(key), value),);

[22.545820]

[22.545909]

sanakirja_table_get!(
tree,
PathId,
Inode,
TreeError,
(UnsafePathId::from_fileid(key), value),
);
edit in libpijul/src/pristine/sanakirja.rs at line 513

[22.546862]

[22.546862]

TreeError,
edit in libpijul/src/pristine/sanakirja.rs at line 524

[22.547109]→[22.547109:547110](∅→∅),[22.547129]→[22.547129:547169](∅→∅),[22.547169]→[22.36943:36944](∅→∅),[22.36944]→[22.547188:547241](∅→∅),[22.547188]→[22.547188:547241](∅→∅)

type Changeset = Db<ChangeId, u64>;

type Revchangeset = Db<u64, (ChangeId, Merkle)>;
edit in libpijul/src/pristine/sanakirja.rs at line 525

[22.36946]→[22.547260:547589](∅→∅),[22.547260]→[22.547260:547589](∅→∅),[22.547608]→[22.547608:547648](∅→∅),[22.547667]→[22.547667:548014](∅→∅),[22.548033]→[22.548033:548208](∅→∅),[22.548208]→[22.2066:2135](∅→∅),[22.2135]→[22.548302:548309](∅→∅),[22.548302]→[22.548302:548309](∅→∅),[22.548328]→[22.548328:548387](∅→∅),[22.548387]→[22.36947:36948](∅→∅),[22.36948]→[22.548406:548606](∅→∅),[22.548406]→[22.548406:548606](∅→∅)

type Channelstates = Db<Merkle, u64>;
sanakirja_get!(changeset, ChangeId, u64);
sanakirja_get!(revchangeset, u64, (ChangeId, Merkle));
sanakirja_cursor!(changeset, ChangeId, u64);
sanakirja_cursor_ref!(revchangeset, u64, (ChangeId, Merkle));
sanakirja_rev_cursor!(revchangeset, u64, (ChangeId, Merkle));

type Dep = Db<ChangeId, ChangeId>;

type Revdep = Db<ChangeId, ChangeId>;

sanakirja_table_get!(dep, ChangeId, ChangeId);
sanakirja_table_get!(revdep, ChangeId, ChangeId);
sanakirja_cursor_ref!(dep, ChangeId, ChangeId);
sanakirja_table_get!(touched_files, Position<ChangeId>, ChangeId);
sanakirja_table_get!(rev_touched_files, ChangeId, Position<ChangeId>);

fn iter_dep_ref<RT: std::ops::Deref<Target = Self> + Clone>(
txn: RT,
p: ChangeId,
) -> super::Cursor<Self, RT, Self::DepCursor, ChangeId, ChangeId> {
Self::cursor_dep_ref(txn.clone(), &txn.dep, Some((p, None)))
}

type Touched_files = Db<Position<ChangeId>, ChangeId>;

type Rev_touched_files = Db<ChangeId, Position<ChangeId>>;
sanakirja_iter!(touched_files, Position<ChangeId>, ChangeId);
sanakirja_iter!(rev_touched_files, ChangeId, Position<ChangeId>);
edit in libpijul/src/pristine/sanakirja.rs at line 540

[22.549082]

[22.549082]

fn iter_inodes(
&self,
) -> Result<
super::Cursor<Self, &Self, Self::InodesCursor, Inode, Position<ChangeId>>,
TxnErr<Self::TreeError>,
> {
self.cursor_inodes(&self.inodes, None)
}

#[cfg(debug_assertions)]
fn iter_revinodes(
&self,
) -> Result<
super::Cursor<Self, &Self, Self::RevinodesCursor, Position<ChangeId>, Inode>,
TxnErr<SanakirjaError>,
> {
self.cursor_revinodes(&self.revinodes, None)
}

fn iter_partials<'txn>(
&'txn self,
k: &str,
) -> Result<
super::Cursor<Self, &'txn Self, Self::PartialsCursor, SmallString, Position<ChangeId>>,
TxnErr<SanakirjaError>,
> {
let k0 = SmallString::from_str(k);
self.cursor_partials(&self.partials, Some((k0, None)))
}
}

impl<T: ::sanakirja::Transaction> TxnT for GenericTxn<T> {
fn hash_from_prefix(
&self,
s: &str,
) -> Result<(Hash, ChangeId), super::HashPrefixError<Self::GraphError>> {
let h = if let Some(h) = Hash::from_prefix(s) {
h
} else {
return Err(super::HashPrefixError::Parse(s.to_string()));
};
let mut result = None;
debug!("h = {:?}", h);
for x in self
.txn
.iter(&self.internal, Some((h, None)))
.map_err(|e| super::HashPrefixError::Txn(e.into()))?
{
let (e, i) = x.map_err(|e| super::HashPrefixError::Txn(e.into()))?;
debug!("{:?} {:?}", e, i);
if e < h {
continue;
} else {
let b32 = e.to_base32();
debug!("{:?}", b32);
let (b32, _) = b32.split_at(s.len().min(b32.len()));
if b32 != s {
break;
} else if result.is_none() {
result = Some((e, i))
} else {
return Err(super::HashPrefixError::Ambiguous(s.to_string()));
}
}
}
if let Some(result) = result {
Ok(result)
} else {
Err(super::HashPrefixError::NotFound(s.to_string()))
}
}
edit in libpijul/src/pristine/sanakirja.rs at line 612

[22.549083]

[22.549083]

fn hash_from_prefix_remote<'txn>(
&'txn self,
remote: &RemoteRef<Self>,
s: &str,
) -> Result<Hash, super::HashPrefixError<Self::GraphError>> {
let remote = remote.borrow();
let h = if let Some(h) = Hash::from_prefix(s) {
h
} else {
return Err(super::HashPrefixError::Parse(s.to_string()));
};
let mut result = None;
debug!("h = {:?}", h);
for x in self
.txn
.iter(&remote.rev, Some((h, None)))
.map_err(|e| super::HashPrefixError::Txn(e.into()))?
{
let (e, _) = x.map_err(|e| super::HashPrefixError::Txn(e.into()))?;
debug!("{:?}", e);
if e < h {
continue;
} else {
let b32 = e.to_base32();
debug!("{:?}", b32);
let (b32, _) = b32.split_at(s.len().min(b32.len()));
if b32 != s {
break;
} else if result.is_none() {
result = Some(e)
} else {
return Err(super::HashPrefixError::Ambiguous(s.to_string()));
}
}
}
if let Some(result) = result {
Ok(result)
} else {
Err(super::HashPrefixError::NotFound(s.to_string()))
}
}
replacement in libpijul/src/pristine/sanakirja.rs at line 655

[22.549091]→[22.549091:549160](∅→∅)

fn load_channel(&self, name: &str) -> Option<ChannelRef<Self>> {

[22.549091]

[22.549160]

fn load_channel(
&self,
name: &str,
) -> Result<Option<ChannelRef<Self>>, TxnErr<Self::GraphError>> {
replacement in libpijul/src/pristine/sanakirja.rs at line 667

[22.549585]→[22.549585:549607](∅→∅)

)

[22.549585]

[22.549607]

)?
replacement in libpijul/src/pristine/sanakirja.rs at line 682

[22.550134]→[22.550134:550167](∅→∅)

return None;

[22.550134]

[22.550167]

return Ok(None);
replacement in libpijul/src/pristine/sanakirja.rs at line 687

[22.550246]→[22.374:430](∅→∅)

self.open_channels.borrow().get(&name).cloned()

[22.550246]

[22.550312]

Ok(self.open_channels.borrow().get(&name).cloned())
replacement in libpijul/src/pristine/sanakirja.rs at line 690

[22.550319]→[22.550319:550386](∅→∅)

fn load_remote(&self, name: &str) -> Option<RemoteRef<Self>> {

[22.550319]

[22.550386]

fn load_remote(&self, name: &str) -> Result<Option<RemoteRef<Self>>, TxnErr<Self::GraphError>> {
replacement in libpijul/src/pristine/sanakirja.rs at line 698

[22.550721]→[22.550721:550741](∅→∅)

) {

[22.550721]

[22.550741]

)? {
replacement in libpijul/src/pristine/sanakirja.rs at line 709

[22.551128]→[22.551128:551161](∅→∅)

return None;

[22.551128]

[22.551161]

return Ok(None);
replacement in libpijul/src/pristine/sanakirja.rs at line 714

[22.551240]→[22.431:486](∅→∅)

self.open_remotes.borrow().get(&name).cloned()

[22.551240]

[22.551305]

Ok(self.open_remotes.borrow().get(&name).cloned())
replacement in libpijul/src/pristine/sanakirja.rs at line 733

[22.551813]→[22.551813:551898](∅→∅)

fn iter_channels<'txn>(&'txn self, start: &str) -> ChannelIterator<'txn, Self> {

[22.551813]

[22.551898]

fn iter_channels<'txn>(
&'txn self,
start: &str,
) -> Result<ChannelIterator<'txn, Self>, TxnErr<Self::GraphError>> {
replacement in libpijul/src/pristine/sanakirja.rs at line 739

[22.552019]→[22.552019:552125](∅→∅)

ChannelIterator {
cursor: self.txn.set_cursors(&self.channels, Some((name, None))).0,

[22.552019]

[22.552125]

Ok(ChannelIterator {
cursor: self.txn.set_cursors(&self.channels, Some((name, None)))?.0,
replacement in libpijul/src/pristine/sanakirja.rs at line 742

[22.552148]→[22.552148:552158](∅→∅)

}

[22.552148]

[22.552158]

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

[22.552611]→[22.552611:552695](∅→∅)

fn iter_remotes<'txn>(&'txn self, start: &str) -> RemotesIterator<'txn, Self> {

[22.552611]

[22.552695]

fn iter_remotes<'txn>(
&'txn self,
start: &str,
) -> Result<RemotesIterator<'txn, Self>, TxnErr<Self::GraphError>> {
replacement in libpijul/src/pristine/sanakirja.rs at line 766

[22.552816]→[22.552816:552921](∅→∅)

RemotesIterator {
cursor: self.txn.set_cursors(&self.remotes, Some((name, None))).0,

[22.552816]

[22.552921]

Ok(RemotesIterator {
cursor: self.txn.set_cursors(&self.remotes, Some((name, None)))?.0,
replacement in libpijul/src/pristine/sanakirja.rs at line 769

[22.552944]→[22.552944:552954](∅→∅)

}

[22.552944]

[22.552954]

})
edit in libpijul/src/pristine/sanakirja.rs at line 772

[22.36950]→[22.2136:2256](∅→∅),[22.2256]→[22.553148:553195](∅→∅),[22.553148]→[22.553148:553195](∅→∅),[22.553195]→[22.553195:553202](∅→∅),[22.553202]→[22.709:738](∅→∅),[22.738]→[8.445:571](∅→∅),[8.571]→[22.880:940](∅→∅),[22.880]→[22.880:940](∅→∅),[22.940]→[22.115:115](∅→∅),[22.115]→[22.2257:2292](∅→∅),[22.553202]→[22.2257:2292](∅→∅),[22.2292]→[22.553267:553288](∅→∅),[22.553267]→[22.553267:553288](∅→∅),[22.553288]→[22.2293:2368](∅→∅),[22.2368]→[22.553368:553430](∅→∅),[22.553368]→[22.553368:553430](∅→∅),[22.553430]→[22.2369:2401](∅→∅),[22.2401]→[22.553492:553513](∅→∅),[22.553492]→[22.553492:553513](∅→∅),[22.553513]→[22.2402:2477](∅→∅),[22.2477]→[22.553593:553652](∅→∅),[22.553593]→[22.553593:553652](∅→∅),[22.553652]→[22.2478:2514](∅→∅),[22.2514]→[22.553718:553749](∅→∅),[22.553718]→[22.553718:553749](∅→∅),[22.553749]→[22.2515:2610](∅→∅),[22.2610]→[22.553853:553932](∅→∅),[22.553853]→[22.553853:553932](∅→∅),[22.553932]→[22.2611:2651](∅→∅),[22.2651]→[22.554002:554023](∅→∅),[22.554002]→[22.554002:554023](∅→∅),[22.554023]→[22.2652:2749](∅→∅),[22.2749]→[22.554125:554218](∅→∅),[22.554125]→[22.554125:554218](∅→∅),[22.554237]→[22.554237:554517](∅→∅)

fn iter_inodes(
&self,
) -> super::Cursor<Self, &Self, Self::InodesCursor, Inode, Position<ChangeId>> {
self.cursor_inodes(&self.inodes, None)
}

#[cfg(debug_assertions)]
fn iter_revinodes(
&self,
) -> super::Cursor<Self, &Self, Self::RevinodesCursor, Position<ChangeId>, Inode> {
self.cursor_revinodes(&self.revinodes, None)
}

fn iter_revdep(
&self,
k: ChangeId,
) -> super::Cursor<Self, &Self, Self::DepCursor, ChangeId, ChangeId> {
self.cursor_dep(&self.revdep, Some((k, None)))
}

fn iter_dep(
&self,
k: ChangeId,
) -> super::Cursor<Self, &Self, Self::DepCursor, ChangeId, ChangeId> {
self.cursor_dep(&self.dep, Some((k, None)))
}

fn iter_touched(
&self,
k: Position<ChangeId>,
) -> super::Cursor<Self, &Self, Self::Touched_filesCursor, Position<ChangeId>, ChangeId> {
self.cursor_touched_files(&self.touched_files, Some((k, None)))
}

fn iter_rev_touched(
&self,
k: ChangeId,
) -> super::Cursor<Self, &Self, Self::Rev_touched_filesCursor, ChangeId, Position<ChangeId>>
{
self.cursor_rev_touched_files(&self.rev_touched_files, Some((k, None)))
}

fn iter_partials<'txn>(
&'txn self,
k: &str,
) -> super::Cursor<Self, &'txn Self, Self::PartialsCursor, SmallString, Position<ChangeId>>
{
let k0 = SmallString::from_str(k);
self.cursor_partials(&self.partials, Some((k0, None)))
}
replacement in libpijul/src/pristine/sanakirja.rs at line 782

[22.554839]→[22.554839:554923](∅→∅)

) -> super::Cursor<Self, &'txn Self, Self::RemoteCursor, u64, (Hash, Merkle)> {

[22.554839]

[22.554923]

) -> Result<
super::Cursor<Self, &'txn Self, Self::RemoteCursor, u64, (Hash, Merkle)>,
TxnErr<Self::GraphError>,
> {
replacement in libpijul/src/pristine/sanakirja.rs at line 793

[22.555087]→[22.555087:555174](∅→∅)

) -> super::RevCursor<Self, &'txn Self, Self::RemoteCursor, u64, (Hash, Merkle)> {

[22.555087]

[22.555174]

) -> Result<
super::RevCursor<Self, &'txn Self, Self::RemoteCursor, u64, (Hash, Merkle)>,
TxnErr<Self::GraphError>,
> {
replacement in libpijul/src/pristine/sanakirja.rs at line 800

[22.555242]→[22.555242:555312](∅→∅)

fn get_remote(&mut self, name: &str) -> Option<RemoteRef<Self>> {

[22.555242]

[22.555312]

fn get_remote(
&mut self,
name: &str,
) -> Result<Option<RemoteRef<Self>>, TxnErr<Self::GraphError>> {
replacement in libpijul/src/pristine/sanakirja.rs at line 811

[22.555647]→[22.555647:555667](∅→∅)

) {

[22.555647]

[22.555667]

)? {
replacement in libpijul/src/pristine/sanakirja.rs at line 822

[22.556054]→[22.556054:556087](∅→∅)

return None;

[22.556054]

[22.556087]

return Ok(None);
replacement in libpijul/src/pristine/sanakirja.rs at line 827

[22.556166]→[22.487:542](∅→∅)

self.open_remotes.borrow().get(&name).cloned()

[22.556166]

[22.556231]

Ok(self.open_remotes.borrow().get(&name).cloned())
replacement in libpijul/src/pristine/sanakirja.rs at line 830

[22.556238]→[22.556238:556369](∅→∅)

fn last_remote(&self, remote: &Self::Remote) -> Option<(u64, (Hash, Merkle))> {
self.txn.rev_iter(remote, None).next()

[22.556238]

[22.556369]

fn last_remote(
&self,
remote: &Self::Remote,
) -> Result<Option<(u64, (Hash, Merkle))>, TxnErr<Self::GraphError>> {
Ok(self.txn.rev_iter(remote, None)?.next().transpose()?)
replacement in libpijul/src/pristine/sanakirja.rs at line 837

[22.556376]→[22.556376:556533](∅→∅),[22.556533]→[22.543:579](∅→∅)

fn get_remote_state(&self, remote: &Self::Remote, n: u64) -> Option<(u64, (Hash, Merkle))> {
self.txn
.iter(remote, Some((n, None)))
.find(|(k, _)| *k >= n)

[22.556376]

[22.556591]

fn get_remote_state(
&self,
remote: &Self::Remote,
n: u64,
) -> Result<Option<(u64, (Hash, Merkle))>, TxnErr<Self::GraphError>> {
for x in self.txn.iter(remote, Some((n, None)))? {
let (k, m) = x?;
if k >= n {
return Ok(Some((k, m)));
}
}
Ok(None)
replacement in libpijul/src/pristine/sanakirja.rs at line 851

[22.556598]→[22.556598:556746](∅→∅)

fn remote_has_change(&self, remote: &RemoteRef<Self>, hash: Hash) -> bool {
self.txn.get(&remote.db.borrow().rev, hash, None).is_some()

[22.556598]

[22.556746]

fn remote_has_change(
&self,
remote: &RemoteRef<Self>,
hash: Hash,
) -> Result<bool, TxnErr<Self::GraphError>> {
Ok(self.txn.get(&remote.db.borrow().rev, hash, None)?.is_some())
replacement in libpijul/src/pristine/sanakirja.rs at line 858

[22.556752]→[22.556752:556898](∅→∅)

fn remote_has_state(&self, remote: &RemoteRef<Self>, m: Merkle) -> bool {
self.txn.get(&remote.db.borrow().states, m, None).is_some()

[22.556752]

[22.556898]

fn remote_has_state(
&self,
remote: &RemoteRef<Self>,
m: Merkle,
) -> Result<bool, TxnErr<Self::GraphError>> {
Ok(self.txn.get(&remote.db.borrow().states, m, None)?.is_some())
replacement in libpijul/src/pristine/sanakirja.rs at line 865

[22.556904]→[22.556904:557051](∅→∅),[22.557051]→[22.557051:557057](∅→∅),[22.557057]→[22.557057:557915](∅→∅),[22.557915]→[22.557915:557921](∅→∅),[22.557921]→[22.557921:558202](∅→∅)

fn channel_has_state(&self, channel: &ChannelRef<Self>, m: Merkle) -> bool {
self.txn.get(&channel.borrow().states, m, None).is_some()
}
}

/*
impl<T> MutTxn<T> {
pub fn with_remote_mut<F: FnMut(&mut Db<u64, (Hash, Merkle)>)>(
&mut self,
name: &str,
mut f: F,
) -> Result<bool, anyhow::Error> {
let name = SmallString::from_str(name);
let name = UnsafeSmallStr::from_small_str(name.as_small_str());
if let Some((mut db0, db1, db2)) = self.txn.get(&self.remotes, name, None) {
f(&mut db0);

let mut db: ::sanakirja::Db<UnsafeSmallStr, (u64, u64, u64)> =
unsafe { std::mem::transmute(self.remotes) };

self.txn.del(&mut self.rng, &mut db, name, None)?;
self.remotes = unsafe { std::mem::transmute(db) };

self.txn
.put(&mut self.rng, &mut self.remotes, name, (db0, db1, db2))?;

Ok(true)
} else {
Ok(false)
}
}

pub fn del_remote(&mut self, name: &str) -> Result<(), anyhow::Error> {
let name = SmallString::from_str(name);
let name = UnsafeSmallStr::from_small_str(name.as_small_str());
self.txn.del(&mut self.rng, &mut self.remotes, name, None)?;
Ok(())

[22.556904]

[22.558202]

fn channel_has_state(
&self,
channel: &ChannelRef<Self>,
m: Merkle,
) -> Result<bool, TxnErr<Self::GraphError>> {
Ok(self.txn.get(&channel.borrow().states, m, None)?.is_some())
edit in libpijul/src/pristine/sanakirja.rs at line 873

[22.558210]→[22.558210:558214](∅→∅),[22.558214]→[22.558214:558872](∅→∅)

*/

impl MutTxnT for MutTxn<()> {
sanakirja_put_del!(internal, Hash, ChangeId);
sanakirja_put_del!(external, ChangeId, Hash);

sanakirja_put_del!(inodes, Inode, Position<ChangeId>);
sanakirja_put_del!(revinodes, Position<ChangeId>, Inode);

sanakirja_put_del!(tree, PathId, Inode, UnsafePathId::from_fileid(k), v);
sanakirja_put_del!(revtree, Inode, PathId, k, UnsafePathId::from_fileid(v),);

sanakirja_put_del!(dep, ChangeId, ChangeId);
sanakirja_put_del!(revdep, ChangeId, ChangeId);
sanakirja_put_del!(touched_files, Position<ChangeId>, ChangeId);
sanakirja_put_del!(rev_touched_files, ChangeId, Position<ChangeId>);
edit in libpijul/src/pristine/sanakirja.rs at line 874

[22.558873]

[22.558892]

impl GraphMutTxnT for MutTxn<()> {
replacement in libpijul/src/pristine/sanakirja.rs at line 880

[22.559008]→[22.14284:14321](∅→∅)

) -> Result<bool, Self::Error> {

[22.559008]

[22.559047]

) -> Result<bool, TxnErr<Self::GraphError>> {
replacement in libpijul/src/pristine/sanakirja.rs at line 889

[22.559250]→[22.14322:14359](∅→∅)

) -> Result<bool, Self::Error> {

[22.559250]

[22.559289]

) -> Result<bool, TxnErr<Self::GraphError>> {
edit in libpijul/src/pristine/sanakirja.rs at line 893

[22.559394]

[22.559394]

sanakirja_put_del!(internal, Hash, ChangeId, GraphError);
sanakirja_put_del!(external, ChangeId, Hash, GraphError);
}
replacement in libpijul/src/pristine/sanakirja.rs at line 897

[22.559395]→[22.14360:14454](∅→∅),[22.14454]→[22.559510:559731](∅→∅),[22.559510]→[22.559510:559731](∅→∅),[22.559731]→[22.36953:36954](∅→∅),[22.36954]→[22.559750:559846](∅→∅),[22.559750]→[22.559750:559846](∅→∅),[22.559846]→[22.14455:14492](∅→∅),[22.14492]→[22.559885:560107](∅→∅),[22.559885]→[22.559885:560107](∅→∅)

fn put_partials(&mut self, k: &str, e: Position<ChangeId>) -> Result<bool, Self::Error> {
let k = SmallString::from_str(k);
Ok(self.txn.put(
&mut self.rng,
&mut self.partials,
UnsafeSmallStr::from_small_str(k.as_small_str()),
e,
)?)
}

fn del_partials(
&mut self,
k: &str,
e: Option<Position<ChangeId>>,
) -> Result<bool, Self::Error> {
let k = SmallString::from_str(k);
Ok(self.txn.del(
&mut self.rng,
&mut self.partials,
UnsafeSmallStr::from_small_str(k.as_small_str()),
e,
)?)
}

[22.559395]

[22.560126]

impl ChannelMutTxnT for MutTxn<()> {
replacement in libpijul/src/pristine/sanakirja.rs at line 904

[22.560268]→[22.14493:14540](∅→∅),[22.14540]→[22.560317:560386](∅→∅),[22.560317]→[22.560317:560386](∅→∅)

) -> Result<Option<Merkle>, Self::Error> {
if self.get_changeset(&channel.changes, p, None).is_none() {

[22.560268]

[22.560386]

) -> Result<Option<Merkle>, TxnErr<Self::GraphError>> {
if self.get_changeset(&channel.changes, p, None)?.is_none() {
replacement in libpijul/src/pristine/sanakirja.rs at line 908

[22.560477]→[22.560477:560596](∅→∅)

let m = if let Some((_, (_, m))) = self.txn.rev_iter(&channel.revchanges, None).next() {
m

[22.560477]

[22.560596]

let m = if let Some(x) = self.txn.rev_iter(&channel.revchanges, None)?.next() {
(x?.1).1
replacement in libpijul/src/pristine/sanakirja.rs at line 915

[22.560719]→[22.560719:560783](∅→∅)

.get_revchangeset(&channel.revchanges, t, None)

[22.560719]

[22.560783]

.get_revchangeset(&channel.revchanges, t, None)?
replacement in libpijul/src/pristine/sanakirja.rs at line 932

[22.561234]→[22.14541:14578](∅→∅)

) -> Result<bool, Self::Error> {

[22.561234]

[22.561273]

) -> Result<bool, TxnErr<Self::GraphError>> {
replacement in libpijul/src/pristine/sanakirja.rs at line 934

[22.561308]→[22.561308:561390](∅→∅)

for (t_, (p, _)) in self.txn.iter(&channel.revchanges, Some((t, None))) {

[22.561308]

[22.561390]

for x in self.txn.iter(&channel.revchanges, Some((t, None)))? {
let (t_, (p, _)) = x?;
replacement in libpijul/src/pristine/sanakirja.rs at line 941

[22.561510]→[22.561510:561597](∅→∅)

for (t_, (_, m_)) in self.txn.rev_iter(&channel.revchanges, Some((t, None))) {

[22.561510]

[22.561597]

for x in self.txn.rev_iter(&channel.revchanges, Some((t, None)))? {
let (t_, (_, m_)) = x?;
replacement in libpijul/src/pristine/sanakirja.rs at line 953

[22.561901]→[22.561901:561962](∅→∅)

m = m.next(&self.get_external(*p).unwrap());

[22.561901]

[22.561962]

m = m.next(&self.get_external(*p)?.unwrap());
edit in libpijul/src/pristine/sanakirja.rs at line 961

[22.562193]

[22.562193]

}
}

impl DepsMutTxnT for MutTxn<()> {
sanakirja_put_del!(dep, ChangeId, ChangeId, DepsError);
sanakirja_put_del!(revdep, ChangeId, ChangeId, DepsError);
sanakirja_put_del!(touched_files, Position<ChangeId>, ChangeId, DepsError);
sanakirja_put_del!(rev_touched_files, ChangeId, Position<ChangeId>, DepsError);
}

impl TreeMutTxnT for MutTxn<()> {
sanakirja_put_del!(inodes, Inode, Position<ChangeId>, TreeError);
sanakirja_put_del!(revinodes, Position<ChangeId>, Inode, TreeError);

sanakirja_put_del!(
tree,
PathId,
Inode,
TreeError,
UnsafePathId::from_fileid(k),
v
);
sanakirja_put_del!(
revtree,
Inode,
PathId,
TreeError,
k,
UnsafePathId::from_fileid(v)
);

fn put_partials(
&mut self,
k: &str,
e: Position<ChangeId>,
) -> Result<bool, TxnErr<Self::TreeError>> {
let k = SmallString::from_str(k);
Ok(self.txn.put(
&mut self.rng,
&mut self.partials,
UnsafeSmallStr::from_small_str(k.as_small_str()),
e,
)?)
edit in libpijul/src/pristine/sanakirja.rs at line 1006

[22.562200]

[22.562200]

fn del_partials(
&mut self,
k: &str,
e: Option<Position<ChangeId>>,
) -> Result<bool, TxnErr<Self::TreeError>> {
let k = SmallString::from_str(k);
Ok(self.txn.del(
&mut self.rng,
&mut self.partials,
UnsafeSmallStr::from_small_str(k.as_small_str()),
e,
)?)
}
}

impl MutTxnT for MutTxn<()> {
replacement in libpijul/src/pristine/sanakirja.rs at line 1027

[22.562319]→[22.14579:14616](∅→∅)

) -> Result<bool, Self::Error> {

[22.562319]

[22.562358]

) -> Result<bool, Self::GraphError> {
replacement in libpijul/src/pristine/sanakirja.rs at line 1034

[22.562607]→[22.14617:14715](∅→∅)

fn del_remote(&mut self, remote: &mut RemoteRef<Self>, k: u64) -> Result<bool, Self::Error> {

[22.562607]

[22.562707]

fn del_remote(
&mut self,
remote: &mut RemoteRef<Self>,
k: u64,
) -> Result<bool, Self::GraphError> {
replacement in libpijul/src/pristine/sanakirja.rs at line 1040

[22.562753]→[22.562753:562823](∅→∅)

if let Some((h, m)) = self.txn.get(&remote.remote, k, None) {

[22.562753]

[22.562823]

if let Some((h, m)) = self.txn.get(&remote.remote, k, None)? {
replacement in libpijul/src/pristine/sanakirja.rs at line 1049

[22.563092]→[22.14716:14812](∅→∅)

fn open_or_create_channel(&mut self, name: &str) -> Result<ChannelRef<Self>, Self::Error> {

[22.563092]

[22.563190]

fn open_or_create_channel(&mut self, name: &str) -> Result<ChannelRef<Self>, Self::GraphError> {
replacement in libpijul/src/pristine/sanakirja.rs at line 1065

[22.563779]→[22.563779:563799](∅→∅)

) {

[22.563779]

[22.563799]

)? {
replacement in libpijul/src/pristine/sanakirja.rs at line 1106

[22.565222]→[22.14813:14873](∅→∅)

) -> Result<ChannelRef<Self>, ForkError<Self::Error>> {

[22.565222]

[22.565273]

) -> Result<ChannelRef<Self>, ForkError<Self::GraphError>> {
edit in libpijul/src/pristine/sanakirja.rs at line 1116

[22.565555]

[22.565555]

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

[22.566578]→[22.15715:15761](∅→∅)

) -> Result<(), ForkError<Self::Error>> {

[22.566578]

[22.566615]

) -> Result<(), ForkError<Self::GraphError>> {
edit in libpijul/src/pristine/sanakirja.rs at line 1162

[22.566855]

[22.566855]

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

[22.567504]→[22.16141:16215](∅→∅)

fn drop_channel(&mut self, name: &str) -> Result<bool, Self::Error> {

[22.567504]

[22.567580]

fn drop_channel(&mut self, name: &str) -> Result<bool, Self::GraphError> {
replacement in libpijul/src/pristine/sanakirja.rs at line 1207

[22.567999]→[22.16216:16310](∅→∅)

fn open_or_create_remote(&mut self, name: &str) -> Result<RemoteRef<Self>, Self::Error> {

[22.567999]

[22.568095]

fn open_or_create_remote(&mut self, name: &str) -> Result<RemoteRef<Self>, Self::GraphError> {
replacement in libpijul/src/pristine/sanakirja.rs at line 1216

[22.568483]→[22.568483:568503](∅→∅)

) {

[22.568483]

[22.568503]

)? {
replacement in libpijul/src/pristine/sanakirja.rs at line 1247

[22.569566]→[22.16311:16397](∅→∅)

fn drop_remote(&mut self, remote: RemoteRef<Self>) -> Result<bool, Self::Error> {

[22.569566]

[22.569654]

fn drop_remote(&mut self, remote: RemoteRef<Self>) -> Result<bool, Self::GraphError> {
replacement in libpijul/src/pristine/sanakirja.rs at line 1260

[22.570030]→[22.16398:16477](∅→∅)

fn drop_named_remote(&mut self, name: &str) -> Result<bool, Self::Error> {

[22.570030]

[22.570111]

fn drop_named_remote(&mut self, name: &str) -> Result<bool, Self::GraphError> {
replacement in libpijul/src/pristine/sanakirja.rs at line 1273

[22.570478]→[22.16478:16531](∅→∅)

fn commit(mut self) -> Result<(), Self::Error> {

[22.570478]

[22.570533]

fn commit(mut self) -> Result<(), Self::GraphError> {
replacement in libpijul/src/pristine/sanakirja.rs at line 1312

[22.572085]→[22.572085:572161](∅→∅)

pub fn load_const_channel(&self, name: &str) -> Option<Channel<Self>> {

[22.572085]

[22.572161]

pub fn load_const_channel(&self, name: &str) -> Result<Option<Channel<Self>>, SanakirjaError> {
replacement in libpijul/src/pristine/sanakirja.rs at line 1318

[22.572420]→[22.572420:572459](∅→∅)

) {
Some(Channel {

[22.572420]

[22.572459]

)? {
Ok(Some(Channel {
replacement in libpijul/src/pristine/sanakirja.rs at line 1327

[22.572696]→[22.572696:572711](∅→∅)

})

[22.572696]

[22.572711]

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

[22.572728]→[22.572728:572745](∅→∅)

None

[22.572728]

[22.572745]

Ok(None)
replacement in libpijul/src/pristine/sanakirja.rs at line 1386

[22.574894]→[22.16715:16806](∅→∅)

fn put_remotes(&mut self, remote: RemoteRef<Self>) -> Result<(), ::sanakirja::Error> {

[22.574894]

[22.574980]

fn put_remotes(&mut self, remote: RemoteRef<Self>) -> Result<(), SanakirjaError> {
replacement in libpijul/src/pristine/sanakirja.rs at line 1410

[22.575835]→[22.16807:16900](∅→∅)

fn commit_remote(&mut self, remote: RemoteRef<Self>) -> Result<(), ::sanakirja::Error> {

[22.575835]

[22.575923]

fn commit_remote(&mut self, remote: RemoteRef<Self>) -> Result<(), SanakirjaError> {
replacement in libpijul/src/pristine/mod.rs at line 40

[22.587546]→[22.587546:587576](∅→∅)

pub struct Channel<T: TxnT> {

[22.587546]

[22.587576]

pub struct Channel<T: ChannelTxnT> {
replacement in libpijul/src/pristine/mod.rs at line 50

[22.587807]→[22.587807:587840](∅→∅)

pub struct ChannelRef<T: TxnT> {

[22.587807]

[22.587840]

pub struct ChannelRef<T: ChannelTxnT> {
replacement in libpijul/src/pristine/mod.rs at line 54

[22.587886]→[22.587886:587926](∅→∅)

impl<T: TxnT> Clone for ChannelRef<T> {

[22.587886]

[22.587926]

impl<T: ChannelTxnT> Clone for ChannelRef<T> {
replacement in libpijul/src/pristine/mod.rs at line 60

[22.588006]→[22.588006:588033](∅→∅)

impl<T: TxnT> Channel<T> {

[22.588006]

[22.588033]

impl<T: ChannelTxnT> Channel<T> {
replacement in libpijul/src/pristine/mod.rs at line 66

[21.6577]→[21.6577:6607](∅→∅)

impl<T: MutTxnT> Channel<T> {

[21.6577]

[21.6607]

impl<T: ChannelTxnT> Channel<T> {
replacement in libpijul/src/pristine/mod.rs at line 81

[22.588200]→[22.588200:588230](∅→∅)

impl<T: TxnT> ChannelRef<T> {

[22.588200]

[22.588230]

impl<T: ChannelTxnT> ChannelRef<T> {
replacement in libpijul/src/pristine/mod.rs at line 120

[22.16925]→[22.16925:16952](∅→∅)

pub enum HashPrefixError {

[22.16925]

[22.16952]

pub enum HashPrefixError<T: std::error::Error + 'static> {
edit in libpijul/src/pristine/mod.rs at line 127

[22.17146]

[22.17146]

#[error(transparent)]
Txn(T),
replacement in libpijul/src/pristine/mod.rs at line 139

[22.17347]→[22.589140:589205](∅→∅),[22.589140]→[22.589140:589205](∅→∅),[22.589205]→[22.17348:17407](∅→∅)

/// The trait of immutable transactions.
pub trait TxnT: Sized {
type Error: std::error::Error + Send + Sync + 'static;

[22.17347]

[22.589205]

#[derive(Debug, Error)]
#[error(transparent)]
pub struct TxnErr<E: std::error::Error + 'static>(pub E);

pub trait GraphTxnT: Sized {
type GraphError: std::error::Error + Send + Sync + 'static;
replacement in libpijul/src/pristine/mod.rs at line 146

[22.589224]→[22.589224:589313](∅→∅)

cursor_ref!(graph, Vertex<ChangeId>, Edge);
get!(graph, Vertex<ChangeId>, Edge);

[22.589224]

[22.589313]

cursor_ref!(graph, Vertex<ChangeId>, Edge, GraphError);
get!(graph, Vertex<ChangeId>, Edge, GraphError);
/// Returns the external hash of an internal change identifier, if
/// the change is known.
fn get_external(&self, p: ChangeId) -> Result<Option<Hash>, TxnErr<Self::GraphError>>;

/// Returns the internal change identifier of change with external
/// hash `hash`, if the change is known.
fn get_internal(&self, p: Hash) -> Result<Option<ChangeId>, TxnErr<Self::GraphError>>;
}
edit in libpijul/src/pristine/mod.rs at line 157

[22.589314]

[22.589314]

pub trait ChannelTxnT: GraphTxnT {
replacement in libpijul/src/pristine/mod.rs at line 159

[22.589337]→[22.589337:589412](∅→∅)

get!(changeset, ChangeId, u64);
cursor!(changeset, ChangeId, u64);

[22.589337]

[22.589412]

get!(changeset, ChangeId, u64, GraphError);
cursor!(changeset, ChangeId, u64, GraphError);
replacement in libpijul/src/pristine/mod.rs at line 163

[22.589439]→[22.589439:589600](∅→∅)

get!(revchangeset, u64, (ChangeId, Merkle));
cursor_ref!(revchangeset, u64, (ChangeId, Merkle));
rev_cursor!(revchangeset, u64, (ChangeId, Merkle));

[22.589439]

[22.589600]

get!(revchangeset, u64, (ChangeId, Merkle), GraphError);
cursor_ref!(revchangeset, u64, (ChangeId, Merkle), GraphError);
rev_cursor!(revchangeset, u64, (ChangeId, Merkle), GraphError);
edit in libpijul/src/pristine/mod.rs at line 168

[22.589628]

[22.589628]

}

pub trait DepsTxnT: Sized {
type DepsError: std::error::Error + Send + Sync + 'static;
table!(revdep);
table!(dep);
table_get!(dep, ChangeId, ChangeId, DepsError);
cursor_ref!(dep, ChangeId, ChangeId, DepsError);
table_get!(revdep, ChangeId, ChangeId, DepsError);
fn iter_revdep(
&self,
p: ChangeId,
) -> Result<Cursor<Self, &Self, Self::DepCursor, ChangeId, ChangeId>, TxnErr<Self::DepsError>>;
fn iter_dep(
&self,
p: ChangeId,
) -> Result<Cursor<Self, &Self, Self::DepCursor, ChangeId, ChangeId>, TxnErr<Self::DepsError>>;
fn iter_dep_ref<RT: std::ops::Deref<Target = Self> + Clone>(
txn: RT,
p: ChangeId,
) -> Result<Cursor<Self, RT, Self::DepCursor, ChangeId, ChangeId>, TxnErr<Self::DepsError>>;
fn iter_touched(
&self,
p: Position<ChangeId>,
) -> Result<
Cursor<Self, &Self, Self::Touched_filesCursor, Position<ChangeId>, ChangeId>,
TxnErr<Self::DepsError>,
>;
fn iter_rev_touched(
&self,
p: ChangeId,
) -> Result<
Cursor<Self, &Self, Self::Rev_touched_filesCursor, ChangeId, Position<ChangeId>>,
TxnErr<Self::DepsError>,
>;
table!(touched_files);
table!(rev_touched_files);
table_get!(touched_files, Position<ChangeId>, ChangeId, DepsError);
table_get!(rev_touched_files, ChangeId, Position<ChangeId>, DepsError);
iter!(touched_files, Position<ChangeId>, ChangeId, DepsError);
iter!(rev_touched_files, ChangeId, Position<ChangeId>, DepsError);
}
edit in libpijul/src/pristine/mod.rs at line 211

[22.589629]

[22.589629]

pub trait TreeTxnT: Sized {
type TreeError: std::error::Error + Send + Sync + 'static;
replacement in libpijul/src/pristine/mod.rs at line 214

[22.589647]→[22.589647:589721](∅→∅)

table_get!(tree, PathId, Inode);
iter!(tree, OwnedPathId, Inode);

[22.589647]

[22.589721]

table_get!(tree, PathId, Inode, TreeError);
iter!(tree, OwnedPathId, Inode, TreeError);
replacement in libpijul/src/pristine/mod.rs at line 218

[22.589743]→[22.589743:589823](∅→∅)

table_get!(revtree, Inode, PathId);
iter!(revtree, Inode, OwnedPathId);

[22.589743]

[22.589823]

table_get!(revtree, Inode, PathId, TreeError);
iter!(revtree, Inode, OwnedPathId, TreeError);
replacement in libpijul/src/pristine/mod.rs at line 223

[22.964]→[22.589844:589949](∅→∅),[22.589844]→[22.589844:589949](∅→∅)

table_get!(inodes, Inode, Position<ChangeId>);
table_get!(revinodes, Position<ChangeId>, Inode);

[22.964]

[22.589949]

table_get!(inodes, Inode, Position<ChangeId>, TreeError);
table_get!(revinodes, Position<ChangeId>, Inode, TreeError);
replacement in libpijul/src/pristine/mod.rs at line 227

[22.589972]→[22.589972:590028](∅→∅)

cursor!(partials, SmallString, Position<ChangeId>);

[22.589972]

[22.590028]

cursor!(partials, SmallString, Position<ChangeId>, TreeError);
cursor!(inodes, Inode, Position<ChangeId>, TreeError);
fn iter_inodes(
&self,
) -> Result<
Cursor<Self, &Self, Self::InodesCursor, Inode, Position<ChangeId>>,
TxnErr<Self::TreeError>,
>;
replacement in libpijul/src/pristine/mod.rs at line 236

[22.590029]→[22.590029:590120](∅→∅)

table!(channels);
cursor!(channels, SmallString, (u64, u64, u64, u64, u64, u64));

[22.590029]

[22.590139]

#[cfg(debug_assertions)]
cursor!(revinodes, Position<ChangeId>, Inode, TreeError);
#[cfg(debug_assertions)]
fn iter_revinodes(
&self,
) -> Result<
Cursor<Self, &Self, Self::RevinodesCursor, Position<ChangeId>, Inode>,
TxnErr<Self::TreeError>,
>;
replacement in libpijul/src/pristine/mod.rs at line 248

[22.590210]→[22.590210:590300](∅→∅)

) -> Cursor<Self, &'txn Self, Self::PartialsCursor, SmallString, Position<ChangeId>>;

[22.590210]

[22.590300]

) -> Result<
Cursor<Self, &'txn Self, Self::PartialsCursor, SmallString, Position<ChangeId>>,
TxnErr<Self::TreeError>,
>;
}
replacement in libpijul/src/pristine/mod.rs at line 254

[22.590301]→[22.590301:590867](∅→∅),[22.590886]→[22.590886:591060](∅→∅),[22.591079]→[22.591079:591136](∅→∅)

table!(revdep);
table!(dep);
table_get!(dep, ChangeId, ChangeId);
cursor_ref!(dep, ChangeId, ChangeId);
table_get!(revdep, ChangeId, ChangeId);

table!(touched_files);
table!(rev_touched_files);
table_get!(touched_files, Position<ChangeId>, ChangeId);
table_get!(rev_touched_files, ChangeId, Position<ChangeId>);
iter!(touched_files, Position<ChangeId>, ChangeId);
iter!(rev_touched_files, ChangeId, Position<ChangeId>);

/// Returns the external hash of an internal change identifier, if
/// the change is known.
fn get_external(&self, p: ChangeId) -> Option<Hash>;

/// Returns the internal change identifier of change with external
/// hash `hash`, if the change is known.
fn get_internal(&self, p: Hash) -> Option<ChangeId>;

[22.590301]

[22.591136]

/// The trait of immutable transactions.
pub trait TxnT:
GraphTxnT
+ ChannelTxnT
+ DepsTxnT<DepsError = <Self as GraphTxnT>::GraphError>
+ TreeTxnT<TreeError = <Self as GraphTxnT>::GraphError>
{
table!(channels);
cursor!(channels, SmallString, (u64, u64, u64, u64, u64, u64));
replacement in libpijul/src/pristine/mod.rs at line 264

[22.591137]→[22.17408:17499](∅→∅)

fn hash_from_prefix(&self, prefix: &str) -> Result<(Hash, ChangeId), HashPrefixError>;

[22.591137]

[22.591226]

fn hash_from_prefix(
&self,
prefix: &str,
) -> Result<(Hash, ChangeId), HashPrefixError<Self::GraphError>>;
replacement in libpijul/src/pristine/mod.rs at line 272

[22.591329]→[22.17500:17540](∅→∅)

) -> Result<Hash, HashPrefixError>;

[22.591329]

[22.591367]

) -> Result<Hash, HashPrefixError<Self::GraphError>>;
replacement in libpijul/src/pristine/mod.rs at line 284

[22.591984]→[22.591984:592052](∅→∅)

fn load_channel(&self, name: &str) -> Option<ChannelRef<Self>>;

[22.591984]

[22.592052]

fn load_channel(
&self,
name: &str,
) -> Result<Option<ChannelRef<Self>>, TxnErr<Self::GraphError>>;
replacement in libpijul/src/pristine/mod.rs at line 289

[22.592053]→[22.592053:592119](∅→∅)

fn load_remote(&self, name: &str) -> Option<RemoteRef<Self>>;

[22.592053]

[22.592119]

fn load_remote(&self, name: &str) -> Result<Option<RemoteRef<Self>>, TxnErr<Self::GraphError>>;
replacement in libpijul/src/pristine/mod.rs at line 293

[22.592225]→[22.592225:592310](∅→∅),[22.592329]→[22.592329:592412](∅→∅),[22.599224]→[22.599224:599225](∅→∅),[22.599225]→[8.572:672](∅→∅),[8.672]→[22.600030:600031](∅→∅),[22.600030]→[22.600030:600031](∅→∅),[22.600031]→[8.673:770](∅→∅),[8.770]→[22.600186:600187](∅→∅),[22.600186]→[22.600186:600187](∅→∅),[22.600206]→[22.600206:600373](∅→∅)

fn iter_channels<'txn>(&'txn self, start: &str) -> ChannelIterator<'txn, Self>;

fn iter_remotes<'txn>(&'txn self, start: &str) -> RemotesIterator<'txn, Self>;

fn iter_revdep(&self, p: ChangeId) -> Cursor<Self, &Self, Self::DepCursor, ChangeId, ChangeId>;

fn iter_dep(&self, p: ChangeId) -> Cursor<Self, &Self, Self::DepCursor, ChangeId, ChangeId>;

fn iter_dep_ref<RT: std::ops::Deref<Target = Self> + Clone>(
txn: RT,
p: ChangeId,
) -> Cursor<Self, RT, Self::DepCursor, ChangeId, ChangeId>;

[22.592225]

[22.600373]

fn iter_channels<'txn>(
&'txn self,
start: &str,
) -> Result<ChannelIterator<'txn, Self>, TxnErr<Self::GraphError>>;
replacement in libpijul/src/pristine/mod.rs at line 298

[22.600374]→[8.771:807](∅→∅),[8.807]→[22.600440:600471](∅→∅),[22.600440]→[22.600440:600471](∅→∅),[22.600471]→[8.808:895](∅→∅)

fn iter_touched(
&self,
p: Position<ChangeId>,
) -> Cursor<Self, &Self, Self::Touched_filesCursor, Position<ChangeId>, ChangeId>;

[22.600374]

[22.600563]

fn iter_remotes<'txn>(
&'txn self,
start: &str,
) -> Result<RemotesIterator<'txn, Self>, TxnErr<Self::GraphError>>;
edit in libpijul/src/pristine/mod.rs at line 303

[22.600564]→[8.896:936](∅→∅),[8.936]→[22.600634:600655](∅→∅),[22.600634]→[22.600634:600655](∅→∅),[22.600655]→[8.937:1028](∅→∅),[8.1028]→[22.605607:605608](∅→∅),[22.605607]→[22.605607:605608](∅→∅)

fn iter_rev_touched(
&self,
p: ChangeId,
) -> Cursor<Self, &Self, Self::Rev_touched_filesCursor, ChangeId, Position<ChangeId>>;
replacement in libpijul/src/pristine/mod.rs at line 315

[22.606010]→[22.606010:606086](∅→∅)

) -> Cursor<Self, &'txn Self, Self::RemoteCursor, u64, (Hash, Merkle)>;

[22.606010]

[22.606086]

) -> Result<
Cursor<Self, &'txn Self, Self::RemoteCursor, u64, (Hash, Merkle)>,
TxnErr<Self::GraphError>,
>;
replacement in libpijul/src/pristine/mod.rs at line 324

[22.606192]→[22.606192:606425](∅→∅)

) -> RevCursor<Self, &'txn Self, Self::RemoteCursor, u64, (Hash, Merkle)>;

fn get_remote(&mut self, name: &str) -> Option<RemoteRef<Self>>;

fn last_remote(&self, remote: &Self::Remote) -> Option<(u64, (Hash, Merkle))>;

[22.606192]

[22.606425]

) -> Result<
RevCursor<Self, &'txn Self, Self::RemoteCursor, u64, (Hash, Merkle)>,
TxnErr<Self::GraphError>,
>;
replacement in libpijul/src/pristine/mod.rs at line 329

[22.606426]→[22.606426:606522](∅→∅)

fn get_remote_state(&self, remote: &Self::Remote, n: u64) -> Option<(u64, (Hash, Merkle))>;

[22.606426]

[22.606522]

fn get_remote(
&mut self,
name: &str,
) -> Result<Option<RemoteRef<Self>>, TxnErr<Self::GraphError>>;
replacement in libpijul/src/pristine/mod.rs at line 334

[22.606523]→[22.606523:606765](∅→∅)

fn remote_has_change(&self, remote: &RemoteRef<Self>, hash: Hash) -> bool;
fn remote_has_state(&self, remote: &RemoteRef<Self>, hash: Merkle) -> bool;
fn channel_has_state(&self, channel: &ChannelRef<Self>, hash: Merkle) -> bool;

[22.606523]

[22.36993]

fn last_remote(
&self,
remote: &Self::Remote,
) -> Result<Option<(u64, (Hash, Merkle))>, TxnErr<Self::GraphError>>;
replacement in libpijul/src/pristine/mod.rs at line 339

[22.37026]→[22.37026:37074](∅→∅),[22.37074]→[8.1029:1126](∅→∅)

cursor!(inodes, Inode, Position<ChangeId>);
fn iter_inodes(&self) -> Cursor<Self, &Self, Self::InodesCursor, Inode, Position<ChangeId>>;

[22.36994]

[22.965]

fn get_remote_state(
&self,
remote: &Self::Remote,
n: u64,
) -> Result<Option<(u64, (Hash, Merkle))>, TxnErr<Self::GraphError>>;
replacement in libpijul/src/pristine/mod.rs at line 345

[22.966]→[22.966:1075](∅→∅),[22.1075]→[8.1127:1150](∅→∅)

#[cfg(debug_assertions)]
cursor!(revinodes, Position<ChangeId>, Inode);
#[cfg(debug_assertions)]
fn iter_revinodes(

[22.966]

[8.1150]

fn remote_has_change(
&self,
remote: &RemoteRef<Self>,
hash: Hash,
) -> Result<bool, TxnErr<Self::GraphError>>;
fn remote_has_state(
replacement in libpijul/src/pristine/mod.rs at line 352

[8.1165]→[8.1165:1245](∅→∅)

) -> Cursor<Self, &Self, Self::RevinodesCursor, Position<ChangeId>, Inode>;

[8.1165]

[22.37267]

remote: &RemoteRef<Self>,
hash: Merkle,
) -> Result<bool, TxnErr<Self::GraphError>>;
fn channel_has_state(
&self,
channel: &ChannelRef<Self>,
hash: Merkle,
) -> Result<bool, TxnErr<Self::GraphError>>;
replacement in libpijul/src/pristine/mod.rs at line 364

[22.37377]→[22.37377:37431](∅→∅)

pub(crate) fn iter_adjacent<'db, 'txn: 'db, T: TxnT>(

[22.37377]

[22.37431]

pub(crate) fn iter_adjacent<'db, 'txn: 'db, T: GraphTxnT>(
replacement in libpijul/src/pristine/mod.rs at line 366

[22.37449]→[22.37449:37479](∅→∅)

channel: &'db Channel<T>,

[22.37449]

[22.37479]

graph: &'db T::Graph,
replacement in libpijul/src/pristine/mod.rs at line 370

[22.37556]→[22.37556:37589](∅→∅)

) -> AdjacentIterator<'txn, T> {

[22.37556]

[22.37589]

) -> Result<AdjacentIterator<'txn, T>, TxnErr<T::GraphError>> {
replacement in libpijul/src/pristine/mod.rs at line 376

[22.37711]→[22.37711:37796](∅→∅)

AdjacentIterator {
it: iter_graph(txn, &channel.graph, key, Some(edge)),

[22.37711]

[22.37796]

Ok(AdjacentIterator {
it: iter_graph(txn, graph, key, Some(edge))?,
replacement in libpijul/src/pristine/mod.rs at line 381

[22.37845]→[22.607389:607395](∅→∅),[22.607389]→[22.607389:607395](∅→∅)

}

[22.37845]

[21.6832]

})
replacement in libpijul/src/pristine/mod.rs at line 384

[21.6835]→[21.6835:6895](∅→∅)

pub(crate) fn iter_alive_children<'db, 'txn: 'db, T: TxnT>(

[21.6835]

[21.6895]

pub(crate) fn iter_alive_children<'db, 'txn: 'db, T: GraphTxnT>(
replacement in libpijul/src/pristine/mod.rs at line 386

[21.6913]→[21.6913:6943](∅→∅)

channel: &'db Channel<T>,

[21.6913]

[21.6943]

graph: &'db T::Graph,
replacement in libpijul/src/pristine/mod.rs at line 388

[21.6970]→[21.6970:7003](∅→∅)

) -> AdjacentIterator<'txn, T> {

[21.6970]

[21.7003]

) -> Result<AdjacentIterator<'txn, T>, TxnErr<T::GraphError>> {
replacement in libpijul/src/pristine/mod.rs at line 391

[21.7035]→[21.7035:7052](∅→∅)

channel,

[21.7035]

[21.7052]

graph,
replacement in libpijul/src/pristine/mod.rs at line 398

[22.607396]→[21.7137:7198](∅→∅)

pub(crate) fn iter_deleted_parents<'db, 'txn: 'db, T: TxnT>(

[22.607396]

[21.7198]

pub(crate) fn iter_deleted_parents<'db, 'txn: 'db, T: GraphTxnT>(
replacement in libpijul/src/pristine/mod.rs at line 400

[21.7216]→[21.7216:7246](∅→∅)

channel: &'db Channel<T>,

[21.7216]

[21.7246]

graph: &'db T::Graph,
replacement in libpijul/src/pristine/mod.rs at line 402

[21.7273]→[21.7273:7306](∅→∅)

) -> AdjacentIterator<'txn, T> {

[21.7273]

[21.7306]

) -> Result<AdjacentIterator<'txn, T>, TxnErr<T::GraphError>> {
replacement in libpijul/src/pristine/mod.rs at line 405

[21.7338]→[21.7338:7355](∅→∅)

channel,

[21.7338]

[21.7355]

graph,
replacement in libpijul/src/pristine/mod.rs at line 412

[21.7451]→[21.7451:7504](∅→∅)

pub(crate) fn iter_adj_all<'db, 'txn: 'db, T: TxnT>(

[21.7451]

[21.7504]

pub(crate) fn iter_adj_all<'db, 'txn: 'db, T: GraphTxnT>(
replacement in libpijul/src/pristine/mod.rs at line 414

[21.7522]→[21.7522:7552](∅→∅)

channel: &'db Channel<T>,

[21.7522]

[21.7552]

graph: &'db T::Graph,
replacement in libpijul/src/pristine/mod.rs at line 416

[21.7579]→[21.7579:7687](∅→∅)

) -> AdjacentIterator<'txn, T> {
iter_adjacent(txn, channel, key, EdgeFlags::empty(), EdgeFlags::all())

[21.7579]

[21.7687]

) -> Result<AdjacentIterator<'txn, T>, TxnErr<T::GraphError>> {
iter_adjacent(txn, graph, key, EdgeFlags::empty(), EdgeFlags::all())
replacement in libpijul/src/pristine/mod.rs at line 420

[21.7690]→[22.37849:37992](∅→∅),[22.607396]→[22.37849:37992](∅→∅)

pub(crate) fn tree_path<T: TxnT>(txn: &T, v: Position<ChangeId>) -> Option<String> {
if let Some(mut inode) = txn.get_revinodes(v, None) {

[21.7690]

[22.37992]

pub(crate) fn tree_path<T: TreeTxnT>(
txn: &T,
v: Position<ChangeId>,
) -> Result<Option<String>, TxnErr<T::TreeError>> {
if let Some(mut inode) = txn.get_revinodes(v, None)? {
replacement in libpijul/src/pristine/mod.rs at line 427

[22.38066]→[22.38066:38129](∅→∅)

if let Some(next) = txn.get_revtree(inode, None) {

[22.38066]

[22.38129]

if let Some(next) = txn.get_revtree(inode, None)? {
replacement in libpijul/src/pristine/mod.rs at line 432

[22.38310]→[22.38310:38339](∅→∅)

return None;

[22.38310]

[22.38339]

return Ok(None);
replacement in libpijul/src/pristine/mod.rs at line 439

[22.38532]→[22.38532:38591](∅→∅)

Some(result)
} else {
None

[22.38532]

[22.607771]

return Ok(Some(result));
edit in libpijul/src/pristine/mod.rs at line 441

[22.607781]→[22.38592:38618](∅→∅)

} else {
None
edit in libpijul/src/pristine/mod.rs at line 442

[22.607802]

[22.38619]

Ok(None)
replacement in libpijul/src/pristine/mod.rs at line 445

[22.607803]→[22.38622:38716](∅→∅)

pub(crate) fn internal<T: TxnT>(txn: &T, h: &Option<Hash>, p: ChangeId) -> Option<ChangeId> {

[22.607803]

[22.38716]

pub(crate) fn internal<T: GraphTxnT>(
txn: &T,
h: &Option<Hash>,
p: ChangeId,
) -> Result<Option<ChangeId>, TxnErr<T::GraphError>> {
replacement in libpijul/src/pristine/mod.rs at line 451

[22.38731]→[22.38731:38781](∅→∅)

Some(Hash::None) => Some(ChangeId::ROOT),

[22.38731]

[22.38781]

Some(Hash::None) => Ok(Some(ChangeId::ROOT)),
replacement in libpijul/src/pristine/mod.rs at line 453

[22.38821]→[22.38821:38846](∅→∅)

None => Some(p),

[22.38821]

[22.347]

None => Ok(Some(p)),
replacement in libpijul/src/pristine/mod.rs at line 458

[22.17565]→[22.17565:17630](∅→∅)

#[error("Inconsistent change")]
pub struct InconsistentChange {}

[22.17565]

[22.17630]

pub enum InconsistentChange<T: std::error::Error + 'static> {
#[error("Undeclared dependency")]
UndeclaredDep,
#[error(transparent)]
Txn(T),
}

impl<T: std::error::Error + 'static> std::convert::From<TxnErr<T>> for InconsistentChange<T> {
fn from(e: TxnErr<T>) -> Self {
InconsistentChange::Txn(e.0)
}
}
replacement in libpijul/src/pristine/mod.rs at line 471

[22.17631]→[22.38850:38887](∅→∅),[22.354]→[22.38850:38887](∅→∅)

pub(crate) fn internal_pos<T: TxnT>(

[22.17631]

[22.38887]

pub(crate) fn internal_pos<T: GraphTxnT>(
replacement in libpijul/src/pristine/mod.rs at line 475

[22.38959]→[22.17632:17686](∅→∅)

) -> Result<Position<ChangeId>, InconsistentChange> {

[22.38959]

[22.0]

) -> Result<Position<ChangeId>, InconsistentChange<T::GraphError>> {
replacement in libpijul/src/pristine/mod.rs at line 477

[22.47]→[22.47:94](∅→∅)

if let Some(p) = txn.get_internal(p) {

[22.47]

[22.94]

if let Some(p) = txn.get_internal(p)? {
replacement in libpijul/src/pristine/mod.rs at line 480

[22.39254]→[22.17687:17734](∅→∅)

return Err(InconsistentChange {});

[22.39254]

[22.167]

return Err(InconsistentChange::UndeclaredDep);
replacement in libpijul/src/pristine/mod.rs at line 492

[22.39319]→[22.39319:39360](∅→∅)

pub(crate) fn iter_graph<'txn, T: TxnT>(

[22.39319]

[22.39360]

pub(crate) fn iter_graph<'txn, T: GraphTxnT>(
replacement in libpijul/src/pristine/mod.rs at line 497

[22.39446]→[22.39446:39512](∅→∅)

) -> Cursor<T, &'txn T, T::GraphCursor, Vertex<ChangeId>, Edge> {

[22.39446]

[22.4286]

) -> Result<Cursor<T, &'txn T, T::GraphCursor, Vertex<ChangeId>, Edge>, TxnErr<T::GraphError>> {
replacement in libpijul/src/pristine/mod.rs at line 501

[22.39578]→[22.39578:39650](∅→∅)

pub(crate) fn iter_graph_ref<T: TxnT, RT: std::ops::Deref<Target = T>>(

[22.39578]

[22.39650]

pub(crate) fn iter_graph_ref<T: GraphTxnT, RT: std::ops::Deref<Target = T>>(
replacement in libpijul/src/pristine/mod.rs at line 506

[22.39731]→[22.39731:39792](∅→∅)

) -> Cursor<T, RT, T::GraphCursor, Vertex<ChangeId>, Edge> {

[22.39731]

[22.4329]

) -> Result<Cursor<T, RT, T::GraphCursor, Vertex<ChangeId>, Edge>, TxnErr<T::GraphError>> {
replacement in libpijul/src/pristine/mod.rs at line 510

[22.39866]→[22.39866:39919](∅→∅)

pub(crate) fn changeid_log<'db, 'txn: 'db, T: TxnT>(

[22.39866]

[22.39919]

pub(crate) fn changeid_log<'db, 'txn: 'db, T: ChannelTxnT>(
replacement in libpijul/src/pristine/mod.rs at line 514

[22.39982]→[22.39982:40056](∅→∅)

) -> Cursor<T, &'txn T, T::RevchangesetCursor, u64, (ChangeId, Merkle)> {

[22.39982]

[22.40056]

) -> Result<Cursor<T, &'txn T, T::RevchangesetCursor, u64, (ChangeId, Merkle)>, TxnErr<T::GraphError>>
{
replacement in libpijul/src/pristine/mod.rs at line 519

[22.40128]→[22.40128:40182](∅→∅)

pub(crate) fn current_state<'db, 'txn: 'db, T: TxnT>(

[22.40128]

[22.40182]

pub(crate) fn current_state<'db, 'txn: 'db, T: ChannelTxnT>(
replacement in libpijul/src/pristine/mod.rs at line 522

[22.40230]→[16.197:211](∅→∅),[16.211]→[22.40252:40311](∅→∅),[22.40252]→[22.40252:40311](∅→∅)

) -> Merkle {
txn.rev_cursor_revchangeset(&channel.revchanges, None)

[22.40230]

[22.40311]

) -> Result<Merkle, TxnErr<T::GraphError>> {
if let Some(e) = txn
.rev_cursor_revchangeset(&channel.revchanges, None)?
replacement in libpijul/src/pristine/mod.rs at line 526

[22.40327]→[22.40327:40357](∅→∅),[22.40357]→[16.212:247](∅→∅)

.map(|(_, (_, m))| m)
.unwrap_or(Merkle::zero())

[22.40327]

[22.40357]

{
let (_, (_, m)) = e?;
Ok(m)
} else {
Ok(Merkle::zero())
}
replacement in libpijul/src/pristine/mod.rs at line 534

[22.40360]→[22.40360:40434](∅→∅)

pub(crate) fn changeid_log_ref<T: TxnT, RT: std::ops::Deref<Target = T>>(

[22.40360]

[22.40434]

pub(crate) fn changeid_log_ref<T: ChannelTxnT, RT: std::ops::Deref<Target = T>>(
replacement in libpijul/src/pristine/mod.rs at line 538

[22.40488]→[22.40488:40634](∅→∅)

) -> Cursor<T, RT, T::RevchangesetCursor, u64, (ChangeId, Merkle)> {
T::cursor_revchangeset_ref(txn, &channel.revchanges, Some((from, None)))

[22.40488]

[22.40634]

) -> Result<Cursor<T, RT, T::RevchangesetCursor, u64, (ChangeId, Merkle)>, TxnErr<T::GraphError>> {
Ok(T::cursor_revchangeset_ref(
txn,
&channel.revchanges,
Some((from, None)),
)?)
replacement in libpijul/src/pristine/mod.rs at line 546

[22.40637]→[22.40637:40694](∅→∅)

pub(crate) fn changeid_rev_log<'db, 'txn: 'db, T: TxnT>(

[22.40637]

[22.40694]

pub(crate) fn changeid_rev_log<'db, 'txn: 'db, T: ChannelTxnT>(
replacement in libpijul/src/pristine/mod.rs at line 550

[22.40765]→[22.40765:40926](∅→∅)

) -> RevCursor<T, &'txn T, T::RevchangesetCursor, u64, (ChangeId, Merkle)> {
txn.rev_cursor_revchangeset(&channel.revchanges, from.map(|from| (from, None)))

[22.40765]

[22.40926]

) -> Result<
RevCursor<T, &'txn T, T::RevchangesetCursor, u64, (ChangeId, Merkle)>,
TxnErr<T::GraphError>,
> {
Ok(txn.rev_cursor_revchangeset(&channel.revchanges, from.map(|from| (from, None)))?)
replacement in libpijul/src/pristine/mod.rs at line 557

[22.40929]→[22.40929:40982](∅→∅)

pub(crate) fn log_for_path<'txn, 'channel, T: TxnT>(

[22.40929]

[22.40982]

pub(crate) fn log_for_path<
'txn,
'channel,
T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>,
>(
replacement in libpijul/src/pristine/mod.rs at line 566

[22.41089]→[22.41089:41239](∅→∅)

) -> PathChangeset<'channel, 'txn, T> {
PathChangeset {
iter: txn.cursor_revchangeset(&channel.revchanges, Some((from_timestamp, None))),

[22.41089]

[22.41239]

) -> Result<PathChangeset<'channel, 'txn, T>, TxnErr<T::GraphError>> {
Ok(PathChangeset {
iter: txn.cursor_revchangeset(&channel.revchanges, Some((from_timestamp, None)))?,
replacement in libpijul/src/pristine/mod.rs at line 572

[22.41282]→[22.608084:608090](∅→∅),[22.608084]→[22.608084:608090](∅→∅)

}

[22.41282]

[22.41283]

})
replacement in libpijul/src/pristine/mod.rs at line 575

[22.608091]→[22.41286:41343](∅→∅)

pub(crate) fn rev_log_for_path<'txn, 'channel, T: TxnT>(

[22.608091]

[22.41343]

pub(crate) fn rev_log_for_path<
'txn,
'channel,
T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>,
>(
replacement in libpijul/src/pristine/mod.rs at line 584

[22.41450]→[22.41450:41610](∅→∅)

) -> RevPathChangeset<'channel, 'txn, T> {
RevPathChangeset {
iter: txn.rev_cursor_revchangeset(&channel.revchanges, Some((from_timestamp, None))),

[22.41450]

[22.41610]

) -> Result<RevPathChangeset<'channel, 'txn, T>, TxnErr<T::GraphError>> {
Ok(RevPathChangeset {
iter: txn.rev_cursor_revchangeset(&channel.revchanges, Some((from_timestamp, None)))?,
replacement in libpijul/src/pristine/mod.rs at line 590

[22.41653]→[22.525:531](∅→∅),[22.525]→[22.525:531](∅→∅)

}

[22.41653]

[22.41654]

})
replacement in libpijul/src/pristine/mod.rs at line 594

[22.41708]→[22.41708:41742](∅→∅)

pub(crate) fn test_edge<T: TxnT>(

[22.41708]

[22.41742]

pub(crate) fn test_edge<T: GraphTxnT>(
replacement in libpijul/src/pristine/mod.rs at line 596

[22.41755]→[22.41755:41781](∅→∅)

channel: &Channel<T>,

[22.41755]

[22.41781]

channel: &T::Graph,
replacement in libpijul/src/pristine/mod.rs at line 601

[22.41875]→[22.41875:41887](∅→∅)

) -> bool {

[22.41875]

[22.41887]

) -> Result<bool, TxnErr<T::GraphError>> {
replacement in libpijul/src/pristine/mod.rs at line 613

[22.42133]→[22.42133:42282](∅→∅)

let mut cursor = txn.cursor_graph(&channel.graph, Some((key, Some(edge))));
let (a_, b_) = cursor.next().unwrap();
a_.change == a.change

[22.42133]

[22.42282]

let mut cursor = txn.cursor_graph(&channel, Some((key, Some(edge))))?;
let (a_, b_) = cursor.next().unwrap()?;
Ok(a_.change == a.change
replacement in libpijul/src/pristine/mod.rs at line 620

[22.42390]→[22.42390:42414](∅→∅)

&& b_.dest == b

[22.42390]

[22.42414]

&& b_.dest == b)
replacement in libpijul/src/pristine/mod.rs at line 624

[22.42459]→[22.42459:42740](∅→∅),[22.42740]→[22.270:419](∅→∅)

pub(crate) fn is_alive<T: TxnT>(txn: &T, channel: &Channel<T>, a: Vertex<ChangeId>) -> bool {
a.is_root()
|| iter_adjacent(
txn,
channel,
a,
EdgeFlags::PARENT,
EdgeFlags::all() - EdgeFlags::DELETED,
)
.any(|e| {
!e.flag.contains(EdgeFlags::PSEUDO)
&& (e.flag.contains(EdgeFlags::BLOCK) || a.is_empty())
})

[22.42459]

[22.42868]

pub(crate) fn is_alive<T: GraphTxnT>(
txn: &T,
channel: &T::Graph,
a: Vertex<ChangeId>,
) -> Result<bool, TxnErr<T::GraphError>> {
if a.is_root() {
return Ok(true);
}
for e in iter_adjacent(
txn,
channel,
a,
EdgeFlags::PARENT,
EdgeFlags::all() - EdgeFlags::DELETED,
)? {
let e = e?;
if !e.flag.contains(EdgeFlags::PSEUDO)
&& (e.flag.contains(EdgeFlags::BLOCK) || a.is_empty())
{
return Ok(true);
}
}
Ok(false)
replacement in libpijul/src/pristine/mod.rs at line 649

[22.608172]→[22.42871:43003](∅→∅)

pub(crate) fn make_changeid<T: TxnT>(txn: &T, h: &Hash) -> ChangeId {
if let Some(h) = txn.get_internal(*h) {
return h;

[22.608172]

[22.43003]

pub(crate) fn make_changeid<T: GraphTxnT>(
txn: &T,
h: &Hash,
) -> Result<ChangeId, TxnErr<T::GraphError>> {
if let Some(h) = txn.get_internal(*h)? {
return Ok(h);
replacement in libpijul/src/pristine/mod.rs at line 659

[22.43100]→[22.43100:43145](∅→∅)

Hash::None => return ChangeId::ROOT,

[22.43100]

[22.43145]

Hash::None => return Ok(ChangeId::ROOT),
replacement in libpijul/src/pristine/mod.rs at line 662

[22.43225]→[22.43225:43267](∅→∅)

while txn.get_external(p).is_some() {

[22.43225]

[22.43267]

while txn.get_external(p)?.is_some() {
replacement in libpijul/src/pristine/mod.rs at line 665

[22.608592]→[22.43316:43322](∅→∅)

p

[22.608592]

[22.43322]

Ok(p)
replacement in libpijul/src/pristine/mod.rs at line 669

[22.43350]→[22.43350:43405](∅→∅)

pub fn debug_tree<P: AsRef<std::path::Path>, T: TxnT>(

[22.43350]

[22.43405]

pub fn debug_tree<P: AsRef<std::path::Path>, T: TreeTxnT>(
replacement in libpijul/src/pristine/mod.rs at line 678

[22.43626]→[22.43626:43699](∅→∅)

for t in txn.iter_tree(root, None) {
writeln!(f, "{:?}", t)?

[22.43626]

[22.43699]

for t in txn.iter_tree(root, None).unwrap() {
writeln!(f, "{:?}", t.unwrap())?
replacement in libpijul/src/pristine/mod.rs at line 685

[22.43744]→[22.43744:43788](∅→∅)

pub fn debug_tree_print<T: TxnT>(txn: &T) {

[22.43744]

[22.43788]

pub fn debug_tree_print<T: TreeTxnT>(txn: &T) {
replacement in libpijul/src/pristine/mod.rs at line 690

[22.43904]→[22.43904:43971](∅→∅)

for t in txn.iter_tree(root, None) {
debug!("{:?}", t)

[22.43904]

[22.609454]

for t in txn.iter_tree(root, None).unwrap() {
debug!("{:?}", t.unwrap())
replacement in libpijul/src/pristine/mod.rs at line 698

[22.44179]→[22.44179:44237](∅→∅)

pub fn debug_to_file<P: AsRef<std::path::Path>, T: TxnT>(

[22.44179]

[22.44237]

pub fn debug_to_file<P: AsRef<std::path::Path>, T: ChannelTxnT>(
replacement in libpijul/src/pristine/mod.rs at line 705

[22.44404]→[22.44404:44488](∅→∅)

let channel = channel.r.borrow();
let done = debug(txn, &channel, &mut f)?;

[22.44404]

[22.44488]

let done = debug(txn, &channel.borrow().graph, &mut f)?;
replacement in libpijul/src/pristine/mod.rs at line 712

[22.44585]→[22.44585:44643](∅→∅)

pub fn debug_revtree<P: AsRef<std::path::Path>, T: TxnT>(

[22.44585]

[22.44643]

pub fn debug_revtree<P: AsRef<std::path::Path>, T: TreeTxnT>(
replacement in libpijul/src/pristine/mod.rs at line 717

[22.44748]→[22.44748:44831](∅→∅)

for t in txn.iter_revtree(Inode::ROOT, None) {
writeln!(f, "{:?}", t)?

[22.44748]

[22.610454]

for t in txn.iter_revtree(Inode::ROOT, None).unwrap() {
writeln!(f, "{:?}", t.unwrap())?
replacement in libpijul/src/pristine/mod.rs at line 724

[22.44871]→[22.44871:44995](∅→∅)

pub fn debug_revtree_print<T: TxnT>(txn: &T) {
for t in txn.iter_revtree(Inode::ROOT, None) {
debug!("{:?}", t)

[22.44871]

[22.611449]

pub fn debug_revtree_print<T: TreeTxnT>(txn: &T) {
for t in txn.iter_revtree(Inode::ROOT, None).unwrap() {
debug!("{:?}", t.unwrap())
replacement in libpijul/src/pristine/mod.rs at line 731

[22.45024]→[22.45024:45064](∅→∅)

pub fn debug_inodes<T: TxnT>(txn: &T) {

[22.45024]

[22.45064]

pub fn debug_inodes<T: TreeTxnT>(txn: &T) {
replacement in libpijul/src/pristine/mod.rs at line 733

[22.45092]→[22.45092:45166](∅→∅)

for t in txn.iter_inodes() {
debug!("debug_inodes = {:?}", t)

[22.45092]

[22.45166]

for t in txn.iter_inodes().unwrap() {
debug!("debug_inodes = {:?}", t.unwrap())
replacement in libpijul/src/pristine/mod.rs at line 740

[22.1235]→[22.1235:1278](∅→∅)

pub fn debug_revinodes<T: TxnT>(txn: &T) {

[22.1235]

[22.1278]

pub fn debug_revinodes<T: TreeTxnT>(txn: &T) {
replacement in libpijul/src/pristine/mod.rs at line 742

[22.1309]→[22.1309:1389](∅→∅)

for t in txn.iter_revinodes() {
debug!("debug_revinodes = {:?}", t)

[22.1309]

[22.1389]

for t in txn.iter_revinodes().unwrap() {
debug!("debug_revinodes = {:?}", t.unwrap())
replacement in libpijul/src/pristine/mod.rs at line 751

[22.45354]→[22.45354:45387](∅→∅)

pub fn debug<W: Write, T: TxnT>(

[22.45354]

[22.45387]

pub fn debug<W: Write, T: GraphTxnT>(
replacement in libpijul/src/pristine/mod.rs at line 753

[22.45400]→[22.45400:45426](∅→∅)

channel: &Channel<T>,

[22.45400]

[22.45426]

channel: &T::Graph,
replacement in libpijul/src/pristine/mod.rs at line 756

[22.17878]→[22.294:351](∅→∅),[22.45475]→[22.294:351](∅→∅)

let cursor = txn.cursor_graph(&channel.graph, None);

[22.17878]

[22.45536]

let cursor = txn.cursor_graph(&channel, None).unwrap();
replacement in libpijul/src/pristine/mod.rs at line 760

[22.45655]→[22.301:328](∅→∅)

for (k, v) in cursor {

[22.45655]

[22.45700]

for x in cursor {
let (k, v) = x.unwrap();
replacement in libpijul/src/pristine/mod.rs at line 773

[22.45951]→[22.45951:45980](∅→∅)

pub fn check_alive<T: TxnT>(

[22.612336]

[22.45980]

pub fn check_alive<T: ChannelTxnT>(
replacement in libpijul/src/pristine/mod.rs at line 775

[22.45993]→[22.45993:46022](∅→∅)

channel: &ChannelRef<T>,

[22.45993]

[22.46022]

channel: &T::Graph,
edit in libpijul/src/pristine/mod.rs at line 780

[22.46145]→[22.46145:46183](∅→∅),[22.46183]→[22.613571:613572](∅→∅),[22.613571]→[22.613571:613572](∅→∅)

let channel = channel.r.borrow();
replacement in libpijul/src/pristine/mod.rs at line 793

[22.46586]→[22.46586:46598](∅→∅)

) {

[22.46586]

[22.46598]

)
.unwrap()
{
let e = e.unwrap();
replacement in libpijul/src/pristine/mod.rs at line 804

[22.46782]→[22.352:409](∅→∅)

let cursor = txn.cursor_graph(&channel.graph, None);

[22.46782]

[22.46843]

let cursor = txn.cursor_graph(&channel, None);
replacement in libpijul/src/pristine/mod.rs at line 810

[22.47042]→[22.329:356](∅→∅)

for (k, v) in cursor {

[22.47042]

[22.47087]

for x in cursor.unwrap() {
let (k, v) = x.unwrap();
replacement in libpijul/src/pristine/mod.rs at line 815

[22.47231]→[22.47231:47331](∅→∅)

reachable_pseudo.push((k0, find_file(txn, &channel, k0, &mut stack, &mut visited)))

[22.47231]

[22.614588]

reachable_pseudo.push((
k0,
find_file(txn, &channel, k0, &mut stack, &mut visited).unwrap(),
))
replacement in libpijul/src/pristine/mod.rs at line 840

[22.4618]→[22.4618:4696](∅→∅)

let file = find_file(txn, &channel, k, &mut stack, &mut visited);

[22.4618]

[22.4696]

let file = find_file(txn, &channel, k, &mut stack, &mut visited).unwrap();
replacement in libpijul/src/pristine/mod.rs at line 845

[22.48127]→[22.48127:48220](∅→∅)

reachable_pseudo.push((k0, find_file(txn, &channel, k0, &mut stack, &mut visited)));

[22.48127]

[22.48220]

reachable_pseudo.push((
k0,
find_file(txn, &channel, k0, &mut stack, &mut visited).unwrap(),
));
replacement in libpijul/src/pristine/mod.rs at line 854

[22.48285]→[22.48285:48308](∅→∅)

fn find_file<T: TxnT>(

[22.48272]

[22.48308]

fn find_file<T: GraphTxnT>(
replacement in libpijul/src/pristine/mod.rs at line 856

[22.48321]→[22.48321:48347](∅→∅)

channel: &Channel<T>,

[22.48321]

[22.48347]

channel: &T::Graph,
replacement in libpijul/src/pristine/mod.rs at line 860

[22.48456]→[22.48456:48488](∅→∅)

) -> Option<Vertex<ChangeId>> {

[22.48456]

[22.48488]

) -> Result<Option<Vertex<ChangeId>>, TxnErr<T::GraphError>> {
replacement in libpijul/src/pristine/mod.rs at line 869

[22.48684]→[22.48684:48773](∅→∅)

for e in iter_adjacent(txn, &channel, kk, EdgeFlags::PARENT, EdgeFlags::all()) {

[22.48684]

[22.48773]

for e in iter_adjacent(txn, &channel, kk, EdgeFlags::PARENT, EdgeFlags::all())? {
let e = e?;
replacement in libpijul/src/pristine/mod.rs at line 880

[22.616290]→[22.49030:49039](∅→∅)

file

[22.616290]

[22.49039]

Ok(file)
replacement in libpijul/src/pristine/mod.rs at line 883

[22.451]→[22.451:489](∅→∅)

pub fn debug_root<W: Write, T: TxnT>(

[22.616291]

[22.49091]

pub fn debug_root<W: Write, T: GraphTxnT>(
replacement in libpijul/src/pristine/mod.rs at line 885

[22.49104]→[22.49104:49130](∅→∅)

channel: &Channel<T>,

[22.49104]

[22.49130]

channel: &T::Graph,
replacement in libpijul/src/pristine/mod.rs at line 898

[22.49443]→[21.7691:7741](∅→∅)

for e in iter_adj_all(txn, &channel, v) {

[22.49443]

[22.507]

for e in iter_adj_all(txn, &channel, v).unwrap() {
let e = e.unwrap();
replacement in libpijul/src/pristine/mod.rs at line 928

[22.617477]→[22.617477:617520](∅→∅)

fn debug_edge<T: TxnT, W: std::io::Write>(

[22.617477]

[22.617520]

fn debug_edge<T: GraphTxnT, W: std::io::Write>(
replacement in libpijul/src/pristine/mod.rs at line 930

[22.617533]→[22.617533:617559](∅→∅)

channel: &Channel<T>,

[22.617533]

[22.617559]

channel: &T::Graph,
replacement in libpijul/src/pristine/mod.rs at line 1035

[22.620388]→[22.620388:620464](∅→∅)

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

[22.620373]

[22.620464]

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

[22.620597]→[22.620597:620676](∅→∅)

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

[22.620582]

[22.620676]

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

[22.620794]→[22.620794:621360](∅→∅)

initialized_cursor!(graph, Vertex<ChangeId>, Edge);
initialized_cursor!(changeset, ChangeId, u64);
initialized_cursor!(revchangeset, u64, (ChangeId, Merkle));
initialized_rev_cursor!(revchangeset, u64, (ChangeId, Merkle));
initialized_cursor!(tree, OwnedPathId, Inode);
initialized_cursor!(revtree, Inode, OwnedPathId);
initialized_cursor!(dep, ChangeId, ChangeId);
initialized_cursor!(partials, SmallString, Position<ChangeId>);
initialized_cursor!(rev_touched_files, ChangeId, Position<ChangeId>);
initialized_cursor!(touched_files, Position<ChangeId>, ChangeId);

[22.620794]

[22.621360]

initialized_cursor!(graph, Vertex<ChangeId>, Edge, GraphTxnT, GraphError);
initialized_cursor!(changeset, ChangeId, u64, ChannelTxnT, GraphError);
initialized_cursor!(
revchangeset,
u64,
(ChangeId, Merkle),
ChannelTxnT,
GraphError
);
initialized_rev_cursor!(
revchangeset,
u64,
(ChangeId, Merkle),
ChannelTxnT,
GraphError
);
initialized_cursor!(tree, OwnedPathId, Inode, TreeTxnT, TreeError);
initialized_cursor!(revtree, Inode, OwnedPathId, TreeTxnT, TreeError);
initialized_cursor!(dep, ChangeId, ChangeId, DepsTxnT, DepsError);
initialized_cursor!(
partials,
SmallString,
Position<ChangeId>,
TreeTxnT,
TreeError
);
initialized_cursor!(
rev_touched_files,
ChangeId,
Position<ChangeId>,
DepsTxnT,
DepsError
);
initialized_cursor!(
touched_files,
Position<ChangeId>,
ChangeId,
DepsTxnT,
DepsError
);
replacement in libpijul/src/pristine/mod.rs at line 1089

[22.621492]→[22.621492:621548](∅→∅)

initialized_cursor!(inodes, Inode, Position<ChangeId>);

[22.621464]

[22.1431]

initialized_cursor!(inodes, Inode, Position<ChangeId>, TreeTxnT, TreeError);
replacement in libpijul/src/pristine/mod.rs at line 1091

[22.1456]→[22.1456:1515](∅→∅)

initialized_cursor!(revinodes, Position<ChangeId>, Inode);

[22.1456]

[22.621548]

initialized_cursor!(revinodes, Position<ChangeId>, Inode, TreeTxnT, TreeError);
replacement in libpijul/src/pristine/mod.rs at line 1094

[22.621660]→[22.621660:621705](∅→∅)

pub struct AdjacentIterator<'txn, T: TxnT> {

[22.621645]

[22.621705]

pub struct AdjacentIterator<'txn, T: GraphTxnT> {
replacement in libpijul/src/pristine/mod.rs at line 1102

[22.621907]→[22.621907:621990](∅→∅)

impl<'txn, T: TxnT> Iterator for AdjacentIterator<'txn, T> {
type Item = Edge;

[22.621907]

[22.621990]

impl<'txn, T: GraphTxnT> Iterator for AdjacentIterator<'txn, T> {
type Item = Result<Edge, TxnErr<T::GraphError>>;
replacement in libpijul/src/pristine/mod.rs at line 1106

[22.622052]→[22.622052:622420](∅→∅)

if let Some((v, e)) = self.it.next() {
debug!("adjacent iterator: {:?} {:?}", v, e);
if v == self.key {
if e.flag >= self.min_flag {
if e.flag <= self.max_flag {
return Some(e);
} else {
return None;

[22.622052]

[22.622420]

match self.it.next() {
Some(Ok((v, e))) => {
debug!("adjacent iterator: {:?} {:?}", v, e);
if v == self.key {
if e.flag >= self.min_flag {
if e.flag <= self.max_flag {
return Some(Ok(e));
} else {
return None;
}
edit in libpijul/src/pristine/mod.rs at line 1117

[22.622446]

[22.622446]

} else if v > self.key {
return None;
replacement in libpijul/src/pristine/mod.rs at line 1120

[22.622468]→[22.622468:622509](∅→∅)

} else if v > self.key {

[22.622468]

[22.622509]

}
Some(Err(e)) => return Some(Err(e)),
None => {
debug!("adjacent iterator: over");
edit in libpijul/src/pristine/mod.rs at line 1126

[22.622560]→[22.622560:622661](∅→∅)

} else {
debug!("adjacent iterator: over");
return None;
replacement in libpijul/src/pristine/mod.rs at line 1131

[22.622694]→[22.622694:622756](∅→∅)

pub struct PathChangeset<'channel, 'txn: 'channel, T: TxnT> {

[22.622694]

[22.622756]

pub struct PathChangeset<'channel, 'txn: 'channel, T: ChannelTxnT + DepsTxnT> {
replacement in libpijul/src/pristine/mod.rs at line 1138

[22.622919]→[22.622919:622984](∅→∅)

pub struct RevPathChangeset<'channel, 'txn: 'channel, T: TxnT> {

[22.622919]

[22.622984]

pub struct RevPathChangeset<'channel, 'txn: 'channel, T: ChannelTxnT + DepsTxnT> {
replacement in libpijul/src/pristine/mod.rs at line 1145

[22.623150]→[22.623150:623260](∅→∅)

impl<'channel, 'txn: 'channel, T: TxnT> Iterator for PathChangeset<'channel, 'txn, T> {
type Item = Hash;

[22.623150]

[22.623260]

impl<
'channel,
'txn: 'channel,
T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>,
> Iterator for PathChangeset<'channel, 'txn, T>
{
type Item = Result<Hash, TxnErr<T::GraphError>>;
replacement in libpijul/src/pristine/mod.rs at line 1153

[22.623307]→[22.623307:623453](∅→∅)

while let Some((_, (changeid, _))) = self.iter.next() {
for (p, touched) in self.txn.iter_rev_touched_files(changeid, None) {

[22.623307]

[22.623453]

while let Some(x) = self.iter.next() {
let (_, (changeid, _)) = match x {
Ok(x) => x,
Err(e) => return Some(Err(e)),
};
let iter = match self.txn.iter_rev_touched_files(changeid, None) {
Ok(iter) => iter,
Err(e) => return Some(Err(e)),
};
for x in iter {
let (p, touched) = match x {
Ok(x) => x,
Err(e) => return Some(Err(e)),
};
replacement in libpijul/src/pristine/mod.rs at line 1172

[22.623603]→[22.623603:623742](∅→∅)

if is_ancestor_of(self.txn, self.channel, self.key, touched) {
return self.txn.get_external(changeid);

[22.623603]

[22.623742]

match is_ancestor_of(self.txn, &self.channel.graph, self.key, touched) {
Ok(true) => return self.txn.get_external(changeid).transpose(),
Err(e) => return Some(Err(e)),
Ok(false) => {}
replacement in libpijul/src/pristine/mod.rs at line 1183

[22.623806]→[22.623806:623919](∅→∅)

impl<'channel, 'txn: 'channel, T: TxnT> Iterator for RevPathChangeset<'channel, 'txn, T> {
type Item = Hash;

[22.623806]

[22.623919]

impl<
'channel,
'txn: 'channel,
T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>,
> Iterator for RevPathChangeset<'channel, 'txn, T>
{
type Item = Result<Hash, TxnErr<T::GraphError>>;
replacement in libpijul/src/pristine/mod.rs at line 1191

[22.623966]→[22.623966:624112](∅→∅)

while let Some((_, (changeid, _))) = self.iter.next() {
for (p, touched) in self.txn.iter_rev_touched_files(changeid, None) {

[22.623966]

[22.624112]

loop {
let changeid = match self.iter.next()? {
Err(e) => return Some(Err(e)),
Ok((_, (changeid, _))) => changeid,
};
let iter = match self.txn.iter_rev_touched_files(changeid, None) {
Ok(iter) => iter,
Err(e) => return Some(Err(e)),
};
for x in iter {
let (p, touched) = match x {
Ok(x) => x,
Err(e) => return Some(Err(e)),
};
replacement in libpijul/src/pristine/mod.rs at line 1210

[22.624262]→[22.624262:624401](∅→∅)

if is_ancestor_of(self.txn, self.channel, self.key, touched) {
return self.txn.get_external(changeid);

[22.624262]

[22.624401]

match is_ancestor_of(self.txn, &self.channel.graph, self.key, touched) {
Ok(true) => return self.txn.get_external(changeid).transpose(),
Err(e) => return Some(Err(e)),
Ok(false) => {}
edit in libpijul/src/pristine/mod.rs at line 1217

[22.624443]→[22.624443:624456](∅→∅)

None
replacement in libpijul/src/pristine/mod.rs at line 1220

[22.624465]→[22.624465:624493](∅→∅)

fn is_ancestor_of<T: TxnT>(

[22.624465]

[22.624493]

fn is_ancestor_of<T: GraphTxnT>(
replacement in libpijul/src/pristine/mod.rs at line 1222

[22.624506]→[22.624506:624532](∅→∅)

channel: &Channel<T>,

[22.624506]

[22.624532]

channel: &T::Graph,
replacement in libpijul/src/pristine/mod.rs at line 1225

[22.624586]→[22.624586:624598](∅→∅)

) -> bool {

[22.624586]

[22.624598]

) -> Result<bool, TxnErr<T::GraphError>> {
replacement in libpijul/src/pristine/mod.rs at line 1232

[22.624799]→[22.624799:624824](∅→∅)

return true;

[22.624799]

[22.624824]

return Ok(true);
replacement in libpijul/src/pristine/mod.rs at line 1243

[22.625107]→[22.625107:625119](∅→∅)

) {

[22.625107]

[22.625119]

)? {
let p = p?;
replacement in libpijul/src/pristine/mod.rs at line 1253

[22.625458]→[22.625458:625474](∅→∅)

) {

[22.625458]

[22.625474]

)? {
let pp = pp?;
replacement in libpijul/src/pristine/mod.rs at line 1256

[22.625508]→[22.625508:625541](∅→∅)

return true;

[22.625508]

[22.625541]

return Ok(true);
replacement in libpijul/src/pristine/mod.rs at line 1262

[22.625625]→[22.625625:625635](∅→∅)

false

[22.625625]

[22.625635]

Ok(false)
replacement in libpijul/src/pristine/mod.rs at line 1271

[22.625794]→[22.625794:625825](∅→∅)

type Item = ChannelRef<T>;

[22.625794]

[22.625825]

type Item = Result<ChannelRef<T>, TxnErr<T::GraphError>>;
replacement in libpijul/src/pristine/mod.rs at line 1273

[22.625872]→[22.625872:626130](∅→∅)

let next: Option<(SmallString, (u64, u64, u64, u64, u64, u64))> =
self.txn.cursor_channels_next(&mut self.cursor);
if let Some((name, _)) = next {
self.txn.load_channel(name.as_str())
} else {
None

[22.625872]

[22.626130]

// Option<(SmallString, (u64, u64, u64, u64, u64, u64))>
match self.txn.cursor_channels_next(&mut self.cursor) {
Err(e) => Some(Err(e)),
Ok(Some((name, _))) => self.txn.load_channel(name.as_str()).transpose(),
Ok(None) => None,
replacement in libpijul/src/pristine/mod.rs at line 1288

[22.626304]→[22.626304:626334](∅→∅)

type Item = RemoteRef<T>;

[22.626304]

[22.626334]

type Item = Result<RemoteRef<T>, TxnErr<T::GraphError>>;
replacement in libpijul/src/pristine/mod.rs at line 1290

[22.626381]→[22.626381:626622](∅→∅)

let next: Option<(SmallString, (u64, u64, u64))> =
self.txn.cursor_remotes_next(&mut self.cursor);
if let Some((name, _)) = next {
self.txn.load_remote(name.as_str())
} else {
None

[22.626381]

[22.626622]

match self.txn.cursor_remotes_next(&mut self.cursor) {
Ok(Some((name, _))) => self.txn.load_remote(name.as_str()).transpose(),
Ok(None) => None,
Err(e) => Some(Err(e)),
replacement in libpijul/src/pristine/mod.rs at line 1298

[22.626696]→[22.626696:626843](∅→∅)

/// The trait of immutable transactions.
pub trait MutTxnT: TxnT {
put_del!(internal, Hash, ChangeId);
put_del!(external, ChangeId, Hash);

[22.626696]

[22.626843]

pub trait GraphMutTxnT: GraphTxnT {
put_del!(internal, Hash, ChangeId, GraphError);
put_del!(external, ChangeId, Hash, GraphError);
edit in libpijul/src/pristine/mod.rs at line 1302

[22.626844]→[22.626844:627224](∅→∅),[22.628320]→[22.628320:628321](∅→∅)

put_del!(inodes, Inode, Position<ChangeId>);
put_del!(revinodes, Position<ChangeId>, Inode);

put_del!(tree, PathId, Inode);
put_del!(revtree, Inode, PathId);

put_del!(dep, ChangeId, ChangeId);
put_del!(revdep, ChangeId, ChangeId);

put_del!(touched_files, Position<ChangeId>, ChangeId);
put_del!(rev_touched_files, ChangeId, Position<ChangeId>);
replacement in libpijul/src/pristine/mod.rs at line 1308

[22.629258]→[22.17914:17950](∅→∅)

) -> Result<bool, Self::Error>;

[22.629258]

[22.629296]

) -> Result<bool, TxnErr<Self::GraphError>>;
replacement in libpijul/src/pristine/mod.rs at line 1316

[22.629546]→[22.17951:17987](∅→∅)

) -> Result<bool, Self::Error>;

[22.629546]

[22.629584]

) -> Result<bool, TxnErr<Self::GraphError>>;
}
edit in libpijul/src/pristine/mod.rs at line 1319

[22.629585]

[22.629585]

pub trait ChannelMutTxnT: ChannelTxnT + GraphMutTxnT {
replacement in libpijul/src/pristine/mod.rs at line 1327

[22.629939]→[22.17988:18034](∅→∅)

) -> Result<Option<Merkle>, Self::Error>;

[22.629939]

[22.629987]

) -> Result<Option<Merkle>, TxnErr<Self::GraphError>>;
replacement in libpijul/src/pristine/mod.rs at line 1335

[22.630240]→[22.18035:18071](∅→∅)

) -> Result<bool, Self::Error>;

[22.630240]

[22.630278]

) -> Result<bool, TxnErr<Self::GraphError>>;
}

pub trait DepsMutTxnT: DepsTxnT {
put_del!(dep, ChangeId, ChangeId, DepsError);
put_del!(revdep, ChangeId, ChangeId, DepsError);
put_del!(touched_files, Position<ChangeId>, ChangeId, DepsError);
put_del!(rev_touched_files, ChangeId, Position<ChangeId>, DepsError);
}

pub trait TreeMutTxnT: TreeTxnT {
put_del!(inodes, Inode, Position<ChangeId>, TreeError);
put_del!(revinodes, Position<ChangeId>, Inode, TreeError);
put_del!(tree, PathId, Inode, TreeError);
put_del!(revtree, Inode, PathId, TreeError);
fn put_partials(
&mut self,
k: &str,
e: Position<ChangeId>,
) -> Result<bool, TxnErr<Self::TreeError>>;

fn del_partials(
&mut self,
k: &str,
e: Option<Position<ChangeId>>,
) -> Result<bool, TxnErr<Self::TreeError>>;
}
edit in libpijul/src/pristine/mod.rs at line 1363

[22.630279]

[22.630279]

/// The trait of immutable transactions.
pub trait MutTxnT:
GraphMutTxnT
+ ChannelMutTxnT
+ DepsMutTxnT<DepsError = <Self as GraphTxnT>::GraphError>
+ TreeMutTxnT<TreeError = <Self as GraphTxnT>::GraphError>
+ TxnT
{
replacement in libpijul/src/pristine/mod.rs at line 1381

[22.631045]→[22.18072:18167](∅→∅)

fn open_or_create_channel(&mut self, name: &str) -> Result<ChannelRef<Self>, Self::Error>;

[22.631045]

[22.631142]

fn open_or_create_channel(&mut self, name: &str) -> Result<ChannelRef<Self>, Self::GraphError>;
replacement in libpijul/src/pristine/mod.rs at line 1387

[22.631231]→[22.18168:18227](∅→∅)

) -> Result<ChannelRef<Self>, ForkError<Self::Error>>;

[22.631231]

[22.631281]

) -> Result<ChannelRef<Self>, ForkError<Self::GraphError>>;
replacement in libpijul/src/pristine/mod.rs at line 1393

[22.631384]→[22.18228:18273](∅→∅)

) -> Result<(), ForkError<Self::Error>>;

[22.631384]

[22.631420]

) -> Result<(), ForkError<Self::GraphError>>;
replacement in libpijul/src/pristine/mod.rs at line 1395

[22.631421]→[22.18274:18347](∅→∅)

fn drop_channel(&mut self, name: &str) -> Result<bool, Self::Error>;

[22.631421]

[22.631496]

fn drop_channel(&mut self, name: &str) -> Result<bool, Self::GraphError>;
replacement in libpijul/src/pristine/mod.rs at line 1398

[22.631530]→[22.18348:18396](∅→∅),[22.18396]→[22.636462:636463](∅→∅),[22.636462]→[22.636462:636463](∅→∅),[22.636463]→[22.18397:18490](∅→∅)

fn commit(self) -> Result<(), Self::Error>;

fn put_partials(&mut self, k: &str, e: Position<ChangeId>) -> Result<bool, Self::Error>;

[22.631530]

[22.637989]

fn commit(self) -> Result<(), Self::GraphError>;
replacement in libpijul/src/pristine/mod.rs at line 1400

[22.637990]→[22.18491:18600](∅→∅)

fn del_partials(&mut self, k: &str, e: Option<Position<ChangeId>>)
-> Result<bool, Self::Error>;

[22.637990]

[22.638143]

fn open_or_create_remote(&mut self, name: &str) -> Result<RemoteRef<Self>, Self::GraphError>;
edit in libpijul/src/pristine/mod.rs at line 1402

[22.638144]→[22.18601:18694](∅→∅),[22.18694]→[22.638239:638240](∅→∅),[22.638239]→[22.638239:638240](∅→∅)

fn open_or_create_remote(&mut self, name: &str) -> Result<RemoteRef<Self>, Self::Error>;
replacement in libpijul/src/pristine/mod.rs at line 1407

[22.638359]→[22.18695:18731](∅→∅)

) -> Result<bool, Self::Error>;

[22.638359]

[22.638397]

) -> Result<bool, Self::GraphError>;
replacement in libpijul/src/pristine/mod.rs at line 1409

[22.638398]→[22.18732:18829](∅→∅)

fn del_remote(&mut self, remote: &mut RemoteRef<Self>, k: u64) -> Result<bool, Self::Error>;

[22.638398]

[22.638497]

fn del_remote(
&mut self,
remote: &mut RemoteRef<Self>,
k: u64,
) -> Result<bool, Self::GraphError>;
replacement in libpijul/src/pristine/mod.rs at line 1415

[22.638498]→[22.18830:18915](∅→∅)

fn drop_remote(&mut self, remote: RemoteRef<Self>) -> Result<bool, Self::Error>;

[22.638498]

[22.638585]

fn drop_remote(&mut self, remote: RemoteRef<Self>) -> Result<bool, Self::GraphError>;
replacement in libpijul/src/pristine/mod.rs at line 1417

[22.638586]→[22.18916:18996](∅→∅)

fn drop_named_remote(&mut self, remote: &str) -> Result<bool, Self::Error>;

[22.638586]

[22.50088]

fn drop_named_remote(&mut self, remote: &str) -> Result<bool, Self::GraphError>;
replacement in libpijul/src/pristine/mod.rs at line 1420

[22.50091]→[22.50091:50138](∅→∅)

pub(crate) fn put_inodes_with_rev<T: MutTxnT>(

[22.50091]

[22.50138]

pub(crate) fn put_inodes_with_rev<T: TreeMutTxnT>(
replacement in libpijul/src/pristine/mod.rs at line 1424

[22.50207]→[22.18997:19025](∅→∅)

) -> Result<(), T::Error> {

[22.50207]

[22.50240]

) -> Result<(), TxnErr<T::TreeError>> {
replacement in libpijul/src/pristine/mod.rs at line 1430

[22.1530]→[22.1530:1577](∅→∅)

pub(crate) fn del_inodes_with_rev<T: MutTxnT>(

[22.1530]

[22.1577]

pub(crate) fn del_inodes_with_rev<T: TreeMutTxnT>(
replacement in libpijul/src/pristine/mod.rs at line 1434

[22.1646]→[22.19026:19056](∅→∅)

) -> Result<bool, T::Error> {

[22.1646]

[22.1681]

) -> Result<bool, TxnErr<T::TreeError>> {
replacement in libpijul/src/pristine/mod.rs at line 1443

[22.1846]→[22.1846:1891](∅→∅)

pub(crate) fn put_tree_with_rev<T: MutTxnT>(

[22.1846]

[22.1891]

pub(crate) fn put_tree_with_rev<T: TreeMutTxnT>(
replacement in libpijul/src/pristine/mod.rs at line 1447

[22.1947]→[22.19057:19085](∅→∅)

) -> Result<(), T::Error> {

[22.1947]

[22.1980]

) -> Result<(), TxnErr<T::TreeError>> {
replacement in libpijul/src/pristine/mod.rs at line 1453

[22.50333]→[22.2054:2099](∅→∅)

pub(crate) fn del_tree_with_rev<T: MutTxnT>(

[22.50333]

[22.2099]

pub(crate) fn del_tree_with_rev<T: TreeMutTxnT>(
replacement in libpijul/src/pristine/mod.rs at line 1457

[22.2155]→[22.19086:19116](∅→∅)

) -> Result<bool, T::Error> {

[22.2155]

[22.2190]

) -> Result<bool, TxnErr<T::TreeError>> {
replacement in libpijul/src/pristine/mod.rs at line 1470

[22.50444]→[22.50444:50483](∅→∅)

pub(crate) fn split_block<T: MutTxnT>(

[22.50444]

[22.50483]

pub(crate) fn split_block<T: GraphMutTxnT>(
replacement in libpijul/src/pristine/mod.rs at line 1472

[22.50500]→[22.50500:50530](∅→∅)

channel: &mut Channel<T>,

[22.50500]

[22.50530]

graph: &mut T::Graph,
replacement in libpijul/src/pristine/mod.rs at line 1475

[22.50582]→[22.19117:19145](∅→∅),[22.19145]→[22.50615:50937](∅→∅),[22.50615]→[22.50615:50937](∅→∅)

) -> Result<(), T::Error> {
trace!("key = {:?}, pos = {:?}", key, pos);
let adjacent: Vec<_> = txn
.cursor_graph(&channel.graph, Some((key, None)))
.take_while(|&(k, _)| k <= key)
.filter(|&(k, _)| k == key)
.map(|(_, e)| e)
.collect();
debug!("adjacent {:?}", adjacent);
for chi in adjacent {

[22.50582]

[22.50937]

buf: &mut Vec<Edge>,
) -> Result<(), TxnErr<T::GraphError>> {
for x in txn.cursor_graph(graph, Some((key, None)))? {
let (k, v) = x?;
if k > key {
break;
} else if k < key {
continue;
}
buf.push(v)
}
for chi in buf.drain(..) {
replacement in libpijul/src/pristine/mod.rs at line 1491

[22.51153]→[22.51153:51178](∅→∅)

channel,

[22.51153]

[22.51178]

graph,
replacement in libpijul/src/pristine/mod.rs at line 1507

[22.51588]→[22.51588:51648](∅→∅)

txn.del_graph(&mut channel.graph, key, Some(chi))?;

[22.51588]

[22.51648]

txn.del_graph(graph, key, Some(chi))?;
replacement in libpijul/src/pristine/mod.rs at line 1509

[22.51671]→[22.51671:51703](∅→∅)

&mut channel.graph,

[22.51671]

[22.51703]

graph,
replacement in libpijul/src/pristine/mod.rs at line 1529

[22.52142]→[22.52142:52188](∅→∅)

pub(crate) fn del_graph_with_rev<T: MutTxnT>(

[22.52142]

[22.52188]

pub(crate) fn del_graph_with_rev<T: GraphMutTxnT>(
replacement in libpijul/src/pristine/mod.rs at line 1531

[22.52205]→[22.52205:52235](∅→∅)

channel: &mut Channel<T>,

[22.52205]

[22.52235]

graph: &mut T::Graph,
replacement in libpijul/src/pristine/mod.rs at line 1536

[22.52349]→[22.19146:19176](∅→∅)

) -> Result<bool, T::Error> {

[22.52349]

[22.52384]

) -> Result<bool, TxnErr<T::GraphError>> {
replacement in libpijul/src/pristine/mod.rs at line 1543

[22.52598]→[22.52598:52626](∅→∅)

&mut channel.graph,

[22.52598]

[22.52626]

graph,
replacement in libpijul/src/pristine/mod.rs at line 1555

[22.52866]→[22.52866:52894](∅→∅)

&mut channel.graph,

[22.52866]

[22.52894]

graph,
replacement in libpijul/src/pristine/mod.rs at line 1570

[22.53180]→[22.53180:53226](∅→∅)

pub(crate) fn put_graph_with_rev<T: MutTxnT>(

[22.53180]

[22.53226]

pub(crate) fn put_graph_with_rev<T: GraphMutTxnT>(
replacement in libpijul/src/pristine/mod.rs at line 1572

[22.53243]→[22.53243:53273](∅→∅)

channel: &mut Channel<T>,

[22.53243]

[22.53273]

graph: &mut T::Graph,
replacement in libpijul/src/pristine/mod.rs at line 1577

[22.53375]→[22.19177:19207](∅→∅)

) -> Result<bool, T::Error> {

[22.53375]

[22.53410]

) -> Result<bool, TxnErr<T::GraphError>> {
replacement in libpijul/src/pristine/mod.rs at line 1587

[22.53742]→[22.53742:53770](∅→∅)

&mut channel.graph,

[22.53742]

[22.53770]

graph,
replacement in libpijul/src/pristine/mod.rs at line 1599

[22.54004]→[22.54004:54032](∅→∅)

&mut channel.graph,

[22.54004]

[22.54032]

graph,
replacement in libpijul/src/pristine/mod.rs at line 1614

[22.54311]→[22.54311:54354](∅→∅)

pub(crate) fn register_change<T: MutTxnT>(

[22.54311]

[22.54354]

pub(crate) fn register_change<
T: GraphMutTxnT + DepsMutTxnT<DepsError = <T as GraphTxnT>::GraphError>,
>(
replacement in libpijul/src/pristine/mod.rs at line 1621

[22.54432]→[22.19208:19236](∅→∅)

) -> Result<(), T::Error> {

[22.54432]

[22.12106]

) -> Result<(), TxnErr<T::GraphError>> {
replacement in libpijul/src/pristine/mod.rs at line 1627

[22.12187]→[22.54658:54718](∅→∅),[22.54658]→[22.54658:54718](∅→∅)

let dep_internal = txn.get_internal(*dep).unwrap();

[22.12187]

[22.12188]

let dep_internal = txn.get_internal(*dep)?.unwrap();
edit in libpijul/src/pristine/mod.rs at line 1649

[22.55157]

[22.55157]

let change = if let Some(c) = inode.change {
txn.get_internal(c)?.unwrap_or(internal)
} else {
internal
};
replacement in libpijul/src/pristine/mod.rs at line 1655

[22.55188]→[22.55188:55337](∅→∅)

change: inode
.change
.and_then(|change| txn.get_internal(change))
.unwrap_or(internal),

[22.55188]

[22.55337]

change,
replacement in libpijul/src/pristine/mod.rs at line 1676

[22.583]→[22.583:650](∅→∅)

pub fn check_tree_inodes<T: TxnT>(txn: &T, channel: &Channel<T>) {

[22.583]

[22.650]

pub fn check_tree_inodes<T: GraphTxnT + TreeTxnT>(txn: &T, channel: &T::Graph) {
replacement in libpijul/src/pristine/mod.rs at line 1678

[22.670]→[22.670:717](∅→∅)

for (inode, vertex) in txn.iter_inodes() {

[22.670]

[22.717]

for x in txn.iter_inodes().unwrap() {
let (inode, vertex) = x.unwrap();
replacement in libpijul/src/pristine/mod.rs at line 1682

[22.783]→[22.783:847](∅→∅)

if let Some(next) = txn.get_revtree(inode_, None) {

[22.783]

[22.847]

if let Some(next) = txn.get_revtree(inode_, None).unwrap() {
replacement in libpijul/src/pristine/mod.rs at line 1688

[22.1006]→[22.1006:1067](∅→∅),[22.1067]→[21.7742:7816](∅→∅),[21.7816]→[22.1275:1334](∅→∅),[22.1275]→[22.1275:1334](∅→∅)

if !is_alive(txn, &channel, vertex.inode_vertex()) {
for e in iter_adj_all(txn, &channel, vertex.inode_vertex()) {
error!("{:?} {:?} {:?}", inode, vertex, e)

[22.1006]

[22.1334]

if !is_alive(txn, &channel, vertex.inode_vertex()).unwrap() {
for e in iter_adj_all(txn, channel, vertex.inode_vertex()).unwrap() {
error!("{:?} {:?} {:?}", inode, vertex, e.unwrap())
replacement in libpijul/src/pristine/mod.rs at line 1705

[22.1708]→[22.1708:1758](∅→∅)

for (id, inode) in txn.iter_tree(id0, None) {

[22.1708]

[22.1758]

for x in txn.iter_tree(id0, None).unwrap() {
let (id, inode) = x.unwrap();
replacement in libpijul/src/pristine/mod.rs at line 1714

[22.1993]→[22.1993:2064](∅→∅)

pub fn check_alive_debug<T: TxnT, C: crate::changestore::ChangeStore>(

[22.1993]

[22.2064]

pub fn check_alive_debug<T: ChannelTxnT, C: crate::changestore::ChangeStore>(
replacement in libpijul/src/pristine/mod.rs at line 1717

[22.2094]→[22.2094:2123](∅→∅)

channel: &ChannelRef<T>,

[22.2094]

[22.2123]

channel: &Channel<T>,
replacement in libpijul/src/pristine/mod.rs at line 1720

[22.19271]→[22.2171:2245](∅→∅),[22.2171]→[22.2171:2245](∅→∅)

let (alive, reachable) = crate::pristine::check_alive(txn, &channel);

[22.19271]

[22.2245]

let (alive, reachable) = crate::pristine::check_alive(txn, &channel.graph);
replacement in libpijul/src/pristine/mod.rs at line 1737

[22.489]→[22.489:590](∅→∅)

let (path, _) = crate::fs::find_path(changes, txn, &channel.borrow(), true, file_).unwrap();

[22.489]

[22.590]

let (path, _) = crate::fs::find_path(changes, txn, channel, true, file_).unwrap();
replacement in libpijul/src/pristine/mod.rs at line 1746

[22.835]→[22.2776:2938](∅→∅),[22.2776]→[22.2776:2938](∅→∅)

let graph = crate::alive::retrieve::retrieve(txn, &channel.borrow(), file_);
graph.debug(changes, txn, &channel.borrow(), false, false, &mut f)?;

[22.835]

[22.2938]

let graph = crate::alive::retrieve::retrieve(txn, &channel.graph, file_).unwrap();
graph.debug(changes, txn, &channel.graph, false, false, &mut f)?;
replacement in libpijul/src/pristine/mod.rs at line 1750

[22.906]→[22.3018:3058](∅→∅),[22.3018]→[22.3018:3058](∅→∅),[22.3058]→[22.806:872](∅→∅)

let channel = channel.borrow();
debug_root(txn, &channel, file.unwrap(), &mut f, false)?;

[22.906]

[22.3117]

debug_root(txn, &channel.graph, file.unwrap(), &mut f, false)?;
edit in libpijul/src/pristine/channel_dump.rs at line 10

[22.19475]

[22.19475]

}

impl<T: std::error::Error + 'static> std::convert::From<TxnErr<T>> for ChannelDumpError<T> {
fn from(e: TxnErr<T>) -> Self {
ChannelDumpError::Txn(e.0)
}
replacement in libpijul/src/pristine/channel_dump.rs at line 18

[22.650094]→[22.650094:650167](∅→∅)

enum DumpChannelState<T: super::TxnT, RT: std::ops::Deref<Target = T>> {

[22.650094]

[22.650167]

enum DumpChannelState<
T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>,
RT: std::ops::Deref<Target = T>,
> {
replacement in libpijul/src/pristine/channel_dump.rs at line 35

[22.650588]→[22.650588:650608](∅→∅)

T: super::TxnT,

[22.650588]

[22.650608]

T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>,
replacement in libpijul/src/pristine/channel_dump.rs at line 71

[22.651272]→[22.651272:651296](∅→∅)

T: super::TxnT,

[22.651272]

[22.651296]

T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>,
replacement in libpijul/src/pristine/channel_dump.rs at line 76

[22.651454]→[22.651454:651481](∅→∅)

type Item = DumpChunk;

[22.651454]

[22.651481]

type Item = Result<DumpChunk, TxnErr<T::GraphError>>;
replacement in libpijul/src/pristine/channel_dump.rs at line 86

[22.651789]→[22.651789:651854](∅→∅)

while let Some((h, dep)) = deps.next() {

[22.651789]

[22.651854]

while let Some(x) = deps.next() {
let (h, dep) = match x {
Ok(x) => x,
Err(e) => return Some(Err(e)),
};
replacement in libpijul/src/pristine/channel_dump.rs at line 104

[22.652501]→[22.652501:652563](∅→∅)

return Some(DumpChunk::Dep(msg));

[22.652501]

[22.652563]

return Some(Ok(DumpChunk::Dep(msg)));
replacement in libpijul/src/pristine/channel_dump.rs at line 107

[22.652611]→[22.652611:652750](∅→∅)

if let Some((_, (h, _))) = log.next() {
let deps = Some(T::iter_dep_ref(self.txn.clone(), h));

[22.652611]

[22.652750]

if let Some(x) = log.next() {
let (_, (h, _)) = match x {
Ok(e) => e,
Err(e) => return Some(Err(e)),
};
let deps = match T::iter_dep_ref(self.txn.clone(), h) {
Ok(e) => Some(e),
Err(e) => return Some(Err(e)),
};
replacement in libpijul/src/pristine/channel_dump.rs at line 121

[22.652955]→[22.652955:653024](∅→∅)

let ext = self.txn.get_external(h).unwrap();

[22.652955]

[22.653024]

let ext = match self.txn.get_external(h) {
Ok(ext) => ext.unwrap(),
Err(e) => return Some(Err(e)),
};
replacement in libpijul/src/pristine/channel_dump.rs at line 129

[22.653253]→[22.653253:653312](∅→∅)

return Some(DumpChunk::Hash(msg));

[22.653253]

[22.653312]

return Some(Ok(DumpChunk::Hash(msg)));
replacement in libpijul/src/pristine/channel_dump.rs at line 132

[22.653409]→[22.55589:55640](∅→∅)

graph: iter_graph_ref(

[22.653409]

[22.653463]

graph: match iter_graph_ref(
replacement in libpijul/src/pristine/channel_dump.rs at line 137

[22.653650]→[22.653650:653681](∅→∅)

),

[22.653650]

[22.653681]

) {
Ok(x) => x,
Err(e) => return Some(Err(e)),
},
replacement in libpijul/src/pristine/channel_dump.rs at line 151

[22.654008]→[22.654008:654065](∅→∅)

if let Some((v, e)) = graph.next() {

[22.654008]

[22.654065]

if let Some(x) = graph.next() {
let (v, e) = match x {
Err(e) => return Some(Err(e)),
Ok(x) => x,
};
replacement in libpijul/src/pristine/channel_dump.rs at line 180

[22.655490]→[22.655490:655553](∅→∅)

return Some(DumpChunk::Edge(buf));

[22.655490]

[22.655553]

return Some(Ok(DumpChunk::Edge(buf)));
replacement in libpijul/src/pristine/channel_dump.rs at line 193

[22.656272]→[22.656272:656334](∅→∅)

return Some(DumpChunk::End(buf));

[22.656272]

[22.656334]

return Some(Ok(DumpChunk::End(buf)));
replacement in libpijul/src/pristine/channel_dump.rs at line 202

[22.656845]→[22.656845:656903](∅→∅)

return Some(DumpChunk::End(buf));

[22.656845]

[22.656903]

return Some(Ok(DumpChunk::End(buf)));
replacement in libpijul/src/pristine/channel_dump.rs at line 212

[22.657034]→[22.657034:657054](∅→∅)

T: super::TxnT,

[22.657034]

[22.657054]

T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>,
replacement in libpijul/src/pristine/channel_dump.rs at line 218

[22.657193]→[22.657193:657240](∅→∅)

) -> DumpChannel<T, RT, C> {
DumpChannel {

[22.657193]

[22.657240]

) -> Result<DumpChannel<T, RT, C>, TxnErr<T::GraphError>> {
Ok(DumpChannel {
replacement in libpijul/src/pristine/channel_dump.rs at line 221

[22.657288]→[22.55641:55702](∅→∅)

log: changeid_log_ref(txn.clone(), &channel, 0),

[22.657288]

[22.657352]

log: changeid_log_ref(txn.clone(), &channel, 0)?,
replacement in libpijul/src/pristine/channel_dump.rs at line 227

[22.657455]→[22.657455:657461](∅→∅)

}

[22.657455]

[22.657461]

})
replacement in libpijul/src/pristine/channel_dump.rs at line 230

[22.657464]→[22.657464:657516](∅→∅)

pub struct ChannelFromDump<'a, T: super::MutTxnT> {

[22.657464]

[22.657516]

pub struct ChannelFromDump<'a, T: ChannelMutTxnT> {
replacement in libpijul/src/pristine/channel_dump.rs at line 322

[22.660741]→[22.660741:660794](∅→∅)

impl<'a, T: super::MutTxnT> ChannelFromDump<'a, T> {

[22.660741]

[22.660794]

impl<'a, T: ChannelMutTxnT + DepsMutTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>>
ChannelFromDump<'a, T>
{
replacement in libpijul/src/pristine/channel_dump.rs at line 341

[22.661301]→[22.19478:19547](∅→∅)

pub fn read(&mut self, bytes: &[u8]) -> Result<bool, T::Error> {

[22.661301]

[22.661375]

pub fn read(&mut self, bytes: &[u8]) -> Result<bool, TxnErr<T::GraphError>> {
replacement in libpijul/src/pristine/channel_dump.rs at line 350

[22.661853]→[22.661853:661918](∅→∅)

if let Some(hh) = self.txn.get_external(p) {

[22.661853]

[22.661918]

if let Some(hh) = self.txn.get_external(p)? {
replacement in libpijul/src/pristine/channel_dump.rs at line 352

[22.661958]→[22.55703:55772](∅→∅)

let pp = make_changeid(self.txn, &hash);

[22.661958]

[22.662026]

let pp = make_changeid(self.txn, &hash)?;
replacement in libpijul/src/pristine/channel_dump.rs at line 422

[22.664926]→[22.664926:664964](∅→∅)

fn finish_channel<T: super::MutTxnT>(

[22.664926]

[22.664964]

fn finish_channel<T: super::ChannelMutTxnT>(
replacement in libpijul/src/pristine/channel_dump.rs at line 427

[22.665110]→[22.19548:19576](∅→∅)

) -> Result<(), T::Error> {

[22.665110]

[22.665143]

) -> Result<(), TxnErr<T::GraphError>> {
replacement in libpijul/src/pristine/block.rs at line 4

[22.19602]→[22.19602:19694](∅→∅)

#[error("Block error: {:?}", block)]
pub struct BlockError {
block: Position<ChangeId>,

[22.19602]

[22.19694]

pub enum BlockError<T: std::error::Error + 'static> {
#[error(transparent)]
Txn(T),
#[error("Block error: {:?}", block)]
Block { block: Position<ChangeId> },
}

impl<T: std::error::Error + 'static> std::convert::From<TxnErr<T>> for BlockError<T> {
fn from(e: TxnErr<T>) -> Self {
BlockError::Txn(e.0)
}
replacement in libpijul/src/pristine/block.rs at line 18

[22.65]→[22.65:116](∅→∅)

pub(crate) fn find_block<'db, 'txn: 'db, T: TxnT>(

[22.65]

[22.116]

pub(crate) fn find_block<'db, 'txn: 'db, T: GraphTxnT>(
replacement in libpijul/src/pristine/block.rs at line 20

[22.134]→[22.134:164](∅→∅)

channel: &'db Channel<T>,

[22.134]

[22.164]

graph: &'db T::Graph,
replacement in libpijul/src/pristine/block.rs at line 22

[22.191]→[22.19697:19741](∅→∅)

) -> Result<Vertex<ChangeId>, BlockError> {

[22.191]

[22.237]

) -> Result<Vertex<ChangeId>, BlockError<T::GraphError>> {
replacement in libpijul/src/pristine/block.rs at line 32

[22.470]→[22.470:608](∅→∅)

let mut cursor = txn.cursor_graph(&channel.graph, Some((key, None)));
let mut k = if let Some((k, _)) = cursor.next() {
k

[22.470]

[22.608]

let mut cursor = txn.cursor_graph(graph, Some((key, None)))?;
let mut k = if let Some(k) = cursor.next() {
k?.0
replacement in libpijul/src/pristine/block.rs at line 36

[22.621]→[22.19742:19787](∅→∅)

return Err(BlockError { block: p });

[22.621]

[22.680]

return Err(BlockError::Block { block: p });
replacement in libpijul/src/pristine/block.rs at line 45

[22.1113]→[22.1113:1179](∅→∅)

if let Some((k_, _)) = cursor.prev() {
k = k_

[22.1113]

[22.1179]

if let Some(k_) = cursor.prev() {
k = k_?.0
replacement in libpijul/src/pristine/block.rs at line 58

[22.1526]→[22.19788:19837](∅→∅)

return Err(BlockError { block: p });

[22.1526]

[22.1589]

return Err(BlockError::Block { block: p });
replacement in libpijul/src/pristine/block.rs at line 60

[22.1599]→[22.1599:1665](∅→∅)

if let Some((k_, _)) = cursor.next() {
k = k_

[22.1599]

[22.1665]

if let Some(k_) = cursor.next() {
k = k_?.0
replacement in libpijul/src/pristine/block.rs at line 67

[22.1789]→[22.19838:19871](∅→∅)

Err(BlockError { block: p })

[22.1789]

[22.1836]

Err(BlockError::Block { block: p })
replacement in libpijul/src/pristine/block.rs at line 71

[22.1878]→[22.1878:1933](∅→∅)

pub(crate) fn find_block_end<'db, 'txn: 'db, T: TxnT>(

[22.1878]

[22.1933]

pub(crate) fn find_block_end<'db, 'txn: 'db, T: GraphTxnT>(
replacement in libpijul/src/pristine/block.rs at line 73

[22.1951]→[22.1951:1981](∅→∅)

channel: &'db Channel<T>,

[22.1951]

[22.1981]

graph: &'db T::Graph,
replacement in libpijul/src/pristine/block.rs at line 75

[22.2008]→[22.19872:19916](∅→∅)

) -> Result<Vertex<ChangeId>, BlockError> {

[22.2008]

[22.2054]

) -> Result<Vertex<ChangeId>, BlockError<T::GraphError>> {
replacement in libpijul/src/pristine/block.rs at line 85

[22.2326]→[22.2326:2464](∅→∅)

let mut cursor = txn.cursor_graph(&channel.graph, Some((key, None)));
let mut k = if let Some((k, _)) = cursor.next() {
k

[22.2326]

[22.2464]

let mut cursor = txn.cursor_graph(graph, Some((key, None)))?;
let mut k = if let Some(k) = cursor.next() {
k?.0
replacement in libpijul/src/pristine/block.rs at line 89

[22.2477]→[22.19917:19962](∅→∅)

return Err(BlockError { block: p });

[22.2477]

[22.2536]

return Err(BlockError::Block { block: p });
replacement in libpijul/src/pristine/block.rs at line 106

[22.3253]→[22.3253:3319](∅→∅)

if let Some((k_, _)) = cursor.prev() {
k = k_

[22.3253]

[22.3319]

if let Some(k_) = cursor.prev() {
k = k_?.0
replacement in libpijul/src/pristine/block.rs at line 116

[22.3643]→[22.3643:3709](∅→∅)

if let Some((k_, _)) = cursor.next() {
k = k_

[22.3643]

[22.3709]

if let Some(k_) = cursor.next() {
k = k_?.0
replacement in libpijul/src/pristine/block.rs at line 126

[22.3968]→[22.19963:20000](∅→∅)

Err(BlockError { block: p })

[22.3968]

[22.4019]

Err(BlockError::Block { block: p })
replacement in libpijul/src/output/output.rs at line 37

[22.673225]→[22.20081:20153](∅→∅)

) -> Result<Vec<Conflict>, OutputError<P::Error, T::Error, R::Error>> {

[22.673225]

[22.673269]

) -> Result<Vec<Conflict>, OutputError<P::Error, T::GraphError, R::Error>> {
replacement in libpijul/src/output/output.rs at line 51

[22.673568]→[22.673568:673584](∅→∅)

T: MutTxnT,

[22.673568]

[22.673584]

T: TreeMutTxnT + ChannelTxnT + GraphMutTxnT<GraphError = <T as TreeTxnT>::TreeError>,
replacement in libpijul/src/output/output.rs at line 63

[22.673828]→[22.20154:20226](∅→∅)

) -> Result<Vec<Conflict>, OutputError<P::Error, T::Error, R::Error>> {

[22.673828]

[22.673931]

) -> Result<Vec<Conflict>, OutputError<P::Error, T::TreeError, R::Error>> {
replacement in libpijul/src/output/output.rs at line 71

[22.674146]→[22.674146:674163](∅→∅)

channel,

[22.674146]

[22.674163]

&channel.graph,
replacement in libpijul/src/output/output.rs at line 80

[22.674352]→[22.674352:674437](∅→∅)

let dead = collect_dead_files(txn, channel, pending_change_id, Inode::ROOT);

[22.674352]

[22.674437]

let dead = collect_dead_files(txn, &channel.graph, pending_change_id, Inode::ROOT)?;
replacement in libpijul/src/output/output.rs at line 122

[22.676154]→[22.676154:676216](∅→∅)

if let Some((inode, _)) = output_item.inode {

[22.676154]

[22.676216]

let output_item_inode =
if let Some(inode) = txn.get_revinodes(output_item.pos, None)? {
Some((inode, txn.get_inodes(inode, None)?.unwrap()))
} else {
None
};

if let Some((inode, _)) = output_item_inode {
edit in libpijul/src/output/output.rs at line 159

[22.677510]

[22.677510]

output_item_inode,
replacement in libpijul/src/output/output.rs at line 165

[22.677697]→[22.677697:677788](∅→∅)

let dead = collect_dead_files(txn, channel, pending_change_id, inode);

[22.677697]

[22.677788]

let dead = collect_dead_files(txn, &channel.graph, pending_change_id, inode)?;
replacement in libpijul/src/output/output.rs at line 176

[22.678240]→[22.678240:678273](∅→∅)

channel,

[22.678240]

[22.678273]

&channel.graph,
replacement in libpijul/src/output/output.rs at line 182

[22.678463]→[22.678463:678486](∅→∅)

)?

[22.678463]

[22.678486]

)?;
replacement in libpijul/src/output/output.rs at line 224

[22.21084]→[22.21084:21147](∅→∅)

fn move_or_create<T: MutTxnT, R: WorkingCopy, C: ChangeStore>(

[22.21084]

[22.679732]

fn move_or_create<T: TreeMutTxnT, R: WorkingCopy, C: ChangeStore>(
edit in libpijul/src/output/output.rs at line 228

[22.679797]

[22.679797]

output_item_inode: Option<(Inode, Position<ChangeId>)>,
replacement in libpijul/src/output/output.rs at line 232

[22.679880]→[22.21148:21212](∅→∅)

) -> Result<Inode, OutputError<C::Error, T::Error, R::Error>> {

[22.679880]

[22.679916]

) -> Result<Inode, OutputError<C::Error, T::TreeError, R::Error>> {
replacement in libpijul/src/output/output.rs at line 240

[22.21214]→[22.680195:680245](∅→∅),[22.680195]→[22.680195:680245](∅→∅)

if let Some((inode, _)) = output_item.inode {

[22.21214]

[22.680245]

if let Some((inode, _)) = output_item_inode {
replacement in libpijul/src/output/output.rs at line 244

[22.680369]→[22.680369:680438](∅→∅)

if let Some(ref current_name) = inode_filename(txn, inode) {

[22.680369]

[22.680438]

if let Some(ref current_name) = inode_filename(txn, inode)? {
replacement in libpijul/src/output/output.rs at line 247

[22.680552]→[22.680552:680631](∅→∅)

let parent = txn.get_revtree(inode, None).unwrap().to_owned();

[22.680552]

[22.680631]

let parent = txn.get_revtree(inode, None)?.unwrap().to_owned();
replacement in libpijul/src/output/output.rs at line 249

[22.680701]→[22.21215:21339](∅→∅)

del_tree_with_rev(txn, parent.as_file_id(), inode)
.map_err(PristineOutputError::Txn)?;

[22.680701]

[22.680852]

del_tree_with_rev(txn, parent.as_file_id(), inode)?;
replacement in libpijul/src/output/output.rs at line 267

[22.681455]→[22.681455:681523](∅→∅)

if let Some(inode) = txn.get_tree(file_id_, None) {

[22.681455]

[13.0]

if let Some(inode) = txn.get_tree(file_id_, None)? {
replacement in libpijul/src/output/output.rs at line 271

[22.681620]→[22.21590:21804](∅→∅)

put_inodes_with_rev(txn, inode, output_item.pos)
.map_err(PristineOutputError::Txn)?;
put_tree_with_rev(txn, file_id_, inode).map_err(PristineOutputError::Txn)?;

[22.681620]

[22.681836]

put_inodes_with_rev(txn, inode, output_item.pos)?;
put_tree_with_rev(txn, file_id_, inode)?;
replacement in libpijul/src/output/output.rs at line 276

[22.681944]→[22.681944:682008](∅→∅)

if let Some(inode) = txn.get_tree(file_id_, None) {

[22.681944]

[13.72]

if let Some(inode) = txn.get_tree(file_id_, None)? {
replacement in libpijul/src/output/output.rs at line 280

[22.682097]→[22.21935:22120](∅→∅)

put_inodes_with_rev(txn, inode, output_item.pos).map_err(PristineOutputError::Txn)?;
put_tree_with_rev(txn, file_id_, inode).map_err(PristineOutputError::Txn)?;

[22.682097]

[22.682297]

put_inodes_with_rev(txn, inode, output_item.pos)?;
put_tree_with_rev(txn, file_id_, inode)?;
replacement in libpijul/src/output/output.rs at line 285

[22.682397]→[22.682397:682457](∅→∅)

if let Some(inode) = txn.get_tree(file_id_, None) {

[22.682397]

[13.140]

if let Some(inode) = txn.get_tree(file_id_, None)? {
replacement in libpijul/src/output/output.rs at line 288

[22.682538]→[22.682538:682581](∅→∅)

let inode = create_new_inode(txn);

[22.682538]

[22.682581]

let inode = create_new_inode(txn)?;
replacement in libpijul/src/output/output.rs at line 293

[22.682701]→[22.22243:22420](∅→∅)

put_inodes_with_rev(txn, inode, output_item.pos).map_err(PristineOutputError::Txn)?;
put_tree_with_rev(txn, file_id_, inode).map_err(PristineOutputError::Txn)?;

[22.682701]

[13.239]

put_inodes_with_rev(txn, inode, output_item.pos)?;
put_tree_with_rev(txn, file_id_, inode)?;
replacement in libpijul/src/output/output.rs at line 300

[13.416]→[13.416:523](∅→∅)

txn.put_tree(path_id.as_file_id(), inode)
.map_err(PristineOutputError::Txn)?;

[13.416]

[13.523]

txn.put_tree(path_id.as_file_id(), inode)?;
replacement in libpijul/src/output/output.rs at line 306

[22.22422]→[22.22422:22482](∅→∅)

fn output_file<T: MutTxnT, P: ChangeStore, W: WorkingCopy>(

[22.22422]

[22.683010]

fn output_file<T: ChannelTxnT + GraphMutTxnT, P: ChangeStore, W: WorkingCopy>(
replacement in libpijul/src/output/output.rs at line 313

[22.683171]→[22.22483:22544](∅→∅),[22.22544]→[22.683204:683261](∅→∅),[22.683204]→[22.683204:683261](∅→∅)

) -> Result<(), OutputError<P::Error, T::Error, W::Error>> {
let mut l = retrieve(txn, channel, output_item.pos);

[22.683171]

[22.683261]

) -> Result<(), OutputError<P::Error, T::GraphError, W::Error>> {
let mut l = retrieve(txn, &channel.graph, output_item.pos)?;
replacement in libpijul/src/output/output.rs at line 321

[22.683557]→[22.55773:55839](∅→∅)

let dest = find_block(txn, &channel, edge.dest).unwrap();

[22.683557]

[22.683622]

let dest = find_block(txn, &channel.graph, edge.dest).unwrap();
replacement in libpijul/src/output/output.rs at line 323

[22.683698]→[22.22669:22804](∅→∅)

del_graph_with_rev(txn, channel, edge.flag, vertex, dest, edge.introduced_by)
.map_err(PristineOutputError::Txn)?;

[22.683698]

[22.683785]

del_graph_with_rev(
txn,
&mut channel.graph,
edge.flag,
vertex,
dest,
edge.introduced_by,
)?;
replacement in libpijul/src/output/output.rs at line 335

[22.22806]→[22.683859:683894](∅→∅),[22.683859]→[22.683859:683894](∅→∅)

fn collect_dead_files<T: MutTxnT>(

[22.22806]

[22.683894]

fn collect_dead_files<T: TreeMutTxnT + GraphTxnT<GraphError = <T as TreeTxnT>::TreeError>>(
replacement in libpijul/src/output/output.rs at line 337

[22.683911]→[22.683911:683937](∅→∅)

channel: &Channel<T>,

[22.683911]

[22.683937]

channel: &T::Graph,
replacement in libpijul/src/output/output.rs at line 340

[22.683988]→[22.683988:684041](∅→∅)

) -> HashMap<OwnedPathId, (Inode, Option<String>)> {

[22.683988]

[22.684041]

) -> Result<HashMap<OwnedPathId, (Inode, Option<String>)>, TxnErr<T::GraphError>> {
replacement in libpijul/src/output/output.rs at line 346

[22.684246]→[22.684246:684293](∅→∅)

for (id, inode_) in txn.iter_tree(

[22.684246]

[22.684293]

for x in txn.iter_tree(
replacement in libpijul/src/output/output.rs at line 352

[22.684462]→[22.684462:684478](∅→∅)

) {

[22.684462]

[22.684478]

)? {
let (id, inode_) = x?;
replacement in libpijul/src/output/output.rs at line 360

[22.684700]→[22.684700:684773](∅→∅)

if let Some(vertex) = txn.get_inodes(inode_, None) {

[22.684700]

[22.684773]

if let Some(vertex) = txn.get_inodes(inode_, None)? {
replacement in libpijul/src/output/output.rs at line 362

[22.684832]→[22.55929:56007](∅→∅)

&& !is_alive(txn, channel, vertex.inode_vertex())

[22.684832]

[22.684909]

&& !is_alive(txn, channel, vertex.inode_vertex())?
replacement in libpijul/src/output/output.rs at line 368

[22.685037]→[22.685037:685124](∅→∅)

dead.insert(id.to_owned(), (inode_, inode_filename(txn, inode_)));

[22.685037]

[22.685124]

dead.insert(id.to_owned(), (inode_, inode_filename(txn, inode_)?));
replacement in libpijul/src/output/output.rs at line 377

[22.685337]→[22.685337:685346](∅→∅)

dead

[22.685337]

[22.685346]

Ok(dead)
replacement in libpijul/src/output/output.rs at line 380

[22.22808]→[22.22808:22872](∅→∅)

fn kill_dead_files<T: MutTxnT, W: WorkingCopy, C: ChangeStore>(

[22.22808]

[22.685451]

fn kill_dead_files<T: TreeMutTxnT, W: WorkingCopy, C: ChangeStore>(
replacement in libpijul/src/output/output.rs at line 384

[22.685544]→[22.22873:22934](∅→∅)

) -> Result<(), OutputError<C::Error, T::Error, W::Error>> {

[22.685544]

[22.685577]

) -> Result<(), OutputError<C::Error, T::TreeError, W::Error>> {
replacement in libpijul/src/output/output.rs at line 387

[22.685693]→[22.22935:23031](∅→∅),[22.2703]→[22.685885:685946](∅→∅),[22.23031]→[22.685885:685946](∅→∅),[22.685885]→[22.685885:685946](∅→∅)

del_tree_with_rev(txn, fileid.as_file_id(), *inode).map_err(PristineOutputError::Txn)?;
if let Some(vertex) = txn.get_inodes(*inode, None) {

[22.685693]

[22.2704]

del_tree_with_rev(txn, fileid.as_file_id(), *inode)?;
if let Some(vertex) = txn.get_inodes(*inode, None)? {
replacement in libpijul/src/output/output.rs at line 390

[22.2768]→[22.23032:23121](∅→∅)

del_inodes_with_rev(txn, *inode, vertex).map_err(PristineOutputError::Txn)?;

[22.2768]

[22.686069]

del_inodes_with_rev(txn, *inode, vertex)?;
edit in libpijul/src/output/mod.rs at line 46

[22.24228]

[22.24228]

}
}

impl<C: std::error::Error, T: std::error::Error + 'static> From<TxnErr<T>>
for PristineOutputError<C, T>
{
fn from(e: TxnErr<T>) -> Self {
PristineOutputError::Txn(e.0)
}
}

impl<C: std::error::Error, T: std::error::Error + 'static, W: std::error::Error> From<TxnErr<T>>
for OutputError<C, T, W>
{
fn from(e: TxnErr<T>) -> Self {
OutputError::Pristine(e.into())
replacement in libpijul/src/output/mod.rs at line 66

[22.24261]→[22.24261:24329](∅→∅)

pub enum FileError<ChangestoreError: std::error::Error + 'static> {

[22.24261]

[22.24329]

pub enum FileError<ChangestoreError: std::error::Error + 'static, T: std::error::Error + 'static> {
edit in libpijul/src/output/mod.rs at line 69

[22.24390]

[22.24390]

#[error(transparent)]
Txn(T),
replacement in libpijul/src/output/mod.rs at line 75

[22.24451]→[22.24451:24529](∅→∅)

impl<C: std::error::Error, T: std::error::Error + 'static> From<FileError<C>>

[22.24451]

[22.24529]

impl<C: std::error::Error, T: std::error::Error + 'static> From<FileError<C, T>>
replacement in libpijul/src/output/mod.rs at line 78

[22.24565]→[22.24565:24604](∅→∅)

fn from(e: FileError<C>) -> Self {

[22.24565]

[22.24604]

fn from(e: FileError<C, T>) -> Self {
edit in libpijul/src/output/mod.rs at line 82

[22.24760]

[22.24760]

FileError::Txn(t) => PristineOutputError::Txn(t),
edit in libpijul/src/output/mod.rs at line 87

[22.24779]

[22.686366]

impl<C: std::error::Error, T: std::error::Error + 'static> From<TxnErr<T>> for FileError<C, T> {
fn from(e: TxnErr<T>) -> Self {
FileError::Txn(e.0)
}
}
edit in libpijul/src/output/mod.rs at line 99

[22.686494]→[22.686494:686542](∅→∅)

inode: Option<(Inode, Position<ChangeId>)>,
replacement in libpijul/src/output/mod.rs at line 102

[22.686566]→[22.686566:686612](∅→∅)

fn collect_children<T: TxnT, P: ChangeStore>(

[22.686566]

[22.686612]

fn collect_children<T: GraphTxnT, P: ChangeStore>(
replacement in libpijul/src/output/mod.rs at line 105

[22.686642]→[22.686642:686668](∅→∅)

channel: &Channel<T>,

[22.686642]

[22.686668]

channel: &T::Graph,
replacement in libpijul/src/output/mod.rs at line 111

[22.686842]→[22.24780:24839](∅→∅)

) -> Result<(), PristineOutputError<P::Error, T::Error>> {

[22.686842]

[22.686875]

) -> Result<(), PristineOutputError<P::Error, T::GraphError>> {
replacement in libpijul/src/output/mod.rs at line 115

[22.56049]→[22.686940:686958](∅→∅),[22.686940]→[22.686940:686958](∅→∅)

&channel,

[22.56049]

[22.686958]

channel,
edit in libpijul/src/output/mod.rs at line 117

[22.686992]→[22.686992:687102](∅→∅),[22.687102]→[22.56050:56091](∅→∅),[22.56091]→[22.687134:687186](∅→∅),[22.687134]→[22.687134:687186](∅→∅)

EdgeFlags::empty(),
EdgeFlags::all(),
) {
debug!("inode_pos, e = {:?}", e);
}
for e in iter_adjacent(
txn,
&channel,
inode_pos.inode_vertex(),
replacement in libpijul/src/output/mod.rs at line 119

[22.687279]→[22.687279:687287](∅→∅),[22.687350]→[22.687350:687411](∅→∅),[22.687411]→[22.56092:56162](∅→∅)

) {
// This unwrap is ok since e.dest is in the channel.
let name_vertex = find_block(txn, &channel, e.dest).unwrap();

[22.687279]

[22.687480]

)? {
let e = e?;
let name_vertex = find_block(txn, channel, e.dest).unwrap();
replacement in libpijul/src/output/mod.rs at line 124

[22.24856]→[22.24856:24999](∅→∅)

.get_contents(|h| txn.get_external(h), name_vertex, &mut name_buf)
.map_err(|e| PristineOutputError::Changestore(e))?;

[22.24856]

[22.687603]

.get_contents(|h| txn.get_external(h).unwrap(), name_vertex, &mut name_buf)
.map_err(PristineOutputError::Changestore)?;
edit in libpijul/src/output/mod.rs at line 140

[22.688203]→[22.56163:56333](∅→∅),[22.56333]→[22.688301:688346](∅→∅),[22.688301]→[22.688301:688346](∅→∅)

for e in iter_adjacent(
txn,
&channel,
name_vertex,
EdgeFlags::empty(),
EdgeFlags::all(),
) {
debug!("e = {:?}", e);
}
replacement in libpijul/src/output/mod.rs at line 142

[22.56407]→[22.56407:56429](∅→∅)

&channel,

[22.56407]

[22.56429]

channel,
replacement in libpijul/src/output/mod.rs at line 146

[22.56555]→[22.56555:56565](∅→∅)

)

[22.56555]

[22.56565]

)?
replacement in libpijul/src/output/mod.rs at line 149

[22.56591]→[22.56591:56609](∅→∅)

child

[22.56591]

[22.56609]

child?
replacement in libpijul/src/output/mod.rs at line 151

[22.56626]→[22.56626:56665](∅→∅)

let child = iter_adjacent(

[22.56626]

[22.56665]

let mut edge = None;
for e in iter_adjacent(
replacement in libpijul/src/output/mod.rs at line 154

[22.56686]→[22.688419:688445](∅→∅),[22.688419]→[22.688419:688445](∅→∅)

&channel,

[22.56686]

[22.688445]

channel,
replacement in libpijul/src/output/mod.rs at line 158

[22.56721]→[22.688583:688597](∅→∅),[22.688583]→[22.688583:688597](∅→∅),[22.688597]→[22.4898:4957](∅→∅),[22.4957]→[22.56784:56807](∅→∅),[22.688617]→[22.56784:56807](∅→∅),[22.56807]→[22.688897:688898](∅→∅),[22.688897]→[22.688897:688898](∅→∅)

)
.find(|e| !e.flag.contains(EdgeFlags::PARENT))
.unwrap();

[22.56721]

[22.688898]

)? {
let e = e?;
if !e.flag.contains(EdgeFlags::PARENT) {
edge = Some(e);
break;
}
}
let e = edge.unwrap();
replacement in libpijul/src/output/mod.rs at line 167

[22.688970]→[22.873:962](∅→∅)

debug_root(txn, channel, child.dest.inode_vertex(), &mut f, false).unwrap();

[22.688970]

[22.689072]

debug_root(txn, channel, e.dest.inode_vertex(), &mut f, false).unwrap();
edit in libpijul/src/output/mod.rs at line 172

[22.689154]→[22.689154:689352](∅→∅)

let child_inode = txn
.get_revinodes(child.dest, None)
.map(|inode| (inode, txn.get_inodes(inode, None).unwrap()));
debug!("child_inode: {:?}", child_inode);
replacement in libpijul/src/output/mod.rs at line 180

[22.689609]→[22.689609:689709](∅→∅)

inode: child_inode,
is_zombie: is_zombie(txn, channel, child.dest),

[22.689609]

[22.689709]

is_zombie: is_zombie(txn, channel, child.dest)?,
replacement in libpijul/src/output/mod.rs at line 187

[22.689756]→[22.689756:689844](∅→∅)

fn is_zombie<T: TxnT>(txn: &T, channel: &Channel<T>, pos: Position<ChangeId>) -> bool {

[22.689756]

[22.689844]

fn is_zombie<T: GraphTxnT>(
txn: &T,
channel: &T::Graph,
pos: Position<ChangeId>,
) -> Result<bool, TxnErr<T::GraphError>> {
replacement in libpijul/src/output/mod.rs at line 193

[22.689916]→[22.56895:56973](∅→∅),[22.56973]→[22.689993:690028](∅→∅),[22.689993]→[22.689993:690028](∅→∅)

iter_adjacent(txn, &channel, pos.inode_vertex(), f, f | EdgeFlags::BLOCK)
.next()
.is_some()

[22.689916]

[22.690028]

if let Some(n) =
iter_adjacent(txn, channel, pos.inode_vertex(), f, f | EdgeFlags::BLOCK)?.next()
{
n?;
Ok(true)
} else {
Ok(false)
}
edit in libpijul/src/output/archive.rs at line 86

[22.25418]

[22.25418]

#[error(transparent)]
P(P),
replacement in libpijul/src/output/archive.rs at line 97

[22.25744]→[22.25744:25791](∅→∅)

File(#[from] crate::output::FileError<P>),

[22.25744]

[22.25791]

File(#[from] crate::output::FileError<P, T>),
replacement in libpijul/src/output/archive.rs at line 102

[22.692169]→[22.692169:692262](∅→∅)

pub(crate) fn archive<'a, T: TxnT, P: ChangeStore, I: Iterator<Item = &'a str>, A: Archive>(

[22.692169]

[22.692262]

impl<
P: std::error::Error + 'static,
T: std::error::Error + 'static,
A: std::error::Error + 'static,
> std::convert::From<TxnErr<T>> for ArchiveError<P, T, A>
{
fn from(e: TxnErr<T>) -> Self {
ArchiveError::Txn(e.0)
}
}

pub(crate) fn archive<
'a,
T: ChannelTxnT,
P: ChangeStore,
I: Iterator<Item = &'a str>,
A: Archive,
>(
replacement in libpijul/src/output/archive.rs at line 125

[22.692359]→[22.25880:25953](∅→∅)

) -> Result<Vec<Conflict>, ArchiveError<P::Error, T::Error, A::Error>> {

[22.692359]

[22.692403]

) -> Result<Vec<Conflict>, ArchiveError<P::Error, T::GraphError, A::Error>> {
replacement in libpijul/src/output/archive.rs at line 134

[22.692654]→[22.692654:692672](∅→∅)

&channel,

[22.692654]

[22.692672]

&channel.graph,
replacement in libpijul/src/output/archive.rs at line 175

[22.694102]→[22.694102:694350](∅→∅)

if let Some((inode, _)) = output_item.inode {
if !done_inodes.insert(inode) {
debug!("inode already visited: {:?} {:?}", a, inode);
continue;
}

[22.694102]

[22.694350]

if !done_inodes.insert(output_item.pos) {
debug!("inode already visited: {:?} {:?}", a, output_item.pos);
continue;
replacement in libpijul/src/output/archive.rs at line 195

[22.695038]→[22.695038:695072](∅→∅)

&channel,

[22.695038]

[22.695072]

&channel.graph,
replacement in libpijul/src/output/archive.rs at line 201

[22.695278]→[22.695278:695301](∅→∅)

)?

[22.695278]

[22.695301]

)?;
replacement in libpijul/src/output/archive.rs at line 203

[22.695326]→[22.695326:695414](∅→∅)

let mut l = crate::alive::retrieve(txn, &channel, output_item.pos);

[22.695326]

[22.695414]

let mut l = crate::alive::retrieve(txn, &channel.graph, output_item.pos)?;
replacement in libpijul/src/missing_context.rs at line 13

[22.26180]→[22.26180:26211](∅→∅)

Block(#[from] BlockError),

[22.26180]

[22.26211]

Block(#[from] BlockError<TxnError>),
replacement in libpijul/src/missing_context.rs at line 15

[22.26237]→[22.26237:26283](∅→∅)

Inconsistent(#[from] InconsistentChange),

[22.26237]

[22.26283]

Inconsistent(#[from] InconsistentChange<TxnError>),
}

impl<T: std::error::Error + 'static> std::convert::From<TxnErr<T>> for MissingError<T> {
fn from(e: TxnErr<T>) -> Self {
MissingError::Txn(e.0)
}
replacement in libpijul/src/missing_context.rs at line 25

[22.696724]→[22.696724:696763](∅→∅)

pub(crate) fn load_graph<T: TxnT>(

[22.696724]

[22.696763]

pub(crate) fn load_graph<T: GraphTxnT>(
replacement in libpijul/src/missing_context.rs at line 28

[22.696799]→[22.696799:696829](∅→∅)

channel: &Channel<T>,

[22.696799]

[22.696829]

channel: &T::Graph,
replacement in libpijul/src/missing_context.rs at line 30

[22.696868]→[22.26286:26379](∅→∅)

) -> Result<Option<&(Graph, HashMap<Vertex<ChangeId>, VertexId>)>, InconsistentChange> {

[22.696868]

[22.696955]

) -> Result<
Option<&(Graph, HashMap<Vertex<ChangeId>, VertexId>)>,
InconsistentChange<T::GraphError>,
> {
replacement in libpijul/src/missing_context.rs at line 39

[22.697186]→[22.697186:697262](∅→∅)

change: if let Some(i) = txn.get_internal(change) {

[22.697186]

[22.697262]

change: if let Some(i) = txn.get_internal(change)? {
replacement in libpijul/src/missing_context.rs at line 42

[22.697325]→[22.26380:26443](∅→∅)

return Err(InconsistentChange {});

[22.697325]

[22.697406]

return Err(InconsistentChange::UndeclaredDep);
replacement in libpijul/src/missing_context.rs at line 46

[22.697496]→[22.697496:697575](∅→∅)

let mut graph = crate::alive::retrieve(txn, channel, pos);

[22.697496]

[22.697575]

let mut graph = crate::alive::retrieve(txn, channel, pos)?;
replacement in libpijul/src/missing_context.rs at line 63

[22.698054]→[22.698054:698070](∅→∅)

T: MutTxnT,

[22.698054]

[22.698070]

T: GraphMutTxnT,
replacement in libpijul/src/missing_context.rs at line 67

[22.698140]→[22.698140:698170](∅→∅)

channel: &mut Channel<T>,

[22.698140]

[22.698170]

channel: &mut T::Graph,
replacement in libpijul/src/missing_context.rs at line 73

[22.698287]→[22.26446:26488](∅→∅)

) -> Result<(), MissingError<T::Error>> {

[22.698264]

[22.698320]

) -> Result<(), MissingError<T::GraphError>> {
replacement in libpijul/src/missing_context.rs at line 90

[22.698941]→[21.9620:9719](∅→∅)

repair_regular_up(txn, channel, &alive, d, EdgeFlags::PSEUDO).map_err(MissingError::Txn)?;

[22.698941]

[22.699912]

repair_regular_up(txn, channel, &alive, d, EdgeFlags::PSEUDO)?;
replacement in libpijul/src/missing_context.rs at line 95

[22.699976]→[21.9720:9754](∅→∅)

fn repair_regular_up<T: MutTxnT>(

[22.699976]

[22.700008]

fn repair_regular_up<T: GraphMutTxnT>(
replacement in libpijul/src/missing_context.rs at line 97

[22.700025]→[22.700025:700055](∅→∅)

channel: &mut Channel<T>,

[22.700025]

[21.9755]

channel: &mut T::Graph,
replacement in libpijul/src/missing_context.rs at line 101

[21.9840]→[21.9840:9868](∅→∅)

) -> Result<(), T::Error> {

[21.9840]

[21.9868]

) -> Result<(), TxnErr<T::GraphError>> {
replacement in libpijul/src/missing_context.rs at line 119

[22.700694]→[22.700694:700710](∅→∅)

T: MutTxnT,

[22.700694]

[22.700710]

T: GraphMutTxnT,
replacement in libpijul/src/missing_context.rs at line 123

[22.700780]→[22.700780:700810](∅→∅)

channel: &mut Channel<T>,

[22.700780]

[22.700810]

channel: &mut T::Graph,
replacement in libpijul/src/missing_context.rs at line 128

[22.700904]→[22.26697:26739](∅→∅)

) -> Result<(), MissingError<T::Error>> {

[22.700904]

[22.700937]

) -> Result<(), MissingError<T::GraphError>> {
replacement in libpijul/src/missing_context.rs at line 148

[21.10564]→[21.10564:10699](∅→∅)

put_graph_with_rev(txn, channel, EdgeFlags::PSEUDO, d, desc, ChangeId::ROOT)
.map_err(MissingError::Txn)?;

[21.10564]

[22.701825]

put_graph_with_rev(txn, channel, EdgeFlags::PSEUDO, d, desc, ChangeId::ROOT)?;
replacement in libpijul/src/missing_context.rs at line 154

[22.26798]→[22.701909:701965](∅→∅),[22.701909]→[22.701909:701965](∅→∅)

pub(crate) fn repair_context_nondeleted<T: MutTxnT, K>(

[22.26798]

[22.701965]

pub(crate) fn repair_context_nondeleted<T: GraphMutTxnT, K>(
replacement in libpijul/src/missing_context.rs at line 156

[22.701982]→[22.701982:702012](∅→∅)

channel: &mut Channel<T>,

[22.701982]

[22.702012]

channel: &mut T::Graph,
replacement in libpijul/src/missing_context.rs at line 162

[22.702145]→[22.26799:26839](∅→∅)

) -> Result<(), MissingError<T::Error>>

[22.702145]

[22.702176]

) -> Result<(), MissingError<T::GraphError>>
replacement in libpijul/src/missing_context.rs at line 175

[21.10983]→[21.10983:11056](∅→∅)

if deleted_by_unknown(txn, channel, source, change_id, &mut known) {

[21.10983]

[21.11056]

if deleted_by_unknown(txn, channel, source, change_id, &mut known)? {
replacement in libpijul/src/missing_context.rs at line 183

[22.704009]→[21.11304:11340](∅→∅)

fn reconnect_target_up<T: MutTxnT>(

[22.704009]

[21.11340]

fn reconnect_target_up<T: GraphMutTxnT>(
replacement in libpijul/src/missing_context.rs at line 185

[21.11357]→[21.11357:11387](∅→∅)

channel: &mut Channel<T>,

[21.11357]

[21.11387]

channel: &mut T::Graph,
replacement in libpijul/src/missing_context.rs at line 190

[21.11501]→[21.11501:11543](∅→∅)

) -> Result<(), MissingError<T::Error>> {

[21.11501]

[22.704175]

) -> Result<(), MissingError<T::GraphError>> {
replacement in libpijul/src/missing_context.rs at line 192

[22.704213]→[21.11544:11602](∅→∅)

for v in iter_deleted_parents(txn, channel, target) {

[22.704213]

[21.11602]

for v in iter_deleted_parents(txn, channel, target)? {
let v = v?;
replacement in libpijul/src/missing_context.rs at line 211

[22.704871]→[21.11925:11966](∅→∅)

fn reconnect_target_down<T: MutTxnT, K>(

[22.704871]

[21.11966]

fn reconnect_target_down<T: GraphMutTxnT, K>(
replacement in libpijul/src/missing_context.rs at line 213

[21.11983]→[21.11983:12013](∅→∅)

channel: &mut Channel<T>,

[21.11983]

[21.12013]

channel: &mut T::Graph,
replacement in libpijul/src/missing_context.rs at line 219

[21.12146]→[21.12146:12186](∅→∅)

) -> Result<(), MissingError<T::Error>>

[21.12146]

[21.12186]

) -> Result<(), MissingError<T::GraphError>>
replacement in libpijul/src/missing_context.rs at line 225

[22.705017]→[21.12223:12273](∅→∅)

for v in iter_adj_all(txn, channel, target) {

[22.705017]

[22.705105]

for v in iter_adj_all(txn, channel, target)? {
let v = v?;
replacement in libpijul/src/missing_context.rs at line 237

[22.705429]→[22.705429:705493](∅→∅)

let intro = txn.get_external(v.introduced_by).unwrap();

[22.705429]

[22.705493]

let intro = txn.get_external(v.introduced_by)?.unwrap();
replacement in libpijul/src/missing_context.rs at line 249

[21.12277]→[21.12277:12312](∅→∅)

fn deleted_by_unknown<T: TxnT, K>(

[21.12277]

[21.12312]

fn deleted_by_unknown<T: GraphTxnT, K>(
replacement in libpijul/src/missing_context.rs at line 251

[21.12325]→[21.12325:12351](∅→∅)

channel: &Channel<T>,

[21.12325]

[21.12351]

channel: &T::Graph,
replacement in libpijul/src/missing_context.rs at line 255

[21.12425]→[21.12425:12435](∅→∅)

) -> bool

[21.12425]

[21.12435]

) -> Result<bool, TxnErr<T::GraphError>>
replacement in libpijul/src/missing_context.rs at line 260

[21.12511]→[21.12511:12569](∅→∅)

for v in iter_deleted_parents(txn, channel, source) {

[21.12511]

[21.12569]

for v in iter_deleted_parents(txn, channel, source)? {
let v = v?;
replacement in libpijul/src/missing_context.rs at line 265

[21.12667]→[21.12667:12762](∅→∅)

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

[21.12667]

[21.12762]

if v.introduced_by == change_id || known(txn.get_external(v.introduced_by)?.unwrap()) {
replacement in libpijul/src/missing_context.rs at line 267

[21.12832]→[21.12832:12858](∅→∅)

return false;

[21.12832]

[21.12858]

return Ok(false);
replacement in libpijul/src/missing_context.rs at line 274

[21.13049]→[21.13049:13072](∅→∅)

deleted_by_unknown

[21.13049]

[22.705747]

Ok(deleted_by_unknown)
replacement in libpijul/src/missing_context.rs at line 277

[22.705805]→[22.705805:705858](∅→∅)

pub(crate) fn repair_context_deleted<T: MutTxnT, K>(

[22.705750]

[22.705858]

pub(crate) fn repair_context_deleted<T: GraphMutTxnT, K>(
replacement in libpijul/src/missing_context.rs at line 279

[22.705875]→[22.705875:705905](∅→∅)

channel: &mut Channel<T>,

[22.705875]

[22.705905]

channel: &mut T::Graph,
replacement in libpijul/src/missing_context.rs at line 285

[22.706038]→[22.26840:26880](∅→∅)

) -> Result<(), MissingError<T::Error>>

[22.706038]

[22.706069]

) -> Result<(), MissingError<T::GraphError>>
replacement in libpijul/src/missing_context.rs at line 332

[21.13518]→[21.13518:13733](∅→∅)

) -> Result<&(Graph, HashMap<Vertex<ChangeId>, VertexId>), InconsistentChange> {
if let Some(n) = self.0.get(&inode) {
Ok(n)
} else {
Err(InconsistentChange {})
}

[21.13518]

[21.13733]

) -> Option<&(Graph, HashMap<Vertex<ChangeId>, VertexId>)> {
self.0.get(&inode)
replacement in libpijul/src/missing_context.rs at line 378

[22.708025]→[22.708025:708066](∅→∅)

fn collect_unknown_children<T: TxnT, K>(

[22.708025]

[22.708066]

fn collect_unknown_children<T: GraphTxnT, K>(
replacement in libpijul/src/missing_context.rs at line 380

[22.708079]→[22.708079:708105](∅→∅)

channel: &Channel<T>,

[22.708079]

[22.708105]

channel: &T::Graph,
replacement in libpijul/src/missing_context.rs at line 385

[22.708208]→[22.708208:708216](∅→∅)

) where

[22.708208]

[22.708216]

) -> Result<(), TxnErr<T::GraphError>>
where
replacement in libpijul/src/missing_context.rs at line 389

[22.708246]→[21.14368:14430](∅→∅)

for v in iter_alive_children(txn, channel, dest_vertex) {

[22.708246]

[22.58199]

for v in iter_alive_children(txn, channel, dest_vertex)? {
let v = v?;
replacement in libpijul/src/missing_context.rs at line 402

[22.708829]→[22.58323:58350](∅→∅)

if !iter_adjacent(

[22.708668]

[22.58350]

let mut not_del_by_change = true;
for e in iter_adjacent(
replacement in libpijul/src/missing_context.rs at line 409

[22.58495]→[22.58495:58558](∅→∅),[22.58558]→[22.709088:709098](∅→∅),[22.709088]→[22.709088:709098](∅→∅),[22.709161]→[22.709161:709229](∅→∅)

)
.any(|e| e.introduced_by == v.introduced_by)
{
let intro = txn.get_external(v.introduced_by).unwrap();

[22.58495]

[22.709229]

)? {
let e = e?;
if e.introduced_by == v.introduced_by {
not_del_by_change = false;
break;
}
}
if not_del_by_change {
let intro = txn.get_external(v.introduced_by)?.unwrap();
edit in libpijul/src/missing_context.rs at line 423

[22.709326]

[22.709326]

Ok(())
replacement in libpijul/src/missing_context.rs at line 426

[22.709329]→[22.709329:709375](∅→∅)

fn repair_children_of_deleted<T: MutTxnT, K>(

[22.709329]

[22.709375]

fn repair_children_of_deleted<T: GraphMutTxnT, K>(
replacement in libpijul/src/missing_context.rs at line 428

[22.709392]→[22.709392:709422](∅→∅)

channel: &mut Channel<T>,

[22.709392]

[22.709422]

channel: &mut T::Graph,
replacement in libpijul/src/missing_context.rs at line 434

[22.709559]→[22.26883:26923](∅→∅)

) -> Result<(), MissingError<T::Error>>

[22.709559]

[22.709590]

) -> Result<(), MissingError<T::GraphError>>
replacement in libpijul/src/missing_context.rs at line 439

[22.709745]→[22.709745:709829](∅→∅)

collect_unknown_children(txn, channel, ws, dest_vertex, change_id, &mut known);

[22.709745]

[22.709829]

collect_unknown_children(txn, channel, ws, dest_vertex, change_id, &mut known)?;
replacement in libpijul/src/missing_context.rs at line 446

[21.14621]→[21.14621:14706](∅→∅),[21.14706]→[22.26938:26980](∅→∅),[22.26938]→[22.26938:26980](∅→∅)

put_graph_with_rev(txn, channel, EdgeFlags::db(), dest_vertex, p, change_id)
.map_err(MissingError::Txn)?;

[21.14621]

[21.14707]

put_graph_with_rev(txn, channel, EdgeFlags::db(), dest_vertex, p, change_id)?;
replacement in libpijul/src/missing_context.rs at line 451

[21.14894]→[21.14894:14977](∅→∅),[21.14977]→[22.27003:27053](∅→∅),[22.27003]→[22.27003:27053](∅→∅)

put_graph_with_rev(txn, channel, EdgeFlags::db(), u, v, change_id)
.map_err(MissingError::Txn)?;

[21.14894]

[21.14978]

put_graph_with_rev(txn, channel, EdgeFlags::db(), u, v, change_id)?;
replacement in libpijul/src/missing_context.rs at line 457

[22.711106]→[21.15045:15084](∅→∅)

if is_alive(txn, channel, p) {

[22.711106]

[21.15084]

if is_alive(txn, channel, p)? {
replacement in libpijul/src/missing_context.rs at line 468

[22.58891]→[22.711693:711740](∅→∅),[22.711693]→[22.711693:711740](∅→∅)

pub(crate) fn delete_pseudo_edges<T: MutTxnT>(

[22.58891]

[22.711740]

pub(crate) fn delete_pseudo_edges<T: GraphMutTxnT>(
replacement in libpijul/src/missing_context.rs at line 470

[22.711757]→[22.711757:711787](∅→∅)

channel: &mut Channel<T>,

[22.711757]

[22.711787]

channel: &mut T::Graph,
replacement in libpijul/src/missing_context.rs at line 472

[22.711811]→[22.27054:27096](∅→∅)

) -> Result<(), MissingError<T::Error>> {

[22.711811]

[22.711844]

) -> Result<(), MissingError<T::GraphError>> {
replacement in libpijul/src/missing_context.rs at line 478

[22.712042]→[22.252:341](∅→∅)

if !is_alive(txn, channel, dest_vertex) && !ws.repaired.contains(&dest_vertex) {

[22.712042]

[22.712091]

if !is_alive(txn, channel, dest_vertex)? && !ws.repaired.contains(&dest_vertex) {
replacement in libpijul/src/missing_context.rs at line 481

[22.59006]→[22.59006:59054](∅→∅)

if !is_alive(txn, channel, p) {

[22.59006]

[22.59054]

if !is_alive(txn, channel, p)? {
replacement in libpijul/src/missing_context.rs at line 484

[21.15382]→[21.15382:15530](∅→∅)

del_graph_with_rev(txn, channel, e.flag, p, dest_vertex, e.introduced_by)
.map_err(MissingError::Txn)?;

[21.15382]

[22.712510]

del_graph_with_rev(txn, channel, e.flag, p, dest_vertex, e.introduced_by)?;
replacement in libpijul/src/missing_context.rs at line 488

[22.59247]→[22.59247:59295](∅→∅)

if !is_alive(txn, channel, p) {

[22.59247]

[22.59295]

if !is_alive(txn, channel, p)? {
replacement in libpijul/src/missing_context.rs at line 490

[22.59363]→[22.27170:27318](∅→∅)

del_graph_with_rev(txn, channel, e.flag, dest_vertex, p, e.introduced_by)
.map_err(MissingError::Txn)?;

[22.59363]

[22.712749]

del_graph_with_rev(txn, channel, e.flag, dest_vertex, p, e.introduced_by)?;
replacement in libpijul/src/missing_context.rs at line 498

[22.712811]→[22.712811:712864](∅→∅)

pub(crate) fn collect_zombie_context<T: MutTxnT, K>(

[22.712811]

[22.712864]

pub(crate) fn collect_zombie_context<T: GraphMutTxnT, K>(
replacement in libpijul/src/missing_context.rs at line 500

[22.712881]→[22.712881:712911](∅→∅)

channel: &mut Channel<T>,

[22.712881]

[22.712911]

channel: &mut T::Graph,
replacement in libpijul/src/missing_context.rs at line 506

[22.713044]→[22.27319:27359](∅→∅)

) -> Result<(), MissingError<T::Error>>

[22.713044]

[22.713075]

) -> Result<(), MissingError<T::GraphError>>
replacement in libpijul/src/missing_context.rs at line 524

[22.713587]→[22.713587:713599](∅→∅)

) {

[22.713587]

[22.713599]

)? {
let v = v?;
replacement in libpijul/src/missing_context.rs at line 535

[22.713956]→[22.713956:714028](∅→∅)

let intro = txn.get_external(v.introduced_by).unwrap();

[22.713956]

[22.714028]

let intro = txn.get_external(v.introduced_by)?.unwrap();
replacement in libpijul/src/missing_context.rs at line 552

[22.714391]→[22.714391:714415](∅→∅)

fn zombify<T: MutTxnT>(

[22.714391]

[22.714415]

fn zombify<T: GraphMutTxnT>(
replacement in libpijul/src/missing_context.rs at line 554

[22.714432]→[22.714432:714462](∅→∅)

channel: &mut Channel<T>,

[22.714432]

[22.714462]

channel: &mut T::Graph,
replacement in libpijul/src/missing_context.rs at line 560

[22.714609]→[22.27360:27402](∅→∅)

) -> Result<(), MissingError<T::Error>> {

[22.714609]

[22.714642]

) -> Result<(), MissingError<T::GraphError>> {
replacement in libpijul/src/missing_context.rs at line 577

[22.715820]→[22.27403:27467](∅→∅)

)
.map_err(MissingError::Txn)?;

[22.715820]

[22.715840]

)?;
replacement in libpijul/src/missing_context.rs at line 590

[22.716138]→[22.716138:716150](∅→∅)

) {

[22.716138]

[22.716150]

)? {
let parent = parent?;
replacement in libpijul/src/missing_context.rs at line 603

[22.716619]→[22.27468:27592](∅→∅)

put_graph_with_rev(txn, channel, flag, parent_dest, v, change_id)
.map_err(MissingError::Txn)?;

[22.716619]

[22.716698]

put_graph_with_rev(txn, channel, flag, parent_dest, v, change_id)?;
replacement in libpijul/src/missing_context.rs at line 609

[22.716728]→[22.716728:716781](∅→∅)

pub(crate) fn repair_parents_of_deleted<T: MutTxnT>(

[22.716728]

[22.716781]

pub(crate) fn repair_parents_of_deleted<T: GraphMutTxnT>(
replacement in libpijul/src/missing_context.rs at line 611

[22.716798]→[22.716798:716828](∅→∅)

channel: &mut Channel<T>,

[22.716798]

[22.716828]

channel: &mut T::Graph,
replacement in libpijul/src/missing_context.rs at line 613

[22.716852]→[22.27593:27635](∅→∅)

) -> Result<(), MissingError<T::Error>> {

[22.716852]

[22.716885]

) -> Result<(), MissingError<T::GraphError>> {
replacement in libpijul/src/lib.rs at line 98

[22.60252]→[22.3293:3419](∅→∅)

Base32, ChangeId, Channel, ChannelRef, EdgeFlags, Hash, Inode, Merkle, MutTxnT, OwnedPathId,
RemoteRef, TxnT, Vertex,

[22.60252]

[22.60358]

Base32, ChangeId, Channel, ChannelRef, ChannelTxnT, DepsTxnT, EdgeFlags, GraphTxnT, Hash,
Inode, Merkle, MutTxnT, OwnedPathId, RemoteRef, TreeTxnT, TxnT, Vertex,
replacement in libpijul/src/lib.rs at line 116

[22.720799]→[22.27741:27833](∅→∅)

) -> Result<(u64, pristine::Merkle), crate::apply::ApplyError<C::Error, Self::Error>> {

[22.720799]

[22.720857]

) -> Result<(u64, pristine::Merkle), crate::apply::ApplyError<C::Error, Self::GraphError>> {
replacement in libpijul/src/lib.rs at line 126

[22.721167]→[22.27834:27905](∅→∅)

) -> Result<(), crate::apply::ApplyError<C::Error, Self::Error>> {

[22.721167]

[22.721204]

) -> Result<(), crate::apply::ApplyError<C::Error, Self::GraphError>> {
replacement in libpijul/src/lib.rs at line 135

[22.721471]→[22.27906:27998](∅→∅)

) -> Result<(u64, pristine::Merkle), crate::apply::ApplyError<C::Error, Self::Error>> {

[22.721471]

[22.721529]

) -> Result<(u64, pristine::Merkle), crate::apply::ApplyError<C::Error, Self::GraphError>> {
replacement in libpijul/src/lib.rs at line 144

[22.721775]→[22.27999:28070](∅→∅)

) -> Result<(), crate::apply::ApplyError<C::Error, Self::Error>> {

[22.721775]

[22.721812]

) -> Result<(), crate::apply::ApplyError<C::Error, Self::GraphError>> {
replacement in libpijul/src/lib.rs at line 153

[22.722067]→[22.28071:28142](∅→∅)

) -> Result<(), crate::apply::ApplyError<C::Error, Self::Error>> {

[22.722067]

[22.722104]

) -> Result<(), crate::apply::ApplyError<C::Error, Self::GraphError>> {
replacement in libpijul/src/lib.rs at line 164

[22.722441]→[22.28143:28230](∅→∅)

) -> Result<(u64, pristine::Merkle), crate::apply::LocalApplyError<Self::Error>> {

[22.722441]

[22.722499]

) -> Result<(u64, pristine::Merkle), crate::apply::LocalApplyError<Self::GraphError>> {
replacement in libpijul/src/lib.rs at line 174

[22.722831]→[22.28231:28318](∅→∅)

) -> Result<(u64, pristine::Merkle), crate::apply::LocalApplyError<Self::Error>> {

[22.722831]

[22.722889]

) -> Result<(u64, pristine::Merkle), crate::apply::LocalApplyError<Self::GraphError>> {
replacement in libpijul/src/lib.rs at line 186

[22.723283]→[22.28319:28402](∅→∅),[22.28402]→[22.723320:723405](∅→∅),[22.723320]→[22.723320:723405](∅→∅)

) -> Result<(), crate::record::RecordError<C::Error, W::Error, Self::Error>> {
builder.record(self, diff_algorithm, channel, working_copy, changes, prefix)

[22.723283]

[22.723405]

) -> Result<(), crate::record::RecordError<C::Error, W::Error, Self::GraphError>>
where
<W as crate::working_copy::WorkingCopy>::Error: 'static,
{
builder.record(
self,
diff_algorithm,
&mut channel.borrow_mut(),
working_copy,
changes,
prefix,
)
replacement in libpijul/src/lib.rs at line 207

[22.723681]→[22.28403:28500](∅→∅)

) -> Result<record::Recorded, crate::record::RecordError<C::Error, W::Error, Self::Error>> {

[22.723681]

[22.723732]

) -> Result<record::Recorded, crate::record::RecordError<C::Error, W::Error, Self::GraphError>>
where
<W as crate::working_copy::WorkingCopy>::Error: 'static,
{
replacement in libpijul/src/lib.rs at line 212

[22.723789]→[22.723789:723876](∅→∅)

builder.record(self, diff_algorithm, channel, working_copy, changes, prefix)?;

[22.723789]

[22.723876]

builder.record(
self,
diff_algorithm,
&mut channel.borrow_mut(),
working_copy,
changes,
prefix,
)?;
replacement in libpijul/src/lib.rs at line 228

[22.724094]→[22.28501:28584](∅→∅)

) -> Result<pristine::Hash, crate::apply::ApplyError<C::Error, Self::Error>> {

[22.724094]

[22.724183]

) -> Result<pristine::Hash, crate::apply::ApplyError<C::Error, Self::GraphError>> {
replacement in libpijul/src/lib.rs at line 242

[22.724655]→[22.724655:724707](∅→∅)

.map(|rec| rec.globalize(self))

[22.724655]

[22.724707]

.map(|rec| rec.globalize(self).unwrap())
replacement in libpijul/src/lib.rs at line 264

[22.725363]→[22.28706:28778](∅→∅)

) -> Result<bool, unrecord::UnrecordError<C::Error, Self::Error>> {

[22.725363]

[22.725402]

) -> Result<bool, unrecord::UnrecordError<C::Error, Self::GraphError>> {
replacement in libpijul/src/lib.rs at line 275

[22.725733]→[22.28779:28874](∅→∅)

) -> Result<Vec<output::Conflict>, output::OutputError<C::Error, Self::Error, R::Error>> {

[22.725733]

[22.725789]

) -> Result<Vec<output::Conflict>, output::OutputError<C::Error, Self::GraphError, R::Error>>
{
replacement in libpijul/src/lib.rs at line 290

[22.726194]→[22.28875:28956](∅→∅)

fn add_file(&mut self, path: &str) -> Result<(), fs::FsError<Self::Error>> {

[22.726194]

[22.726264]

fn add_file(&mut self, path: &str) -> Result<(), fs::FsError<Self::GraphError>> {
replacement in libpijul/src/lib.rs at line 298

[22.726545]→[22.28957:29037](∅→∅)

fn add_dir(&mut self, path: &str) -> Result<(), fs::FsError<Self::Error>> {

[22.726545]

[22.726614]

fn add_dir(&mut self, path: &str) -> Result<(), fs::FsError<Self::GraphError>> {
replacement in libpijul/src/lib.rs at line 305

[22.726871]→[22.29038:29128](∅→∅)

fn add(&mut self, path: &str, is_dir: bool) -> Result<(), fs::FsError<Self::Error>> {

[22.726871]

[22.726950]

fn add(&mut self, path: &str, is_dir: bool) -> Result<(), fs::FsError<Self::GraphError>> {
replacement in libpijul/src/lib.rs at line 309

[22.727005]→[22.29129:29217](∅→∅)

fn move_file(&mut self, a: &str, b: &str) -> Result<(), fs::FsError<Self::Error>> {

[22.727005]

[22.727082]

fn move_file(&mut self, a: &str, b: &str) -> Result<(), fs::FsError<Self::GraphError>> {
replacement in libpijul/src/lib.rs at line 313

[22.727123]→[22.29218:29299](∅→∅)

fn remove_file(&mut self, a: &str) -> Result<(), fs::FsError<Self::Error>> {

[22.727123]

[22.727193]

fn remove_file(&mut self, a: &str) -> Result<(), fs::FsError<Self::GraphError>> {
replacement in libpijul/src/lib.rs at line 323

[22.29376]→[22.29376:29439](∅→∅)

pristine::channel_dump::ChannelDumpError<Self::Error>,

[22.29376]

[22.29439]

pristine::channel_dump::ChannelDumpError<Self::GraphError>,
replacement in libpijul/src/lib.rs at line 326

[22.29486]→[22.727418:727465](∅→∅),[22.727418]→[22.727418:727465](∅→∅)

if self.load_channel(name).is_none() {

[22.29486]

[22.29487]

if self.load_channel(name)?.is_none() {
replacement in libpijul/src/lib.rs at line 342

[22.728008]→[22.29742:29838](∅→∅)

) -> Result<Vec<output::Conflict>, output::ArchiveError<P::Error, Self::Error, A::Error>> {

[22.728008]

[22.728064]

) -> Result<Vec<output::Conflict>, output::ArchiveError<P::Error, Self::GraphError, A::Error>>
{
replacement in libpijul/src/lib.rs at line 370

[22.728757]→[22.29839:29935](∅→∅)

) -> Result<Vec<output::Conflict>, output::ArchiveError<P::Error, Self::Error, A::Error>> {

[22.728757]

[22.728813]

) -> Result<Vec<output::Conflict>, output::ArchiveError<P::Error, Self::GraphError, A::Error>>
{
replacement in libpijul/src/lib.rs at line 374

[22.728883]→[22.60445:60532](∅→∅)

for (_, (h, m)) in pristine::changeid_rev_log(self, &channel.borrow(), None) {

[22.728883]

[22.728959]

for x in pristine::changeid_rev_log(self, &channel.borrow(), None)? {
let (_, (h, m)) = x?;
replacement in libpijul/src/lib.rs at line 386

[22.729224]→[22.729224:729279](∅→∅)

let h = self.get_external(h).unwrap();

[22.729224]

[22.729279]

let h = self.get_external(h)?.unwrap();
replacement in libpijul/src/lib.rs at line 400

[22.729657]→[22.729657:729756](∅→∅)

fn is_directory(&self, inode: pristine::Inode) -> bool {
fs::is_directory(self, inode)

[22.729657]

[22.729756]

fn is_directory(&self, inode: pristine::Inode) -> Result<bool, Self::TreeError> {
fs::is_directory(self, inode).map_err(|e| e.0)
replacement in libpijul/src/lib.rs at line 404

[22.729763]→[22.729763:729845](∅→∅)

fn is_tracked(&self, path: &str) -> bool {
fs::is_tracked(self, path)

[22.729763]

[22.729845]

fn is_tracked(&self, path: &str) -> Result<bool, Self::TreeError> {
fs::is_tracked(self, path).map_err(|e| e.0)
replacement in libpijul/src/lib.rs at line 416

[22.730108]→[22.730108:730131](∅→∅),[22.730131]→[22.5019:5080](∅→∅),[22.5080]→[22.730259:730324](∅→∅),[22.730259]→[22.730259:730324](∅→∅)

) -> Option<u64> {
let cid = pristine::TxnT::get_internal(self, hash)?;
self.get_changeset(&channel.borrow().changes, cid, None)

[22.730108]

[22.60612]

) -> Result<Option<u64>, Self::GraphError> {
if let Some(cid) = pristine::GraphTxnT::get_internal(self, hash).map_err(|e| e.0)? {
self.get_changeset(&channel.borrow().changes, cid, None)
.map_err(|e| e.0)
} else {
Ok(None)
}
replacement in libpijul/src/lib.rs at line 429

[22.60743]→[22.60743:60804](∅→∅)

) -> bool {
pristine::is_alive(self, channel, a)

[22.60743]

[22.730324]

) -> Result<bool, Self::GraphError> {
pristine::is_alive(self, &channel.graph, a).map_err(|e| e.0)
replacement in libpijul/src/lib.rs at line 433

[22.730331]→[16.248:333](∅→∅),[16.333]→[22.60898:60945](∅→∅),[22.60898]→[22.60898:60945](∅→∅)

fn current_state(&self, channel: &pristine::Channel<Self>) -> pristine::Merkle {
pristine::current_state(self, channel)

[22.730331]

[22.60945]

fn current_state(
&self,
channel: &pristine::Channel<Self>,
) -> Result<pristine::Merkle, Self::GraphError> {
pristine::current_state(self, channel).map_err(|e| e.0)
replacement in libpijul/src/lib.rs at line 444

[22.730450]→[22.730450:730491](∅→∅)

) -> Log<'txn, Self> {
Log {

[22.730450]

[22.730491]

) -> Result<Log<'txn, Self>, Self::GraphError> {
Ok(Log {
replacement in libpijul/src/lib.rs at line 447

[22.730514]→[22.60953:61016](∅→∅),[22.61016]→[22.730566:730576](∅→∅),[22.730566]→[22.730566:730576](∅→∅)

iter: pristine::changeid_log(self, channel, from),
}

[22.730514]

[22.61017]

iter: pristine::changeid_log(self, channel, from).map_err(|e| e.0)?,
})
replacement in libpijul/src/lib.rs at line 456

[22.61205]→[22.61205:61319](∅→∅)

) -> pristine::PathChangeset<'channel, 'txn, Self> {
pristine::log_for_path(self, channel, pos, from)

[22.61205]

[22.61319]

) -> Result<pristine::PathChangeset<'channel, 'txn, Self>, Self::GraphError> {
pristine::log_for_path(self, channel, pos, from).map_err(|e| e.0)
replacement in libpijul/src/lib.rs at line 465

[22.61511]→[22.61511:61632](∅→∅)

) -> pristine::RevPathChangeset<'channel, 'txn, Self> {
pristine::rev_log_for_path(self, channel, pos, from)

[22.61511]

[22.730576]

) -> Result<pristine::RevPathChangeset<'channel, 'txn, Self>, Self::DepsError> {
pristine::rev_log_for_path(self, channel, pos, from).map_err(|e| e.0)
replacement in libpijul/src/lib.rs at line 473

[22.730718]→[22.730718:730765](∅→∅)

) -> RevLog<'txn, Self> {
RevLog {

[22.730718]

[22.730765]

) -> Result<RevLog<'txn, Self>, Self::GraphError> {
Ok(RevLog {
replacement in libpijul/src/lib.rs at line 476

[22.730788]→[22.61633:61700](∅→∅),[22.61700]→[22.730844:730854](∅→∅),[22.730844]→[22.730844:730854](∅→∅)

iter: pristine::changeid_rev_log(self, channel, from),
}

[22.730788]

[22.730854]

iter: pristine::changeid_rev_log(self, channel, from).map_err(|e| e.0)?,
})
replacement in libpijul/src/lib.rs at line 484

[22.61826]→[22.61826:61985](∅→∅)

) -> pristine::RevCursor<
Self,
&'txn Self,
Self::RevchangesetCursor,
u64,
(pristine::ChangeId, pristine::Merkle),

[22.61826]

[22.61985]

) -> Result<
pristine::RevCursor<
Self,
&'txn Self,
Self::RevchangesetCursor,
u64,
(pristine::ChangeId, pristine::Merkle),
>,
Self::GraphError,
replacement in libpijul/src/lib.rs at line 494

[22.61993]→[22.61993:62049](∅→∅)

pristine::changeid_rev_log(self, channel, from)

[22.61993]

[22.62049]

pristine::changeid_rev_log(self, channel, from).map_err(|e| e.0)
replacement in libpijul/src/lib.rs at line 501

[22.730958]→[22.730958:731143](∅→∅)

) -> Option<(pristine::Hash, pristine::Merkle)> {
self.get_revchangeset(&channel.borrow().revchanges, n, None)
.map(|(h, m)| (self.get_external(h).unwrap(), m))

[22.730958]

[22.731143]

) -> Result<Option<(pristine::Hash, pristine::Merkle)>, Self::GraphError> {
if let Some((h, m)) = self
.get_revchangeset(&channel.borrow().revchanges, n, None)
.map_err(|e| e.0)?
{
Ok(Some((self.get_external(h).map_err(|e| e.0)?.unwrap(), m)))
} else {
Ok(None)
}
replacement in libpijul/src/lib.rs at line 516

[22.731261]→[22.731261:731284](∅→∅),[22.731284]→[22.62057:62122](∅→∅)

) -> Option<u64> {
if let Some(h) = pristine::TxnT::get_internal(self, h) {

[22.731261]

[22.731332]

) -> Result<Option<u64>, Self::GraphError> {
if let Some(h) = pristine::GraphTxnT::get_internal(self, h).map_err(|e| e.0)? {
edit in libpijul/src/lib.rs at line 519

[22.731399]

[22.731399]

.map_err(|e| e.0)
replacement in libpijul/src/lib.rs at line 521

[22.731416]→[22.731416:731433](∅→∅)

None

[22.731416]

[22.731433]

Ok(None)
replacement in libpijul/src/lib.rs at line 525

[22.731450]→[22.3034:3108](∅→∅),[22.3108]→[22.62123:62189](∅→∅),[22.731541]→[22.62123:62189](∅→∅),[22.62189]→[22.731590:731617](∅→∅),[22.731590]→[22.731590:731617](∅→∅)

fn touched_files(&self, h: pristine::Hash) -> Option<Touched<Self>> {
if let Some(id) = pristine::TxnT::get_internal(self, h) {
Some(Touched {

[22.731450]

[22.731617]

fn touched_files(&self, h: pristine::Hash) -> Result<Option<Touched<Self>>, Self::DepsError> {
if let Some(id) = pristine::GraphTxnT::get_internal(self, h).map_err(|e| e.0)? {
Ok(Some(Touched {
replacement in libpijul/src/lib.rs at line 529

[22.731644]→[22.731644:731705](∅→∅)

iter: self.iter_rev_touched_files(id, None),

[22.731644]

[22.731705]

iter: self.iter_rev_touched_files(id, None).map_err(|e| e.0)?,
replacement in libpijul/src/lib.rs at line 531

[22.731725]→[22.731725:731740](∅→∅)

})

[22.731725]

[22.731740]

}))
replacement in libpijul/src/lib.rs at line 533

[22.731757]→[22.731757:731774](∅→∅)

None

[22.731757]

[22.731774]

Ok(None)
replacement in libpijul/src/lib.rs at line 542

[22.731981]→[22.30000:30044](∅→∅)

) -> Result<(String, bool), C::Error> {

[22.731981]

[22.732030]

) -> Result<(String, bool), output::FileError<C::Error, Self::GraphError>> {
replacement in libpijul/src/lib.rs at line 544

[22.732074]→[22.62190:62272](∅→∅)

change: pristine::TxnT::get_internal(self, position.change).unwrap(),

[22.732074]

[22.732139]

change: pristine::GraphTxnT::get_internal(self, position.change)?.unwrap(),
replacement in libpijul/src/lib.rs at line 555

[22.732453]→[22.30045:30089](∅→∅)

) -> Result<(String, bool), C::Error> {

[22.732453]

[22.732502]

) -> Result<(String, bool), output::FileError<C::Error, Self::GraphError>> {
replacement in libpijul/src/lib.rs at line 557

[22.732546]→[22.62273:62355](∅→∅)

change: pristine::TxnT::get_internal(self, position.change).unwrap(),

[22.732546]

[22.732611]

change: pristine::GraphTxnT::get_internal(self, position.change)?.unwrap(),
replacement in libpijul/src/lib.rs at line 568

[22.732890]→[22.30090:30179](∅→∅),[22.30179]→[22.732971:733032](∅→∅),[22.732971]→[22.732971:733032](∅→∅)

) -> Result<(pristine::Position<pristine::ChangeId>, bool), fs::FsError<C::Error>> {
fs::follow_oldest_path(changes, self, channel, path)

[22.732890]

[22.733032]

) -> Result<
(pristine::Position<pristine::ChangeId>, bool),
fs::FsErrorC<C::Error, Self::GraphError>,
> {
fs::follow_oldest_path(changes, self, &channel.borrow(), path)
replacement in libpijul/src/lib.rs at line 581

[22.733275]→[22.30180:30231](∅→∅)

) -> Result<(), output::FileError<C::Error>> {

[22.733275]

[22.733312]

) -> Result<(), output::FileError<C::Error, Self::GraphError>> {
replacement in libpijul/src/lib.rs at line 584

[22.733390]→[22.733390:733451](∅→∅)

let mut graph = alive::retrieve(self, &channel, v0);

[22.733390]

[22.733451]

let mut graph = alive::retrieve(self, &channel.graph, v0)?;
replacement in libpijul/src/lib.rs at line 594

[22.733724]→[22.30232:30328](∅→∅)

) -> Result<Vec<output::Conflict>, output::ArchiveError<C::Error, Self::Error, A::Error>> {

[22.733724]

[22.733780]

) -> Result<Vec<output::Conflict>, output::ArchiveError<C::Error, Self::GraphError, A::Error>>
{
replacement in libpijul/src/lib.rs at line 605

[22.734091]→[22.30329:30425](∅→∅)

) -> Result<Vec<output::Conflict>, output::ArchiveError<C::Error, Self::Error, A::Error>> {

[22.734091]

[22.734147]

) -> Result<Vec<output::Conflict>, output::ArchiveError<C::Error, Self::GraphError, A::Error>>
{
replacement in libpijul/src/lib.rs at line 612

[22.62415]→[22.62415:62462](∅→∅)

channel: &'db pristine::Channel<Self>,

[22.62415]

[22.62462]

graph: &'db pristine::Channel<Self>,
replacement in libpijul/src/lib.rs at line 616

[22.62581]→[22.62581:62703](∅→∅)

) -> pristine::AdjacentIterator<'txn, Self> {
pristine::iter_adjacent(self, channel, key, min_flag, max_flag)

[22.62581]

[22.62703]

) -> Result<pristine::AdjacentIterator<'txn, Self>, pristine::TxnErr<Self::GraphError>> {
pristine::iter_adjacent(self, &graph.graph, key, min_flag, max_flag)
replacement in libpijul/src/lib.rs at line 621

[22.734218]→[22.734218:734260](∅→∅)

pub struct Log<'txn, T: pristine::TxnT> {

[22.734218]

[22.734260]

pub struct Log<'txn, T: pristine::ChannelTxnT> {
replacement in libpijul/src/lib.rs at line 632

[22.734436]→[22.734436:734553](∅→∅)

impl<'txn, T: pristine::TxnT> Iterator for Log<'txn, T> {
type Item = (u64, (pristine::Hash, pristine::Merkle));

[22.734436]

[22.734553]

impl<'txn, T: pristine::ChannelTxnT> Iterator for Log<'txn, T> {
type Item = Result<(u64, (pristine::Hash, pristine::Merkle)), T::GraphError>;
replacement in libpijul/src/lib.rs at line 635

[22.734600]→[22.734600:734714](∅→∅)

self.iter
.next()
.map(|(n, (c, m))| (n, (self.txn.get_external(c).unwrap(), m)))

[22.734600]

[22.734714]

match self.iter.next() {
Some(Ok((n, (c, m)))) => {
let ext = match self.txn.get_external(c) {
Err(pristine::TxnErr(e)) => return Some(Err(e)),
Ok(Some(ext)) => ext,
Ok(None) => panic!("Unknown change {:?}", c),
};
Some(Ok((n, (ext, m))))
}
None => None,
Some(Err(e)) => Some(Err(e.0)),
}
replacement in libpijul/src/lib.rs at line 650

[22.734723]→[22.734723:734768](∅→∅)

pub struct RevLog<'txn, T: pristine::TxnT> {

[22.734723]

[22.734768]

pub struct RevLog<'txn, T: pristine::ChannelTxnT> {
replacement in libpijul/src/lib.rs at line 661

[22.734947]→[22.734947:735067](∅→∅)

impl<'txn, T: pristine::TxnT> Iterator for RevLog<'txn, T> {
type Item = (u64, (pristine::Hash, pristine::Merkle));

[22.734947]

[22.735067]

impl<'txn, T: pristine::ChannelTxnT> Iterator for RevLog<'txn, T> {
type Item = Result<(u64, (pristine::Hash, pristine::Merkle)), T::GraphError>;
replacement in libpijul/src/lib.rs at line 664

[22.735114]→[22.735114:735228](∅→∅)

self.iter
.next()
.map(|(n, (c, m))| (n, (self.txn.get_external(c).unwrap(), m)))

[22.735114]

[22.735228]

match self.iter.next() {
Some(Ok((n, (c, m)))) => match self.txn.get_external(c) {
Ok(Some(ext)) => Some(Ok((n, (ext, m)))),
Err(e) => Some(Err(e.0)),
Ok(None) => panic!("Unknown change {:?}", c),
},
None => None,
Some(Err(e)) => Some(Err(e.0)),
}
replacement in libpijul/src/lib.rs at line 676

[22.735237]→[22.735237:735283](∅→∅)

pub struct Touched<'txn, T: pristine::TxnT> {

[22.735237]

[22.735283]

pub struct Touched<'txn, T: pristine::DepsTxnT> {
replacement in libpijul/src/lib.rs at line 688

[22.735507]→[22.735507:735621](∅→∅)

impl<'txn, T: pristine::TxnT> Iterator for Touched<'txn, T> {
type Item = pristine::Position<pristine::Hash>;

[22.735507]

[22.735621]

impl<
'txn,
T: pristine::DepsTxnT + pristine::GraphTxnT<GraphError = <T as pristine::DepsTxnT>::DepsError>,
> Iterator for Touched<'txn, T>
{
type Item = Result<pristine::Position<pristine::Hash>, T::DepsError>;
replacement in libpijul/src/lib.rs at line 695

[22.735668]→[22.735668:735725](∅→∅)

while let Some((cid, file)) = self.iter.next() {

[22.735668]

[22.735725]

while let Some(x) = self.iter.next() {
let (cid, file) = match x {
Ok(x) => x,
Err(e) => return Some(Err(e.0)),
};
replacement in libpijul/src/lib.rs at line 703

[22.735824]→[22.735824:735947](∅→∅)

let change = self.txn.get_external(file.change).unwrap();
return Some(pristine::Position {

[22.735824]

[22.735947]

let change = match self.txn.get_external(file.change) {
Ok(ext) => ext.unwrap(),
Err(e) => return Some(Err(e.0)),
};
return Some(Ok(pristine::Position {
replacement in libpijul/src/lib.rs at line 710

[22.736010]→[22.736010:736030](∅→∅)

});

[22.736010]

[22.736030]

}));
replacement in libpijul/src/fs.rs at line 25

[22.30501]→[22.30501:30559](∅→∅)

#[error("Path not found: {0}")]
NotFound(String),

[22.30501]

[22.30559]

#[error(transparent)]
NotFound(#[from] FsNotFound),
edit in libpijul/src/fs.rs at line 29

[22.30634]

[22.30634]

#[error(transparent)]
Txn(T),
}

#[derive(Debug, Error)]
pub enum FsErrorC<C: std::error::Error + 'static, T: std::error::Error + 'static> {
edit in libpijul/src/fs.rs at line 37

[22.30672]

[22.30672]

#[error(transparent)]
Changestore(C),
#[error(transparent)]
NotFound(#[from] FsNotFound),
}

#[derive(Debug, Error)]
#[error("Path not found: {0}")]
pub struct FsNotFound(String);

impl<T: std::error::Error + 'static> std::convert::From<TxnErr<T>> for FsError<T> {
fn from(e: TxnErr<T>) -> Self {
FsError::Txn(e.0)
}
}

impl<C: std::error::Error + 'static, T: std::error::Error + 'static> std::convert::From<TxnErr<T>>
for FsErrorC<C, T>
{
fn from(e: TxnErr<T>) -> Self {
FsErrorC::Txn(e.0)
}
replacement in libpijul/src/fs.rs at line 61

[22.1]→[22.738541:738608](∅→∅),[22.30675]→[22.738541:738608](∅→∅),[22.738541]→[22.738541:738608](∅→∅)

pub(crate) fn create_new_inode<T: MutTxnT>(txn: &mut T) -> Inode {

[22.30675]

[22.738608]

pub(crate) fn create_new_inode<T: TreeMutTxnT>(txn: &mut T) -> Result<Inode, TxnErr<T::TreeError>> {
replacement in libpijul/src/fs.rs at line 66

[22.738741]→[22.738741:738805](∅→∅)

already_taken = txn.get_revtree(inode, None).is_some();

[22.738741]

[22.738805]

already_taken = txn.get_revtree(inode, None)?.is_some();
replacement in libpijul/src/fs.rs at line 68

[22.738811]→[22.738811:738821](∅→∅)

inode

[22.738811]

[22.738821]

Ok(inode)
replacement in libpijul/src/fs.rs at line 73

[22.738959]→[22.738959:739021](∅→∅)

pub fn is_directory<T: TxnT>(txn: &T, inode: Inode) -> bool {

[22.738959]

[22.739021]

pub fn is_directory<T: TreeTxnT>(txn: &T, inode: Inode) -> Result<bool, TxnErr<T::TreeError>> {
replacement in libpijul/src/fs.rs at line 75

[22.739051]→[22.739051:739072](∅→∅)

return true;

[22.739051]

[22.739072]

return Ok(true);
replacement in libpijul/src/fs.rs at line 81

[22.739183]→[22.739183:739241](∅→∅)

for (pid, _) in txn.iter_tree(pathid.clone(), None) {

[22.739183]

[22.739241]

for x in txn.iter_tree(pathid.clone(), None)? {
let (pid, _) = x?;
replacement in libpijul/src/fs.rs at line 88

[22.739351]→[22.739351:739372](∅→∅)

return true;

[22.739351]

[22.739372]

return Ok(true);
replacement in libpijul/src/fs.rs at line 90

[22.739378]→[22.739378:739388](∅→∅)

false

[22.739378]

[22.739388]

Ok(false)
replacement in libpijul/src/fs.rs at line 93

[22.5]→[22.739445:739487](∅→∅),[22.739445]→[22.739445:739487](∅→∅)

fn closest_in_repo_ancestor<'a, T: TxnT>(

[22.5]

[22.739487]

fn closest_in_repo_ancestor<'a, T: TreeTxnT>(
replacement in libpijul/src/fs.rs at line 96

[22.739519]→[22.739519:739584](∅→∅)

) -> (Inode, std::iter::Peekable<crate::path::Components<'a>>) {

[22.739519]

[22.739584]

) -> Result<(Inode, std::iter::Peekable<crate::path::Components<'a>>), TxnErr<T::TreeError>> {
replacement in libpijul/src/fs.rs at line 107

[22.739962]→[22.739962:740027](∅→∅)

for (id, inode) in txn.iter_tree(fileid.clone(), None) {

[22.739962]

[22.740027]

for x in txn.iter_tree(fileid.clone(), None)? {
let (id, inode) = x?;
replacement in libpijul/src/fs.rs at line 130

[22.740541]→[22.740541:740579](∅→∅)

(fileid.parent_inode, components)

[22.740541]

[22.740579]

Ok((fileid.parent_inode, components))
replacement in libpijul/src/fs.rs at line 134

[22.30737]→[22.30737:30823](∅→∅)

pub fn find_inode<T: TxnT>(txn: &T, path: &str) -> Result<Inode, FsError<T::Error>> {

[22.30737]

[22.740814]

pub fn find_inode<T: TreeTxnT>(txn: &T, path: &str) -> Result<Inode, FsError<T::TreeError>> {
replacement in libpijul/src/fs.rs at line 136

[22.740840]→[22.740840:740926](∅→∅)

let (inode, mut remaining_path_components) = closest_in_repo_ancestor(txn, path);

[22.740840]

[22.740926]

let (inode, mut remaining_path_components) = closest_in_repo_ancestor(txn, path)?;
replacement in libpijul/src/fs.rs at line 140

[22.741040]→[22.30824:30873](∅→∅)

Err(FsError::NotFound(path.to_string()))

[22.741040]

[22.741140]

Err(FsNotFound(path.to_string()).into())
replacement in libpijul/src/fs.rs at line 147

[22.741242]→[22.741242:741300](∅→∅)

pub fn is_tracked<T: TxnT>(txn: &T, path: &str) -> bool {

[22.741242]

[22.741300]

pub fn is_tracked<T: TreeTxnT>(txn: &T, path: &str) -> Result<bool, TxnErr<T::TreeError>> {
replacement in libpijul/src/fs.rs at line 149

[22.741337]→[22.741337:741419](∅→∅)

let (_, mut remaining_path_components) = closest_in_repo_ancestor(txn, path);

[22.741337]

[22.741419]

let (_, mut remaining_path_components) = closest_in_repo_ancestor(txn, path)?;
replacement in libpijul/src/fs.rs at line 151

[22.741457]→[22.741457:741504](∅→∅)

remaining_path_components.next().is_none()

[22.741457]

[22.741504]

Ok(remaining_path_components.next().is_none())
replacement in libpijul/src/fs.rs at line 155

[22.741617]→[22.741617:741691](∅→∅)

pub fn inode_filename<T: TxnT>(txn: &T, inode: Inode) -> Option<String> {

[22.741617]

[22.741691]

pub fn inode_filename<T: TreeTxnT>(
txn: &T,
inode: Inode,
) -> Result<Option<String>, TxnErr<T::TreeError>> {
replacement in libpijul/src/fs.rs at line 162

[22.741768]→[22.741768:741815](∅→∅)

match txn.get_revtree(current, None) {

[22.741768]

[22.741815]

match txn.get_revtree(current, None)? {
replacement in libpijul/src/fs.rs at line 172

[22.742118]→[22.742118:742147](∅→∅)

return None;

[22.742118]

[22.742147]

return Ok(None);
replacement in libpijul/src/fs.rs at line 184

[22.742417]→[22.742417:742432](∅→∅)

Some(path)

[22.742417]

[22.742432]

Ok(Some(path))
replacement in libpijul/src/fs.rs at line 189

[22.742616]→[22.742616:742647](∅→∅)

fn make_new_child<T: MutTxnT>(

[22.742616]

[22.742647]

fn make_new_child<T: TreeMutTxnT>(
replacement in libpijul/src/fs.rs at line 195

[22.742759]→[22.30874:30914](∅→∅)

) -> Result<Inode, FsError<T::Error>> {

[22.742759]

[22.742795]

) -> Result<Inode, FsError<T::TreeError>> {
replacement in libpijul/src/fs.rs at line 201

[22.15]→[22.742982:743052](∅→∅),[22.742982]→[22.742982:743052](∅→∅)

if let Some(inode) = txn.get_tree(parent_id.as_file_id(), None) {

[22.15]

[22.743052]

if let Some(inode) = txn.get_tree(parent_id.as_file_id(), None)? {
replacement in libpijul/src/fs.rs at line 208

[22.743256]→[22.30915:31009](∅→∅),[22.2896]→[22.743414:743482](∅→∅),[22.31009]→[22.743414:743482](∅→∅),[22.743414]→[22.743414:743482](∅→∅),[22.743482]→[22.31010:31094](∅→∅)

del_tree_with_rev(txn, parent_id.as_file_id(), inode).map_err(FsError::Txn)?;
if let Some(vertex) = txn.get_inodes(inode, None) {
del_inodes_with_rev(txn, inode, vertex).map_err(FsError::Txn)?;

[22.743256]

[22.743619]

del_tree_with_rev(txn, parent_id.as_file_id(), inode)?;
if let Some(vertex) = txn.get_inodes(inode, None)? {
del_inodes_with_rev(txn, inode, vertex)?;
replacement in libpijul/src/fs.rs at line 212

[22.743637]→[22.31095:31189](∅→∅)

put_tree_with_rev(txn, parent_id.as_file_id(), child).map_err(FsError::Txn)?;

[22.743637]

[22.743764]

put_tree_with_rev(txn, parent_id.as_file_id(), child)?;
replacement in libpijul/src/fs.rs at line 220

[22.744073]→[22.744073:744116](∅→∅)

None => create_new_inode(txn),

[22.744073]

[22.744116]

None => create_new_inode(txn)?,
replacement in libpijul/src/fs.rs at line 224

[22.744222]→[22.31253:31345](∅→∅)

put_tree_with_rev(txn, parent_id.as_file_id(), child_inode).map_err(FsError::Txn)?;

[22.744222]

[22.744345]

put_tree_with_rev(txn, parent_id.as_file_id(), child_inode)?;
replacement in libpijul/src/fs.rs at line 231

[22.744509]→[22.31346:31446](∅→∅)

txn.put_tree(dir_id.as_file_id(), child_inode)
.map_err(FsError::Txn)?;

[22.744509]

[22.744570]

txn.put_tree(dir_id.as_file_id(), child_inode)?;
replacement in libpijul/src/fs.rs at line 237

[22.17]→[22.744668:744705](∅→∅),[22.744668]→[22.744668:744705](∅→∅)

pub(crate) fn add_inode<T: MutTxnT>(

[22.17]

[22.744705]

pub(crate) fn add_inode<T: TreeMutTxnT>(
replacement in libpijul/src/fs.rs at line 242

[22.744782]→[22.31447:31484](∅→∅)

) -> Result<(), FsError<T::Error>> {

[22.744782]

[22.744815]

) -> Result<(), FsError<T::TreeError>> {
replacement in libpijul/src/fs.rs at line 245

[22.744894]→[22.744894:744980](∅→∅)

let (current_inode, unrecorded_path) = closest_in_repo_ancestor(txn, parent);

[22.744894]

[22.744980]

let (current_inode, unrecorded_path) = closest_in_repo_ancestor(txn, parent)?;
replacement in libpijul/src/fs.rs at line 264

[22.745758]→[22.745758:745788](∅→∅)

pub fn move_file<T: MutTxnT>(

[22.745758]

[22.745788]

pub fn move_file<T: TreeMutTxnT>(
replacement in libpijul/src/fs.rs at line 268

[22.745846]→[22.31485:31522](∅→∅)

) -> Result<(), FsError<T::Error>> {

[22.745846]

[22.745879]

) -> Result<(), FsError<T::TreeError>> {
replacement in libpijul/src/fs.rs at line 274

[22.746015]→[22.746015:746054](∅→∅)

pub fn move_file_by_inode<T: MutTxnT>(

[22.746015]

[22.746054]

pub fn move_file_by_inode<T: TreeMutTxnT>(
replacement in libpijul/src/fs.rs at line 278

[22.746112]→[22.31523:31560](∅→∅),[22.31560]→[22.746145:746213](∅→∅),[22.746145]→[22.746145:746213](∅→∅)

) -> Result<(), FsError<T::Error>> {
let fileref = txn.get_revtree(inode, None).unwrap().to_owned();

[22.746112]

[22.746213]

) -> Result<(), FsError<T::TreeError>> {
let fileref = txn.get_revtree(inode, None)?.unwrap().to_owned();
replacement in libpijul/src/fs.rs at line 281

[22.746252]→[22.31561:31641](∅→∅)

del_tree_with_rev(txn, fileref.as_file_id(), inode).map_err(FsError::Txn)?;

[22.746252]

[22.746499]

del_tree_with_rev(txn, fileref.as_file_id(), inode)?;
replacement in libpijul/src/fs.rs at line 291

[22.746770]→[22.746770:746780](∅→∅)

)

[22.746770]

[22.746780]

)?
replacement in libpijul/src/fs.rs at line 297

[22.21]→[22.746923:746961](∅→∅),[22.746923]→[22.746923:746961](∅→∅)

pub(crate) fn rec_delete<T: MutTxnT>(

[22.21]

[22.746961]

pub(crate) fn rec_delete<T: TreeMutTxnT>(
replacement in libpijul/src/fs.rs at line 301

[22.747046]→[22.31642:31679](∅→∅)

) -> Result<(), FsError<T::Error>> {

[22.747021]

[22.747079]

) -> Result<(), FsError<T::TreeError>> {
replacement in libpijul/src/fs.rs at line 308

[22.747248]→[22.747248:747309](∅→∅)

for (k, inode) in txn.iter_tree(file_id.clone(), None) {

[22.747248]

[22.747309]

for x in txn.iter_tree(file_id.clone(), None)? {
let (k, inode) = x?;
replacement in libpijul/src/fs.rs at line 330

[22.67]→[10.0:188](∅→∅)

assert!(
inode.is_root()
|| txn
.del_tree(file_id.as_file_id(), Some(inode))
.map_err(FsError::Txn)?
);

[22.67]

[22.748177]

assert!(inode.is_root() || txn.del_tree(file_id.as_file_id(), Some(inode))?);
replacement in libpijul/src/fs.rs at line 332

[22.748183]→[10.189:304](∅→∅),[10.304]→[22.3292:3352](∅→∅),[22.31879]→[22.3292:3352](∅→∅),[22.3292]→[22.3292:3352](∅→∅),[22.3352]→[22.31880:31956](∅→∅)

if !inode.is_root()
&& del_tree_with_rev(txn, parent.as_file_id(), inode).map_err(FsError::Txn)?
{
if let Some(vertex) = txn.get_inodes(inode, None) {
del_inodes_with_rev(txn, inode, vertex).map_err(FsError::Txn)?;

[22.748183]

[22.748543]

if !inode.is_root() && del_tree_with_rev(txn, parent.as_file_id(), inode)? {
if let Some(vertex) = txn.get_inodes(inode, None)? {
del_inodes_with_rev(txn, inode, vertex)?;
replacement in libpijul/src/fs.rs at line 347

[22.748753]→[22.31957:32048](∅→∅)

pub fn remove_file<T: MutTxnT>(txn: &mut T, path: &str) -> Result<(), FsError<T::Error>> {

[22.748753]

[22.748840]

pub fn remove_file<T: TreeMutTxnT>(txn: &mut T, path: &str) -> Result<(), FsError<T::TreeError>> {
replacement in libpijul/src/fs.rs at line 356

[10.469]→[10.469:526](∅→∅)

txn.get_revtree(inode, None).unwrap().to_owned()

[10.469]

[10.526]

txn.get_revtree(inode, None)?.unwrap().to_owned()
replacement in libpijul/src/fs.rs at line 368

[22.749331]→[22.749331:749379](∅→∅)

pub struct WorkingCopyChildren<'txn, T: TxnT> {

[22.749331]

[22.749379]

pub struct WorkingCopyChildren<'txn, T: TreeTxnT> {
replacement in libpijul/src/fs.rs at line 373

[22.749482]→[22.749482:749584](∅→∅)

impl<'txn, T: TxnT> Iterator for WorkingCopyChildren<'txn, T> {
type Item = (SmallString, Inode);

[22.749482]

[22.749584]

impl<'txn, T: TreeTxnT> Iterator for WorkingCopyChildren<'txn, T> {
type Item = Result<(SmallString, Inode), T::TreeError>;
replacement in libpijul/src/fs.rs at line 377

[22.749646]→[22.749646:749849](∅→∅)

if let Some((k, v)) = self.iter.next() {
if k.parent_inode == self.inode {
if k.basename.len() > 0 {
return Some((k.basename, v));

[22.749646]

[22.749849]

match self.iter.next() {
Some(Ok((k, v))) => {
if k.parent_inode == self.inode {
if k.basename.len() > 0 {
return Some(Ok((k.basename, v)));
}
} else if k.parent_inode > self.inode {
return None;
edit in libpijul/src/fs.rs at line 386

[22.749871]→[22.749871:749960](∅→∅)

} else if k.parent_inode > self.inode {
return None;
replacement in libpijul/src/fs.rs at line 387

[22.749978]→[22.749978:750028](∅→∅)

} else {
return None;

[22.749978]

[22.750028]

None => return None,
Some(Err(e)) => return Some(Err(e.0)),
replacement in libpijul/src/fs.rs at line 395

[22.750130]→[22.3167:3256](∅→∅),[22.3256]→[22.750247:750455](∅→∅),[22.750247]→[22.750247:750455](∅→∅)

pub fn working_copy_children<T: TxnT>(txn: &T, inode: Inode) -> WorkingCopyChildren<T> {
WorkingCopyChildren {
iter: txn.iter_tree(
OwnedPathId {
parent_inode: inode,
basename: SmallString::new(),
},
None,
),

[22.750130]

[22.750455]

pub fn working_copy_children<T: TreeTxnT>(
txn: &T,
inode: Inode,
) -> Result<WorkingCopyChildren<T>, T::TreeError> {
Ok(WorkingCopyChildren {
iter: txn
.iter_tree(
OwnedPathId {
parent_inode: inode,
basename: SmallString::new(),
},
None,
)
.map_err(|e| e.0)?,
replacement in libpijul/src/fs.rs at line 410

[22.750470]→[22.750470:750476](∅→∅)

}

[22.750470]

[22.750476]

})
replacement in libpijul/src/fs.rs at line 416

[22.750665]→[22.750665:750713](∅→∅)

pub struct WorkingCopyIterator<'txn, T: TxnT> {

[22.750665]

[22.750713]

pub struct WorkingCopyIterator<'txn, T: TreeTxnT> {
replacement in libpijul/src/fs.rs at line 421

[22.750767]→[22.750767:750864](∅→∅)

impl<'txn, T: TxnT> Iterator for WorkingCopyIterator<'txn, T> {
type Item = (Inode, String);

[22.750767]

[22.750864]

impl<'txn, T: TreeTxnT> Iterator for WorkingCopyIterator<'txn, T> {
type Item = Result<(Inode, String), T::TreeError>;
replacement in libpijul/src/fs.rs at line 431

[6.44]→[22.751146:751211](∅→∅),[22.751146]→[22.751146:751211](∅→∅)

for (k, v) in self.txn.iter_tree(fileid, None) {

[6.44]

[22.751211]

let iter = match self.txn.iter_tree(fileid, None) {
Ok(iter) => iter,
Err(e) => return Some(Err(e.0)),
};
for x in iter {
let (k, v) = match x {
Ok(x) => x,
Err(e) => return Some(Err(e.0)),
};
replacement in libpijul/src/fs.rs at line 453

[22.751704]→[22.751704:751752](∅→∅)

return Some((inode, name));

[22.751704]

[22.751752]

return Some(Ok((inode, name)));
replacement in libpijul/src/fs.rs at line 463

[22.751917]→[22.3257:3341](∅→∅)

pub fn iter_working_copy<T: TxnT>(txn: &T, root: Inode) -> WorkingCopyIterator<T> {

[22.751917]

[22.752018]

pub fn iter_working_copy<T: TreeTxnT>(txn: &T, root: Inode) -> WorkingCopyIterator<T> {
replacement in libpijul/src/fs.rs at line 475

[22.13264]→[22.13264:13319](∅→∅)

pub struct GraphDescendants<'txn, 'channel, T: TxnT> {

[22.13264]

[22.13319]

pub struct GraphDescendants<'txn, 'channel, T: GraphTxnT> {
replacement in libpijul/src/fs.rs at line 477

[22.13337]→[22.13337:13372](∅→∅)

channel: &'channel Channel<T>,

[22.13337]

[22.13372]

channel: &'channel T::Graph,
replacement in libpijul/src/fs.rs at line 482

[22.752110]→[22.13458:13575](∅→∅)

impl<'txn, 'channel, T: TxnT> Iterator for GraphDescendants<'txn, 'channel, T> {
type Item = Position<ChangeId>;

[22.752110]

[22.13575]

impl<'txn, 'channel, T: GraphTxnT> Iterator for GraphDescendants<'txn, 'channel, T> {
type Item = Result<Position<ChangeId>, T::GraphError>;
replacement in libpijul/src/fs.rs at line 486

[22.13672]→[22.13672:14276](∅→∅)

if let Some(child) = adj.next() {
self.stack.push(adj);
let dest = find_block(self.txn, &self.channel, child.dest).unwrap();
let grandchild = iter_adjacent(
self.txn,
&self.channel,
dest,
EdgeFlags::FOLDER,
EdgeFlags::FOLDER | EdgeFlags::PSEUDO | EdgeFlags::BLOCK,
)
.next()
.unwrap();

if self.visited.insert(grandchild.dest) {
self.stack.push(iter_adjacent(

[22.13672]

[22.14276]

match adj.next() {
Some(Ok(child)) => {
self.stack.push(adj);
let dest = match find_block(self.txn, self.channel, child.dest) {
Ok(dest) => dest,
Err(BlockError::Txn(t)) => return Some(Err(t)),
Err(e) => panic!("{}", e),
};
let grandchild = match iter_adjacent(
replacement in libpijul/src/fs.rs at line 496

[22.14310]→[22.14310:14405](∅→∅)

&self.channel,
grandchild.dest.inode_vertex(),

[22.14310]

[22.14405]

self.channel,
dest,
replacement in libpijul/src/fs.rs at line 500

[22.14530]→[22.14530:14553](∅→∅)

))

[22.14530]

[22.14553]

) {
Ok(mut x) => match x.next().unwrap() {
Ok(x) => x,
Err(e) => return Some(Err(e.0)),
},
Err(e) => return Some(Err(e.0)),
};

if self.visited.insert(grandchild.dest) {
match iter_adjacent(
self.txn,
self.channel,
grandchild.dest.inode_vertex(),
EdgeFlags::FOLDER,
EdgeFlags::FOLDER | EdgeFlags::PSEUDO | EdgeFlags::BLOCK,
) {
Ok(adj) => self.stack.push(adj),
Err(e) => return Some(Err(e.0)),
}
}
return Some(Ok(grandchild.dest));
replacement in libpijul/src/fs.rs at line 522

[22.14571]→[22.14571:14686](∅→∅)

return Some(grandchild.dest);
} else {
// No child left, actually pop.

[22.14571]

[22.14686]

Some(Err(e)) => return Some(Err(e.0)),
None => {
// No child left, actually pop.
}
replacement in libpijul/src/fs.rs at line 534

[22.14870]→[22.14870:14926](∅→∅)

pub fn iter_graph_descendants<'txn, 'channel, T: TxnT>(

[22.14870]

[22.14926]

pub fn iter_graph_descendants<'txn, 'channel, T: GraphTxnT>(
replacement in libpijul/src/fs.rs at line 536

[22.14944]→[22.14944:14979](∅→∅)

channel: &'channel Channel<T>,

[22.14944]

[22.14979]

channel: &'channel T::Graph,
replacement in libpijul/src/fs.rs at line 538

[22.15008]→[22.15008:15074](∅→∅)

) -> GraphDescendants<'txn, 'channel, T> {
GraphDescendants {

[22.15008]

[22.15074]

) -> Result<GraphDescendants<'txn, 'channel, T>, T::GraphError> {
Ok(GraphDescendants {
replacement in libpijul/src/fs.rs at line 546

[22.15281]→[22.15281:15293](∅→∅)

)],

[22.15281]

[22.15293]

)
.map_err(|e| e.0)?],
replacement in libpijul/src/fs.rs at line 551

[22.15356]→[22.15356:15362](∅→∅)

}

[22.15356]

[22.15362]

})
replacement in libpijul/src/fs.rs at line 559

[22.752344]→[22.752344:752433](∅→∅)

pub struct GraphChildren<'txn, 'channel, 'changes, T: TxnT, P: ChangeStore + 'changes> {

[22.752344]

[22.752433]

pub struct GraphChildren<'txn, 'channel, 'changes, T: GraphTxnT, P: ChangeStore + 'changes> {
replacement in libpijul/src/fs.rs at line 561

[22.752451]→[22.752451:752486](∅→∅)

channel: &'channel Channel<T>,

[22.752451]

[22.752486]

channel: &'channel T::Graph,
replacement in libpijul/src/fs.rs at line 567

[22.752569]→[22.752569:752645](∅→∅)

impl<'txn, 'channel, 'changes, T: TxnT, P: ChangeStore + 'changes> Iterator

[22.752569]

[22.752645]

impl<'txn, 'channel, 'changes, T: GraphTxnT, P: ChangeStore + 'changes> Iterator
replacement in libpijul/src/fs.rs at line 570

[22.752701]→[22.752701:752762](∅→∅)

type Item = (Position<ChangeId>, InodeMetadata, String);

[22.752701]

[22.752762]

type Item = Result<(Position<ChangeId>, InodeMetadata, String), T::GraphError>;
replacement in libpijul/src/fs.rs at line 572

[22.752809]→[22.752809:752852](∅→∅),[22.752852]→[22.62710:62791](∅→∅),[22.62791]→[22.752932:753346](∅→∅),[22.752932]→[22.752932:753346](∅→∅)

self.adj.next().map(move |child| {
let dest = find_block(self.txn, &self.channel, child.dest).unwrap();
let mut buf = std::mem::replace(&mut self.buf, Vec::new());
self.changes
.get_contents(|p| self.txn.get_external(p), dest, &mut buf)
.unwrap();
self.buf = buf;
let (perms, basename) = self.buf.split_at(2);
let perms = InodeMetadata::from_basename(perms);
let basename = std::str::from_utf8(basename).unwrap();

[22.752809]

[22.753346]

let child = match self.adj.next()? {
Ok(child) => child,
Err(e) => return Some(Err(e.0)),
};
let dest = find_block(self.txn, self.channel, child.dest).unwrap();
let mut buf = std::mem::replace(&mut self.buf, Vec::new());
self.changes
.get_contents(|p| self.txn.get_external(p).unwrap(), dest, &mut buf)
.unwrap();
self.buf = buf;
let (perms, basename) = self.buf.split_at(2);
let perms = InodeMetadata::from_basename(perms);
let basename = std::str::from_utf8(basename).unwrap();
replacement in libpijul/src/fs.rs at line 586

[22.753347]→[22.62792:62950](∅→∅),[22.62950]→[22.62950:63024](∅→∅),[22.63024]→[22.63024:63081](∅→∅),[22.63081]→[22.753681:753751](∅→∅),[22.753681]→[22.753681:753751](∅→∅)

let grandchild = iter_adjacent(
self.txn,
&self.channel,
dest,
EdgeFlags::FOLDER,
EdgeFlags::FOLDER | EdgeFlags::PSEUDO | EdgeFlags::BLOCK,
)
.next()
.unwrap();
(grandchild.dest, perms, basename.to_string())
})

[22.753347]

[22.753751]

let grandchild = match iter_adjacent(
self.txn,
self.channel,
dest,
EdgeFlags::FOLDER,
EdgeFlags::FOLDER | EdgeFlags::PSEUDO | EdgeFlags::BLOCK,
) {
Ok(mut adj) => match adj.next() {
Some(Ok(n)) => n,
None => unreachable!(),
Some(Err(e)) => return Some(Err(e.0)),
},
Err(e) => return Some(Err(e.0)),
};
Some(Ok((grandchild.dest, perms, basename.to_string())))
replacement in libpijul/src/fs.rs at line 609

[22.754002]→[22.754002:754037](∅→∅)

channel: &'channel Channel<T>,

[22.754002]

[22.754037]

channel: &'channel T::Graph,
replacement in libpijul/src/fs.rs at line 611

[22.754066]→[22.754066:754117](∅→∅)

) -> GraphChildren<'txn, 'channel, 'changes, T, P>

[22.754066]

[22.754117]

) -> Result<GraphChildren<'txn, 'channel, 'changes, T, P>, T::GraphError>
replacement in libpijul/src/fs.rs at line 613

[22.754123]→[22.754123:754136](∅→∅)

T: TxnT,

[22.754123]

[22.754136]

T: GraphTxnT,
replacement in libpijul/src/fs.rs at line 616

[22.754158]→[22.754158:754178](∅→∅)

GraphChildren {

[22.754158]

[22.754178]

Ok(GraphChildren {
replacement in libpijul/src/fs.rs at line 620

[22.63127]→[22.754235:754257](∅→∅),[22.754235]→[22.754235:754257](∅→∅)

&channel,

[22.63127]

[22.754257]

channel,
replacement in libpijul/src/fs.rs at line 624

[22.754390]→[22.754390:754401](∅→∅)

),

[22.754390]

[22.754401]

)
.map_err(|e| e.0)?,
replacement in libpijul/src/fs.rs at line 629

[22.754448]→[22.754448:754454](∅→∅)

}

[22.754448]

[22.754454]

})
replacement in libpijul/src/fs.rs at line 635

[22.754635]→[22.754635:754725](∅→∅)

pub struct GraphBasenames<'txn, 'channel, 'changes, T: TxnT, P: ChangeStore + 'changes> {

[22.754635]

[22.754725]

pub struct GraphBasenames<'txn, 'channel, 'changes, T: GraphTxnT, P: ChangeStore + 'changes> {
replacement in libpijul/src/fs.rs at line 637

[22.754743]→[22.754743:754778](∅→∅)

channel: &'channel Channel<T>,

[22.754743]

[22.754778]

channel: &'channel T::Graph,
replacement in libpijul/src/fs.rs at line 643

[22.754861]→[22.754861:754937](∅→∅)

impl<'txn, 'channel, 'changes, T: TxnT, P: ChangeStore + 'changes> Iterator

[22.754861]

[22.754937]

impl<'txn, 'channel, 'changes, T: GraphTxnT, P: ChangeStore + 'changes> Iterator
replacement in libpijul/src/fs.rs at line 646

[22.754994]→[22.754994:755055](∅→∅)

type Item = (Position<ChangeId>, InodeMetadata, String);

[22.754994]

[22.755055]

type Item = Result<(Position<ChangeId>, InodeMetadata, String), T::GraphError>;
replacement in libpijul/src/fs.rs at line 648

[22.755102]→[22.0:51](∅→∅)

while let Some(parent) = self.adj.next() {

[22.755102]

[22.63128]

loop {
let parent = match self.adj.next() {
Some(Ok(n)) => n,
Some(Err(e)) => return Some(Err(e.0)),
None => return None,
};
replacement in libpijul/src/fs.rs at line 657

[22.755328]→[22.755328:755404](∅→∅)

.get_contents(|p| self.txn.get_external(p), dest, &mut buf)

[22.755328]

[22.755404]

.get_contents(|p| self.txn.get_external(p).unwrap(), dest, &mut buf)
replacement in libpijul/src/fs.rs at line 663

[22.755657]→[22.52:106](∅→∅)

if let Some(grandparent) = iter_adjacent(

[22.755657]

[22.63260]

match iter_adjacent(
replacement in libpijul/src/fs.rs at line 669

[22.63488]→[22.63488:63522](∅→∅),[22.63522]→[22.107:187](∅→∅)

)
.next()
{
return Some((grandparent.dest, perms, basename));

[22.63488]

[22.187]

) {
Ok(mut adj) => match adj.next() {
Some(Ok(grandparent)) => return Some(Ok((grandparent.dest, perms, basename))),
Some(Err(e)) => return Some(Err(e.0)),
None => {}
},
Err(e) => return Some(Err(e.0)),
edit in libpijul/src/fs.rs at line 678

[22.211]→[22.211:224](∅→∅)

None
replacement in libpijul/src/fs.rs at line 688

[22.756353]→[22.756353:756388](∅→∅)

channel: &'channel Channel<T>,

[22.756353]

[22.756388]

channel: &'channel T::Graph,
replacement in libpijul/src/fs.rs at line 690

[22.756417]→[22.756417:756469](∅→∅)

) -> GraphBasenames<'txn, 'channel, 'changes, T, P>

[22.756417]

[22.756469]

) -> Result<GraphBasenames<'txn, 'channel, 'changes, T, P>, T::GraphError>
replacement in libpijul/src/fs.rs at line 692

[22.756475]→[22.756475:756488](∅→∅)

T: TxnT,

[22.756475]

[22.756488]

T: GraphTxnT,
replacement in libpijul/src/fs.rs at line 695

[22.756510]→[22.756510:756531](∅→∅)

GraphBasenames {

[22.756510]

[22.756531]

Ok(GraphBasenames {
replacement in libpijul/src/fs.rs at line 699

[22.63591]→[22.756588:756610](∅→∅),[22.756588]→[22.756588:756610](∅→∅)

&channel,

[22.63591]

[22.756610]

channel,
replacement in libpijul/src/fs.rs at line 703

[22.756764]→[22.756764:756775](∅→∅)

),

[22.756764]

[22.756775]

)
.map_err(|e| e.0)?,
replacement in libpijul/src/fs.rs at line 708

[22.756822]→[22.756822:756828](∅→∅)

}

[22.756822]

[22.756828]

})
replacement in libpijul/src/fs.rs at line 720

[22.757313]→[22.757313:757405](∅→∅)

pub fn iter_paths<T: TxnT, F: FnMut(&mut dyn Iterator<Item = Position<ChangeId>>) -> bool>(

[22.757313]

[22.757405]

pub fn iter_paths<T: GraphTxnT, F: FnMut(&mut dyn Iterator<Item = Position<ChangeId>>) -> bool>(
replacement in libpijul/src/fs.rs at line 722

[22.757418]→[22.757418:757447](∅→∅)

channel: &ChannelRef<T>,

[22.757418]

[22.757447]

graph: &T::Graph,
replacement in libpijul/src/fs.rs at line 725

[22.757490]→[22.757490:757532](∅→∅)

) {
let channel = channel.r.borrow();

[22.757490]

[22.757532]

) -> Result<(), T::GraphError> {
replacement in libpijul/src/fs.rs at line 743

[22.758177]→[22.63592:63688](∅→∅),[22.63688]→[22.758289:758464](∅→∅),[22.758289]→[22.758289:758464](∅→∅),[22.758464]→[22.63689:63870](∅→∅),[22.63870]→[22.758664:758898](∅→∅),[22.758664]→[22.758664:758898](∅→∅)

for (_, parent) in iter_graph(txn, &channel.graph, cur_key.inode_vertex(), Some(e))
.take_while(|&(k, _)| k == cur_key.inode_vertex())
.filter(|&(_, ref v)| v.flag.contains(EdgeFlags::FOLDER | EdgeFlags::PARENT))
{
let parent_dest = find_block_end(txn, &channel, parent.dest).unwrap();
for (_, grandparent) in iter_graph(txn, &channel.graph, parent_dest, Some(e))
.take_while(|&(k, _)| k == parent_dest)
.filter(|&(_, ref v)| v.flag.contains(EdgeFlags::FOLDER | EdgeFlags::PARENT))
{
stack.push((grandparent.dest, false))

[22.758177]

[22.758898]

for x in iter_graph(txn, &graph, cur_key.inode_vertex(), Some(e)).map_err(|e| e.0)? {
let (k, parent) = x.map_err(|e| e.0)?;
if k != cur_key.inode_vertex() {
break;
} else if !parent.flag.contains(EdgeFlags::FOLDER | EdgeFlags::PARENT) {
continue;
}
let parent_dest = find_block_end(txn, &graph, parent.dest).unwrap();
for x in iter_graph(txn, &graph, parent_dest, Some(e)).map_err(|e| e.0)? {
let (k, grandparent) = x.map_err(|e| e.0)?;
if k != parent_dest {
break;
}
if grandparent
.flag
.contains(EdgeFlags::FOLDER | EdgeFlags::PARENT)
{
stack.push((grandparent.dest, false))
}
edit in libpijul/src/fs.rs at line 769

[22.759025]

[22.759025]

Ok(())
replacement in libpijul/src/fs.rs at line 772

[22.759028]→[22.759028:759087](∅→∅)

pub(crate) fn follow_oldest_path<T: TxnT, C: ChangeStore>(

[22.759028]

[22.759087]

pub(crate) fn follow_oldest_path<T: ChannelTxnT, C: ChangeStore>(
replacement in libpijul/src/fs.rs at line 775

[22.759117]→[22.759117:759146](∅→∅)

channel: &ChannelRef<T>,

[22.759117]

[22.759146]

channel: &Channel<T>,
replacement in libpijul/src/fs.rs at line 777

[22.759162]→[22.32049:32110](∅→∅)

) -> Result<(Position<ChangeId>, bool), FsError<C::Error>> {

[22.759162]

[22.759219]

) -> Result<(Position<ChangeId>, bool), FsErrorC<C::Error, T::GraphError>> {
edit in libpijul/src/fs.rs at line 779

[22.759247]→[22.759247:759283](∅→∅)

let channel = channel.borrow();
replacement in libpijul/src/fs.rs at line 787

[22.759605]→[22.63871:64035](∅→∅)

for name in iter_adjacent(txn, &channel, current.inode_vertex(), flag0, flag1) {
let name_dest = find_block(txn, &channel, name.dest).unwrap();

[22.759605]

[22.759767]

for name in iter_adjacent(txn, &channel.graph, current.inode_vertex(), flag0, flag1)? {
let name = name?;
let name_dest = find_block(txn, &channel.graph, name.dest).unwrap();
replacement in libpijul/src/fs.rs at line 793

[22.32131]→[22.32131:32253](∅→∅)

.get_contents(|h| txn.get_external(h), name_dest, &mut name_buf)
.map_err(FsError::Txn)?;

[22.32131]

[22.759934]

.get_contents(|h| txn.get_external(h).unwrap(), name_dest, &mut name_buf)
.map_err(FsErrorC::Changestore)?;
replacement in libpijul/src/fs.rs at line 812

[22.760549]→[22.64036:64107](∅→∅)

current = iter_adjacent(txn, &channel, next, flag0, flag1)

[22.760549]

[22.760636]

current = iter_adjacent(txn, &channel.graph, next, flag0, flag1)?
replacement in libpijul/src/fs.rs at line 814

[22.760660]→[22.760660:760686](∅→∅)

.unwrap()

[22.760660]

[22.760686]

.unwrap()?
replacement in libpijul/src/fs.rs at line 817

[22.760725]→[22.32254:32315](∅→∅)

return Err(FsError::NotFound(path.to_string()));

[22.760725]

[22.760849]

return Err(FsErrorC::NotFound(FsNotFound(path.to_string())));
replacement in libpijul/src/fs.rs at line 823

[22.760952]→[22.760952:760995](∅→∅)

pub fn find_path<T: TxnT, C: ChangeStore>(

[22.760897]

[22.760995]

pub fn find_path<T: ChannelTxnT, C: ChangeStore>(
replacement in libpijul/src/fs.rs at line 829

[22.761102]→[22.32316:32356](∅→∅)

) -> Result<(String, bool), C::Error> {

[22.761102]

[22.761147]

) -> Result<(String, bool), crate::output::FileError<C::Error, T::GraphError>> {
replacement in libpijul/src/fs.rs at line 839

[22.761463]→[22.64108:64178](∅→∅)

let inode_vertex = find_block_end(txn, &channel, v).unwrap();

[22.761463]

[22.761532]

let inode_vertex = find_block_end(txn, &channel.graph, v).unwrap();
replacement in libpijul/src/fs.rs at line 841

[22.761584]→[22.64179:64261](∅→∅)

for name in iter_adjacent(txn, channel, v.inode_vertex(), flag0, flag1) {

[22.761584]

[22.761665]

for name in iter_adjacent(txn, &channel.graph, v.inode_vertex(), flag0, flag1)? {
let name = name?;
replacement in libpijul/src/fs.rs at line 848

[22.761841]→[22.761841:761914](∅→∅)

.get_changeset(&channel.changes, name.dest.change, None)

[22.761841]

[22.761914]

.get_changeset(&channel.changes, name.dest.change, None)?
replacement in libpijul/src/fs.rs at line 851

[22.761942]→[22.64262:64341](∅→∅)

let name_dest = find_block_end(txn, &channel, name.dest).unwrap();

[22.761942]

[22.762020]

let name_dest = find_block_end(txn, &channel.graph, name.dest).unwrap();
replacement in libpijul/src/fs.rs at line 853

[22.762071]→[22.64342:64427](∅→∅),[22.64427]→[22.641:723](∅→∅),[22.723]→[22.762280:762294](∅→∅),[22.762280]→[22.762280:762294](∅→∅)

if let Some(next) = iter_adjacent(txn, channel, name_dest, flag0, flag1)
.find(|e| e.flag.contains(EdgeFlags::PARENT | EdgeFlags::FOLDER))
{

[22.762071]

[22.762294]

let mut next = None;
for e in iter_adjacent(txn, &channel.graph, name_dest, flag0, flag1)? {
let e = e?;
if e.flag.contains(EdgeFlags::PARENT | EdgeFlags::FOLDER) {
next = Some(e);
break;
}
}
if let Some(next) = next {
replacement in libpijul/src/fs.rs at line 882

[22.762998]→[22.762998:763079](∅→∅)

changes.get_contents(|h| txn.get_external(h), name, &mut name_buf)?;

[22.762998]

[22.763079]

changes
.get_contents(|h| txn.get_external(h).unwrap(), name, &mut name_buf)
.map_err(crate::output::FileError::Changestore)?;
replacement in libpijul/src/find_alive.rs at line 4

[22.32358]→[22.763521:763561](∅→∅),[22.763521]→[22.763521:763561](∅→∅)

pub(crate) fn find_alive_down<T: TxnT>(

[22.32358]

[22.763561]

pub(crate) fn find_alive_down<T: GraphTxnT>(
replacement in libpijul/src/find_alive.rs at line 6

[22.763574]→[22.763574:763600](∅→∅)

channel: &Channel<T>,

[22.763574]

[22.763600]

channel: &T::Graph,
replacement in libpijul/src/find_alive.rs at line 8

[22.763631]→[22.32359:32412](∅→∅)

) -> Result<HashSet<Vertex<ChangeId>>, BlockError> {

[22.763631]

[22.763686]

) -> Result<HashSet<Vertex<ChangeId>>, BlockError<T::GraphError>> {
replacement in libpijul/src/find_alive.rs at line 23

[22.764231]→[21.15531:15586](∅→∅)

for v in iter_adj_all(txn, &channel, vertex) {

[22.764231]

[22.764387]

for v in iter_adj_all(txn, &channel, vertex)? {
let v = v?;
replacement in libpijul/src/find_alive.rs at line 48

[22.32414]→[22.765190:765228](∅→∅),[22.765190]→[22.765190:765228](∅→∅)

pub(crate) fn find_alive_up<T: TxnT>(

[22.32414]

[22.765228]

pub(crate) fn find_alive_up<T: GraphTxnT>(
replacement in libpijul/src/find_alive.rs at line 50

[22.765241]→[22.765241:765267](∅→∅)

channel: &Channel<T>,

[22.765241]

[21.15587]

channel: &T::Graph,
replacement in libpijul/src/find_alive.rs at line 54

[21.15653]→[21.15653:15706](∅→∅)

) -> Result<HashSet<Vertex<ChangeId>>, BlockError> {

[21.15653]

[22.765386]

) -> Result<HashSet<Vertex<ChangeId>>, BlockError<T::GraphError>> {
replacement in libpijul/src/find_alive.rs at line 73

[21.15740]→[21.15740:15798](∅→∅)

let mut it = iter_adj_all(txn, &channel, vertex);

[21.15740]

[21.15798]

let mut it = iter_adj_all(txn, &channel, vertex)?;
edit in libpijul/src/find_alive.rs at line 75

[21.15838]

[22.766233]

let v = v?;
replacement in libpijul/src/find_alive.rs at line 86

[21.16111]→[21.16111:16202](∅→∅)

is_file |= it.any(|e| !e.flag.intersects(EdgeFlags::parent_folder()));

[21.16111]

[21.16202]

for e in it {
let e = e?;
is_file |= !e.flag.intersects(EdgeFlags::parent_folder())
}
replacement in libpijul/src/diff/mod.rs at line 34

[22.33244]→[22.33244:33297](∅→∅)

pub enum DiffError<P: std::error::Error + 'static> {

[22.33244]

[22.33297]

pub enum DiffError<P: std::error::Error + 'static, T: std::error::Error + 'static> {
#[error(transparent)]
Output(#[from] crate::output::FileError<P, T>),
replacement in libpijul/src/diff/mod.rs at line 38

[22.33323]→[22.33323:33372](∅→∅)

Output(#[from] crate::output::FileError<P>),

[22.33323]

[22.33372]

Txn(T),
}

impl<T: std::error::Error + 'static, C: std::error::Error + 'static> std::convert::From<TxnErr<T>>
for DiffError<C, T>
{
fn from(e: TxnErr<T>) -> Self {
DiffError::Txn(e.0)
}
replacement in libpijul/src/diff/mod.rs at line 50

[22.794116]→[22.794116:794165](∅→∅)

pub(crate) fn diff<T: TxnT, P: ChangeStore>(

[22.794116]

[22.794165]

pub(crate) fn diff<T: ChannelTxnT, P: ChangeStore>(
replacement in libpijul/src/diff/mod.rs at line 60

[22.794388]→[22.33375:33418](∅→∅)

) -> Result<(), DiffError<P::Error>> {

[22.794388]

[22.794425]

) -> Result<(), DiffError<P::Error, T::GraphError>> {
replacement in libpijul/src/diff/mod.rs at line 67

[22.5921]→[22.5921:5994](∅→∅)

self.diff_binary(changes, txn, channel, path, inode, a, &b);

[22.5921]

[22.5994]

self.diff_binary(changes, txn, &channel.graph, path, inode, a, &b)?;
replacement in libpijul/src/diff/mod.rs at line 122

[22.796903]→[22.796903:796932](∅→∅)

channel,

[22.796903]

[22.796932]

&channel.graph,
replacement in libpijul/src/diff/mod.rs at line 129

[22.797108]→[22.293:312](∅→∅)

);

[22.797108]

[22.797127]

)?;
replacement in libpijul/src/diff/mod.rs at line 139

[22.797338]→[22.797338:797383](∅→∅)

fn diff_binary<T: TxnT, C: ChangeStore>(

[22.797338]

[22.797383]

fn diff_binary<T: GraphTxnT, C: ChangeStore>(
replacement in libpijul/src/diff/mod.rs at line 143

[22.797440]→[22.797440:797470](∅→∅)

channel: &Channel<T>,

[22.797440]

[22.797470]

channel: &T::Graph,
replacement in libpijul/src/diff/mod.rs at line 148

[22.797588]→[22.797588:797596](∅→∅)

) {

[22.797588]

[22.797596]

) -> Result<(), TxnErr<T::GraphError>> {
replacement in libpijul/src/diff/mod.rs at line 162

[22.798199]→[22.65554:65652](∅→∅)

for e in iter_adjacent(txn, channel, v.vertex, EdgeFlags::PARENT, EdgeFlags::all()) {

[22.798199]

[22.798296]

for e in iter_adjacent(txn, channel, v.vertex, EdgeFlags::PARENT, EdgeFlags::all())? {
let e = e?;
replacement in libpijul/src/diff/mod.rs at line 220

[22.800730]→[22.800730:800741](∅→∅)

})

[22.800730]

[22.800741]

});
Ok(())
replacement in libpijul/src/diff/delete.rs at line 11

[22.805718]→[22.805718:805753](∅→∅)

pub(super) fn delete<T: TxnT>(

[22.805718]

[22.805753]

pub(super) fn delete<T: GraphTxnT>(
replacement in libpijul/src/diff/delete.rs at line 14

[22.805789]→[22.805789:805819](∅→∅)

channel: &Channel<T>,

[22.805789]

[22.805819]

channel: &T::Graph,
replacement in libpijul/src/diff/delete.rs at line 21

[22.805988]→[22.400:408](∅→∅)

) {

[22.805988]

[22.806025]

) -> Result<(), TxnErr<T::GraphError>> {
replacement in libpijul/src/diff/delete.rs at line 23

[22.806059]→[22.806059:806121](∅→∅)

self.delete_lines(txn, channel, diff, d, lines_a, r);

[22.806059]

[22.806121]

self.delete_lines(txn, channel, diff, d, lines_a, r)?;
edit in libpijul/src/diff/delete.rs at line 37

[22.806419]

[22.806434]

Ok(())
replacement in libpijul/src/diff/delete.rs at line 47

[22.806715]→[22.806715:806745](∅→∅)

fn delete_lines<T: TxnT>(

[22.806715]

[22.806745]

fn delete_lines<T: GraphTxnT>(
replacement in libpijul/src/diff/delete.rs at line 50

[22.806781]→[22.806781:806811](∅→∅)

channel: &Channel<T>,

[22.806781]

[22.806811]

channel: &T::Graph,
replacement in libpijul/src/diff/delete.rs at line 55

[22.806904]→[22.806904:806984](∅→∅)

) {
let deletion = delete_lines(txn, channel, diff, d, lines_a, r);

[22.806904]

[22.806984]

) -> Result<(), TxnErr<T::GraphError>> {
let deletion = delete_lines(txn, channel, diff, d, lines_a, r)?;
edit in libpijul/src/diff/delete.rs at line 81

[22.808311]

[22.808311]

Ok(())
replacement in libpijul/src/diff/delete.rs at line 85

[22.3]→[22.808374:808400](∅→∅),[22.808374]→[22.808374:808400](∅→∅)

fn delete_lines<T: TxnT>(

[22.3]

[22.808400]

fn delete_lines<T: GraphTxnT>(
replacement in libpijul/src/diff/delete.rs at line 87

[22.808413]→[22.808413:808439](∅→∅)

channel: &Channel<T>,

[22.808413]

[22.808439]

channel: &T::Graph,
replacement in libpijul/src/diff/delete.rs at line 92

[22.808516]→[22.808516:808532](∅→∅)

) -> Deletion {

[22.808516]

[22.808532]

) -> Result<Deletion, TxnErr<T::GraphError>> {
replacement in libpijul/src/diff/delete.rs at line 116

[22.809674]→[22.1294:1308](∅→∅)

)

[22.809674]

[22.1308]

)?
replacement in libpijul/src/diff/delete.rs at line 148

[22.810144]→[22.810144:810154](∅→∅)

)

[22.810144]

[22.810154]

)?
replacement in libpijul/src/diff/delete.rs at line 150

[22.810160]→[22.810160:810173](∅→∅)

deletion

[22.810160]

[22.810173]

Ok(deletion)
replacement in libpijul/src/diff/delete.rs at line 153

[22.810231]→[22.810231:810259](∅→∅)

fn delete_parents<T: TxnT>(

[22.810176]

[22.810259]

fn delete_parents<T: GraphTxnT>(
replacement in libpijul/src/diff/delete.rs at line 155

[22.810272]→[22.810272:810298](∅→∅)

channel: &Channel<T>,

[22.810272]

[22.810298]

channel: &T::Graph,
replacement in libpijul/src/diff/delete.rs at line 159

[22.810391]→[22.810391:810395](∅→∅),[22.810395]→[22.65735:65763](∅→∅)

) {
for v in iter_adjacent(

[22.810391]

[22.65763]

) -> Result<(), TxnErr<T::GraphError>> {
for e in iter_adjacent(
replacement in libpijul/src/diff/delete.rs at line 166

[22.65866]→[22.65866:65963](∅→∅),[22.65963]→[22.810627:810684](∅→∅),[22.810627]→[22.810627:810684](∅→∅)

)
.filter(|e| e.flag.contains(EdgeFlags::PARENT) && !e.flag.contains(EdgeFlags::PSEUDO))
{
let previous = v.flag - EdgeFlags::PARENT;

[22.65866]

[22.1831]

)? {
let e = e?;
if !e.flag.contains(EdgeFlags::PARENT) || e.flag.contains(EdgeFlags::PSEUDO) {
continue;
}
let previous = e.flag - EdgeFlags::PARENT;
replacement in libpijul/src/diff/delete.rs at line 174

[22.1912]→[22.1912:1962](∅→∅)

&& !v.flag.contains(EdgeFlags::BLOCK)

[22.1912]

[22.1962]

&& !e.flag.contains(EdgeFlags::BLOCK)
replacement in libpijul/src/diff/delete.rs at line 182

[22.811053]→[22.811053:811088](∅→∅)

v.dest.to_option()

[22.811053]

[22.811088]

e.dest.to_option()
replacement in libpijul/src/diff/delete.rs at line 187

[22.811281]→[22.811281:811331](∅→∅)

introduced_by: Some(v.introduced_by),

[22.811281]

[22.47]

introduced_by: Some(e.introduced_by),
edit in libpijul/src/diff/delete.rs at line 190

[22.811869]

[22.811869]

Ok(())
replacement in libpijul/src/diff/delete.rs at line 265

[22.7]→[22.814473:814504](∅→∅),[22.814473]→[22.814473:814504](∅→∅)

fn resurrect_zombies<T: TxnT>(

[22.7]

[22.814504]

fn resurrect_zombies<T: GraphTxnT>(
replacement in libpijul/src/diff/delete.rs at line 267

[22.814517]→[22.814517:814543](∅→∅)

channel: &Channel<T>,

[22.814517]

[22.814543]

channel: &T::Graph,
replacement in libpijul/src/diff/delete.rs at line 276

[22.814723]→[22.814723:814727](∅→∅)

) {

[22.814723]

[22.1973]

) -> Result<(), TxnErr<T::GraphError>> {
replacement in libpijul/src/diff/delete.rs at line 312

[22.815923]→[22.815923:815938](∅→∅)

);

[22.815923]

[22.815938]

)?;
edit in libpijul/src/diff/delete.rs at line 321

[22.816200]

[22.816200]

Ok(())
replacement in libpijul/src/diff/delete.rs at line 324

[22.9]→[22.816267:816297](∅→∅),[22.816267]→[22.816267:816297](∅→∅)

fn resurrect_zombie<T: TxnT>(

[22.9]

[22.816297]

fn resurrect_zombie<T: GraphTxnT>(
replacement in libpijul/src/diff/delete.rs at line 326

[22.816310]→[22.816310:816336](∅→∅)

channel: &Channel<T>,

[22.816310]

[22.816336]

channel: &T::Graph,
replacement in libpijul/src/diff/delete.rs at line 330

[22.816420]→[22.816420:816424](∅→∅)

) {

[22.816420]

[22.2085]

) -> Result<(), TxnErr<T::GraphError>> {
replacement in libpijul/src/diff/delete.rs at line 338

[22.816579]→[22.816579:816587](∅→∅)

) {

[22.816579]

[22.816587]

)? {
let e = e?;
edit in libpijul/src/diff/delete.rs at line 357

[22.817189]

[22.817189]

Ok(())
replacement in libpijul/src/change.rs at line 195

[22.835829]→[22.835829:835927](∅→∅)

pub fn dependencies<'a, Local: 'a, I: Iterator<Item = &'a Record<Option<Hash>, Local>>, T: TxnT>(

[22.835774]

[22.835927]

pub fn dependencies<
'a,
Local: 'a,
I: Iterator<Item = &'a Record<Option<Hash>, Local>>,
T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>,
>(
replacement in libpijul/src/change.rs at line 202

[22.835940]→[22.835940:835969](∅→∅)

channel: &ChannelRef<T>,

[22.835940]

[22.835969]

channel: &Channel<T>,
replacement in libpijul/src/change.rs at line 204

[22.835985]→[22.316:346](∅→∅)

) -> (Vec<Hash>, Vec<Hash>) {

[22.835985]

[22.836025]

) -> Result<(Vec<Hash>, Vec<Hash>), TxnErr<T::DepsError>> {
edit in libpijul/src/change.rs at line 207

[22.836104]→[22.836104:836142](∅→∅)

let channel = channel.r.borrow();
replacement in libpijul/src/change.rs at line 236

[22.837398]→[22.837398:837559](∅→∅)

add_zombie_deps_from(txn, &channel, &mut zombie_deps, e.from);
add_zombie_deps_to(txn, &channel, &mut zombie_deps, e.to)

[22.837398]

[22.837559]

add_zombie_deps_from(txn, &channel.graph, &mut zombie_deps, e.from)?;
add_zombie_deps_to(txn, &channel.graph, &mut zombie_deps, e.to)?
replacement in libpijul/src/change.rs at line 242

[22.837662]→[22.837662:837714](∅→∅)

let deps = minimize_deps(txn, &channel, &deps);

[22.837662]

[22.837714]

let deps = minimize_deps(txn, &channel, &deps)?;
replacement in libpijul/src/change.rs at line 248

[22.446]→[22.446:540](∅→∅)

let a = txn.get_internal(*a).unwrap();
let b = txn.get_internal(*b).unwrap();

[22.446]

[22.66061]

let a = txn.get_internal(*a).unwrap().unwrap();
let b = txn.get_internal(*b).unwrap().unwrap();
replacement in libpijul/src/change.rs at line 251

[22.66114]→[22.66114:66178](∅→∅)

.cmp(&txn.get_changeset(&channel.changes, b, None))

[22.66114]

[22.644]

.unwrap()
.cmp(&txn.get_changeset(&channel.changes, b, None).unwrap())
replacement in libpijul/src/change.rs at line 256

[22.757]→[22.757:851](∅→∅)

let a = txn.get_internal(*a).unwrap();
let b = txn.get_internal(*b).unwrap();

[22.757]

[22.66179]

let a = txn.get_internal(*a).unwrap().unwrap();
let b = txn.get_internal(*b).unwrap().unwrap();
replacement in libpijul/src/change.rs at line 259

[22.66232]→[22.66232:66296](∅→∅)

.cmp(&txn.get_changeset(&channel.changes, b, None))

[22.66232]

[22.955]

.unwrap()
.cmp(&txn.get_changeset(&channel.changes, b, None).unwrap())
replacement in libpijul/src/change.rs at line 262

[22.963]→[22.837778:837802](∅→∅),[22.837778]→[22.837778:837802](∅→∅)

(deps, zombie_deps)

[22.963]

[22.837802]

Ok((deps, zombie_deps))
replacement in libpijul/src/change.rs at line 265

[22.837805]→[22.66297:66393](∅→∅)

pub fn full_dependencies<T: TxnT>(txn: &T, channel: &ChannelRef<T>) -> (Vec<Hash>, Vec<Hash>) {

[22.837805]

[22.837922]

pub fn full_dependencies<T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>>(
txn: &T,
channel: &ChannelRef<T>,
) -> Result<(Vec<Hash>, Vec<Hash>), TxnErr<T::DepsError>> {
replacement in libpijul/src/change.rs at line 271

[22.837994]→[22.66394:66451](∅→∅),[22.66451]→[22.838050:838097](∅→∅),[22.838050]→[22.838050:838097](∅→∅)

for (_, (ch, _)) in changeid_log(txn, &channel, 0) {
let h = txn.get_external(ch).unwrap();

[22.837994]

[22.838097]

for x in changeid_log(txn, &channel, 0)? {
let (_, (ch, _)) = x?;
let h = txn.get_external(ch)?.unwrap();
replacement in libpijul/src/change.rs at line 276

[22.838127]→[22.838127:838179](∅→∅),[22.838179]→[22.995:1018](∅→∅)

let deps = minimize_deps(txn, &channel, &deps);
(deps, Vec::new())

[22.838127]

[22.838207]

let deps = minimize_deps(txn, &channel, &deps)?;
Ok((deps, Vec::new()))
replacement in libpijul/src/change.rs at line 280

[22.838265]→[22.838265:838299](∅→∅)

fn add_zombie_deps_from<T: TxnT>(

[22.838210]

[22.838299]

fn add_zombie_deps_from<T: GraphTxnT>(
replacement in libpijul/src/change.rs at line 282

[22.838312]→[22.838312:838338](∅→∅)

channel: &Channel<T>,

[22.838312]

[22.838338]

channel: &T::Graph,
replacement in libpijul/src/change.rs at line 285

[22.838412]→[22.838412:838416](∅→∅)

) {

[22.838412]

[22.838416]

) -> Result<(), TxnErr<T::GraphError>> {
replacement in libpijul/src/change.rs at line 288

[22.838485]→[22.838485:838535](∅→∅)

change: txn.get_internal(p).unwrap(),

[22.838485]

[22.838535]

change: txn.get_internal(p)?.unwrap(),
replacement in libpijul/src/change.rs at line 292

[22.838587]→[22.838587:838603](∅→∅)

return;

[22.838587]

[22.838603]

return Ok(());
replacement in libpijul/src/change.rs at line 295

[22.66514]→[21.17040:17091](∅→∅),[22.66604]→[22.838760:838826](∅→∅),[21.17091]→[22.838760:838826](∅→∅),[22.838760]→[22.838760:838826](∅→∅)

for edge in iter_adj_all(txn, channel, from) {
if let Some(ext) = txn.get_external(edge.introduced_by) {

[22.66514]

[22.838826]

for edge in iter_adj_all(txn, channel, from)? {
let edge = edge?;
if let Some(ext) = txn.get_external(edge.introduced_by)? {
replacement in libpijul/src/change.rs at line 303

[22.838961]→[22.838961:839025](∅→∅)

if let Some(ext) = txn.get_external(edge.dest.change) {

[22.838961]

[22.839025]

if let Some(ext) = txn.get_external(edge.dest.change)? {
edit in libpijul/src/change.rs at line 310

[22.839166]

[22.839166]

Ok(())
replacement in libpijul/src/change.rs at line 313

[22.839169]→[22.839169:839201](∅→∅)

fn add_zombie_deps_to<T: TxnT>(

[22.839169]

[22.839201]

fn add_zombie_deps_to<T: GraphTxnT>(
replacement in libpijul/src/change.rs at line 315

[22.839214]→[22.839214:839240](∅→∅)

channel: &Channel<T>,

[22.839214]

[22.839240]

channel: &T::Graph,
replacement in libpijul/src/change.rs at line 318

[22.839310]→[22.839310:839314](∅→∅)

) {

[22.839310]

[22.839314]

) -> Result<(), TxnErr<T::GraphError>> {
replacement in libpijul/src/change.rs at line 321

[22.839381]→[22.839381:839431](∅→∅)

change: txn.get_internal(p).unwrap(),

[22.839381]

[22.839431]

change: txn.get_internal(p)?.unwrap(),
replacement in libpijul/src/change.rs at line 325

[22.839483]→[22.839483:839499](∅→∅)

return;

[22.839483]

[22.839499]

return Ok(());
replacement in libpijul/src/change.rs at line 329

[22.839576]→[21.17092:17145](∅→∅),[22.66758]→[22.839667:839737](∅→∅),[21.17145]→[22.839667:839737](∅→∅),[22.839667]→[22.839667:839737](∅→∅)

for edge in iter_adj_all(txn, channel, to) {
if let Some(ext) = txn.get_external(edge.introduced_by) {

[22.839576]

[22.839737]

for edge in iter_adj_all(txn, channel, to)? {
let edge = edge?;
if let Some(ext) = txn.get_external(edge.introduced_by)? {
replacement in libpijul/src/change.rs at line 337

[22.839892]→[22.839892:839960](∅→∅)

if let Some(ext) = txn.get_external(edge.dest.change) {

[22.839892]

[22.839960]

if let Some(ext) = txn.get_external(edge.dest.change)? {
edit in libpijul/src/change.rs at line 349

[22.840253]

[22.840253]

Ok(())
replacement in libpijul/src/change.rs at line 351

[22.840310]→[22.1019:1114](∅→∅)

fn minimize_deps<T: TxnT>(txn: &T, channel: &Channel<T>, deps: &BTreeSet<Hash>) -> Vec<Hash> {

[22.840255]

[22.840410]

fn minimize_deps<T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>>(
txn: &T,
channel: &Channel<T>,
deps: &BTreeSet<Hash>,
) -> Result<Vec<Hash>, TxnErr<T::DepsError>> {
replacement in libpijul/src/change.rs at line 365

[22.840655]→[22.840655:840703](∅→∅)

let id = txn.get_internal(*h).unwrap();

[22.840655]

[22.840703]

let id = txn.get_internal(*h)?.unwrap();
replacement in libpijul/src/change.rs at line 367

[22.840736]→[22.840736:840811](∅→∅)

let time = txn.get_changeset(&channel.changes, id, None).unwrap();

[22.840736]

[22.840811]

let time = txn.get_changeset(&channel.changes, id, None)?.unwrap();
replacement in libpijul/src/change.rs at line 386

[22.841420]→[22.841420:841542](∅→∅)

let mut cursor = txn.iter_dep(id);
while let Some((id0, dep)) = txn.cursor_dep_next(&mut cursor.cursor) {

[22.841420]

[22.841542]

let mut cursor = txn.iter_dep(id)?;
while let Some(x) = txn.cursor_dep_next(&mut cursor.cursor)? {
let (id0, dep) = x;
replacement in libpijul/src/change.rs at line 395

[22.841723]→[22.841723:841815](∅→∅)

let time = if let Some(time) = txn.get_changeset(&channel.changes, dep, None) {

[22.841723]

[22.841815]

let time = if let Some(time) = txn.get_changeset(&channel.changes, dep, None)? {
replacement in libpijul/src/change.rs at line 411

[22.842229]→[22.842229:842248](∅→∅)

internal_deps_

[22.842229]

[22.842248]

Ok(internal_deps_
replacement in libpijul/src/change.rs at line 413

[22.842269]→[22.842269:842337](∅→∅)

.map(|id| txn.get_external(id).unwrap())
.collect()

[22.842269]

[22.842337]

.map(|id| txn.get_external(id).unwrap().unwrap())
.collect())
replacement in libpijul/src/change.rs at line 949

[22.860210]→[22.860210:860276](∅→∅)

fn globalize<T: TxnT>(&self, txn: &T) -> Atom<Option<Hash>> {

[22.860210]

[22.860276]

fn globalize<T: GraphTxnT>(&self, txn: &T) -> Result<Atom<Option<Hash>>, T::GraphError> {
replacement in libpijul/src/change.rs at line 958

[22.860484]→[22.860484:860530](∅→∅)

}) => Atom::NewVertex(NewVertex {

[22.860484]

[22.860530]

}) => Ok(Atom::NewVertex(NewVertex {
replacement in libpijul/src/change.rs at line 962

[22.860639]→[22.860639:860716](∅→∅)

change: up.change.and_then(|a| txn.get_external(a)),

[22.860639]

[22.860716]

change: up.change.and_then(|a| txn.get_external(a).unwrap()),
replacement in libpijul/src/change.rs at line 969

[22.860923]→[22.860923:861002](∅→∅)

change: down.change.and_then(|a| txn.get_external(a)),

[22.860923]

[22.861002]

change: down.change.and_then(|a| txn.get_external(a).unwrap()),
replacement in libpijul/src/change.rs at line 977

[22.861217]→[22.861217:861293](∅→∅)

change: inode.change.and_then(|a| txn.get_external(a)),

[22.861217]

[22.861293]

change: inode.change.and_then(|a| txn.get_external(a).unwrap()),
replacement in libpijul/src/change.rs at line 980

[22.861348]→[22.861348:861443](∅→∅)

}),
Atom::EdgeMap(EdgeMap { edges, inode }) => Atom::EdgeMap(EdgeMap {

[22.861348]

[22.861443]

})),
Atom::EdgeMap(EdgeMap { edges, inode }) => Ok(Atom::EdgeMap(EdgeMap {
replacement in libpijul/src/change.rs at line 988

[22.861673]→[22.861673:861761](∅→∅)

change: edge.from.change.and_then(|a| txn.get_external(a)),

[22.861673]

[22.861761]

change: edge.from.change.and_then(|a| txn.get_external(a).unwrap()),
replacement in libpijul/src/change.rs at line 992

[22.861873]→[22.861873:861959](∅→∅)

change: edge.to.change.and_then(|a| txn.get_external(a)),

[22.861873]

[22.861959]

change: edge.to.change.and_then(|a| txn.get_external(a).unwrap()),
replacement in libpijul/src/change.rs at line 997

[22.862150]→[22.862150:862217](∅→∅)

if let Some(a) = txn.get_external(a) {

[22.862150]

[22.862217]

if let Some(a) = txn.get_external(a).unwrap() {
replacement in libpijul/src/change.rs at line 1006

[22.862500]→[22.862500:862576](∅→∅)

change: inode.change.and_then(|a| txn.get_external(a)),

[22.862500]

[22.862576]

change: inode.change.and_then(|a| txn.get_external(a).unwrap()),
replacement in libpijul/src/change.rs at line 1009

[22.862631]→[22.862631:862647](∅→∅)

}),

[22.862631]

[22.862647]

})),
replacement in libpijul/src/change.rs at line 1049

[22.864041]→[22.864041:864140](∅→∅)

pub fn globalize<T: TxnT>(self, txn: &T) -> Record<Option<Hash>, Local> {
match self {

[22.864041]

[22.864140]

pub fn globalize<T: GraphTxnT>(
self,
txn: &T,
) -> Result<Record<Option<Hash>, Local>, T::GraphError> {
Ok(match self {
replacement in libpijul/src/change.rs at line 1055

[22.864210]→[22.864210:864292](∅→∅)

del: del.globalize(txn),
add: add.globalize(txn),

[22.864210]

[22.864292]

del: del.globalize(txn)?,
add: add.globalize(txn)?,
replacement in libpijul/src/change.rs at line 1064

[22.864463]→[22.864463:864579](∅→∅)

del: del.globalize(txn),
contents: contents.as_ref().map(|del| del.globalize(txn)),

[22.864463]

[22.864579]

del: del.globalize(txn)?,
contents: contents.as_ref().map(|del| del.globalize(txn).unwrap()),
replacement in libpijul/src/change.rs at line 1073

[22.864756]→[22.864756:864876](∅→∅)

undel: undel.globalize(txn),
contents: contents.as_ref().map(|del| del.globalize(txn)),

[22.864756]

[22.864876]

undel: undel.globalize(txn)?,
contents: contents.as_ref().map(|del| del.globalize(txn).unwrap()),
replacement in libpijul/src/change.rs at line 1078

[22.864997]→[22.864997:865040](∅→∅)

name: name.globalize(txn),

[22.864997]

[22.865040]

name: name.globalize(txn)?,
replacement in libpijul/src/change.rs at line 1082

[22.865165]→[22.865165:865208](∅→∅)

name: name.globalize(txn),

[22.865165]

[22.865208]

name: name.globalize(txn)?,
replacement in libpijul/src/change.rs at line 1091

[22.865411]→[22.865411:865590](∅→∅)

add_name: add_name.globalize(txn),
add_inode: add_inode.globalize(txn),
contents: contents.as_ref().map(|add| add.globalize(txn)),

[22.865411]

[22.865590]

add_name: add_name.globalize(txn)?,
add_inode: add_inode.globalize(txn)?,
contents: contents.as_ref().map(|add| add.globalize(txn).unwrap()),
replacement in libpijul/src/change.rs at line 1097

[22.865688]→[22.865688:865735](∅→∅)

change: change.globalize(txn),

[22.865688]

[22.865735]

change: change.globalize(txn)?,
replacement in libpijul/src/change.rs at line 1105

[22.865922]→[22.865922:866026](∅→∅)

change: change.globalize(txn),
replacement: replacement.globalize(txn),

[22.865922]

[22.866026]

change: change.globalize(txn)?,
replacement: replacement.globalize(txn)?,
replacement in libpijul/src/change.rs at line 1110

[22.866153]→[22.866153:866200](∅→∅)

change: change.globalize(txn),

[22.866153]

[22.866200]

change: change.globalize(txn)?,
replacement in libpijul/src/change.rs at line 1114

[22.866331]→[22.866331:866378](∅→∅)

change: change.globalize(txn),

[22.866331]

[22.866378]

change: change.globalize(txn)?,
replacement in libpijul/src/change.rs at line 1118

[22.866501]→[22.866501:866548](∅→∅)

change: change.globalize(txn),

[22.866501]

[22.866548]

change: change.globalize(txn)?,
replacement in libpijul/src/change.rs at line 1121

[22.866586]→[22.866586:866596](∅→∅)

}

[22.866586]

[22.866596]

})
replacement in libpijul/src/change.rs at line 1142

[22.867173]→[22.867173:867206](∅→∅)

pub fn make_change<T: TxnT>(

[22.867173]

[22.867206]

pub fn make_change<T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>>(
replacement in libpijul/src/change.rs at line 1149

[22.867387]→[22.867387:867489](∅→∅)

) -> Self {
let (dependencies, extra_known) = dependencies(txn, channel, changes.iter());

[22.867387]

[22.867489]

) -> Result<Self, TxnErr<T::DepsError>> {
let (dependencies, extra_known) = dependencies(txn, &channel.borrow(), changes.iter())?;
replacement in libpijul/src/change.rs at line 1158

[22.867770]→[22.867770:867792](∅→∅)

LocalChange {

[22.867770]

[22.867792]

Ok(LocalChange {
replacement in libpijul/src/change.rs at line 1171

[22.868126]→[22.868126:868136](∅→∅)

}

[22.868126]

[22.868136]

})
replacement in libpijul/src/change/text_changes.rs at line 155

[22.42903]→[22.42903:42950](∅→∅)

pub fn read_and_deps<R: BufRead, T: TxnT>(

[22.42903]

[22.42950]

pub fn read_and_deps<
R: BufRead,
T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>,
>(
replacement in libpijul/src/change/text_changes.rs at line 165

[22.43188]→[22.43188:43278](∅→∅)

let (mut deps, extra) = dependencies(txn, channel, change.hashed.changes.iter());

[22.43188]

[22.43278]

let (mut deps, extra) =
dependencies(txn, &channel.borrow(), change.hashed.changes.iter()).unwrap();
replacement in libpijul/src/apply.rs at line 22

[22.93764]→[22.93764:93820](∅→∅)

pub enum LocalApplyError<TxnError: std::error::Error> {

[22.93764]

[22.93820]

pub enum LocalApplyError<TxnError: std::error::Error + 'static> {
replacement in libpijul/src/apply.rs at line 29

[22.94094]→[22.94094:94263](∅→∅)

#[error(transparent)]
Block(#[from] crate::pristine::BlockError),
#[error(transparent)]
InconsistentChange(#[from] crate::pristine::InconsistentChange),

[22.94094]

[22.94263]

#[error("Block error: {:?}", block)]
Block { block: Position<ChangeId> },
#[error("Invalid change")]
InvalidChange,
edit in libpijul/src/apply.rs at line 35

[22.94266]→[21.17267:17434](∅→∅)

impl<E: std::error::Error> LocalApplyError<E> {
const INCONSISTENT: Self =
LocalApplyError::InconsistentChange(crate::pristine::InconsistentChange {});
}
replacement in libpijul/src/apply.rs at line 39

[22.94468]→[22.94468:94618](∅→∅)

MissingError::Block(e) => LocalApplyError::Block(e),
MissingError::Inconsistent(e) => LocalApplyError::InconsistentChange(e),

[22.94468]

[22.94618]

MissingError::Block(e) => e.into(),
MissingError::Inconsistent(_) => LocalApplyError::InvalidChange,
}
}
}

impl<T: std::error::Error> From<crate::pristine::InconsistentChange<T>> for LocalApplyError<T> {
fn from(err: crate::pristine::InconsistentChange<T>) -> Self {
match err {
InconsistentChange::Txn(e) => LocalApplyError::Txn(e),
_ => LocalApplyError::InvalidChange,
}
}
}

impl<T: std::error::Error> From<crate::pristine::TxnErr<T>> for LocalApplyError<T> {
fn from(err: crate::pristine::TxnErr<T>) -> Self {
LocalApplyError::Txn(err.0)
}
}

impl<C: std::error::Error, T: std::error::Error> From<crate::pristine::TxnErr<T>>
for ApplyError<C, T>
{
fn from(err: crate::pristine::TxnErr<T>) -> Self {
LocalApplyError::Txn(err.0).into()
}
}

impl<T: std::error::Error> From<crate::pristine::BlockError<T>> for LocalApplyError<T> {
fn from(err: crate::pristine::BlockError<T>) -> Self {
match err {
BlockError::Txn(e) => LocalApplyError::Txn(e),
BlockError::Block { block } => LocalApplyError::Block { block },
replacement in libpijul/src/apply.rs at line 87

[22.944880]→[22.94638:94699](∅→∅)

) -> Result<(u64, Merkle), ApplyError<P::Error, T::Error>> {

[22.944880]

[22.944924]

) -> Result<(u64, Merkle), ApplyError<P::Error, T::GraphError>> {
replacement in libpijul/src/apply.rs at line 97

[22.945203]→[22.945203:945329](∅→∅)

if let Some(int) = txn.get_internal(hash) {
if txn.get_changeset(&channel.changes, int, None).is_some() {

[22.945203]

[22.945329]

if let Some(int) = txn.get_internal(hash)? {
if txn.get_changeset(&channel.changes, int, None)?.is_some() {
replacement in libpijul/src/apply.rs at line 105

[22.945450]→[22.945450:945511](∅→∅)

let internal = if let Some(p) = txn.get_internal(hash) {

[22.945450]

[22.945511]

let internal = if let Some(p) = txn.get_internal(hash)? {
replacement in libpijul/src/apply.rs at line 108

[22.945534]→[22.67015:67075](∅→∅),[22.67075]→[22.94854:94940](∅→∅)

let internal: ChangeId = make_changeid(txn, &hash);
register_change(txn, internal, hash, &change).map_err(LocalApplyError::Txn)?;

[22.945534]

[22.945648]

let internal: ChangeId = make_changeid(txn, &hash)?;
register_change(txn, internal, hash, &change)?;
replacement in libpijul/src/apply.rs at line 130

[22.946111]→[22.95086:95136](∅→∅)

) -> Result<(), ApplyError<P::Error, T::Error>> {

[22.946111]

[22.946144]

) -> Result<(), ApplyError<P::Error, T::GraphError>> {
replacement in libpijul/src/apply.rs at line 143

[3.182]→[3.182:244](∅→∅)

if let Some(change_id) = txn.get_internal(hash) {

[3.182]

[3.244]

if let Some(change_id) = txn.get_internal(hash)? {
replacement in libpijul/src/apply.rs at line 145

[3.267]→[3.267:337](∅→∅)

.get_changeset(&channel.changes, change_id, None)

[3.267]

[3.337]

.get_changeset(&channel.changes, change_id, None)?
replacement in libpijul/src/apply.rs at line 160

[22.946763]→[22.946763:946906](∅→∅)

let applied = if let Some(int) = txn.get_internal(hash) {
txn.get_changeset(&channel.changes, int, None).is_some()

[22.946763]

[22.946906]

let applied = if let Some(int) = txn.get_internal(hash)? {
txn.get_changeset(&channel.changes, int, None)?.is_some()
replacement in libpijul/src/apply.rs at line 166

[22.946990]→[22.946990:947063](∅→∅)

let internal = if let Some(p) = txn.get_internal(hash) {

[22.946990]

[22.947063]

let internal = if let Some(p) = txn.get_internal(hash)? {
replacement in libpijul/src/apply.rs at line 169

[22.947110]→[22.67132:67204](∅→∅),[22.67204]→[22.95220:95318](∅→∅)

let internal: ChangeId = make_changeid(txn, &hash);
register_change(txn, internal, hash, &change).map_err(LocalApplyError::Txn)?;

[22.947110]

[22.947248]

let internal: ChangeId = make_changeid(txn, &hash)?;
register_change(txn, internal, hash, &change)?;
replacement in libpijul/src/apply.rs at line 188

[22.947938]→[22.95319:95380](∅→∅)

) -> Result<(u64, Merkle), ApplyError<P::Error, T::Error>> {

[22.947938]

[22.947982]

) -> Result<(u64, Merkle), ApplyError<P::Error, T::GraphError>> {
replacement in libpijul/src/apply.rs at line 199

[22.948278]→[22.95381:95431](∅→∅)

) -> Result<(), ApplyError<P::Error, T::Error>> {

[22.948278]

[22.948311]

) -> Result<(), ApplyError<P::Error, T::GraphError>> {
replacement in libpijul/src/apply.rs at line 210

[22.948511]→[22.184:224](∅→∅)

fn apply_change_to_channel<T: MutTxnT>(

[22.948456]

[22.948727]

fn apply_change_to_channel<T: ChannelMutTxnT>(
replacement in libpijul/src/apply.rs at line 217

[22.948861]→[22.95432:95488](∅→∅)

) -> Result<(u64, Merkle), LocalApplyError<T::Error>> {

[22.948861]

[22.948905]

) -> Result<(u64, Merkle), LocalApplyError<T::GraphError>> {
replacement in libpijul/src/apply.rs at line 220

[22.948963]→[22.95489:95750](∅→∅)

let merkle = if let Some(m) = txn
.put_changes(channel, change_id, channel.apply_counter, hash)
.map_err(LocalApplyError::Txn)?
{
m
} else {
return Err(LocalApplyError::ChangeAlreadyOnChannel { hash: *hash });
};

[22.948963]

[22.949195]

let merkle =
if let Some(m) = txn.put_changes(channel, change_id, channel.apply_counter, hash)? {
m
} else {
return Err(LocalApplyError::ChangeAlreadyOnChannel { hash: *hash });
};
replacement in libpijul/src/apply.rs at line 232

[22.949433]→[22.949433:949531](∅→∅)

Atom::NewVertex(ref n) => put_newvertex(txn, channel, change, ws, change_id, n)?,

[22.949433]

[22.949531]

Atom::NewVertex(ref n) => {
put_newvertex(txn, &mut channel.graph, change, ws, change_id, n)?
}
replacement in libpijul/src/apply.rs at line 240

[22.949815]→[22.949815:949856](∅→∅)

channel,

[22.949815]

[22.949856]

&mut channel.graph,
replacement in libpijul/src/apply.rs at line 245

[22.950014]→[22.95751:95841](∅→∅)

|_, _, _, _| Ok::<bool, LocalApplyError<T::Error>>(true),

[22.950014]

[21.17435]

|_, _, _, _| Ok::<bool, LocalApplyError<T::GraphError>>(true),
replacement in libpijul/src/apply.rs at line 259

[22.886]→[22.886:981](∅→∅),[22.981]→[22.95842:95914](∅→∅),[22.95914]→[22.1018:1047](∅→∅),[22.1018]→[22.1018:1047](∅→∅)

put_newedge(txn, channel, ws, change_id, n.inode, edge, |_, _, _, _| {
Ok::<bool, LocalApplyError<T::Error>>(true)
})?;

[22.886]

[22.1126]

put_newedge(
txn,
&mut channel.graph,
ws,
change_id,
n.inode,
edge,
|_, _, _, _| Ok::<bool, LocalApplyError<T::GraphError>>(true),
)?;
replacement in libpijul/src/apply.rs at line 270

[22.1231]→[22.1231:1268](∅→∅)

channel,

[22.1231]

[22.1268]

&mut channel.graph,
replacement in libpijul/src/apply.rs at line 285

[22.951686]→[21.17468:17531](∅→∅)

clean_obsolete_pseudo_edges(txn, channel, ws, change_id)?;

[22.951686]

[22.951738]

clean_obsolete_pseudo_edges(txn, &mut channel.graph, ws, change_id)?;
replacement in libpijul/src/apply.rs at line 288

[22.951780]→[22.951780:951847](∅→∅),[22.951847]→[21.17532:17576](∅→∅)

repair_missing_contexts(txn, channel, ws, change_id, change)?;
repair_cyclic_paths(txn, channel, ws)?;

[22.951780]

[22.951910]

repair_missing_contexts(txn, &mut channel.graph, ws, change_id, change)?;
repair_cyclic_paths(txn, &mut channel.graph, ws)?;
replacement in libpijul/src/apply.rs at line 300

[22.952448]→[22.952448:952490](∅→∅)

pub fn apply_local_change_ws<T: MutTxnT>(

[22.952448]

[22.952490]

pub fn apply_local_change_ws<
T: ChannelMutTxnT
+ DepsMutTxnT<DepsError = <T as GraphTxnT>::GraphError>
+ TreeMutTxnT<TreeError = <T as GraphTxnT>::GraphError>,
>(
replacement in libpijul/src/apply.rs at line 311

[22.952657]→[22.96185:96241](∅→∅)

) -> Result<(u64, Merkle), LocalApplyError<T::Error>> {

[22.952657]

[22.952760]

) -> Result<(u64, Merkle), LocalApplyError<T::GraphError>> {
replacement in libpijul/src/apply.rs at line 313

[22.952806]→[22.67273:67329](∅→∅)

let internal: ChangeId = make_changeid(txn, &hash);

[22.952806]

[22.0]

let internal: ChangeId = make_changeid(txn, &hash)?;
replacement in libpijul/src/apply.rs at line 319

[22.114]→[22.114:240](∅→∅)

if let Some(int) = txn.get_internal(hash) {
if txn.get_changeset(&channel.changes, int, None).is_some() {

[22.114]

[22.240]

if let Some(int) = txn.get_internal(hash)? {
if txn.get_changeset(&channel.changes, int, None)?.is_some() {
replacement in libpijul/src/apply.rs at line 327

[22.361]→[22.96317:96399](∅→∅)

register_change(txn, internal, hash, &change).map_err(LocalApplyError::Txn)?;

[22.361]

[22.227]

register_change(txn, internal, hash, &change)?;
replacement in libpijul/src/apply.rs at line 331

[22.953296]→[22.953296:953352](∅→∅)

update_inode(txn, &channel, internal, update)?;

[22.953296]

[22.953352]

update_inode(txn, &channel.graph, internal, update)?;
replacement in libpijul/src/apply.rs at line 337

[22.953441]→[22.953441:953480](∅→∅)

pub fn apply_local_change<T: MutTxnT>(

[22.953441]

[22.953480]

pub fn apply_local_change<
T: ChannelMutTxnT
+ DepsMutTxnT<DepsError = <T as GraphTxnT>::GraphError>
+ TreeMutTxnT<TreeError = <T as GraphTxnT>::GraphError>,
>(
replacement in libpijul/src/apply.rs at line 347

[22.953616]→[22.96400:96456](∅→∅)

) -> Result<(u64, Merkle), LocalApplyError<T::Error>> {

[22.953616]

[22.953660]

) -> Result<(u64, Merkle), LocalApplyError<T::GraphError>> {
replacement in libpijul/src/apply.rs at line 358

[22.3408]→[22.953864:953893](∅→∅),[22.953864]→[22.953864:953893](∅→∅)

fn update_inode<T: MutTxnT>(

[22.3408]

[22.953893]

fn update_inode<T: GraphTxnT + TreeMutTxnT<TreeError = <T as GraphTxnT>::GraphError>>(
replacement in libpijul/src/apply.rs at line 360

[22.953910]→[22.953910:953936](∅→∅)

channel: &Channel<T>,

[22.953910]

[22.953936]

channel: &T::Graph,
replacement in libpijul/src/apply.rs at line 363

[22.953986]→[22.96457:96502](∅→∅)

) -> Result<(), LocalApplyError<T::Error>> {

[22.953986]

[22.954019]

) -> Result<(), LocalApplyError<T::TreeError>> {
replacement in libpijul/src/apply.rs at line 372

[22.954317]→[22.954317:954389](∅→∅)

.get_graph(&channel.graph, vertex.inode_vertex(), None)

[22.954317]

[22.954389]

.get_graph(&channel, vertex.inode_vertex(), None)?
replacement in libpijul/src/apply.rs at line 376

[22.954497]→[22.96503:96591](∅→∅)

put_inodes_with_rev(txn, inode, vertex).map_err(LocalApplyError::Txn)?;

[22.954497]

[22.954554]

put_inodes_with_rev(txn, inode, vertex)?;
replacement in libpijul/src/apply.rs at line 382

[22.954777]→[22.954777:954864](∅→∅),[22.954864]→[22.96592:96691](∅→∅)

if let Some(parent) = txn.get_revtree(inode, None).map(|x| x.to_owned()) {
del_tree_with_rev(txn, parent.as_file_id(), inode).map_err(LocalApplyError::Txn)?;

[22.954777]

[22.954997]

if let Some(parent) = txn.get_revtree(inode, None)?.map(|x| x.to_owned()) {
del_tree_with_rev(txn, parent.as_file_id(), inode)?;
replacement in libpijul/src/apply.rs at line 393

[22.955259]→[22.96692:96751](∅→∅),[22.96751]→[22.955275:955339](∅→∅),[22.955275]→[22.955275:955339](∅→∅),[22.955339]→[22.96752:96840](∅→∅)

)
.map_err(LocalApplyError::Txn)?;
if let Some(vertex) = txn.get_inodes(inode, None) {
del_inodes_with_rev(txn, inode, vertex).map_err(LocalApplyError::Txn)?;

[22.955259]

[22.955450]

)?;
if let Some(vertex) = txn.get_inodes(inode, None)? {
del_inodes_with_rev(txn, inode, vertex)?;
replacement in libpijul/src/apply.rs at line 402

[22.3592]→[22.955548:955578](∅→∅),[22.955548]→[22.955548:955578](∅→∅)

fn put_newvertex<T: MutTxnT>(

[22.3592]

[22.955578]

fn put_newvertex<T: GraphMutTxnT>(
replacement in libpijul/src/apply.rs at line 404

[22.955595]→[22.955595:955625](∅→∅)

channel: &mut Channel<T>,

[22.955595]

[22.955625]

graph: &mut T::Graph,
replacement in libpijul/src/apply.rs at line 409

[22.955721]→[22.96841:96886](∅→∅)

) -> Result<(), LocalApplyError<T::Error>> {

[22.955721]

[22.955754]

) -> Result<(), LocalApplyError<T::GraphError>> {
replacement in libpijul/src/apply.rs at line 422

[22.67490]→[21.17599:17747](∅→∅)

if put_up_context(txn, channel, ch, ws, up)? && n.flag.contains(EdgeFlags::FOLDER) {
return Err(LocalApplyError::INCONSISTENT);

[22.67490]

[21.17747]

if put_up_context(txn, graph, ch, ws, up)? && n.flag.contains(EdgeFlags::FOLDER) {
return Err(LocalApplyError::InvalidChange);
replacement in libpijul/src/apply.rs at line 429

[21.17793]→[21.17793:17849](∅→∅)

return Err((InconsistentChange {}).into());

[21.17793]

[21.17849]

return Err(LocalApplyError::InvalidChange);
replacement in libpijul/src/apply.rs at line 431

[21.17859]→[21.17859:18012](∅→∅)

if put_down_context(txn, channel, ch, ws, down)? && !n.flag.contains(EdgeFlags::FOLDER) {
return Err(LocalApplyError::INCONSISTENT);

[21.17859]

[21.18012]

if put_down_context(txn, graph, ch, ws, down)? && !n.flag.contains(EdgeFlags::FOLDER) {
return Err(LocalApplyError::InvalidChange);
replacement in libpijul/src/apply.rs at line 442

[21.18139]→[21.18139:18218](∅→∅),[21.18218]→[22.96963:97016](∅→∅),[22.96963]→[22.96963:97016](∅→∅)

put_graph_with_rev(txn, channel, up_flag, up, vertex, *change)
.map_err(LocalApplyError::Txn)?;

[21.18139]

[22.956703]

put_graph_with_rev(txn, graph, up_flag, up, vertex, *change)?;
replacement in libpijul/src/apply.rs at line 445

[22.956727]→[21.18219:18352](∅→∅)

put_graph_with_rev(txn, channel, n.flag | EdgeFlags::BLOCK, up, vertex, change)
.map_err(LocalApplyError::Txn)?;

[22.956727]

[22.956816]

put_graph_with_rev(txn, graph, n.flag | EdgeFlags::BLOCK, up, vertex, change)?;
replacement in libpijul/src/apply.rs at line 454

[22.956966]→[21.18459:18533](∅→∅),[21.18533]→[22.97131:97176](∅→∅),[22.97131]→[22.97131:97176](∅→∅)

put_graph_with_rev(txn, channel, down_flag, vertex, down, change)
.map_err(LocalApplyError::Txn)?;

[22.956966]

[21.18534]

put_graph_with_rev(txn, graph, down_flag, vertex, down, change)?;
replacement in libpijul/src/apply.rs at line 463

[22.1048]→[22.957608:957639](∅→∅),[22.957608]→[22.957608:957639](∅→∅)

fn put_up_context<T: MutTxnT>(

[22.1048]

[22.957639]

fn put_up_context<T: GraphMutTxnT>(
replacement in libpijul/src/apply.rs at line 465

[22.957656]→[22.957656:957686](∅→∅)

channel: &mut Channel<T>,

[22.957656]

[22.957686]

graph: &mut T::Graph,
replacement in libpijul/src/apply.rs at line 469

[22.957790]→[21.18618:18665](∅→∅)

) -> Result<bool, LocalApplyError<T::Error>> {

[22.957790]

[22.957823]

) -> Result<bool, LocalApplyError<T::GraphError>> {
replacement in libpijul/src/apply.rs at line 474

[22.957945]→[22.68284:68335](∅→∅)

let k = find_block_end(txn, channel, up)?;

[22.957945]

[22.957995]

let k = find_block_end(txn, graph, up)?;
replacement in libpijul/src/apply.rs at line 482

[21.18835]→[22.97283:97363](∅→∅),[22.958453]→[22.97283:97363](∅→∅)

split_block(txn, channel, k, up.pos).map_err(LocalApplyError::Txn)?

[21.18835]

[22.958502]

split_block(txn, graph, k, up.pos, &mut ws.adjbuf)?
replacement in libpijul/src/apply.rs at line 494

[21.18871]→[22.68505:68579](∅→∅),[22.68505]→[22.68505:68579](∅→∅)

for parent in iter_adjacent(txn, &channel, up_vertex, flag0, flag1) {

[21.18871]

[21.18872]

for parent in iter_adjacent(txn, graph, up_vertex, flag0, flag1)? {
let parent = parent?;
replacement in libpijul/src/apply.rs at line 501

[22.68768]→[22.68768:68849](∅→∅)

let introduced_by = txn.get_external(parent.introduced_by).unwrap();

[22.68706]

[22.68849]

let introduced_by = txn.get_external(parent.introduced_by)?.unwrap();
replacement in libpijul/src/apply.rs at line 511

[22.1050]→[22.959262:959295](∅→∅),[22.959262]→[22.959262:959295](∅→∅)

fn put_down_context<T: MutTxnT>(

[22.1050]

[22.959295]

fn put_down_context<T: GraphMutTxnT>(
replacement in libpijul/src/apply.rs at line 513

[22.959312]→[22.959312:959342](∅→∅)

channel: &mut Channel<T>,

[22.959312]

[22.959342]

graph: &mut T::Graph,
replacement in libpijul/src/apply.rs at line 517

[22.959448]→[21.19058:19105](∅→∅),[21.19105]→[22.69263:69309](∅→∅),[22.97423]→[22.69263:69309](∅→∅),[22.959495]→[22.69263:69309](∅→∅)

) -> Result<bool, LocalApplyError<T::Error>> {
let k = find_block(txn, &channel, down)?;

[22.959448]

[22.959540]

) -> Result<bool, LocalApplyError<T::GraphError>> {
let k = find_block(txn, &graph, down)?;
replacement in libpijul/src/apply.rs at line 525

[21.19263]→[22.97424:97502](∅→∅),[22.960068]→[22.97424:97502](∅→∅)

split_block(txn, channel, k, down.pos).map_err(LocalApplyError::Txn)?

[21.19263]

[22.960115]

split_block(txn, graph, k, down.pos, &mut ws.adjbuf)?
replacement in libpijul/src/apply.rs at line 537

[21.19295]→[22.69361:69437](∅→∅),[22.960393]→[22.69361:69437](∅→∅)

for parent in iter_adjacent(txn, &channel, down_vertex, flag0, flag1) {

[21.19295]

[21.19296]

for parent in iter_adjacent(txn, &graph, down_vertex, flag0, flag1)? {
let parent = parent?;
replacement in libpijul/src/apply.rs at line 542

[22.960679]→[22.960679:960764](∅→∅)

let introduced_by = txn.get_external(parent.introduced_by).unwrap();

[22.960613]

[22.960764]

let introduced_by = txn.get_external(parent.introduced_by)?.unwrap();
edit in libpijul/src/apply.rs at line 563

[22.961591]

[22.961591]

adjbuf: Vec<Edge>,
edit in libpijul/src/apply.rs at line 579

[22.962286]

[22.962286]

self.adjbuf.clear();
replacement in libpijul/src/apply.rs at line 589

[22.962629]→[22.962629:962669](∅→∅)

assert!(self.rooted.is_empty())

[22.962629]

[22.962669]

assert!(self.rooted.is_empty());
assert!(self.adjbuf.is_empty());
replacement in libpijul/src/apply.rs at line 596

[22.962811]→[22.962811:962841](∅→∅)

channel: &mut Channel<T>,

[22.962811]

[22.962841]

graph: &mut T::Graph,
replacement in libpijul/src/apply.rs at line 604

[22.963010]→[22.963010:963026](∅→∅),[22.963026]→[22.97561:97692](∅→∅)

T: MutTxnT,
E: From<LocalApplyError<T::Error>>,
F: Fn(&mut T, &mut Channel<T>, Vertex<ChangeId>, Vertex<ChangeId>) -> Result<bool, E>,

[22.963010]

[22.963317]

T: GraphMutTxnT,
E: From<LocalApplyError<T::GraphError>> + From<TxnErr<T::GraphError>>,
F: Fn(&mut T, &mut T::Graph, Vertex<ChangeId>, Vertex<ChangeId>) -> Result<bool, E>,
replacement in libpijul/src/apply.rs at line 611

[22.97720]→[22.97720:97825](∅→∅)

.load_graph(txn, channel, inode)
.map_err(LocalApplyError::InconsistentChange)?;

[22.97720]

[22.963425]

.load_graph(txn, graph, inode)
.map_err(|_| LocalApplyError::InvalidChange)?;
replacement in libpijul/src/apply.rs at line 617

[21.19664]→[21.19664:19722](∅→∅)

return Err(LocalApplyError::INCONSISTENT.into());

[21.19664]

[21.19722]

return Err(LocalApplyError::InvalidChange.into());
replacement in libpijul/src/apply.rs at line 622

[21.19814]→[22.69656:69741](∅→∅),[22.963553]→[22.69656:69741](∅→∅)

let n_introduced_by = if let Some(n) = internal(txn, &n.introduced_by, change) {

[21.19814]

[22.963637]

let n_introduced_by = if let Some(n) = internal(txn, &n.introduced_by, change)? {
replacement in libpijul/src/apply.rs at line 625

[22.963660]→[21.19815:19873](∅→∅)

return Err(LocalApplyError::INCONSISTENT.into());

[22.963660]

[22.963721]

return Err(LocalApplyError::InvalidChange.into());
replacement in libpijul/src/apply.rs at line 628

[22.963729]→[22.963729:963911](∅→∅)

let mut source = find_source_vertex(txn, channel, &n.from, change, inode, n.flag, ws)?;
let mut target = find_target_vertex(txn, channel, &n.to, change, inode, n.flag, ws)?;

[22.963729]

[22.963911]

let mut source = find_source_vertex(txn, graph, &n.from, change, inode, n.flag, ws)?;
let mut target = find_target_vertex(txn, graph, &n.to, change, inode, n.flag, ws)?;
replacement in libpijul/src/apply.rs at line 639

[21.20045]→[22.97954:98042](∅→∅),[22.964639]→[22.97954:98042](∅→∅)

split_block(txn, channel, target, n.to.end).map_err(LocalApplyError::Txn)?;

[21.20045]

[22.964696]

split_block(txn, graph, target, n.to.end, &mut ws.adjbuf)
.map_err(LocalApplyError::from)?;
replacement in libpijul/src/apply.rs at line 645

[22.964790]→[22.964790:964858](∅→∅)

collect_pseudo_edges(txn, channel, ws, inode, target)?;

[22.964790]

[22.964858]

collect_pseudo_edges(txn, graph, ws, inode, target).map_err(LocalApplyError::from)?;
replacement in libpijul/src/apply.rs at line 647

[22.964911]→[22.964911:964985](∅→∅)

reconnect_pseudo_edges(txn, channel, inode, ws, target)?;

[22.964911]

[22.964985]

reconnect_pseudo_edges(txn, graph, inode, ws, target)?;
replacement in libpijul/src/apply.rs at line 653

[22.965043]→[21.20079:20165](∅→∅),[21.20165]→[22.98139:98184](∅→∅),[22.98139]→[22.98139:98184](∅→∅),[22.965742]→[22.965742:965798](∅→∅),[22.965798]→[22.98185:98262](∅→∅),[22.98262]→[22.98262:98311](∅→∅)

del_graph_with_rev(txn, channel, n.previous, source, target, n_introduced_by)
.map_err(LocalApplyError::Txn)?;
if apply_check(txn, channel, source, target)? {
put_graph_with_rev(txn, channel, n.flag, source, target, change)
.map_err(LocalApplyError::Txn)?;

[22.965043]

[22.965876]

del_graph_with_rev(txn, graph, n.previous, source, target, n_introduced_by)?;
if apply_check(txn, graph, source, target)? {
put_graph_with_rev(txn, graph, n.flag, source, target, change)?;
replacement in libpijul/src/apply.rs at line 665

[22.966024]→[22.98312:98406](∅→∅)

target = find_block(txn, channel, target.end_pos()).map_err(LocalApplyError::Block)?;

[22.966024]

[22.966085]

target = find_block(txn, graph, target.end_pos()).map_err(LocalApplyError::from)?;
replacement in libpijul/src/apply.rs at line 671

[22.966196]→[22.966196:966231](∅→∅)

fn find_source_vertex<T: MutTxnT>(

[22.966141]

[22.966231]

fn find_source_vertex<T: GraphMutTxnT>(
replacement in libpijul/src/apply.rs at line 673

[22.966248]→[22.966248:966278](∅→∅)

channel: &mut Channel<T>,

[22.966248]

[22.966278]

channel: &mut T::Graph,
replacement in libpijul/src/apply.rs at line 679

[22.966415]→[22.98407:98466](∅→∅)

) -> Result<Vertex<ChangeId>, LocalApplyError<T::Error>> {

[22.966415]

[22.966462]

) -> Result<Vertex<ChangeId>, LocalApplyError<T::GraphError>> {
replacement in libpijul/src/apply.rs at line 686

[21.20332]→[22.98467:98551](∅→∅),[22.967280]→[22.98467:98551](∅→∅)

split_block(txn, channel, source, from.pos).map_err(LocalApplyError::Txn)?;

[21.20332]

[22.967333]

split_block(txn, channel, source, from.pos, &mut ws.adjbuf)?;
replacement in libpijul/src/apply.rs at line 692

[22.967388]→[22.967388:967423](∅→∅)

fn find_target_vertex<T: MutTxnT>(

[22.967388]

[22.967423]

fn find_target_vertex<T: GraphMutTxnT>(
replacement in libpijul/src/apply.rs at line 694

[22.967440]→[22.967440:967470](∅→∅)

channel: &mut Channel<T>,

[22.967440]

[22.967470]

channel: &mut T::Graph,
replacement in libpijul/src/apply.rs at line 700

[22.967603]→[22.98552:98611](∅→∅)

) -> Result<Vertex<ChangeId>, LocalApplyError<T::Error>> {

[22.967603]

[22.70187]

) -> Result<Vertex<ChangeId>, LocalApplyError<T::GraphError>> {
replacement in libpijul/src/apply.rs at line 708

[21.20449]→[22.98612:98696](∅→∅),[22.968473]→[22.98612:98696](∅→∅)

split_block(txn, channel, target, to.start).map_err(LocalApplyError::Txn)?;

[21.20449]

[22.968526]

split_block(txn, channel, target, to.start, &mut ws.adjbuf)?;
replacement in libpijul/src/apply.rs at line 714

[22.1054]→[22.968637:968674](∅→∅),[22.968637]→[22.968637:968674](∅→∅)

fn collect_pseudo_edges<T: MutTxnT>(

[22.1054]

[22.968674]

fn collect_pseudo_edges<T: GraphMutTxnT>(
replacement in libpijul/src/apply.rs at line 716

[22.968691]→[22.968691:968721](∅→∅)

channel: &mut Channel<T>,

[22.968691]

[22.968721]

channel: &mut T::Graph,
replacement in libpijul/src/apply.rs at line 720

[22.968808]→[22.98697:98742](∅→∅)

) -> Result<(), LocalApplyError<T::Error>> {

[22.968808]

[22.70362]

) -> Result<(), LocalApplyError<T::GraphError>> {
replacement in libpijul/src/apply.rs at line 727

[22.968977]→[22.968977:968985](∅→∅)

) {

[22.968977]

[22.968985]

)? {
let e = e?;
replacement in libpijul/src/apply.rs at line 733

[22.70467]→[22.70467:70514](∅→∅)

if is_alive(txn, channel, p) {

[22.70467]

[22.969250]

if is_alive(txn, channel, p)? {
replacement in libpijul/src/apply.rs at line 748

[22.1056]→[22.969636:969675](∅→∅),[22.969636]→[22.969636:969675](∅→∅)

fn reconnect_pseudo_edges<T: MutTxnT>(

[22.1056]

[22.969675]

fn reconnect_pseudo_edges<T: GraphMutTxnT>(
replacement in libpijul/src/apply.rs at line 750

[22.969692]→[22.969692:969722](∅→∅)

channel: &mut Channel<T>,

[22.969692]

[22.969722]

channel: &mut T::Graph,
replacement in libpijul/src/apply.rs at line 754

[22.969811]→[22.98743:98788](∅→∅)

) -> Result<(), LocalApplyError<T::Error>> {

[22.969811]

[21.20450]

) -> Result<(), LocalApplyError<T::GraphError>> {
replacement in libpijul/src/apply.rs at line 759

[21.20509]→[21.20509:20572](∅→∅)

let (graph, vids) = ws.missing_context.graphs.get(inode)?;

[21.20509]

[22.970270]

let (graph, vids) = if let Some(x) = ws.missing_context.graphs.get(inode) {
x
} else {
return Err(LocalApplyError::InvalidChange.into());
};
replacement in libpijul/src/apply.rs at line 779

[21.20607]→[21.20607:20657](∅→∅)

debug_assert!(is_alive(txn, channel, p));

[21.20607]

[21.20657]

debug_assert!(is_alive(txn, channel, p).unwrap());
replacement in libpijul/src/apply.rs at line 782

[21.20720]→[21.20720:20868](∅→∅),[21.20868]→[22.98933:98986](∅→∅),[22.98933]→[22.98933:98986](∅→∅)

debug_assert!(is_alive(txn, channel, c));
put_graph_with_rev(txn, channel, EdgeFlags::PSEUDO, p, c, ChangeId::ROOT)
.map_err(LocalApplyError::Txn)?;

[21.20720]

[22.971153]

debug_assert!(is_alive(txn, channel, c).unwrap());
put_graph_with_rev(txn, channel, EdgeFlags::PSEUDO, p, c, ChangeId::ROOT)?;
replacement in libpijul/src/apply.rs at line 790

[22.1058]→[22.971251:971306](∅→∅),[22.971251]→[22.971251:971306](∅→∅)

pub(crate) fn clean_obsolete_pseudo_edges<T: MutTxnT>(

[22.1058]

[22.971306]

pub(crate) fn clean_obsolete_pseudo_edges<T: GraphMutTxnT>(
replacement in libpijul/src/apply.rs at line 792

[22.971323]→[22.971323:971353](∅→∅)

channel: &mut Channel<T>,

[22.971323]

[22.971353]

channel: &mut T::Graph,
replacement in libpijul/src/apply.rs at line 795

[21.20894]→[22.98987:99032](∅→∅),[22.971377]→[22.98987:99032](∅→∅)

) -> Result<(), LocalApplyError<T::Error>> {

[21.20894]

[22.971451]

) -> Result<(), LocalApplyError<T::GraphError>> {
replacement in libpijul/src/apply.rs at line 808

[22.972426]→[22.70889:70993](∅→∅)

let a_is_alive = is_alive(txn, channel, a);
let b_is_alive = is_alive(txn, channel, b);

[22.972051]

[21.20941]

let a_is_alive = is_alive(txn, channel, a)?;
let b_is_alive = is_alive(txn, channel, b)?;
replacement in libpijul/src/apply.rs at line 820

[21.21176]→[21.21176:21227](∅→∅)

)
.map_err(LocalApplyError::Txn)?;

[21.21176]

[22.972853]

)?;
replacement in libpijul/src/apply.rs at line 848

[22.1060]→[22.974306:974346](∅→∅),[22.974306]→[22.974306:974346](∅→∅)

fn repair_missing_contexts<T: MutTxnT>(

[22.1060]

[22.974346]

fn repair_missing_contexts<T: GraphMutTxnT>(
replacement in libpijul/src/apply.rs at line 850

[22.974363]→[22.974363:974393](∅→∅)

channel: &mut Channel<T>,

[22.974363]

[22.974393]

channel: &mut T::Graph,
replacement in libpijul/src/apply.rs at line 854

[22.974463]→[22.99411:99456](∅→∅)

) -> Result<(), LocalApplyError<T::Error>> {

[22.974463]

[22.974496]

) -> Result<(), LocalApplyError<T::GraphError>> {
replacement in libpijul/src/apply.rs at line 881

[22.1062]→[21.22106:22151](∅→∅)

fn repair_new_vertex_context_up<T: MutTxnT>(

[22.1062]

[21.22151]

fn repair_new_vertex_context_up<T: GraphMutTxnT>(
replacement in libpijul/src/apply.rs at line 883

[21.22168]→[21.22168:22198](∅→∅)

channel: &mut Channel<T>,

[21.22168]

[21.22198]

channel: &mut T::Graph,
replacement in libpijul/src/apply.rs at line 888

[21.22310]→[21.22310:22355](∅→∅)

) -> Result<(), LocalApplyError<T::Error>> {

[21.22310]

[21.22355]

) -> Result<(), LocalApplyError<T::GraphError>> {
replacement in libpijul/src/apply.rs at line 891

[21.22475]→[21.22475:22516](∅→∅)

if !is_alive(txn, channel, up) {

[21.22475]

[21.22516]

if !is_alive(txn, channel, up)? {
replacement in libpijul/src/apply.rs at line 908

[21.22912]→[21.22912:22959](∅→∅)

fn repair_new_vertex_context_down<T: MutTxnT>(

[21.22912]

[21.22959]

fn repair_new_vertex_context_down<T: GraphMutTxnT>(
replacement in libpijul/src/apply.rs at line 910

[21.22976]→[21.22976:23006](∅→∅)

channel: &mut Channel<T>,

[21.22976]

[21.23006]

channel: &mut T::Graph,
replacement in libpijul/src/apply.rs at line 915

[21.23118]→[21.23118:23163](∅→∅)

) -> Result<(), LocalApplyError<T::Error>> {

[21.23118]

[21.23163]

) -> Result<(), LocalApplyError<T::GraphError>> {
replacement in libpijul/src/apply.rs at line 920

[21.23294]→[21.23294:23334](∅→∅)

for down in n.down_context.iter() {

[21.23294]

[21.23334]

'outer: for down in n.down_context.iter() {
replacement in libpijul/src/apply.rs at line 922

[21.23418]→[21.23418:23444](∅→∅)

if iter_adjacent(

[21.23418]

[21.23444]

for e in iter_adjacent(
replacement in libpijul/src/apply.rs at line 928

[21.23582]→[21.23582:23671](∅→∅)

)
.any(|e| e.introduced_by != change_id)
{
continue;

[21.23582]

[21.23671]

)? {
let e = e?;
if e.introduced_by != change_id {
continue 'outer;
}
replacement in libpijul/src/apply.rs at line 948

[21.24008]→[21.24008:24044](∅→∅)

fn repair_edge_context<T: MutTxnT>(

[21.24008]

[22.978666]

fn repair_edge_context<T: GraphMutTxnT>(
replacement in libpijul/src/apply.rs at line 950

[22.978683]→[22.978683:978713](∅→∅)

channel: &mut Channel<T>,

[22.978683]

[22.978713]

channel: &mut T::Graph,
replacement in libpijul/src/apply.rs at line 955

[21.24076]→[21.24076:24121](∅→∅)

) -> Result<(), LocalApplyError<T::Error>> {

[21.24076]

[21.24121]

) -> Result<(), LocalApplyError<T::GraphError>> {
replacement in libpijul/src/apply.rs at line 987

[21.25019]→[21.25019:25066](∅→∅)

pub(crate) fn repair_cyclic_paths<T: MutTxnT>(

[21.25019]

[21.25066]

pub(crate) fn repair_cyclic_paths<T: GraphMutTxnT>(
replacement in libpijul/src/apply.rs at line 989

[21.25083]→[21.25083:25113](∅→∅)

channel: &mut Channel<T>,

[21.25083]

[21.25113]

channel: &mut T::Graph,
replacement in libpijul/src/apply.rs at line 991

[21.25137]→[22.100107:100152](∅→∅),[22.978783]→[22.100107:100152](∅→∅)

) -> Result<(), LocalApplyError<T::Error>> {

[21.25137]

[22.978816]

) -> Result<(), LocalApplyError<T::GraphError>> {
replacement in libpijul/src/apply.rs at line 1002

[21.25541]→[21.25541:25622](∅→∅)

if let Some(ee) = iter_adjacent(txn, channel, file, f0, f1).next() {

[21.25541]

[21.25622]

let mut iter = iter_adjacent(txn, channel, file, f0, f1)?;
if let Some(ee) = iter.next() {
let ee = ee?;
replacement in libpijul/src/apply.rs at line 1017

[22.979487]→[22.979487:979515](∅→∅)

fn repair_edge<T: MutTxnT>(

[22.979487]

[22.979515]

fn repair_edge<T: GraphMutTxnT>(
replacement in libpijul/src/apply.rs at line 1019

[22.979532]→[22.979532:979562](∅→∅)

channel: &mut Channel<T>,

[22.979532]

[21.25827]

channel: &mut T::Graph,
replacement in libpijul/src/apply.rs at line 1022

[22.979642]→[22.100153:100198](∅→∅)

) -> Result<(), LocalApplyError<T::Error>> {

[22.979642]

[21.25855]

) -> Result<(), LocalApplyError<T::GraphError>> {
replacement in libpijul/src/apply.rs at line 1044

[21.26527]→[21.26527:26609](∅→∅)

for parent in iter_adjacent(txn, channel, current, f, EdgeFlags::all()) {

[21.26527]

[21.26609]

for parent in iter_adjacent(txn, channel, current, f, EdgeFlags::all())? {
let parent = parent?;
replacement in libpijul/src/apply.rs at line 1049

[21.26780]→[21.26780:26820](∅→∅)

let al = iter_adjacent(

[21.26780]

[21.26820]

let al = if let Some(e) = iter_adjacent(
replacement in libpijul/src/apply.rs at line 1055

[21.26984]→[21.26984:27002](∅→∅)

)

[21.26984]

[21.27002]

)?
replacement in libpijul/src/apply.rs at line 1057

[21.27026]→[21.27026:27054](∅→∅)

.is_some();

[21.27026]

[21.27054]

{
e?;
true
} else {
false
};
replacement in libpijul/src/apply.rs at line 1084

[21.27699]→[21.27699:27766](∅→∅)

)
.map_err(LocalApplyError::Txn)?;

[21.27699]

[21.27766]

)?;
replacement in libpijul/src/apply.rs at line 1092

[22.980815]→[22.980815:980838](∅→∅)

fn is_rooted<T: TxnT>(

[22.980815]

[22.980838]

fn is_rooted<T: GraphTxnT>(
replacement in libpijul/src/apply.rs at line 1094

[22.980851]→[22.980851:980877](∅→∅)

channel: &Channel<T>,

[22.980851]

[22.980877]

channel: &T::Graph,
replacement in libpijul/src/apply.rs at line 1097

[22.980926]→[22.100325:100372](∅→∅)

) -> Result<bool, LocalApplyError<T::Error>> {

[22.980926]

[21.27818]

) -> Result<bool, LocalApplyError<T::GraphError>> {
replacement in libpijul/src/apply.rs at line 1100

[21.27872]→[21.27872:27956](∅→∅)

for e in iter_adjacent(txn, channel, v, EdgeFlags::empty(), EdgeFlags::all()) {

[21.27872]

[21.27956]

for e in iter_adjacent(txn, channel, v, EdgeFlags::empty(), EdgeFlags::all())? {
let e = e?;
replacement in libpijul/src/apply.rs at line 1153

[22.72508]→[22.72508:72520](∅→∅)

) {

[22.72508]

[22.981980]

)? {
let parent = parent?;
replacement in libpijul/src/alive/retrieve.rs at line 6

[22.984783]→[22.984783:984876](∅→∅)

pub fn retrieve<T: TxnT>(txn: &T, channel: &Channel<T>, pos0: Position<ChangeId>) -> Graph {

[22.984783]

[22.984935]

pub fn retrieve<T: GraphTxnT>(
txn: &T,
channel: &T::Graph,
pos0: Position<ChangeId>,
) -> Result<Graph, TxnErr<T::GraphError>> {
replacement in libpijul/src/alive/retrieve.rs at line 41

[22.985958]→[22.985958:985970](∅→∅)

) {

[22.985958]

[22.985970]

)? {
let e = e?;
replacement in libpijul/src/alive/retrieve.rs at line 45

[22.986065]→[22.72658:72734](∅→∅)

if let Some(alive) = new_vertex(txn, channel, e.dest) {

[22.986065]

[22.72734]

if let Some(alive) = new_vertex(txn, channel, e.dest)? {
replacement in libpijul/src/alive/retrieve.rs at line 67

[22.986904]→[22.986904:986914](∅→∅)

graph

[22.986904]

[22.986914]

Ok(graph)
replacement in libpijul/src/alive/retrieve.rs at line 70

[22.2140]→[22.73099:73123](∅→∅),[22.986971]→[22.73099:73123](∅→∅)

fn new_vertex<T: TxnT>(

[22.2140]

[22.73123]

fn new_vertex<T: GraphTxnT>(
replacement in libpijul/src/alive/retrieve.rs at line 72

[22.73136]→[22.73136:73162](∅→∅)

channel: &Channel<T>,

[22.73136]

[22.73162]

graph: &T::Graph,
replacement in libpijul/src/alive/retrieve.rs at line 74

[22.73191]→[22.73191:73293](∅→∅),[22.73293]→[22.2141:2204](∅→∅)

) -> Option<AliveVertex> {
let vertex = crate::pristine::find_block(txn, &channel, pos).unwrap();
if !is_alive(txn, &channel, vertex) {
return None;

[22.73191]

[22.2204]

) -> Result<Option<AliveVertex>, TxnErr<T::GraphError>> {
let vertex = crate::pristine::find_block(txn, graph, pos).unwrap();
if !is_alive(txn, graph, vertex)? {
return Ok(None);
}
let mut flags = Flags::empty();
for e in crate::pristine::iter_adjacent(
txn,
graph,
vertex,
EdgeFlags::PARENT | EdgeFlags::DELETED | EdgeFlags::BLOCK,
EdgeFlags::all(),
)? {
if e?
.flag
.contains(EdgeFlags::PARENT | EdgeFlags::DELETED | EdgeFlags::BLOCK)
{
flags = Flags::ZOMBIE;
break;
}
replacement in libpijul/src/alive/retrieve.rs at line 95

[22.2210]→[22.73542:73565](∅→∅),[22.2135]→[22.73542:73565](∅→∅),[22.73542]→[22.73542:73565](∅→∅)

Some(AliveVertex {

[22.2210]

[22.73565]

Ok(Some(AliveVertex {
replacement in libpijul/src/alive/retrieve.rs at line 97

[22.73581]→[22.73581:73801](∅→∅),[22.73801]→[22.7870:7889](∅→∅),[22.7889]→[22.73823:73927](∅→∅),[22.73823]→[22.73823:73927](∅→∅),[22.73927]→[22.7890:7903](∅→∅),[22.7903]→[22.987415:987496](∅→∅),[22.987415]→[22.987415:987496](∅→∅)

flags: if crate::pristine::iter_adjacent(
txn,
&channel,
vertex,
EdgeFlags::PARENT | EdgeFlags::DELETED | EdgeFlags::BLOCK,
EdgeFlags::all(),
)
.any(|e| {
e.flag
.contains(EdgeFlags::PARENT | EdgeFlags::DELETED | EdgeFlags::BLOCK)
}) {
Flags::ZOMBIE
} else {
Flags::empty()
},

[22.73581]

[22.987496]

flags,
replacement in libpijul/src/alive/retrieve.rs at line 103

[22.987594]→[22.73974:73981](∅→∅)

})

[22.987594]

[22.987600]

}))
replacement in libpijul/src/alive/retrieve.rs at line 106

[22.2212]→[22.987657:987705](∅→∅),[22.987657]→[22.987657:987705](∅→∅)

pub(crate) fn remove_forward_edges<T: MutTxnT>(

[22.2212]

[22.987705]

pub(crate) fn remove_forward_edges<T: GraphMutTxnT>(
replacement in libpijul/src/alive/retrieve.rs at line 108

[22.987722]→[22.987722:987752](∅→∅)

channel: &mut Channel<T>,

[22.987722]

[22.987752]

channel: &mut T::Graph,
replacement in libpijul/src/alive/retrieve.rs at line 110

[22.987781]→[22.100373:100401](∅→∅),[22.100401]→[22.987814:987863](∅→∅),[22.987814]→[22.987814:987863](∅→∅)

) -> Result<(), T::Error> {
let mut graph = retrieve(txn, channel, pos);

[22.987781]

[22.987863]

) -> Result<(), TxnErr<T::GraphError>> {
let mut graph = retrieve(txn, channel, pos)?;
replacement in libpijul/src/alive/retrieve.rs at line 115

[22.988012]→[22.988012:988093](∅→∅)

graph.collect_forward_edges(txn, channel, &scc, &forward_scc, &mut forward);

[22.988012]

[22.988093]

graph.collect_forward_edges(txn, channel, &scc, &forward_scc, &mut forward)?;
replacement in libpijul/src/alive/retrieve.rs at line 117

[22.988137]→[22.73982:74065](∅→∅)

let dest = crate::pristine::find_block(txn, &channel, edge.dest).unwrap();

[22.988137]

[22.988202]

let dest = crate::pristine::find_block(txn, channel, edge.dest).unwrap();
replacement in libpijul/src/alive/output.rs at line 16

[22.100436]→[22.988843:988905](∅→∅),[22.988843]→[22.988843:988905](∅→∅)

fn output_conflict<T: TxnT, B: VertexBuffer, P: ChangeStore>(

[22.100436]

[22.988905]

fn output_conflict<T: ChannelTxnT, B: VertexBuffer, P: ChangeStore>(
replacement in libpijul/src/alive/output.rs at line 24

[22.989052]→[22.100437:100476](∅→∅)

) -> Result<(), FileError<P::Error>> {

[22.989052]

[22.989085]

) -> Result<(), FileError<P::Error, T::GraphError>> {
replacement in libpijul/src/alive/output.rs at line 38

[22.989641]→[22.989641:989723](∅→∅)

.map(|a| a.oldest_vertex(changes, txn, channel, graph, sccs))

[22.989641]

[22.989723]

.map(|a| a.oldest_vertex(changes, txn, channel, graph, sccs).unwrap())
replacement in libpijul/src/alive/output.rs at line 44

[22.989862]→[22.989862:989944](∅→∅)

.map(|b| b.oldest_vertex(changes, txn, channel, graph, sccs))

[22.989862]

[22.989944]

.map(|b| b.oldest_vertex(changes, txn, channel, graph, sccs).unwrap())
replacement in libpijul/src/alive/output.rs at line 91

[22.991509]→[22.991509:991556](∅→∅)

fn oldest_vertex<T: TxnT, C: ChangeStore>(

[22.991509]

[22.991556]

fn oldest_vertex<T: ChannelTxnT, C: ChangeStore>(
replacement in libpijul/src/alive/output.rs at line 98

[22.991696]→[22.991696:991711](∅→∅)

) -> u64 {

[22.991696]

[22.991711]

) -> Result<u64, TxnErr<T::GraphError>> {
replacement in libpijul/src/alive/output.rs at line 100

[22.991733]→[22.991733:991839](∅→∅)

PathElement::Scc { ref scc } => sccs[*scc]
.iter()
.map(|x| {

[22.991733]

[22.991839]

PathElement::Scc { ref scc } => {
let mut min: Option<u64> = None;
for x in sccs[*scc].iter() {
replacement in libpijul/src/alive/output.rs at line 104

[22.991876]→[22.991876:991967](∅→∅)

txn.get_changeset(&channel.changes, graph[*x].vertex.change, None)

[22.991876]

[22.991967]

txn.get_changeset(&channel.changes, graph[*x].vertex.change, None)?
replacement in libpijul/src/alive/output.rs at line 106

[22.991989]→[22.991989:992015](∅→∅)

t

[22.991989]

[22.992015]

if let Some(ref mut m) = min {
*m = (*m).min(t)
} else {
min = Some(t)
}
replacement in libpijul/src/alive/output.rs at line 114

[22.992189]→[22.992189:992278](∅→∅)

graph.debug(changes, txn, channel, false, true, f).unwrap();

[22.992189]

[22.992278]

graph
.debug(changes, txn, &channel.graph, false, true, f)
.unwrap();
replacement in libpijul/src/alive/output.rs at line 120

[22.992406]→[22.992406:992862](∅→∅)

})
.min()
.unwrap(),
PathElement::Conflict { ref sides } => sides
.iter()
.map(|x| {
x.path
.iter()
.map(|x| x.oldest_vertex(changes, txn, channel, graph, sccs))
.min()
.unwrap()
})
.min()
.unwrap(),

[22.992406]

[22.992862]

}
Ok(min.unwrap())
}
PathElement::Conflict { ref sides } => {
let mut min: Option<u64> = None;
for x in sides.iter() {
for y in x.path.iter() {
let t = y.oldest_vertex(changes, txn, channel, graph, sccs)?;
if let Some(ref mut m) = min {
*m = (*m).min(t)
} else {
min = Some(t)
}
}
}
Ok(min.unwrap())
}
replacement in libpijul/src/alive/output.rs at line 141

[22.100484]→[22.992935:992992](∅→∅),[22.992935]→[22.992935:992992](∅→∅)

fn output_scc<T: TxnT, B: VertexBuffer, P: ChangeStore>(

[22.100484]

[22.992992]

fn output_scc<T: GraphTxnT, B: VertexBuffer, P: ChangeStore>(
replacement in libpijul/src/alive/output.rs at line 147

[22.993081]→[22.100485:100524](∅→∅)

) -> Result<(), FileError<P::Error>> {

[22.993081]

[22.993114]

) -> Result<(), FileError<P::Error, T::GraphError>> {
replacement in libpijul/src/alive/output.rs at line 163

[22.100647]→[22.100647:100715](∅→∅)

.get_contents(|p| txn.get_external(p), vertex, buf)

[22.100647]

[22.100715]

.get_contents(|p| txn.get_external(p).unwrap(), vertex, buf)
replacement in libpijul/src/alive/output.rs at line 186

[22.100890]→[22.994281:994344](∅→∅),[22.994281]→[22.994281:994344](∅→∅)

pub fn output_graph<T: TxnT, B: VertexBuffer, P: ChangeStore>(

[22.100890]

[22.994344]

pub fn output_graph<T: ChannelTxnT, B: VertexBuffer, P: ChangeStore>(
replacement in libpijul/src/alive/output.rs at line 193

[22.994494]→[22.100891:100945](∅→∅)

) -> Result<(), crate::output::FileError<P::Error>> {

[22.994494]

[22.994527]

) -> Result<(), crate::output::FileError<P::Error, T::GraphError>> {
replacement in libpijul/src/alive/output.rs at line 200

[22.994757]→[22.994757:994833](∅→∅)

graph.collect_forward_edges(txn, channel, &scc, &forward_scc, forward);

[22.994757]

[22.994833]

graph.collect_forward_edges(txn, &channel.graph, &scc, &forward_scc, forward)?;
replacement in libpijul/src/alive/dfs.rs at line 359

[22.1013140]→[22.1013140:1013190](∅→∅)

pub(super) fn collect_forward_edges<T: TxnT>(

[22.1013140]

[22.1013190]

pub(super) fn collect_forward_edges<T: GraphTxnT>(
replacement in libpijul/src/alive/dfs.rs at line 362

[22.1013222]→[22.1013222:1013252](∅→∅)

channel: &Channel<T>,

[22.1013222]

[22.1013252]

channel: &T::Graph,
replacement in libpijul/src/alive/dfs.rs at line 366

[22.1013385]→[22.1013385:1013393](∅→∅)

) {

[22.1013385]

[22.1013393]

) -> Result<(), TxnErr<T::GraphError>> {
replacement in libpijul/src/alive/dfs.rs at line 385

[22.1014294]→[22.1014294:1014324](∅→∅)

)

[22.1014294]

[22.1014324]

)?
edit in libpijul/src/alive/dfs.rs at line 393

[22.1014511]

[22.1014511]

Ok(())
replacement in libpijul/src/alive/debug.rs at line 3

[22.1014644]→[22.1014644:1014700](∅→∅)

use crate::pristine::{Base32, Channel, Position, TxnT};

[22.1014644]

[22.1014700]

use crate::pristine::{Base32, GraphTxnT, Position};
replacement in libpijul/src/alive/debug.rs at line 10

[22.1014871]→[22.1014871:1014924](∅→∅)

pub fn debug<W: Write, T: TxnT, P: ChangeStore>(

[22.1014871]

[22.1014924]

pub fn debug<W: Write, T: GraphTxnT, P: ChangeStore>(
replacement in libpijul/src/alive/debug.rs at line 14

[22.1014977]→[22.1014977:1015007](∅→∅)

channel: &Channel<T>,

[22.1014977]

[22.1015007]

channel: &T::Graph,
replacement in libpijul/src/alive/debug.rs at line 36

[22.101031]→[22.101031:101109](∅→∅)

.get_contents(|h| txn.get_external(h), line.vertex, &mut buf)

[22.101031]

[22.101109]

.get_contents(|h| txn.get_external(h).unwrap(), line.vertex, &mut buf)
replacement in libpijul/src/alive/debug.rs at line 63

[22.1016628]→[22.74253:74351](∅→∅),[22.74351]→[22.1016729:1016807](∅→∅),[22.1016729]→[22.1016729:1016807](∅→∅)

for (_, v) in crate::pristine::iter_graph(txn, &channel.graph, line.vertex, None)
.take_while(|&(k, _)| k == line.vertex)
{

[22.1016628]

[22.1016807]

for x in crate::pristine::iter_graph(txn, &channel, line.vertex, None).unwrap() {
let (k, v) = x.unwrap();
if k != line.vertex {
break;
}
replacement in libpijul/Cargo.toml at line 4

[22.1020894]→[19.184:211](∅→∅)

version = "1.0.0-alpha.22"

[22.1020894]

[22.1020920]

version = "1.0.0-alpha.23"
replacement in libpijul/Cargo.toml at line 86

[22.1022736]→[22.2992:3054](∅→∅)

ondisk-repos = [ "mmap", "zstd", "ignore", "canonical-path" ]

[22.1022736]

[22.1022780]

ondisk-repos = [ "mmap", "zstd", "ignore", "canonical-path", "lru-cache", "tempfile" ]
replacement in libpijul/Cargo.toml at line 95

[22.1022980]→[19.212:233](∅→∅)

sanakirja = "0.14.5"

[22.1022980]

[22.1023001]

sanakirja = "0.15.2"
replacement in libpijul/Cargo.toml at line 105

[22.1023195]→[22.204:227](∅→∅)

pijul-macros = "0.2.0"

[22.1023195]

[22.1023218]

pijul-macros = "0.3.0"
edit in libpijul/Cargo.toml at line 108

[22.1023256]→[22.1023256:1023274](∅→∅)

lru-cache = "0.1"
edit in libpijul/Cargo.toml at line 109

[22.1023288]→[22.1023288:1023305](∅→∅)

tempfile = "3.1"
edit in libpijul/Cargo.toml at line 119

[22.3109]

[22.1023703]

lru-cache = { version = "0.1", optional = true }
tempfile = { version = "3.1", optional = true }
replacement in Cargo.nix at line 85

[22.2998]→[22.2998:3026](∅→∅)

version = "0.14.0";

[22.2998]

[22.3026]

version = "0.14.1";
replacement in Cargo.nix at line 87

[22.3052]→[22.3052:3125](∅→∅)

sha256 = "08x42676mp3wa4amhgnlwlsjxsyarfgr2sc283srppbqkvb2j2bw";

[22.3052]

[22.3125]

sha256 = "1xs5bsi40zpyxbbylyaysya5h36ykcbg91i82415sxw5wk7q4px5";
replacement in Cargo.nix at line 146

[22.5657]→[19.234:262](∅→∅)

version = "1.0.36";

[22.5657]

[22.5685]

version = "1.0.37";
replacement in Cargo.nix at line 148

[22.5711]→[19.263:336](∅→∅)

sha256 = "0yclpf28nrck31p7zwwckqjhvdl2fdlg4xmb3cclfgmilwjk5038";

[22.5711]

[22.5784]

sha256 = "11kaqp25lchr2ckyc46zm6blzndnw0w2w8qv0sp8z4xcxqgw2rzf";
replacement in Cargo.nix at line 703

[22.330]→[22.330:358](∅→∅)

version = "0.13.0";

[22.330]

[22.358]

version = "0.14.0";
replacement in Cargo.nix at line 705

[22.384]→[22.384:457](∅→∅)

sha256 = "022ai0jbbawngrx396qppwgzk4pk3v2fdwckzamvz6h154jsn2m5";

[22.384]

[22.28900]

sha256 = "1ajnr0rga4vya0fza12ighf3ffkm86w1rv8p5wf443s8nd30kj3w";
edit in Cargo.nix at line 744

[22.1482]→[22.1482:1669](∅→∅)

}
{
name = "winapi-util";
packageId = "winapi-util";
optional = true;
target = { target, features }: target."windows";
replacement in Cargo.nix at line 748

[22.1743]→[22.1743:1826](∅→∅)

"default" = [ "unicode-width" "ansi-parsing" "windows-console-colors" ];

[22.1743]

[22.1826]

"default" = [ "unicode-width" "ansi-parsing" ];
replacement in Cargo.nix at line 751

[22.1908]→[22.1908:2035](∅→∅)

resolvedDefaultFeatures = [ "ansi-parsing" "default" "regex" "unicode-width" "winapi-util" "windows-console-colors" ];

[22.1908]

[22.75063]

resolvedDefaultFeatures = [ "ansi-parsing" "default" "regex" "unicode-width" ];
replacement in Cargo.nix at line 1792

[22.59751]→[19.586:619](∅→∅)

"getrandom 0.1.15" = rec {

[22.59751]

[22.59777]

"getrandom 0.1.16" = rec {
replacement in Cargo.nix at line 1794

[22.59810]→[22.59810:59838](∅→∅)

version = "0.1.15";

[22.59810]

[22.59838]

version = "0.1.16";
replacement in Cargo.nix at line 1796

[22.59864]→[22.59864:59937](∅→∅)

sha256 = "1rj7psnlrnmsgyj6x2ag4c6367laq4g8kfd6pzamac99xk07nn7w";

[22.59864]

[22.59937]

sha256 = "1kjzmz60qx9mn615ks1akjbf36n3lkv27zfwbcam0fzmj56wphwg";
replacement in Cargo.nix at line 1803

[22.60074]→[22.60074:60115](∅→∅)

packageId = "cfg-if 0.1.10";

[22.60074]

[22.60115]

packageId = "cfg-if 1.0.0";
edit in Cargo.nix at line 1820

[22.60634]

[19.620]

"wasm-bindgen" = [ "bindgen" "js-sys" ];
replacement in Cargo.nix at line 1875

[22.61459]→[19.1570:1599](∅→∅)

version = "0.13.14";

[22.61459]

[22.61488]

version = "0.13.15";
replacement in Cargo.nix at line 1877

[22.61514]→[19.1600:1673](∅→∅)

sha256 = "0q420j5lw7qchp5f6pgq938dkfi7pfllyqdd8j1yaxkmqyfdjv8q";

[22.61514]

[22.61587]

sha256 = "0na3vsa44nn1sr6pzscn93w69wbmdih277mm2p3f6kcavb4ngwj4";
replacement in Cargo.nix at line 2551

[22.79414]→[22.79414:79441](∅→∅)

version = "0.4.6";

[22.79414]

[22.79441]

version = "0.4.7";
replacement in Cargo.nix at line 2553

[22.79467]→[22.79467:79540](∅→∅)

sha256 = "1rnpb7rr8df76gnlk07b9086cn7fc0dxxy1ghh00q6nip7bklvyw";

[22.79467]

[22.79540]

sha256 = "0di7fggbknwfjcw8cgzm1dnm3ik32l2m1f7nmyh8ipmh45h069fx";
replacement in Cargo.nix at line 2647

[22.82507]→[19.2211:2246](∅→∅)

version = "0.12.16+1.1.0";

[22.82507]

[22.82542]

version = "0.12.17+1.1.0";
replacement in Cargo.nix at line 2649

[22.82568]→[19.2247:2320](∅→∅)

sha256 = "083hr4d1if61pb997myp57hfh0idv26bx5ai2nc5m5zf67wv54cz";

[22.82568]

[22.82641]

sha256 = "0hc89v7kp2b3rbc64cxq024shd85m8vqcs14i3gjclblr9jxzszl";
replacement in Cargo.nix at line 2699

[22.84748]→[19.2321:2357](∅→∅)

version = "1.0.0-alpha.22";

[22.84748]

[22.84783]

version = "1.0.0-alpha.23";
edit in Cargo.nix at line 2766

[22.86369]

[22.86369]

optional = true;
edit in Cargo.nix at line 2801

[22.87143]

[22.87143]

optional = true;
replacement in Cargo.nix at line 2837

[22.87922]→[22.547:619](∅→∅)

"ondisk-repos" = [ "mmap" "zstd" "ignore" "canonical-path" ];

[22.87922]

[22.87977]

"ondisk-repos" = [ "mmap" "zstd" "ignore" "canonical-path" "lru-cache" "tempfile" ];
replacement in Cargo.nix at line 2842

[22.88110]→[22.620:803](∅→∅)

resolvedDefaultFeatures = [ "canonical-path" "default" "dump" "flate2" "ignore" "mmap" "ondisk-repos" "regex" "tar" "tarball" "text-changes" "tokio" "zstd" "zstd-seekable" ];

[22.88110]

[22.88276]

resolvedDefaultFeatures = [ "canonical-path" "default" "dump" "flate2" "ignore" "lru-cache" "mmap" "ondisk-repos" "regex" "tar" "tarball" "tempfile" "text-changes" "tokio" "zstd" "zstd-seekable" ];
replacement in Cargo.nix at line 3272

[22.100155]→[22.100155:100182](∅→∅)

version = "0.2.6";

[22.100155]

[22.100182]

version = "0.2.7";
replacement in Cargo.nix at line 3274

[22.100208]→[22.100208:100281](∅→∅)

sha256 = "0grsinsgq1pd70c6k9mif7wambwq2jxh8jhvdgwf9i7dnlwpkk3g";

[22.100208]

[22.100281]

sha256 = "1m6v16xl8h4pm32pw6yhrvgwznf60bqhj2qhb1yrb8wd3hp6pndq";
edit in Cargo.nix at line 3328

[22.102409]

[22.102409]

}
];
devDependencies = [
{
name = "tempfile";
packageId = "tempfile";
edit in Cargo.nix at line 3337

[22.102453]

[22.102453]

"alpn" = [ "security-framework/alpn" ];
edit in Cargo.nix at line 3873

[22.117476]→[22.117476:117569](∅→∅)

}
{
name = "thiserror";
packageId = "thiserror";
replacement in Cargo.nix at line 3908

[22.118308]→[22.1303:1330](∅→∅)

version = "0.2.0";

[22.118308]

[22.118335]

version = "0.3.0";
replacement in Cargo.nix at line 4215

[22.126837]→[19.3372:3416](∅→∅)

packageId = "getrandom 0.1.15";

[22.126837]

[22.126874]

packageId = "getrandom 0.1.16";
replacement in Cargo.nix at line 4381

[22.129574]→[19.6248:6292](∅→∅)

packageId = "getrandom 0.1.15";

[22.129574]

[19.6292]

packageId = "getrandom 0.1.16";
replacement in Cargo.nix at line 4468

[22.130971]→[19.7444:7488](∅→∅)

packageId = "getrandom 0.1.15";

[22.130971]

[22.131008]

packageId = "getrandom 0.1.16";
replacement in Cargo.nix at line 4857

[22.144463]→[19.7593:7621](∅→∅)

version = "0.14.5";

[22.144463]

[22.144491]

version = "0.15.2";
replacement in Cargo.nix at line 4859

[22.144517]→[19.7622:7695](∅→∅)

sha256 = "1231wkv5dv08k9sv85isaa8ra8j0nd8jjxirlzz7196fws5v4zhf";

[22.144517]

[22.144590]

sha256 = "0bsym4q8zm0q7zk5jj5ik02ip3yjr3p5y27mrsg1p03jazz7jw6y";
edit in Cargo.nix at line 4866

[22.144721]

[22.144721]

name = "crc32fast";
packageId = "crc32fast";
optional = true;
}
{
replacement in Cargo.nix at line 4898

[22.145311]→[22.145311:145344](∅→∅)

"mmap" = [ "memmap" ];

[22.145311]

[22.145344]

"crc32" = [ "crc32fast" ];
"mmap" = [ "memmap" "crc32" ];
replacement in Cargo.nix at line 4901

[22.145355]→[22.145355:145427](∅→∅)

resolvedDefaultFeatures = [ "default" "git2" "memmap" "mmap" ];

[22.145355]

[22.145427]

resolvedDefaultFeatures = [ "crc32" "crc32fast" "default" "git2" "memmap" "mmap" ];
replacement in Cargo.nix at line 5066

[22.150408]→[19.7943:7971](∅→∅)

version = "1.0.60";

[22.150408]

[22.150436]

version = "1.0.61";
replacement in Cargo.nix at line 5068

[22.150462]→[19.7972:8045](∅→∅)

sha256 = "0yapc7xxk8dx12691yj0l13008rgvknmc6krvk8jwj7y4x6yh00m";

[22.150462]

[22.150535]

sha256 = "0nijvxvgcncvd1wbn73zx7q14bdxah0gf2789qd8kdjpa1cv5kjg";
replacement in Cargo.nix at line 5202

[22.154961]→[19.8471:8499](∅→∅)

version = "1.0.55";

[22.154961]

[22.154989]

version = "1.0.56";
replacement in Cargo.nix at line 5204

[22.155015]→[19.8500:8573](∅→∅)

sha256 = "0ypk6j1p1akpd016rh0ksl4rpic7zqbip3k2rjf022fxvl8sfwd5";

[22.155015]

[22.155088]

sha256 = "0wlvjgxhqvcp36zg20q4jzx5khfrk2vhal7fxs3d2w21x7fjv059";
replacement in Cargo.nix at line 5369

[22.159661]→[22.159661:159689](∅→∅)

version = "1.0.22";

[22.159661]

[22.159689]

version = "1.0.23";
replacement in Cargo.nix at line 5371

[22.159715]→[22.159715:159788](∅→∅)

sha256 = "0gp5wp7izpv9rdvq035ajbxcl3g0vck61pg9y6mfsvk1hi5y76hf";

[22.159715]

[22.159788]

sha256 = "0imiv97kdlba0r0ld6mlizfmw5rpmfzhvk7xw8l8k35zd9n63k3n";
replacement in Cargo.nix at line 5385

[22.160090]→[22.160090:160118](∅→∅)

version = "1.0.22";

[22.160090]

[22.160118]

version = "1.0.23";
replacement in Cargo.nix at line 5387

[22.160144]→[22.160144:160217](∅→∅)

sha256 = "0mnx51374c69l1w7gh98prn2wzm2yvmlll4ms567a42vx0ihz8lv";

[22.160144]

[22.160217]

sha256 = "1law4wqpc36hxs4vcgc1pjjniy4l6xn7kwvf0k886xf2mqn3mrwv";
replacement in Cargo.nix at line 5558

[22.2537]→[19.8717:8757](∅→∅)

packageId = "whoami 1.0.1";

[22.2537]

[22.2577]

packageId = "whoami 1.0.3";
replacement in Cargo.nix at line 7033

[22.3095]→[19.10454:10483](∅→∅)

"whoami 1.0.1" = rec {

[22.3095]

[22.3124]

"whoami 1.0.3" = rec {
replacement in Cargo.nix at line 7035

[22.3154]→[19.10484:10511](∅→∅)

version = "1.0.1";

[22.3154]

[22.3181]

version = "1.0.3";
replacement in Cargo.nix at line 7037

[22.3207]→[19.10512:10585](∅→∅)

sha256 = "0d90722ay0dlbgakxghmx5wpiibsqgcjb5wf382mgiplzbkram73";

[22.3207]

[22.3280]

sha256 = "0dmlxqq6758wysx46zr64b4q9g72d0ax9f4hlpb86qgk8vhv55fm";
replacement in Cargo.lock at line 5

[22.1030508]→[22.1030508:1030527](∅→∅)

version = "0.14.0"

[22.1030508]

[22.1030527]

version = "0.14.1"
replacement in Cargo.lock at line 7

[22.1030592]→[22.1030592:1030670](∅→∅)

checksum = "7c0929d69e78dd9bf5408269919fcbcaeb2e35e5d43e5815517cdc6a8e11a423"

[22.1030592]

[22.1030670]

checksum = "a55f82cfe485775d02112886f4169bde0c5894d75e79ead7eafe7e40a25e45f7"
replacement in Cargo.lock at line 29

[22.1031374]→[19.10688:10707](∅→∅)

version = "1.0.36"

[22.1031374]

[22.1031393]

version = "1.0.37"
replacement in Cargo.lock at line 31

[22.1031458]→[19.10708:10786](∅→∅)

checksum = "68803225a7b13e47191bab76f2687382b60d259e8cf37f6e1893658b84bb9479"

[22.1031458]

[22.1031536]

checksum = "ee67c11feeac938fae061b232e38e0b6d94f97a9df10e6271319325ac4c56a86"
replacement in Cargo.lock at line 232

[22.4483]→[22.4483:4502](∅→∅)

version = "0.13.0"

[22.4483]

[22.4502]

version = "0.14.0"
replacement in Cargo.lock at line 234

[22.4567]→[22.4567:4645](∅→∅)

checksum = "a50aab2529019abfabfa93f1e6c41ef392f91fbf179b347a7e96abb524884a08"

[22.4567]

[22.4645]

checksum = "7cc80946b3480f421c2f17ed1cb841753a371c7c5104f51d507e13f532c856aa"
edit in Cargo.lock at line 243

[22.4769]→[22.4769:4785](∅→∅)

"winapi-util",
replacement in Cargo.lock at line 637

[22.1047515]→[22.1047515:1047534](∅→∅)

version = "0.1.15"

[22.1047515]

[22.1047534]

version = "0.1.16"
replacement in Cargo.lock at line 639

[22.1047599]→[22.1047599:1047677](∅→∅)

checksum = "fc587bc0ec293155d5bfa6b9891ec18a1e330c234f896ea47fbada4cadbe47e6"

[22.1047599]

[22.126]

checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"
replacement in Cargo.lock at line 641

[22.143]→[22.143:161](∅→∅)

"cfg-if 0.1.10",

[22.143]

[22.161]

"cfg-if 1.0.0",
replacement in Cargo.lock at line 665

[22.1047978]→[19.10984:11004](∅→∅)

version = "0.13.14"

[22.1047978]

[22.1047998]

version = "0.13.15"
replacement in Cargo.lock at line 667

[22.1048063]→[19.11005:11083](∅→∅)

checksum = "186dd99cc77576e58344ad614fa9bb27bad9d048f85de3ca850c1f4e8b048260"

[22.1048063]

[22.1048141]

checksum = "44f267c9da8a4de3c615b59e23606c75f164f84896e97f4dd6c15a4294de4359"
replacement in Cargo.lock at line 903

[22.1053474]→[22.1053474:1053492](∅→∅)

version = "0.4.6"

[22.1053474]

[22.1053492]

version = "0.4.7"
replacement in Cargo.lock at line 905

[22.1053557]→[22.1053557:1053635](∅→∅)

checksum = "dc6f3ad7b9d11a0c00842ff8de1b60ee58661048eb8049ed33c73594f359d7e6"

[22.1053557]

[22.1053635]

checksum = "dd25036021b0de88a0aff6b850051563c6516d0bf53f8638938edbb9de732736"
replacement in Cargo.lock at line 949

[22.1054943]→[19.11576:11602](∅→∅)

version = "0.12.16+1.1.0"

[22.1054943]

[22.1054969]

version = "0.12.17+1.1.0"
replacement in Cargo.lock at line 951

[22.1055034]→[19.11603:11681](∅→∅)

checksum = "9f91b2f931ee975a98155195be8cd82d02e8e029d7d793d2bac1b8181ac97020"

[22.1055034]

[22.1055112]

checksum = "f4ebdf65ca745126df8824688637aa0535a88900b83362d8ca63893bcf4e8841"
replacement in Cargo.lock at line 963

[22.560]→[19.11682:11709](∅→∅)

version = "1.0.0-alpha.22"

[22.560]

[22.729]

version = "1.0.0-alpha.23"
replacement in Cargo.lock at line 1157

[22.1059712]→[22.1059712:1059730](∅→∅)

version = "0.2.6"

[22.1059712]

[22.1059730]

version = "0.2.7"
replacement in Cargo.lock at line 1159

[22.1059795]→[22.1059795:1059873](∅→∅)

checksum = "6fcc7939b5edc4e4f86b1b4a04bb1498afaaf871b1a6691838ed06fcb48d3a3f"

[22.1059795]

[22.1059873]

checksum = "b8d96b2e1c8da3957d58100b09f102c6d9cfdfced01b7ec5a8974044bb09dbd4"
replacement in Cargo.lock at line 1333

[22.1064071]→[19.12339:12366](∅→∅)

version = "1.0.0-alpha.26"

[22.1064071]

[22.1064097]

version = "1.0.0-alpha.27"
edit in Cargo.lock at line 1364

[22.1064464]→[22.1064464:1064478](∅→∅)

"thiserror",
replacement in Cargo.lock at line 1374

[22.1064574]→[22.340:358](∅→∅)

version = "0.2.0"

[22.1064574]

[22.1064592]

version = "0.3.0"
replacement in Cargo.lock at line 1512

[22.1068267]→[22.492:513](∅→∅)

"getrandom 0.1.15",

[22.1068267]

[22.1068281]

"getrandom 0.1.16",
replacement in Cargo.lock at line 1557

[22.1068787]→[22.1121:1142](∅→∅)

"getrandom 0.1.15",

[22.1068787]

[22.1068801]

"getrandom 0.1.16",
replacement in Cargo.lock at line 1599

[22.1069437]→[22.1627:1648](∅→∅)

"getrandom 0.1.15",

[22.1069437]

[22.1069451]

"getrandom 0.1.16",
replacement in Cargo.lock at line 1711

[22.1072132]→[19.12565:12584](∅→∅)

version = "0.14.5"

[22.1072132]

[22.1072151]

version = "0.15.2"
replacement in Cargo.lock at line 1713

[22.1072216]→[19.12585:12663](∅→∅)

checksum = "0e7eb28be6cea470fea739762951b340229591523a16b4759a08ec56f6e46188"

[22.1072216]

[22.1072294]

checksum = "de7079fe5772801b9ecef5085feec8d28f1b0598b14859e63f18d48f30a95e2f"
edit in Cargo.lock at line 1715

[22.1072311]

[22.1072311]

"crc32fast",
replacement in Cargo.lock at line 1785

[22.1073896]→[19.12864:12883](∅→∅)

version = "1.0.60"

[22.1073896]

[22.1073915]

version = "1.0.61"
replacement in Cargo.lock at line 1787

[22.1073980]→[19.12884:12962](∅→∅)

checksum = "1500e84d27fe482ed1dc791a56eddc2f230046a040fa908c08bda1d9fb615779"

[22.1073980]

[22.1074058]

checksum = "4fceb2595057b6891a4ee808f70054bd2d12f0e97f1cbb78689b59f676df325a"
replacement in Cargo.lock at line 1843

[22.1075798]→[19.13258:13277](∅→∅)

version = "1.0.55"

[22.1075798]

[22.1075817]

version = "1.0.56"
replacement in Cargo.lock at line 1845

[22.1075882]→[19.13278:13356](∅→∅)

checksum = "a571a711dddd09019ccc628e1b17fe87c59b09d513c06c026877aa708334f37a"

[22.1075882]

[22.1075960]

checksum = "a9802ddde94170d186eeee5005b798d9c159fa970403f1be19976d0cfb939b72"
replacement in Cargo.lock at line 1908

[22.1077299]→[22.1077299:1077318](∅→∅)

version = "1.0.22"

[22.1077299]

[22.1077318]

version = "1.0.23"
replacement in Cargo.lock at line 1910

[22.1077383]→[22.1077383:1077461](∅→∅)

checksum = "0e9ae34b84616eedaaf1e9dd6026dbe00dcafa92aa0c8077cb69df1fcfe5e53e"

[22.1077383]

[22.1077461]

checksum = "76cc616c6abf8c8928e2fdcc0dbfab37175edd8fb49a4641066ad1364fdab146"
replacement in Cargo.lock at line 1917

[22.1077536]→[22.1077536:1077555](∅→∅)

version = "1.0.22"

[22.1077536]

[22.1077555]

version = "1.0.23"
replacement in Cargo.lock at line 1919

[22.1077620]→[22.1077620:1077698](∅→∅)

checksum = "9ba20f23e85b10754cd195504aebf6a27e2e6cbe28c17778a0c930724628dd56"

[22.1077620]

[22.1077698]

checksum = "9be73a2caec27583d0046ef3796c3794f868a5bc813db689eed00c7631275cd1"
replacement in Cargo.lock at line 1978

[22.1078575]→[19.13457:13474](∅→∅)

"whoami 1.0.1",

[22.1078575]

[22.1078575]

"whoami 1.0.3",
replacement in Cargo.lock at line 2371

[22.893]→[19.14500:14518](∅→∅)

version = "1.0.1"

[22.893]

[22.911]

version = "1.0.3"
replacement in Cargo.lock at line 2373

[22.976]→[19.14519:14597](∅→∅)

checksum = "e35495e7faf4c657051a8e9725d9c37ac57879e915be3ed55bb401af84382035"

[22.976]

[22.1054]

checksum = "d595b2e146f36183d6a590b8d41568e2bc84c922267f43baf61c956330eeb436"