oknozor/pijul - Change CCLLB7OIFNFYJZTG3UCI7536TOCWSCSXR67VELSB466R24WLJSDAC

Upgrading to Sanakirja 0.15 + version bump

Created by pmeunier on December 31, 2020

CCLLB7OIFNFYJZTG3UCI7536TOCWSCSXR67VELSB466R24WLJSDAC

Dependencies

In channels

main

Change contents

Deletion in pijul-macros/src/lib.rs at line 36 [22.445]
B:BD[22.1411] → [22.1411:1434]
```
        #[doc(hidden)]
```

Insertion in pijul-macros/src/lib.rs at line 52 [22.445]

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

B:BD[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.445]

B:BD[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.445]

B:BD[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>> {

Insertion in pijul-macros/src/lib.rs at line 103 [22.445]

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

B:BD[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.445]

B:BD[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))
            }

Insertion in pijul-macros/src/lib.rs at line 133 [22.445]

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

B:BD[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>>;

Insertion in pijul-macros/src/lib.rs at line 157 [22.445]

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

B:BD[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>>;

Insertion in pijul-macros/src/lib.rs at line 234 [22.445]

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

B:BD[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.445]

B:BD[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>>

Deletion in pijul-macros/src/lib.rs at line 255 [22.445]
B:BD[22.8376] → [22.8376:8403]
```
            #[doc(hidden)]
```
Deletion in pijul-macros/src/lib.rs at line 256 [22.445]
B:BD[22.8434] → [22.8434:8461]
```
            #[doc(hidden)]
```

Replacement in pijul-macros/src/lib.rs at line 259 [22.445]

B:BD[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.445]

B:BD[22.8753] → [22.8753:8794]

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

[22.8753]

[22.8794]

            ) -> Result<Option<(#key, #value)>, TxnErr<Self::#error>>;

Deletion in pijul-macros/src/lib.rs at line 268 [22.445]
B:BD[22.8857] → [22.8857:8880]
```
        #[doc(hidden)]
```

Replacement in pijul-macros/src/lib.rs at line 272 [22.445]

B:BD[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>>;

Deletion in pijul-macros/src/lib.rs at line 281 [22.445]
B:BD[22.9257] → [22.9257:9284]
```
            #[doc(hidden)]
```
Deletion in pijul-macros/src/lib.rs at line 291 [22.445]
B:BD[22.9552] → [22.9552:9575]
```
        #[doc(hidden)]
```
Deletion in pijul-macros/src/lib.rs at line 372 [22.445]
B:BD[22.12226] → [22.12226:12253]
```
            #[doc(hidden)]
```

Replacement in pijul-macros/src/lib.rs at line 376 [22.445]

B:BD[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>> {

Deletion in pijul-macros/src/lib.rs at line 386 [22.445]
B:BD[22.12630] → [22.12630:12657]
```
            #[doc(hidden)]
```

Replacement in pijul-macros/src/lib.rs at line 390 [22.445]

B:BD[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.445]

B:BD[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))

Deletion in pijul-macros/src/lib.rs at line 409 [22.445]
B:BD[22.13310] → [22.13310:13337]
```
            #[doc(hidden)]
```

Replacement in pijul-macros/src/lib.rs at line 413 [22.445]

B:BD[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.445]

B:BD[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.445]

B:BD[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.445]
B:BD[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.445]
B:BD[22.13957] → [22.13957:13975]
```
                }
```
[22.13957]
[22.13975]
```
                })
```
Deletion in pijul-macros/src/lib.rs at line 435 [22.445]
B:BD[22.14029] → [22.14029:14056]
```
            #[doc(hidden)]
```
Deletion in pijul-macros/src/lib.rs at line 436 [22.445]
B:BD[22.14109] → [22.14109:14136]
```
            #[doc(hidden)]
```

Replacement in pijul-macros/src/lib.rs at line 440 [22.445]

B:BD[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.445]

B:BD[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.445]
B:BD[22.14617] → [22.14617:14635]
```
                }
```
[22.14617]
[22.14635]
```
                })
```
Deletion in pijul-macros/src/lib.rs at line 454 [22.445]
B:BD[22.14669] → [22.14669:14696]
```
            #[doc(hidden)]
```

Replacement in pijul-macros/src/lib.rs at line 457 [22.445]

B:BD[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)

Deletion in pijul-macros/src/lib.rs at line 465 [22.445]
B:BD[22.14956] → [22.14956:14983]
```
            #[doc(hidden)]
```

Replacement in pijul-macros/src/lib.rs at line 468 [22.445]

B:BD[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)

Insertion in pijul-macros/src/lib.rs at line 507 [22.445]

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

B:BD[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.445]

B:BD[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.445]

B:BD[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.445]

B:BD[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.445]

B:BD[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.445]

B:BD[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)),
                    }

Insertion in pijul-macros/src/lib.rs at line 578 [22.445]

[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())
    };

Deletion in pijul-macros/src/lib.rs at line 587 [22.445]
B:BD[22.18342] → [22.18342:18365]
```
        #[doc(hidden)]
```
Replacement in pijul-macros/src/lib.rs at line 591 [22.445]
B:BD[22.18449] → [23.0:40]
∅:D[23.40] → [22.18491:18514]
B:BD[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.445]
B:BD[22.18606] → [23.41:81]
```
        ) -> Result<bool, Self::Error>;
```
[22.18606]
[22.18648]
```
        ) -> Result<bool, TxnErr<Self::#error>>;
```

Insertion in pijul-macros/src/lib.rs at line 614 [22.445]

[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())
    };

Insertion in pijul-macros/src/lib.rs at line 624 [22.445]
[22.19583]
[22.19583]
Insertion in pijul-macros/src/lib.rs at line 626 [22.445]
[22.19625]
[22.19625]
Deletion in pijul-macros/src/lib.rs at line 629 [22.445]
B:BD[22.19700] → [22.19700:19727]
```
            #[doc(hidden)]
```

Replacement in pijul-macros/src/lib.rs at line 633 [22.445]

B:BD[22.19827] → [23.82:127]

∅:D[23.127] → [22.19874:19946]

B:BD[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)?)

Deletion in pijul-macros/src/lib.rs at line 636 [22.445]
B:BD[22.19960] → [22.19960:19987]
```
            #[doc(hidden)]
```

Replacement in pijul-macros/src/lib.rs at line 640 [22.445]

B:BD[22.20095] → [23.128:173]

∅:D[23.173] → [22.20142:20214]

B:BD[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)?)

Deletion in pijul-macros/src/lib.rs at line 646 [22.445]
B:BD[22.20299] → [22.20299:20326]
```
            #[doc(hidden)]
```

Replacement in pijul-macros/src/lib.rs at line 650 [22.445]

B:BD[22.20426] → [23.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.445]

B:BD[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)?)

Deletion in pijul-macros/src/lib.rs at line 655 [22.445]
B:BD[22.20629] → [22.20629:20656]
```
            #[doc(hidden)]
```

Replacement in pijul-macros/src/lib.rs at line 659 [22.445]

B:BD[22.20764] → [23.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.445]

B:BD[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.21011]
B:BD[22.21091] → [24.0:18]
```
version = "0.2.0"
```
[22.21091]
[22.21109]
```
version = "0.3.0"
```
Insertion in pijul/src/repository.rs at line 4 [22.21431]
[22.21541]
[25.0]
```
use anyhow::bail;
```
Replacement in pijul/src/repository.rs at line 8 [22.21431]
B:BD[25.40] → [25.40:81]
```
use crate::{config, current_dir, Error};
```
[25.40]
[25.81]
```
use crate::{config, current_dir};
```

Replacement in pijul/src/repository.rs at line 45 [22.21431]

B:BD[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.21431]

B:BD[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.21431]
B:BD[22.25296] → [22.25296:25342]
```
            Err(Error::AlreadyInARepo.into())
```
[22.25296]
[22.25342]
```
            bail!("Already in a repository")
```
Deletion in pijul/src/remote/ssh.rs at line 21 [22.25380]
B:BD[25.366] → [25.366:384]
```
use crate::Error;
```

Replacement in pijul/src/remote/ssh.rs at line 103 [22.25380]

B:BD[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.25380]

B:BD[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.25380]

B:BD[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.25380]

B:BD[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.25380]

B:BD[22.51779] → [26.460:515]

B:BD[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);

Deletion in pijul/src/remote/mod.rs at line 14 [22.52474]
B:BD[25.483] → [25.483:501]
```
use crate::Error;
```

Replacement in pijul/src/remote/mod.rs at line 75 [22.52474]

B:BD[22.54147] → [22.54147:54266]

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

[22.54147]

[27.395]

            bail!("Remote not found: {:?}", name)

Replacement in pijul/src/remote/mod.rs at line 106 [22.52474]

B:BD[27.960] → [27.960:1063]

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

[27.960]

[27.1063]

        bail!("Remote not found: {:?}", name)

Replacement in pijul/src/remote/mod.rs at line 181 [22.52474]

B:BD[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.52474]

B:BD[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.52474]

B:BD[22.58358] → [22.58358:58438]

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

[22.58358]

[27.1790]

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

Replacement in pijul/src/remote/mod.rs at line 272 [22.52474]

B:BD[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.52474]

B:BD[27.1981] → [27.1981:2110]

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

[27.1981]

[27.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.52474]

B:BD[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.52474]

B:BD[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.52474]

B:BD[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.52474]

B:BD[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.52474]

B:BD[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.52474]

B:BD[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.52474]

B:BD[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.52474]

B:BD[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.52474]

B:BD[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.52474]

B:BD[22.76925] → [26.856:899]

            if txn.is_alive(&channel, v) {

[22.76925]

[26.899]

            if txn.is_alive(&channel, v)? {

Replacement in pijul/src/remote/mod.rs at line 710 [22.52474]

B:BD[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.79745]

B:BD[25.535] → [28.4235:4308]

∅:D[28.4308] → [22.79831:79868]

B:BD[22.79831] → [22.79831:79868]

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

[25.535]

[25.536]

use libpijul::pristine::{Hash, Merkle, MutTxnT, Position, TxnT};
use libpijul::*;

Replacement in pijul/src/remote/local.rs at line 24 [22.79745]
B:BD[27.3106] → [27.3106:3135]
```
) -> Option<(u64, Merkle)> {
```
[27.3106]
[27.3135]
```
) -> Result<Option<(u64, Merkle)>, anyhow::Error> {
```

Replacement in pijul/src/remote/local.rs at line 26 [22.79745]

B:BD[27.3164] → [27.3164:3226]

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

[27.3164]

[27.3226]

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

Replacement in pijul/src/remote/local.rs at line 28 [22.79745]

B:BD[27.3239] → [27.3239:3347]

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

[27.3239]

[27.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.79745]

B:BD[22.80263] → [22.80263:80327]

B:BD[22.80327] → [27.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.79745]

B:BD[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.79745]

B:BD[28.4571] → [28.4571:4643]

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

[28.4571]

[28.4643]

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

Replacement in pijul/src/remote/local.rs at line 67 [22.79745]

B:BD[28.4729] → [28.4729:4919]

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

[28.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.79745]

∅:D[28.4961] → [22.81401:81477]

B:BD[22.81401] → [22.81401:81477]

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

[28.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.79745]

B:BD[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.79745]

B:BD[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()
                    })

Insertion in pijul/src/remote/http.rs at line 5 [30.10]
[29.1193]
[29.1193]
```
use anyhow::bail;
```

Replacement in pijul/src/remote/http.rs at line 44 [30.10]

∅:D[20.240] → [31.1063:1183]

B:BD[31.1063] → [31.1063:1183]

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

[20.240]

[31.1183]

            bail!("HTTP error {:?}", res.status())

Replacement in pijul/src/remote/http.rs at line 183 [30.10]

B:BD[28.5693] → [28.5693:5813]

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

[28.5693]

[28.5813]

            bail!("HTTP error {:?}", res.status())

Insertion in pijul/src/main.rs at line 10 [22.83981]
[25.603]
[32.0]
```
use anyhow::bail;
```
Deletion in pijul/src/main.rs at line 13 [22.83981]
B:BD[25.716] → [33.0:32]
B:BD[33.32] → [26.1637:1659]
```
use libpijul::pristine::Base32;
use thiserror::Error;
```

Deletion in pijul/src/main.rs at line 125 [22.83981]

∅:D[4.98] → [22.85867:86849]

B:BD[22.85867] → [22.85867:86849]

B:BD[22.86917] → [22.86917:87334]

B:BD[22.87413] → [22.87413:87666]

B:BD[22.87666] → [25.867:909]

∅:D[25.909] → [22.87719:87776]

B:BD[22.87719] → [22.87719:87776]

B:BD[22.87776] → [34.0:82]

∅:D[34.82] → [22.87776:88054]

B:BD[22.87776] → [22.87776:88054]

B:BD[35.93] → [33.33:133]

B:BD[33.133] → [26.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.83981]

B:BD[22.89714] → [25.910:959]

∅:D[25.959] → [22.89774:89851]

B:BD[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")
    }

Deletion in pijul/src/config.rs at line 1 [22.89866]
B:BD[22.89866] → [7.0:19]
```
use crate::Error;
```
Insertion in pijul/src/config.rs at line 3 [22.89866]
[22.89899]
[25.960]
```
use anyhow::bail;
```

Replacement in pijul/src/config.rs at line 42 [22.89866]

B:BD[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.89866]

B:BD[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.95630]
B:BD[36.59] → [37.900:960]
```
use libpijul::{Base32, MutTxnT, MutTxnTExt, TxnT, TxnTExt};
```
[36.59]
[25.1235]
```
use libpijul::*;
```

Replacement in pijul/src/commands/unrecord.rs at line 39 [22.95630]

B:BD[22.96409] → [33.246:314]

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

[22.96409]

[36.314]

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

Replacement in pijul/src/commands/unrecord.rs at line 63 [22.95630]

B:BD[37.2290] → [37.2290:2390]

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

[37.2290]

[37.2390]

                    .reverse_log(&channel.borrow(), None)?
                    .map(|h| (h.unwrap().1).0)

Replacement in pijul/src/commands/unrecord.rs at line 88 [22.95630]

B:BD[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.95630]

B:BD[22.96953] → [22.96953:97034]

B:BD[22.97034] → [36.487:551]

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

[22.96953]

[36.551]

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

Deletion in pijul/src/commands/reset.rs at line 10 [22.97650]
B:BD[25.1383] → [25.1383:1401]
```
use crate::Error;
```

Replacement in pijul/src/commands/reset.rs at line 41 [22.97650]

∅:D[18.108] → [22.98455:98538]

B:BD[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.97650]

B:BD[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.97650]

∅:D[34.934] → [22.99838:99917]

B:BD[22.99838] → [22.99838:99917]

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

[34.934]

[22.99917]

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

Replacement in pijul/src/commands/reset.rs at line 88 [22.97650]

B:BD[22.100440] → [22.100440:100509]

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

[22.100440]

[22.100509]

                        bail!("Cannot change channel, as there are unrecorded changes.")

Insertion in pijul/src/commands/record.rs at line 5 [22.101759]
[25.1486]
[38.25]
```
use anyhow::bail;
```
Deletion in pijul/src/commands/record.rs at line 17 [22.101759]
B:BD[25.1600] → [25.1600:1618]
```
use crate::Error;
```

Replacement in pijul/src/commands/record.rs at line 76 [22.101759]

B:BD[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.101759]
B:BD[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.101759]

B:BD[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.101759]

B:BD[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.101759]
B:BD[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.111631]
B:BD[22.111707] → [26.2331:2383]
```
use libpijul::{MutTxnT, MutTxnTExt, TxnT, TxnTExt};
```
[22.111707]
[25.1743]
```
use libpijul::*;
```

Replacement in pijul/src/commands/pushpull.rs at line 40 [22.111631]

B:BD[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.111631]

B:BD[28.7290] → [28.7290:7445]

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

[28.7290]

[28.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.111631]

B:BD[22.116268] → [22.116268:116338]

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

[22.116268]

[28.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.111631]

∅:D[28.7524] → [27.4561:4622]

B:BD[27.4561] → [27.4561:4622]

                if txn.remote_has_state(remote_changes, m) {

[28.7524]

[27.4622]

                if txn.remote_has_state(remote_changes, m)? {

Replacement in pijul/src/commands/pushpull.rs at line 178 [22.111631]

B:BD[27.4667] → [27.4667:4789]

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

[27.4667]

[28.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.111631]

B:BD[28.7686] → [28.7686:7768]

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

[28.7686]

[28.7768]

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

Replacement in pijul/src/commands/pushpull.rs at line 192 [22.111631]

B:BD[27.5132] → [27.5132:5206]

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

[27.5132]

[27.5206]

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

Replacement in pijul/src/commands/pushpull.rs at line 194 [22.111631]

B:BD[27.5258] → [27.5258:5404]

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

[27.5258]

[28.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.111631]

B:BD[28.8066] → [28.8066:8152]

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

[28.8066]

[28.8152]

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

Replacement in pijul/src/commands/pushpull.rs at line 309 [22.111631]

∅:D[28.8812] → [27.6267:6416]

B:BD[27.6267] → [27.6267:6416]

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

[28.8812]

[27.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.111631]

B:BD[27.6447] → [27.6447:6521]

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

[27.6447]

[27.6521]

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

Replacement in pijul/src/commands/pushpull.rs at line 325 [22.111631]

B:BD[28.9108] → [28.9108:9305]

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

[28.9108]

[28.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.111631]

B:BD[28.9407] → [28.9407:9472]

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

[28.9407]

[28.9472]

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

Replacement in pijul/src/commands/pushpull.rs at line 334 [22.111631]

∅:D[28.9525] → [27.7112:7193]

B:BD[27.7112] → [27.7112:7193]

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

[28.9525]

[27.7193]

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

Replacement in pijul/src/commands/pushpull.rs at line 336 [22.111631]

B:BD[27.7259] → [27.7259:7403]

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

[27.7259]

[27.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.111631]

B:BD[27.7464] → [27.7464:7530]

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

[27.7464]

[27.7530]

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

Replacement in pijul/src/commands/pushpull.rs at line 343 [22.111631]

B:BD[27.7561] → [27.7561:7644]

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

[27.7561]

[27.7644]

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

Replacement in pijul/src/commands/pushpull.rs at line 348 [22.111631]

B:BD[28.9641] → [28.9641:9733]

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

[28.9641]

[28.9733]

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

Replacement in pijul/src/commands/pushpull.rs at line 436 [22.111631]

B:BD[28.10482] → [28.10482:10557]

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

[28.10482]

[28.10557]

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

Replacement in pijul/src/commands/pushpull.rs at line 488 [22.111631]

B:BD[15.350] → [15.350:401]

                if txn.remote_has_change(rem, d) {

[15.350]

[15.401]

                if txn.remote_has_change(rem, d)? {

Insertion in pijul/src/commands/protocol.rs at line 6 [22.123281]
[25.1914]
[22.123335]
```
use crate::repository::Repository;
use anyhow::bail;
```
Replacement in pijul/src/commands/protocol.rs at line 11 [22.123281]
B:BD[25.1961] → [26.3000:3078]
```
use libpijul::{Base32, ChannelRef, Hash, MutTxnT, MutTxnTExt, TxnT, TxnTExt};
```
[25.1961]
[25.1962]
```
use libpijul::*;
```
Deletion in pijul/src/commands/protocol.rs at line 15 [22.123281]
B:BD[25.1989] → [25.1989:2042]
∅:D[25.2042] → [22.123610:123611]
B:BD[22.123610] → [22.123610:123611]
```
use crate::repository::Repository;
use crate::Error;
```

Replacement in pijul/src/commands/protocol.rs at line 38 [22.123281]

B:BD[22.124435] → [26.3079:3165]

∅:D[26.3165] → [22.124518:124564]

B:BD[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.123281]
B:BD[22.124591] → [39.837:872]
∅:D[39.872] → [22.124627:124677]
B:BD[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.123281]

B:BD[22.125737] → [22.125737:125810]

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

[22.125737]

[39.922]

                    for x in txn.log(&channel.borrow(), pos)? {
                        let (n, (_, m)) = x?;

Replacement in pijul/src/commands/protocol.rs at line 86 [22.123281]

B:BD[22.126196] → [39.1415:1515]

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

[22.126196]

[39.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.123281]

B:BD[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.123281]

B:BD[22.127257] → [28.11485:11554]

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

[22.127257]

[28.11554]

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

Replacement in pijul/src/commands/protocol.rs at line 108 [22.123281]

B:BD[28.11666] → [28.11666:11881]

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

[28.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.123281]

B:BD[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.123281]

∅:D[28.11929] → [22.127543:127675]

B:BD[22.127543] → [22.127543:127675]

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

[28.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.123281]

B:BD[28.11980] → [28.11980:12078]

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

[28.11980]

[28.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.123281]

B:BD[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.123281]

B:BD[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.123281]

B:BD[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.123281]

B:BD[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.133619]
B:BD[36.2244] → [36.2244:2283]
```
        .map(|rec| rec.globalize(txn))
```
[36.2244]
[36.2283]
```
        .map(|rec| rec.globalize(txn).unwrap())
```
Replacement in pijul/src/commands/mod.rs at line 89 [22.133619]
B:BD[36.2516] → [36.2516:2523]
```
    );
```
[36.2516]
[36.2523]
```
    )?;
```

Replacement in pijul/src/commands/mod.rs at line 91 [22.133619]

B:BD[36.2561] → [36.2561:2646]

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

[36.2561]

[36.2646]

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

Insertion in pijul/src/commands/log.rs at line 4 [22.134376]
[25.2088]
[25.2088]
```
use anyhow::bail;
```
Deletion in pijul/src/commands/log.rs at line 10 [22.134376]
B:BD[25.2141] → [25.2141:2159]
```
use crate::Error;
```

Replacement in pijul/src/commands/log.rs at line 35 [22.134376]

B:BD[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.134376]

B:BD[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.134376]

B:BD[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.134376]

B:BD[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.167873]

B:BD[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.169058]

B:BD[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.169058]

B:BD[40.891] → [40.891:939]

                if !txn.is_tracked(&path_str) {

[40.891]

[17.660]

                if !txn.is_tracked(&path_str)? {

Replacement in pijul/src/commands/file_operations.rs at line 184 [22.169058]
B:BD[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.173551]
B:BD[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.173551]
B:BD[22.175484] → [22.175484:175495]
```
        );
```
[22.175484]
[22.175495]
```
        )?;
```
Replacement in pijul/src/commands/diff.rs at line 83 [22.173551]
B:BD[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.173551]

B:BD[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.177758]
B:BD[22.177794] → [22.177794:177812]
```
use crate::Error;
```
[22.177794]
[41.0]
```
use anyhow::bail;
```

Replacement in pijul/src/commands/debug.rs at line 26 [22.177758]

B:BD[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.177758]

B:BD[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.177758]
B:BD[42.264] → [42.264:299]
```
                &channel.borrow(),
```
[42.264]
[42.299]
```
                &channel.borrow().graph,
```

Replacement in pijul/src/commands/debug.rs at line 44 [22.177758]

B:BD[43.102] → [43.102:177]

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

[43.102]

[43.177]

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

Replacement in pijul/src/commands/debug.rs at line 46 [22.177758]

B:BD[43.187] → [43.187:269]

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

[43.187]

[19.0]

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

Insertion in pijul/src/commands/credit.rs at line 4 [22.178684]
[25.2811]
[18.690]
```
use anyhow::bail;
```
Replacement in pijul/src/commands/credit.rs at line 8 [22.178684]
B:BD[22.178851] → [26.5891:5960]
```
use libpijul::{ChangeId, Channel, EdgeFlags, TxnT, TxnTExt, Vertex};
```
[22.178851]
[25.2828]
```
use libpijul::*;
```
Deletion in pijul/src/commands/credit.rs at line 12 [22.178684]
B:BD[25.2880] → [25.2880:2898]
```
use crate::Error;
```

Replacement in pijul/src/commands/credit.rs at line 31 [22.178684]

B:BD[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.178684]

B:BD[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.178684]
B:BD[22.180479] → [26.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.178684]

B:BD[22.180661] → [26.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> {

Deletion in pijul/src/commands/credit.rs at line 99 [22.178684]
B:BD[22.181319] → [26.6160:6190]
```
        use libpijul::Base32;
```
Replacement in pijul/src/commands/credit.rs at line 104 [22.178684]
B:BD[22.181558] → [44.0:56]
```
                .filter(|e| !e.introduced_by.is_root())
```
[22.181558]
[22.181558]
```
                .unwrap()
```

Insertion in pijul/src/commands/credit.rs at line 106 [22.178684]

[22.181572]

                let e = e.unwrap();
                if e.introduced_by.is_root() {
                    continue;
                }

Insertion in pijul/src/commands/clone.rs at line 4 [22.182891]
[25.2925]
[25.2925]
```
use crate::repository::*;
use anyhow::bail;
```
Deletion in pijul/src/commands/clone.rs at line 10 [22.182891]
B:BD[22.183024] → [25.2959:2986]
```
use crate::repository::*;
```

Replacement in pijul/src/commands/clone.rs at line 57 [22.182891]

B:BD[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)

Insertion in pijul/src/commands/channel.rs at line 6 [22.186892]
[11.20]
[32.147]
```
use anyhow::bail;
```

Replacement in pijul/src/commands/channel.rs at line 42 [22.186892]

B:BD[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.186892]

B:BD[34.1311] → [26.6297:6378]

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

[34.1311]

[34.1391]

                    bail!("Cannot delete current channel")

Replacement in pijul/src/commands/channel.rs at line 83 [22.186892]

B:BD[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.186892]

B:BD[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.186892]

B:BD[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 [22.189306]

B:BD[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 [22.189306]

B:BD[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.191083]

B:BD[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.191083]

B:BD[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.194289]

B:BD[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.196374]
B:BD[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.196374]

B:BD[22.197438] → [22.197438:197456]

B:BD[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.196374]
B:BD[22.197874] → [45.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.208900]
∅:D[46.398] → [23.3775:3824]
B:BD[22.210434] → [23.3775:3824]
```
    ) -> Result<(), Error<C::Error, T::Error>> {
```
[46.398]
[22.210471]
```
    ) -> Result<(), Error<C::Error, T::GraphError>> {
```
Replacement in libpijul/src/working_copy/filesystem.rs at line 140 [22.208900]
∅:D[46.875] → [23.3825:3867]
B:BD[40.1792] → [23.3825:3867]
```
    ) -> Result<(), AddError<T::Error>> {
```
[46.875]
[40.1829]
```
    ) -> Result<(), AddError<T::GraphError>> {
```

Replacement in libpijul/src/working_copy/filesystem.rs at line 149 [22.208900]

∅:D[38.1902] → [46.984:1063]

B:BD[46.984] → [46.984:1063]

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

[38.1902]

[46.1063]

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

Replacement in libpijul/src/working_copy/filesystem.rs at line 219 [22.208900]
∅:D[46.3130] → [23.3868:3917]
B:BD[22.211282] → [23.3868:3917]
```
    ) -> Result<(), Error<C::Error, T::Error>> {
```
[46.3130]
[38.2643]
```
    ) -> Result<(), Error<C::Error, T::GraphError>> {
```
Replacement in libpijul/src/unrecord/working_copy.rs at line 6 [22.225940]
∅:D[47.1] → [22.226152:226191]
B:BD[22.226152] → [22.226152:226191]
```
pub fn undo_file_addition<T: MutTxnT>(
```
[47.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.225940]
B:BD[22.226275] → [23.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.225940]

B:BD[22.226458] → [22.226458:226518]

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

[22.226458]

[41.353]

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

Replacement in libpijul/src/unrecord/working_copy.rs at line 25 [22.225940]

∅:D[47.3] → [22.226729:226784]

B:BD[22.226729] → [22.226729:226784]

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

[47.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.225940]
B:BD[22.226907] → [23.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.225940]

B:BD[22.227037] → [26.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.225940]

∅:D[47.5] → [22.227428:227468]

B:BD[22.227428] → [22.227428:227468]

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

[47.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.225940]
B:BD[22.227588] → [23.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.225940]

B:BD[22.227921] → [26.6697:6740]

        let source_parent = iter_adjacent(

[22.227921]

[26.6740]

        let mut source_parent = None;
        for e in iter_adjacent(

Replacement in libpijul/src/unrecord/working_copy.rs at line 66 [22.225940]
B:BD[26.6757] → [26.6757:6779]
```
            &channel,
```
[26.6757]
[26.6779]
```
            &channel.graph,
```

Replacement in libpijul/src/unrecord/working_copy.rs at line 70 [22.225940]

B:BD[26.6880] → [26.6880:6890]

B:BD[26.6890] → [39.1769:1843]

∅:D[39.1843] → [26.6982:7015]

B:BD[26.6982] → [26.6982:7015]

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

[26.6880]

[47.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.225940]

∅:D[23.6928] → [22.228471:228548]

B:BD[22.228471] → [22.228471:228548]

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

[23.6928]

[23.6929]

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

Replacement in libpijul/src/unrecord/working_copy.rs at line 92 [22.225940]

∅:D[47.9] → [22.228923:228969]

B:BD[22.228923] → [22.228923:228969]

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

[47.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.225940]
B:BD[22.229088] → [23.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.225940]

B:BD[23.7110] → [23.7110:7177]

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

[23.7110]

[23.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.225940]
B:BD[22.229428] → [47.10:67]
```
    if let Some(inode) = txn.get_revinodes(dest, None) {
```
[22.229428]
[47.67]
```
    if let Some(inode) = txn.get_revinodes(dest, None)? {
```

Replacement in libpijul/src/unrecord/working_copy.rs at line 114 [22.225940]

B:BD[47.98] → [47.98:152]

B:BD[47.152] → [23.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)?;

[47.98]

[47.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.225940]
∅:D[47.364] → [22.229677:229711]
B:BD[22.229677] → [22.229677:229711]
```
fn find_youngest_parent<T: TxnT>(
```
[47.364]
[22.229711]
```
fn find_youngest_parent<T: ChannelTxnT>(
```
Replacement in libpijul/src/unrecord/working_copy.rs at line 125 [22.225940]
B:BD[22.229781] → [23.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.225940]
B:BD[26.7057] → [26.7057:7074]
```
        channel,
```
[26.7057]
[26.7074]
```
        &channel.graph,
```

Replacement in libpijul/src/unrecord/working_copy.rs at line 133 [22.225940]

B:BD[26.7225] → [26.7225:7303]

∅:D[26.7303] → [22.230163:230169]

B:BD[22.230163] → [22.230163:230169]

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

[26.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.225940]

B:BD[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.225940]
B:BD[22.230687] → [26.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.225940]

B:BD[22.230739] → [23.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.225940]
B:BD[22.230916] → [23.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.225940]

∅:D[26.7432] → [22.231227:231296]

B:BD[22.231227] → [22.231227:231296]

B:BD[22.231296] → [23.7578:7673]

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

[26.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.231493]
B:BD[23.7965] → [23.7965:8013]
```
    Block(#[from] crate::pristine::BlockError),
```
[23.7965]
[23.8013]
```
    Block(#[from] crate::pristine::BlockError<TxnError>),
```

Replacement in libpijul/src/unrecord/mod.rs at line 23 [22.231493]

B:BD[23.8039] → [23.8039:8108]

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

[23.8039]

[23.8108]

    InconsistentChange(#[from] crate::pristine::InconsistentChange<TxnError>),

Insertion in libpijul/src/unrecord/mod.rs at line 34 [22.231493]

[23.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.231493]
B:BD[22.231881] → [23.8615:8670]
```
) -> Result<bool, UnrecordError<P::Error, T::Error>> {
```
[22.231881]
[23.8670]
```
) -> Result<bool, UnrecordError<P::Error, T::GraphError>> {
```
Replacement in libpijul/src/unrecord/mod.rs at line 53 [22.231493]
∅:D[23.8768] → [22.231960:232023]
B:BD[22.231960] → [22.231960:232023]
```
    let change_id = if let Some(h) = txn.get_internal(*hash) {
```
[23.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.231493]

B:BD[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.231493]

B:BD[22.232331] → [22.232331:232391]

B:BD[22.232391] → [23.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.231493]

B:BD[22.232570] → [22.232570:232625]

B:BD[22.232625] → [23.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.231493]

B:BD[23.9161] → [23.9161:9213]

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

[23.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.231493]

B:BD[22.232905] → [23.9214:9267]

∅:D[23.9267] → [22.232938:233031]

B:BD[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.231493]

B:BD[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.231493]

B:BD[22.233292] → [22.233292:233360]

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

[22.233292]

[23.9344]

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

Replacement in libpijul/src/unrecord/mod.rs at line 106 [22.231493]

B:BD[22.233453] → [23.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.231493]
B:BD[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.231493]
B:BD[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.231493]

B:BD[22.233799] → [39.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.231493]
B:BD[22.233971] → [22.233971:233980]
```
    true
```
[22.233971]
[22.233980]
```
    Ok(true)
```
Replacement in libpijul/src/unrecord/mod.rs at line 126 [22.231493]
∅:D[23.9514] → [22.234037:234077]
B:BD[22.234037] → [22.234037:234077]
```
fn unapply<T: MutTxnT, C: ChangeStore>(
```
[23.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.231493]
B:BD[22.234187] → [23.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.231493]

B:BD[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.231493]
B:BD[22.234733] → [22.234733:234766]
```
                        channel,
```
[22.234733]
[26.7433]
```
                        &mut channel.graph,
```

Replacement in libpijul/src/unrecord/mod.rs at line 154 [22.231493]

B:BD[26.7506] → [23.9569:9642]

                    )
                    .map_err(UnrecordError::Txn)?;

[26.7506]

[22.234862]

)?

Replacement in libpijul/src/unrecord/mod.rs at line 156 [22.231493]

B:BD[22.234880] → [23.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.231493]

B:BD[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.231493]

B:BD[39.2017] → [21.115:189]

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

[39.2017]

[39.2074]

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

Replacement in libpijul/src/unrecord/mod.rs at line 167 [22.231493]
B:BD[39.2154] → [39.2154:2179]
```
                channel,
```
[39.2154]
[39.2179]
```
                &mut channel.graph,
```

Replacement in libpijul/src/unrecord/mod.rs at line 188 [22.231493]

B:BD[48.958] → [48.958:1086]

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

[48.958]

[48.1086]

                working_copy::undo_file_addition(txn, change_id, new_vertex)?;

Replacement in libpijul/src/unrecord/mod.rs at line 194 [22.231493]

B:BD[48.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)?;

[48.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.231493]
B:BD[22.236205] → [23.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.231493]
B:BD[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.231493]
B:BD[22.236377] → [23.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.231493]

B:BD[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 [22.231493]
B:BD[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 [22.231493]
B:BD[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 [22.231493]

B:BD[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.231493]
B:BD[26.8203] → [23.9967:10024]
```
            )
            .map_err(UnrecordError::Txn)?;
```
[26.8203]
[22.238504]
```
            )?;
```
Replacement in libpijul/src/unrecord/mod.rs at line 281 [22.231493]
B:BD[22.238934] → [23.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.231493]
B:BD[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 [22.231493]
∅:D[21.1508] → [23.10184:10237]
B:BD[22.239047] → [23.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.231493]
B:BD[22.239152] → [26.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.231493]
B:BD[22.239740] → [22.239740:239752]
```
        ) {
```
[22.239740]
[26.8316]
```
        )? {
            let parent = parent?;
```

Replacement in libpijul/src/unrecord/mod.rs at line 312 [22.231493]

B:BD[26.8385] → [26.8385:8434]

            if !is_alive(txn, channel, parent) {

[26.8385]

[21.1553]

            if !is_alive(txn, channel, parent)? {

Replacement in libpijul/src/unrecord/mod.rs at line 332 [22.231493]
∅:D[23.10239] → [22.240360:240406]
B:BD[22.240360] → [22.240360:240406]
```
fn unapply_edges<T: MutTxnT, P: ChangeStore>(
```
[23.10239]
[22.240406]
```
fn unapply_edges<T: GraphMutTxnT, P: ChangeStore>(
```
Replacement in libpijul/src/unrecord/mod.rs at line 335 [22.231493]
B:BD[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.231493]
B:BD[22.240557] → [23.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.231493]
B:BD[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.231493]

B:BD[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.231493]
B:BD[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.231493]
B:BD[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 [22.231493]
∅:D[21.1958] → [23.10378:10444]
B:BD[22.242168] → [23.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.231493]
B:BD[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.231493]

B:BD[22.242478] → [21.1959:2185]

∅:D[21.2185] → [26.8706:8715]

B:BD[26.8706] → [26.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;
        }

Deletion in libpijul/src/unrecord/mod.rs at line 396 [22.231493]
B:BD[22.243261] → [23.10445:10501]
```
        .map_err(crate::apply::ApplyError::Changestore)
```
Replacement in libpijul/src/unrecord/mod.rs at line 398 [22.231493]
B:BD[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.231493]
B:BD[22.243431] → [23.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.231493]

B:BD[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.231493]

B:BD[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.231493]
B:BD[22.243938] → [23.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.231493]
B:BD[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.231493]
B:BD[22.244079] → [23.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 [22.231493]

B:BD[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.231493]

B:BD[26.9860] → [23.10829:10960]

                del_graph_with_rev(txn, channel, e.flag, v, w, e.introduced_by)
                    .map_err(UnrecordError::Txn)?;

[26.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.231493]

B:BD[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 [22.231493]
B:BD[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 [22.231493]

B:BD[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 [22.231493]
∅:D[21.3886] → [22.246861:246914]
B:BD[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.231493]
B:BD[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.231493]

B:BD[22.247082] → [23.10961:11014]

∅:D[23.11014] → [22.247115:247175]

B:BD[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.231493]

B:BD[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.231493]
B:BD[26.10222] → [26.10222:10267]
```
            if !is_alive(txn, channel, to) {
```
[26.10222]
[22.248246]
```
            if !is_alive(txn, channel, to)? {
```
Replacement in libpijul/src/tests/unrecord.rs at line 128 [22.248807]
B:BD[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.248807]
B:BD[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.248807]

B:BD[22.258535] → [26.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.248807]

B:BD[22.261132] → [26.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.248807]
B:BD[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.248807]
B:BD[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.248807]
B:BD[47.1754] → [47.1754:1794]
```
    let mut inodes = txn.iter_inodes();
```
[47.1754]
[47.1794]
```
    let mut inodes = txn.iter_inodes().unwrap();
```

Replacement in libpijul/src/tests/performance.rs at line 53 [22.278146]

B:BD[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.278146]

B:BD[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.278146]

B:BD[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.285224]

B:BD[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.289338]

B:BD[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.289338]
B:BD[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.289338]
B:BD[22.290724] → [22.290724:290731]
```
    );
```
[22.290724]
[22.290731]
```
    )
    .unwrap();
```

Replacement in libpijul/src/tests/file_conflicts.rs at line 569 [22.305506]

B:BD[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.305506]

B:BD[22.352588] → [26.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.357372]
B:BD[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.357372]

B:BD[26.30412] → [26.30412:30476]

    let (alive_, reachable_) = check_alive(&txn, &channel_bob);

[26.30412]

[22.433556]

    let (alive_, reachable_) = check_alive(&txn, &channel_bob.borrow().graph);

Replacement in libpijul/src/tests/conflict.rs at line 2352 [22.357372]

B:BD[26.30539] → [26.30539:30601]

    let (alive, reachable) = check_alive(&txn, &channel_bob);

[26.30539]

[22.434046]

    let (alive, reachable) = check_alive(&txn, &channel_bob.borrow().graph);

Replacement in libpijul/src/tests/conflict.rs at line 2369 [22.357372]

B:BD[26.30671] → [26.30671:30737]

    let (alive, reachable) = check_alive(&txn, &channel_charlie);

[26.30671]

[22.434801]

    let (alive, reachable) = check_alive(&txn, &channel_charlie.borrow().graph);

Replacement in libpijul/src/tests/conflict.rs at line 2386 [22.357372]

B:BD[22.435224] → [26.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.357372]

B:BD[22.437747] → [26.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.357372]

B:BD[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.357372]

B:BD[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.357372]

B:BD[22.440857] → [26.31289:31350]

        if !is_alive(txn, &channel, vertex.inode_vertex()) {

[22.440857]

[26.31350]

        if !is_alive(txn, &channel.graph, vertex.inode_vertex()).unwrap() {

Replacement in libpijul/src/tests/conflict.rs at line 2565 [22.357372]
∅:D[26.31407] → [22.440957:440983]
B:BD[22.440957] → [22.440957:440983]
```
                &channel,
```
[26.31407]
[22.440983]
```
                &channel.graph,
```
Replacement in libpijul/src/tests/conflict.rs at line 2569 [22.357372]
B:BD[22.441092] → [22.441092:441108]
```
            ) {
```
[22.441092]
[22.441108]
```
            )
            .unwrap()
            {
```

Replacement in libpijul/src/tests/clone.rs at line 37 [22.441393]

B:BD[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.446445]
B:BD[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.446445]
B:BD[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.446445]
B:BD[22.448681] → [22.448681:448688]
```
    );
```
[22.448681]
[22.448688]
```
    )
    .unwrap();
```

Replacement in libpijul/src/tests/change.rs at line 96 [22.446445]

B:BD[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.446445]
B:BD[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.446445]
B:BD[22.449926] → [22.449926:449933]
```
    );
```
[22.449926]
[22.449933]
```
    )
    .unwrap();
```
Replacement in libpijul/src/tests/add_file.rs at line 29 [22.454125]
B:BD[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.454125]

B:BD[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.454125]

B:BD[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.454125]

B:BD[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.454125]
B:BD[22.455890] → [22.455890:455902]
```
        });
```
[22.455890]
[26.31734]
```
        })
        .unwrap();
```

Replacement in libpijul/src/tests/add_file.rs at line 54 [22.454125]

B:BD[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.454125]
B:BD[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.454125]

B:BD[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());

Insertion in libpijul/src/tests/add_file.rs at line 80 [22.454125]
[22.456823]
[22.456823]
```
        .unwrap()
```
Insertion in libpijul/src/tests/add_file.rs at line 82 [22.454125]
[22.456839]
[22.456839]
```
        .unwrap()
```
Replacement in libpijul/src/tests/add_file.rs at line 85 [22.454125]
B:BD[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.454125]

∅:D[26.31831] → [22.457003:457107]

B:BD[22.457003] → [22.457003:457107]

    let mut it = crate::fs::working_copy_children(&txn, inode);
    let (name, _) = it.next().unwrap();

[26.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.454125]
B:BD[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.454125]
B:BD[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.454125]
B:BD[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.454125]

B:BD[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.454125]
B:BD[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.454125]
B:BD[29.3597] → [29.3597:3628]
```
        .map(|(_, file)| file)
```
[29.3597]
[29.3628]
```
        .map(|f| f.unwrap().1)
```
Replacement in libpijul/src/tests/add_file.rs at line 186 [22.454125]
B:BD[29.4203] → [29.4203:4234]
```
        .map(|(_, name)| name)
```
[29.4203]
[29.4234]
```
        .map(|n| n.unwrap().1)
```
Replacement in libpijul/src/tests/add_file.rs at line 673 [22.454125]
B:BD[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.454125]
B:BD[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.454125]
B:BD[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.454125]
B:BD[22.476345] → [22.476345:476352]
```
    );
```
[22.476345]
[22.476352]
```
    )
    .unwrap();
```

Replacement in libpijul/src/tests/add_file.rs at line 720 [22.454125]

B:BD[22.476642] → [26.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.454125]
B:BD[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.454125]
B:BD[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.488880]
B:BD[23.11461] → [23.11461:11499]
```
    Diff(#[from] diff::DiffError<C>),
```
[23.11461]
[23.11499]
```
    Diff(#[from] diff::DiffError<C, T>),
```

Insertion in libpijul/src/record.rs at line 35 [22.488880]

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

B:BD[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.488880]

B:BD[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.488880]
B:BD[22.492511] → [22.492511:492536]
```
            Some(vertex)
```
[22.492511]
[22.492536]
```
            Ok(Some(vertex))
```
Replacement in libpijul/src/record.rs at line 162 [22.488880]
B:BD[22.492553] → [22.492553:492570]
```
            None
```
[22.492553]
[22.492570]
```
            Ok(None)
```
Replacement in libpijul/src/record.rs at line 165 [22.488880]
B:BD[22.492593] → [22.492593:492606]
```
        None
```
[22.492593]
[22.492606]
```
        Ok(None)
```

Replacement in libpijul/src/record.rs at line 170 [22.488880]

B:BD[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.488880]
B:BD[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.488880]

B:BD[22.492891] → [23.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,
    {

Deletion in libpijul/src/record.rs at line 184 [22.488880]
B:BD[22.492973] → [22.492973:493013]
```
        let channel = channel.borrow();
```
Replacement in libpijul/src/record.rs at line 196 [22.488880]
B:BD[22.493559] → [22.493559:493589]
```
                    &channel,
```
[22.493559]
[22.493589]
```
                    &channel.graph,
```
Replacement in libpijul/src/record.rs at line 200 [22.488880]
B:BD[22.493696] → [22.493696:493715]
```
                );
```
[22.493696]
[22.493715]
```
                )?;
```

Replacement in libpijul/src/record.rs at line 202 [22.488880]

B:BD[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.488880]

B:BD[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.488880]

B:BD[22.499681] → [23.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.488880]

B:BD[22.500045] → [26.33988:34069]

∅:D[26.34069] → [22.500138:500208]

B:BD[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.488880]

B:BD[22.500452] → [26.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.488880]

B:BD[23.11892] → [23.11892:11969]

                .get_contents(|p| txn.get_external(p), name_dest, &mut name)

[23.11892]

[23.11969]

                .get_contents(|p| txn.get_external(p).unwrap(), name_dest, &mut name)

Replacement in libpijul/src/record.rs at line 379 [22.488880]

B:BD[22.500926] → [26.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.488880]

B:BD[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.488880]
B:BD[22.502086] → [22.502086:502116]
```
                    &channel,
```
[22.502086]
[22.502116]
```
                    &channel.graph,
```

Replacement in libpijul/src/record.rs at line 412 [22.488880]

B:BD[22.502254] → [23.12023:12093]

                )
                .map_err(RecordError::Changestore)?

[22.502254]

[22.502273]

)?

Replacement in libpijul/src/record.rs at line 418 [22.488880]

B:BD[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.488880]

B:BD[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.488880]

B:BD[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.488880]
B:BD[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.488880]
B:BD[22.503546] → [22.503546:503554]
```
    ) {
```
[22.503546]
[22.503554]
```
    ) -> Result<(), TxnErr<T::GraphError>> {
```

Replacement in libpijul/src/record.rs at line 462 [22.488880]

B:BD[22.503681] → [26.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.488880]

B:BD[22.503959] → [22.503959:504146]

B:BD[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 [22.488880]

B:BD[5.205] → [5.205:227]

∅:D[5.227] → [22.504205:504274]

B:BD[22.504205] → [22.504205:504274]

[5.205]

[22.504274]

};

Replacement in libpijul/src/record.rs at line 487 [22.488880]
B:BD[22.504576] → [22.504576:504598]
```
                    )
```
[22.504576]
[22.504598]
```
                    )?
```
Insertion in libpijul/src/record.rs at line 491 [22.488880]
[22.504640]
[22.504640]
```
        Ok(())
```

Replacement in libpijul/src/record.rs at line 494 [22.488880]

B:BD[22.504647] → [23.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.488880]

B:BD[22.504935] → [23.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.488880]

B:BD[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.488880]

B:BD[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.488880]
B:BD[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.488880]

B:BD[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.488880]
B:BD[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.488880]

B:BD[22.507905] → [23.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.488880]
B:BD[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.488880]
B:BD[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.488880]
B:BD[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.488880]

B:BD[22.511024] → [23.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.488880]

B:BD[26.34642] → [26.34642:34720]

∅:D[26.34720] → [22.511660:511666]

B:BD[22.511660] → [22.511660:511666]

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

[26.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.488880]

B:BD[22.512793] → [26.34721:34800]

∅:D[26.34800] → [22.512871:512960]

B:BD[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.488880]

B:BD[26.34987] → [26.34987:35154]

        )
        .filter(|e| {
            e.flag.contains(EdgeFlags::FOLDER | EdgeFlags::PARENT)
                && !e.flag.contains(EdgeFlags::PSEUDO)
        }) {

[26.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.488880]

B:BD[22.513816] → [26.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.488880]

B:BD[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.488880]
B:BD[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.488880]
B:BD[22.518555] → [22.518555:518563]
```
    ) {
```
[22.518555]
[22.518563]
```
    ) -> Result<(), TxnErr<T::GraphError>> {
```

Replacement in libpijul/src/record.rs at line 880 [22.488880]

B:BD[22.518868] → [26.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.488880]

B:BD[22.519190] → [22.519190:519257]

                self.delete_file_edge(txn, channel, vertex, inode)

[22.519190]

[39.3339]

                self.delete_file_edge(txn, channel, vertex, inode)?

Replacement in libpijul/src/record.rs at line 896 [22.488880]

B:BD[39.3605] → [39.3605:3688]

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

[39.3605]

[39.3688]

                if let Some(inode) = txn.get_revinodes(vertex.start_pos(), None)? {

Replacement in libpijul/src/record.rs at line 907 [22.488880]

B:BD[22.520253] → [39.4120:4214]

                self.delete_inode_vertex(txn, channel, vertex, vertex.start_pos(), full_path)

[22.520253]

                self.delete_inode_vertex(txn, channel, vertex, vertex.start_pos(), full_path)?

Replacement in libpijul/src/record.rs at line 917 [22.488880]
B:BD[22.520514] → [22.520514:520530]
```
            ) {
```
[22.520514]
[22.520530]
```
            )? {
                let edge = edge?;
```

Replacement in libpijul/src/record.rs at line 921 [22.488880]

B:BD[26.35407] → [26.35407:35507]

                    find_block(txn, &channel, edge.dest).expect("delete_recursively, descendants");

[26.35407]

[22.520742]

                    find_block(txn, channel, edge.dest).expect("delete_recursively, descendants");

Insertion in libpijul/src/record.rs at line 936 [22.488880]
[22.521259]
[22.521259]
```
        Ok(())
```
Replacement in libpijul/src/record.rs at line 939 [22.488880]
B:BD[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.488880]
B:BD[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.488880]
B:BD[22.521458] → [22.521458:521466]
```
    ) {
```
[22.521458]
[22.521466]
```
    ) -> Result<(), TxnErr<T::GraphError>> {
```

Replacement in libpijul/src/record.rs at line 954 [22.488880]

B:BD[26.35684] → [26.35684:35822]

        )
        .filter(|e| e.flag.contains(EdgeFlags::PARENT))
        {
            assert!(parent.flag.contains(EdgeFlags::PARENT));

[26.35684]

[26.35822]

        )? {
            let parent = parent?;
            if !parent.flag.contains(EdgeFlags::PARENT) {
                continue;
            }

Replacement in libpijul/src/record.rs at line 960 [22.488880]

B:BD[26.35884] → [26.35884:35967]

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

[26.35884]

[26.35967]

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

Replacement in libpijul/src/record.rs at line 967 [22.488880]

B:BD[22.521694] → [22.521694:521708]

B:BD[22.521708] → [26.36065:36164]

∅:D[26.36164] → [22.522371:522385]

B:BD[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;
                }

Insertion in libpijul/src/record.rs at line 1005 [22.488880]
[22.523734]
[22.523734]
```
        Ok(())
```
Replacement in libpijul/src/record.rs at line 1008 [22.488880]
B:BD[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.488880]
B:BD[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.488880]
B:BD[22.523906] → [22.523906:523914]
```
    ) {
```
[22.523906]
[22.523914]
```
    ) -> Result<(), TxnErr<T::GraphError>> {
```

Replacement in libpijul/src/record.rs at line 1032 [22.488880]

B:BD[26.36386] → [26.36386:36469]

∅:D[26.36469] → [22.524640:524658]

B:BD[22.524640] → [22.524640:524658]

                )
                .filter(|e| !e.flag.contains(EdgeFlags::PSEUDO))
                {

[26.36386]

[22.524658]

                )? {
                    let parent = parent?;
                    if parent.flag.contains(EdgeFlags::PSEUDO) {
                        continue;
                    }

Insertion in libpijul/src/record.rs at line 1049 [22.488880]
[22.525209]
[22.525209]
```
        Ok(())
```

Insertion in libpijul/src/pristine/sanakirja.rs at line 28 [22.531056]

[23.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.531056]

B:BD[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.531056]

B:BD[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.531056]

B:BD[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.531056]
B:BD[22.542222] → [22.542222:542281]
B:BD[22.542281] → [23.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> {
```
Insertion in libpijul/src/pristine/sanakirja.rs at line 358 [22.531056]
[22.542345]
[22.542345]
```
    type GraphError = SanakirjaError;
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 361 [22.531056]

B:BD[22.542403] → [22.542403:542455]

B:BD[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.531056]

B:BD[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.531056]
B:BD[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.531056]
∅:D[26.36940] → [22.542688:542746]
B:BD[22.542688] → [22.542688:542746]
```
    fn get_internal(&self, p: Hash) -> Option<ChangeId> {
```
[26.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.531056]

B:BD[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.531056]
B:BD[22.542828] → [22.542828:542878]
```
            self.txn.get(&self.internal, p, None)
```
[22.542828]
[22.542878]
```
            Err(TxnErr(SanakirjaError::PristineCorrupt))
```
Insertion in libpijul/src/pristine/sanakirja.rs at line 381 [22.531056]
[22.542894]
[22.542894]
```
}
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 383 [22.531056]

B:BD[22.542895] → [23.13700:13794]

∅:D[23.13794] → [22.542980:543067]

B:BD[22.542980] → [22.542980:543067]

B:BD[22.543067] → [23.13795:13865]

∅:D[23.13865] → [22.543147:543716]

B:BD[22.543147] → [22.543147:543716]

B:BD[22.543716] → [23.13866:13948]

∅:D[23.13948] → [22.543884:544005]

B:BD[22.543884] → [22.543884:544005]

B:BD[22.544005] → [23.13949:14014]

∅:D[23.14014] → [22.544126:544136]

B:BD[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)))

Insertion in libpijul/src/pristine/sanakirja.rs at line 411 [22.531056]

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

B:BD[22.544143] → [22.544143:544252]

B:BD[22.544252] → [23.14015:14063]

∅:D[23.14063] → [22.544291:544416]

B:BD[22.544291] → [22.544291:544416]

B:BD[22.544416] → [23.14064:14134]

∅:D[23.14134] → [22.544496:545049]

B:BD[22.544496] → [22.544496:545049]

B:BD[22.545049] → [23.14135:14217]

∅:D[23.14217] → [22.545217:545338]

B:BD[22.545217] → [22.545217:545338]

B:BD[22.545338] → [23.14218:14283]

∅:D[23.14283] → [22.545459:545469]

B:BD[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)))

Insertion in libpijul/src/pristine/sanakirja.rs at line 450 [22.531056]

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

∅:D[41.617] → [22.545544:545669]

B:BD[22.545544] → [22.545544:545669]

    sanakirja_table_get!(inodes, Inode, Position<ChangeId>);
    sanakirja_table_get!(revinodes, Position<ChangeId>, Inode);

[41.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.531056]

B:BD[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),
    );

Insertion in libpijul/src/pristine/sanakirja.rs at line 513 [22.531056]
[22.546862]
[22.546862]
```
        TreeError,
```
Deletion in libpijul/src/pristine/sanakirja.rs at line 524 [22.531056]
B:BD[22.547109] → [22.547109:547110]
B:BD[22.547129] → [22.547129:547169]
B:BD[22.547169] → [26.36943:36944]
∅:D[26.36944] → [22.547188:547241]
B:BD[22.547188] → [22.547188:547241]
```
    type Changeset = Db<ChangeId, u64>;
    type Revchangeset = Db<u64, (ChangeId, Merkle)>;
```

Deletion in libpijul/src/pristine/sanakirja.rs at line 525 [22.531056]

∅:D[26.36946] → [22.547260:547589]

B:BD[22.547260] → [22.547260:547589]

B:BD[22.547608] → [22.547608:547648]

B:BD[22.547667] → [22.547667:548014]

B:BD[22.548033] → [22.548033:548208]

B:BD[22.548208] → [49.2066:2135]

∅:D[49.2135] → [22.548302:548309]

B:BD[22.548302] → [22.548302:548309]

B:BD[22.548328] → [22.548328:548387]

B:BD[22.548387] → [26.36947:36948]

∅:D[26.36948] → [22.548406:548606]

B:BD[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>);

Insertion in libpijul/src/pristine/sanakirja.rs at line 540 [22.531056]

[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()))
        }
    }

Insertion in libpijul/src/pristine/sanakirja.rs at line 612 [22.531056]

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

B:BD[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.531056]
B:BD[22.549585] → [22.549585:549607]
```
                    )
```
[22.549585]
[22.549607]
```
                    )?
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 682 [22.531056]
B:BD[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.531056]

B:BD[22.550246] → [50.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.531056]

B:BD[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.531056]
B:BD[22.550721] → [22.550721:550741]
```
                ) {
```
[22.550721]
[22.550741]
```
                )? {
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 709 [22.531056]
B:BD[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.531056]

B:BD[22.551240] → [50.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.531056]

B:BD[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.531056]

B:BD[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.531056]
B:BD[22.552148] → [22.552148:552158]
```
        }
```
[22.552148]
[22.552158]
```
        })
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 760 [22.531056]

B:BD[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.531056]

B:BD[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.531056]
B:BD[22.552944] → [22.552944:552954]
```
        }
```
[22.552944]
[22.552954]
```
        })
```

Deletion in libpijul/src/pristine/sanakirja.rs at line 772 [22.531056]

B:BD[26.36950] → [49.2136:2256]

∅:D[49.2256] → [22.553148:553195]

B:BD[22.553148] → [22.553148:553195]

B:BD[22.553195] → [22.553195:553202]

B:BD[22.553202] → [41.709:738]

B:BD[41.738] → [8.445:571]

∅:D[8.571] → [41.880:940]

B:BD[41.880] → [41.880:940]

∅:D[41.940] → [52.115:115]

∅:D[52.115] → [49.2257:2292]

B:BD[22.553202] → [49.2257:2292]

∅:D[49.2292] → [22.553267:553288]

B:BD[22.553267] → [22.553267:553288]

B:BD[22.553288] → [49.2293:2368]

∅:D[49.2368] → [22.553368:553430]

B:BD[22.553368] → [22.553368:553430]

B:BD[22.553430] → [49.2369:2401]

∅:D[49.2401] → [22.553492:553513]

B:BD[22.553492] → [22.553492:553513]

B:BD[22.553513] → [49.2402:2477]

∅:D[49.2477] → [22.553593:553652]

B:BD[22.553593] → [22.553593:553652]

B:BD[22.553652] → [49.2478:2514]

∅:D[49.2514] → [22.553718:553749]

B:BD[22.553718] → [22.553718:553749]

B:BD[22.553749] → [49.2515:2610]

∅:D[49.2610] → [22.553853:553932]

B:BD[22.553853] → [22.553853:553932]

B:BD[22.553932] → [49.2611:2651]

∅:D[49.2651] → [22.554002:554023]

B:BD[22.554002] → [22.554002:554023]

B:BD[22.554023] → [49.2652:2749]

∅:D[49.2749] → [22.554125:554218]

B:BD[22.554125] → [22.554125:554218]

B:BD[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.531056]

B:BD[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.531056]

B:BD[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.531056]

B:BD[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.531056]
B:BD[22.555647] → [22.555647:555667]
```
                ) {
```
[22.555647]
[22.555667]
```
                )? {
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 822 [22.531056]
B:BD[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.531056]

B:BD[22.556166] → [50.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.531056]

B:BD[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.531056]

B:BD[22.556376] → [22.556376:556533]

B:BD[22.556533] → [50.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.531056]

B:BD[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.531056]

B:BD[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.531056]

B:BD[22.556904] → [22.556904:557051]

B:BD[22.557051] → [22.557051:557057]

B:BD[22.557057] → [22.557057:557915]

B:BD[22.557915] → [22.557915:557921]

B:BD[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())

Deletion in libpijul/src/pristine/sanakirja.rs at line 873 [22.531056]

B:BD[22.558210] → [22.558210:558214]

B:BD[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>);

Insertion in libpijul/src/pristine/sanakirja.rs at line 874 [22.531056]
[22.558873]
[22.558892]
```
impl GraphMutTxnT for MutTxn<()> {
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 880 [22.531056]
B:BD[22.559008] → [23.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.531056]
B:BD[22.559250] → [23.14322:14359]
```
    ) -> Result<bool, Self::Error> {
```
[22.559250]
[22.559289]
```
    ) -> Result<bool, TxnErr<Self::GraphError>> {
```

Insertion in libpijul/src/pristine/sanakirja.rs at line 893 [22.531056]

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

B:BD[22.559395] → [23.14360:14454]

∅:D[23.14454] → [22.559510:559731]

B:BD[22.559510] → [22.559510:559731]

B:BD[22.559731] → [26.36953:36954]

∅:D[26.36954] → [22.559750:559846]

B:BD[22.559750] → [22.559750:559846]

B:BD[22.559846] → [23.14455:14492]

∅:D[23.14492] → [22.559885:560107]

B:BD[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.531056]

B:BD[22.560268] → [23.14493:14540]

∅:D[23.14540] → [22.560317:560386]

B:BD[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.531056]

B:BD[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.531056]

B:BD[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.531056]
B:BD[22.561234] → [23.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.531056]

B:BD[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.531056]

B:BD[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.531056]

B:BD[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());

Insertion in libpijul/src/pristine/sanakirja.rs at line 961 [22.531056]

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

Insertion in libpijul/src/pristine/sanakirja.rs at line 1006 [22.531056]

[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.531056]
B:BD[22.562319] → [23.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.531056]

B:BD[22.562607] → [23.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.531056]

B:BD[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.531056]

B:BD[22.563092] → [23.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.531056]
B:BD[22.563779] → [22.563779:563799]
```
                ) {
```
[22.563779]
[22.563799]
```
                )? {
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1106 [22.531056]

B:BD[22.565222] → [23.14813:14873]

    ) -> Result<ChannelRef<Self>, ForkError<Self::Error>> {

[22.565222]

[22.565273]

    ) -> Result<ChannelRef<Self>, ForkError<Self::GraphError>> {

Insertion in libpijul/src/pristine/sanakirja.rs at line 1116 [22.531056]
[22.565555]
[22.565555]
```
            .map_err(|e| ForkError::Txn(e.into()))?
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 1153 [22.531056]
B:BD[22.566578] → [23.15715:15761]
```
    ) -> Result<(), ForkError<Self::Error>> {
```
[22.566578]
[22.566615]
```
    ) -> Result<(), ForkError<Self::GraphError>> {
```
Insertion in libpijul/src/pristine/sanakirja.rs at line 1162 [22.531056]
[22.566855]
[22.566855]
```
            .map_err(|e| ForkError::Txn(e.into()))?
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1193 [22.531056]

B:BD[22.567504] → [23.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.531056]

B:BD[22.567999] → [23.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.531056]
B:BD[22.568483] → [22.568483:568503]
```
                ) {
```
[22.568483]
[22.568503]
```
                )? {
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1247 [22.531056]

B:BD[22.569566] → [23.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.531056]

B:BD[22.570030] → [23.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.531056]
B:BD[22.570478] → [23.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.531056]

B:BD[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.531056]
B:BD[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.531056]
B:BD[22.572696] → [22.572696:572711]
```
            })
```
[22.572696]
[22.572711]
```
            }))
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 1329 [22.531056]
B:BD[22.572728] → [22.572728:572745]
```
            None
```
[22.572728]
[22.572745]
```
            Ok(None)
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1386 [22.531056]

B:BD[22.574894] → [23.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.531056]

B:BD[22.575835] → [23.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.586748]
B:BD[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.586748]
B:BD[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.586748]
B:BD[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.586748]
B:BD[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 [22.586748]
B:BD[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.586748]
B:BD[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.586748]
B:BD[23.16925] → [23.16925:16952]
```
pub enum HashPrefixError {
```
[23.16925]
[23.16952]
```
pub enum HashPrefixError<T: std::error::Error + 'static> {
```
Insertion in libpijul/src/pristine/mod.rs at line 127 [22.586748]
[23.17146]
[23.17146]
```
    #[error(transparent)]
    Txn(T),
```

Replacement in libpijul/src/pristine/mod.rs at line 139 [22.586748]

∅:D[23.17347] → [22.589140:589205]

B:BD[22.589140] → [22.589140:589205]

B:BD[22.589205] → [23.17348:17407]

/// The trait of immutable transactions.
pub trait TxnT: Sized {
    type Error: std::error::Error + Send + Sync + 'static;

[23.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.586748]

B:BD[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>>;
}

Insertion in libpijul/src/pristine/mod.rs at line 157 [22.586748]
[22.589314]
[22.589314]
```
pub trait ChannelTxnT: GraphTxnT {
```

Replacement in libpijul/src/pristine/mod.rs at line 159 [22.586748]

B:BD[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.586748]

B:BD[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);

Insertion in libpijul/src/pristine/mod.rs at line 168 [22.586748]

[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);
}

Insertion in libpijul/src/pristine/mod.rs at line 211 [22.586748]

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

B:BD[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.586748]

B:BD[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.586748]

∅:D[41.964] → [22.589844:589949]

B:BD[22.589844] → [22.589844:589949]

    table_get!(inodes, Inode, Position<ChangeId>);
    table_get!(revinodes, Position<ChangeId>, Inode);

[41.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.586748]

B:BD[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.586748]

B:BD[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.586748]

B:BD[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.586748]

B:BD[22.590301] → [22.590301:590867]

B:BD[22.590886] → [22.590886:591060]

B:BD[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.586748]

B:BD[22.591137] → [23.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.586748]
B:BD[22.591329] → [23.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.586748]

B:BD[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.586748]

B:BD[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.586748]

B:BD[22.592225] → [22.592225:592310]

B:BD[22.592329] → [22.592329:592412]

B:BD[22.599224] → [22.599224:599225]

B:BD[22.599225] → [8.572:672]

∅:D[8.672] → [22.600030:600031]

B:BD[22.600030] → [22.600030:600031]

B:BD[22.600031] → [8.673:770]

∅:D[8.770] → [22.600186:600187]

B:BD[22.600186] → [22.600186:600187]

B:BD[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.586748]

B:BD[22.600374] → [8.771:807]

∅:D[8.807] → [22.600440:600471]

B:BD[22.600440] → [22.600440:600471]

B:BD[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>>;

Deletion in libpijul/src/pristine/mod.rs at line 303 [22.586748]
B:BD[22.600564] → [8.896:936]
∅:D[8.936] → [22.600634:600655]
B:BD[22.600634] → [22.600634:600655]
B:BD[22.600655] → [8.937:1028]
∅:D[8.1028] → [22.605607:605608]
B:BD[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.586748]

B:BD[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.586748]

B:BD[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.586748]

B:BD[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.586748]

B:BD[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]

[26.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.586748]

B:BD[26.37026] → [26.37026:37074]

B:BD[26.37074] → [8.1029:1126]

    cursor!(inodes, Inode, Position<ChangeId>);
    fn iter_inodes(&self) -> Cursor<Self, &Self, Self::InodesCursor, Inode, Position<ChangeId>>;

[26.36994]

[41.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.586748]

B:BD[41.966] → [41.966:1075]

B:BD[41.1075] → [8.1127:1150]

    #[cfg(debug_assertions)]
    cursor!(revinodes, Position<ChangeId>, Inode);
    #[cfg(debug_assertions)]
    fn iter_revinodes(

[41.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 [22.586748]

B:BD[8.1165] → [8.1165:1245]

    ) -> Cursor<Self, &Self, Self::RevinodesCursor, Position<ChangeId>, Inode>;

[8.1165]

[26.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.586748]
B:BD[26.37377] → [26.37377:37431]
```
pub(crate) fn iter_adjacent<'db, 'txn: 'db, T: TxnT>(
```
[26.37377]
[26.37431]
```
pub(crate) fn iter_adjacent<'db, 'txn: 'db, T: GraphTxnT>(
```
Replacement in libpijul/src/pristine/mod.rs at line 366 [22.586748]
B:BD[26.37449] → [26.37449:37479]
```
    channel: &'db Channel<T>,
```
[26.37449]
[26.37479]
```
    graph: &'db T::Graph,
```
Replacement in libpijul/src/pristine/mod.rs at line 370 [22.586748]
B:BD[26.37556] → [26.37556:37589]
```
) -> AdjacentIterator<'txn, T> {
```
[26.37556]
[26.37589]
```
) -> Result<AdjacentIterator<'txn, T>, TxnErr<T::GraphError>> {
```

Replacement in libpijul/src/pristine/mod.rs at line 376 [22.586748]

B:BD[26.37711] → [26.37711:37796]

    AdjacentIterator {
        it: iter_graph(txn, &channel.graph, key, Some(edge)),

[26.37711]

[26.37796]

    Ok(AdjacentIterator {
        it: iter_graph(txn, graph, key, Some(edge))?,

Replacement in libpijul/src/pristine/mod.rs at line 381 [22.586748]
∅:D[26.37845] → [22.607389:607395]
B:BD[22.607389] → [22.607389:607395]
```
    }
```
[26.37845]
[21.6832]
```
    })
```

Replacement in libpijul/src/pristine/mod.rs at line 384 [22.586748]

B:BD[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 [22.586748]
B:BD[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 [22.586748]
B:BD[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 [22.586748]
B:BD[21.7035] → [21.7035:7052]
```
        channel,
```
[21.7035]
[21.7052]
```
        graph,
```

Replacement in libpijul/src/pristine/mod.rs at line 398 [22.586748]

B:BD[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 [22.586748]
B:BD[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 [22.586748]
B:BD[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 [22.586748]
B:BD[21.7338] → [21.7338:7355]
```
        channel,
```
[21.7338]
[21.7355]
```
        graph,
```
Replacement in libpijul/src/pristine/mod.rs at line 412 [22.586748]
B:BD[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 [22.586748]
B:BD[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 [22.586748]

B:BD[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 [22.586748]

∅:D[21.7690] → [26.37849:37992]

B:BD[22.607396] → [26.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]

[26.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.586748]

B:BD[26.38066] → [26.38066:38129]

            if let Some(next) = txn.get_revtree(inode, None) {

[26.38066]

[26.38129]

            if let Some(next) = txn.get_revtree(inode, None)? {

Replacement in libpijul/src/pristine/mod.rs at line 432 [22.586748]
B:BD[26.38310] → [26.38310:38339]
```
                return None;
```
[26.38310]
[26.38339]
```
                return Ok(None);
```

Replacement in libpijul/src/pristine/mod.rs at line 439 [22.586748]

B:BD[26.38532] → [26.38532:38591]

            Some(result)
        } else {
            None

[26.38532]

[22.607771]

            return Ok(Some(result));

Deletion in libpijul/src/pristine/mod.rs at line 441 [22.586748]
B:BD[22.607781] → [26.38592:38618]
```
    } else {
        None
```
Insertion in libpijul/src/pristine/mod.rs at line 442 [22.586748]
[22.607802]
[26.38619]
```
    Ok(None)
```

Replacement in libpijul/src/pristine/mod.rs at line 445 [22.586748]

B:BD[22.607803] → [26.38622:38716]

pub(crate) fn internal<T: TxnT>(txn: &T, h: &Option<Hash>, p: ChangeId) -> Option<ChangeId> {

[22.607803]

[26.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.586748]
B:BD[26.38731] → [26.38731:38781]
```
        Some(Hash::None) => Some(ChangeId::ROOT),
```
[26.38731]
[26.38781]
```
        Some(Hash::None) => Ok(Some(ChangeId::ROOT)),
```
Replacement in libpijul/src/pristine/mod.rs at line 453 [22.586748]
B:BD[26.38821] → [26.38821:38846]
```
        None => Some(p),
```
[26.38821]
[53.347]
```
        None => Ok(Some(p)),
```

Replacement in libpijul/src/pristine/mod.rs at line 458 [22.586748]

B:BD[23.17565] → [23.17565:17630]

#[error("Inconsistent change")]
pub struct InconsistentChange {}

[23.17565]

[23.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.586748]
∅:D[23.17631] → [26.38850:38887]
B:BD[53.354] → [26.38850:38887]
```
pub(crate) fn internal_pos<T: TxnT>(
```
[23.17631]
[26.38887]
```
pub(crate) fn internal_pos<T: GraphTxnT>(
```

Replacement in libpijul/src/pristine/mod.rs at line 475 [22.586748]

B:BD[26.38959] → [23.17632:17686]

) -> Result<Position<ChangeId>, InconsistentChange> {

[26.38959]

[54.0]

) -> Result<Position<ChangeId>, InconsistentChange<T::GraphError>> {

Replacement in libpijul/src/pristine/mod.rs at line 477 [22.586748]

B:BD[54.47] → [54.47:94]

        if let Some(p) = txn.get_internal(p) {

[54.47]

[54.94]

        if let Some(p) = txn.get_internal(p)? {

Replacement in libpijul/src/pristine/mod.rs at line 480 [22.586748]

B:BD[26.39254] → [23.17687:17734]

            return Err(InconsistentChange {});

[26.39254]

[54.167]

            return Err(InconsistentChange::UndeclaredDep);

Replacement in libpijul/src/pristine/mod.rs at line 492 [22.586748]
B:BD[26.39319] → [26.39319:39360]
```
pub(crate) fn iter_graph<'txn, T: TxnT>(
```
[26.39319]
[26.39360]
```
pub(crate) fn iter_graph<'txn, T: GraphTxnT>(
```

Replacement in libpijul/src/pristine/mod.rs at line 497 [22.586748]

B:BD[26.39446] → [26.39446:39512]

) -> Cursor<T, &'txn T, T::GraphCursor, Vertex<ChangeId>, Edge> {

[26.39446]

[39.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.586748]

B:BD[26.39578] → [26.39578:39650]

pub(crate) fn iter_graph_ref<T: TxnT, RT: std::ops::Deref<Target = T>>(

[26.39578]

[26.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.586748]

B:BD[26.39731] → [26.39731:39792]

) -> Cursor<T, RT, T::GraphCursor, Vertex<ChangeId>, Edge> {

[26.39731]

[39.4329]

) -> Result<Cursor<T, RT, T::GraphCursor, Vertex<ChangeId>, Edge>, TxnErr<T::GraphError>> {

Replacement in libpijul/src/pristine/mod.rs at line 510 [22.586748]
B:BD[26.39866] → [26.39866:39919]
```
pub(crate) fn changeid_log<'db, 'txn: 'db, T: TxnT>(
```
[26.39866]
[26.39919]
```
pub(crate) fn changeid_log<'db, 'txn: 'db, T: ChannelTxnT>(
```

Replacement in libpijul/src/pristine/mod.rs at line 514 [22.586748]

B:BD[26.39982] → [26.39982:40056]

) -> Cursor<T, &'txn T, T::RevchangesetCursor, u64, (ChangeId, Merkle)> {

[26.39982]

[26.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.586748]
B:BD[26.40128] → [26.40128:40182]
```
pub(crate) fn current_state<'db, 'txn: 'db, T: TxnT>(
```
[26.40128]
[26.40182]
```
pub(crate) fn current_state<'db, 'txn: 'db, T: ChannelTxnT>(
```

Replacement in libpijul/src/pristine/mod.rs at line 522 [22.586748]

B:BD[26.40230] → [16.197:211]

∅:D[16.211] → [26.40252:40311]

B:BD[26.40252] → [26.40252:40311]

) -> Merkle {
    txn.rev_cursor_revchangeset(&channel.revchanges, None)

[26.40230]

[26.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.586748]

B:BD[26.40327] → [26.40327:40357]

B:BD[26.40357] → [16.212:247]

        .map(|(_, (_, m))| m)
        .unwrap_or(Merkle::zero())

[26.40327]

[26.40357]

    {
        let (_, (_, m)) = e?;
        Ok(m)
    } else {
        Ok(Merkle::zero())
    }

Replacement in libpijul/src/pristine/mod.rs at line 534 [22.586748]

B:BD[26.40360] → [26.40360:40434]

pub(crate) fn changeid_log_ref<T: TxnT, RT: std::ops::Deref<Target = T>>(

[26.40360]

[26.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.586748]

B:BD[26.40488] → [26.40488:40634]

) -> Cursor<T, RT, T::RevchangesetCursor, u64, (ChangeId, Merkle)> {
    T::cursor_revchangeset_ref(txn, &channel.revchanges, Some((from, None)))

[26.40488]

[26.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.586748]
B:BD[26.40637] → [26.40637:40694]
```
pub(crate) fn changeid_rev_log<'db, 'txn: 'db, T: TxnT>(
```
[26.40637]
[26.40694]
```
pub(crate) fn changeid_rev_log<'db, 'txn: 'db, T: ChannelTxnT>(
```

Replacement in libpijul/src/pristine/mod.rs at line 550 [22.586748]

B:BD[26.40765] → [26.40765:40926]

) -> RevCursor<T, &'txn T, T::RevchangesetCursor, u64, (ChangeId, Merkle)> {
    txn.rev_cursor_revchangeset(&channel.revchanges, from.map(|from| (from, None)))

[26.40765]

[26.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.586748]

B:BD[26.40929] → [26.40929:40982]

pub(crate) fn log_for_path<'txn, 'channel, T: TxnT>(

[26.40929]

[26.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.586748]

B:BD[26.41089] → [26.41089:41239]

) -> PathChangeset<'channel, 'txn, T> {
    PathChangeset {
        iter: txn.cursor_revchangeset(&channel.revchanges, Some((from_timestamp, None))),

[26.41089]

[26.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.586748]
∅:D[26.41282] → [22.608084:608090]
B:BD[22.608084] → [22.608084:608090]
```
    }
```
[26.41282]
[26.41283]
```
    })
```

Replacement in libpijul/src/pristine/mod.rs at line 575 [22.586748]

B:BD[22.608091] → [26.41286:41343]

pub(crate) fn rev_log_for_path<'txn, 'channel, T: TxnT>(

[22.608091]

[26.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.586748]

B:BD[26.41450] → [26.41450:41610]

) -> RevPathChangeset<'channel, 'txn, T> {
    RevPathChangeset {
        iter: txn.rev_cursor_revchangeset(&channel.revchanges, Some((from_timestamp, None))),

[26.41450]

[26.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.586748]
∅:D[26.41653] → [53.525:531]
B:BD[53.525] → [53.525:531]
```
    }
```
[26.41653]
[26.41654]
```
    })
```
Replacement in libpijul/src/pristine/mod.rs at line 594 [22.586748]
B:BD[26.41708] → [26.41708:41742]
```
pub(crate) fn test_edge<T: TxnT>(
```
[26.41708]
[26.41742]
```
pub(crate) fn test_edge<T: GraphTxnT>(
```
Replacement in libpijul/src/pristine/mod.rs at line 596 [22.586748]
B:BD[26.41755] → [26.41755:41781]
```
    channel: &Channel<T>,
```
[26.41755]
[26.41781]
```
    channel: &T::Graph,
```
Replacement in libpijul/src/pristine/mod.rs at line 601 [22.586748]
B:BD[26.41875] → [26.41875:41887]
```
) -> bool {
```
[26.41875]
[26.41887]
```
) -> Result<bool, TxnErr<T::GraphError>> {
```

Replacement in libpijul/src/pristine/mod.rs at line 613 [22.586748]

B:BD[26.42133] → [26.42133:42282]

    let mut cursor = txn.cursor_graph(&channel.graph, Some((key, Some(edge))));
    let (a_, b_) = cursor.next().unwrap();
    a_.change == a.change

[26.42133]

[26.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.586748]
B:BD[26.42390] → [26.42390:42414]
```
        && b_.dest == b
```
[26.42390]
[26.42414]
```
        && b_.dest == b)
```

Replacement in libpijul/src/pristine/mod.rs at line 624 [22.586748]

B:BD[26.42459] → [26.42459:42740]

B:BD[26.42740] → [43.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())
        })

[26.42459]

[26.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.586748]

B:BD[22.608172] → [26.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]

[26.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.586748]
B:BD[26.43100] → [26.43100:43145]
```
        Hash::None => return ChangeId::ROOT,
```
[26.43100]
[26.43145]
```
        Hash::None => return Ok(ChangeId::ROOT),
```
Replacement in libpijul/src/pristine/mod.rs at line 662 [22.586748]
B:BD[26.43225] → [26.43225:43267]
```
    while txn.get_external(p).is_some() {
```
[26.43225]
[26.43267]
```
    while txn.get_external(p)?.is_some() {
```
Replacement in libpijul/src/pristine/mod.rs at line 665 [22.586748]
B:BD[22.608592] → [26.43316:43322]
```
    p
```
[22.608592]
[26.43322]
```
    Ok(p)
```
Replacement in libpijul/src/pristine/mod.rs at line 669 [22.586748]
B:BD[26.43350] → [26.43350:43405]
```
pub fn debug_tree<P: AsRef<std::path::Path>, T: TxnT>(
```
[26.43350]
[26.43405]
```
pub fn debug_tree<P: AsRef<std::path::Path>, T: TreeTxnT>(
```

Replacement in libpijul/src/pristine/mod.rs at line 678 [22.586748]

B:BD[26.43626] → [26.43626:43699]

    for t in txn.iter_tree(root, None) {
        writeln!(f, "{:?}", t)?

[26.43626]

[26.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.586748]
B:BD[26.43744] → [26.43744:43788]
```
pub fn debug_tree_print<T: TxnT>(txn: &T) {
```
[26.43744]
[26.43788]
```
pub fn debug_tree_print<T: TreeTxnT>(txn: &T) {
```

Replacement in libpijul/src/pristine/mod.rs at line 690 [22.586748]

B:BD[26.43904] → [26.43904:43971]

    for t in txn.iter_tree(root, None) {
        debug!("{:?}", t)

[26.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.586748]

B:BD[26.44179] → [26.44179:44237]

pub fn debug_to_file<P: AsRef<std::path::Path>, T: TxnT>(

[26.44179]

[26.44237]

pub fn debug_to_file<P: AsRef<std::path::Path>, T: ChannelTxnT>(

Replacement in libpijul/src/pristine/mod.rs at line 705 [22.586748]

B:BD[26.44404] → [26.44404:44488]

    let channel = channel.r.borrow();
    let done = debug(txn, &channel, &mut f)?;

[26.44404]

[26.44488]

    let done = debug(txn, &channel.borrow().graph, &mut f)?;

Replacement in libpijul/src/pristine/mod.rs at line 712 [22.586748]
B:BD[26.44585] → [26.44585:44643]
```
pub fn debug_revtree<P: AsRef<std::path::Path>, T: TxnT>(
```
[26.44585]
[26.44643]
```
pub fn debug_revtree<P: AsRef<std::path::Path>, T: TreeTxnT>(
```

Replacement in libpijul/src/pristine/mod.rs at line 717 [22.586748]

B:BD[26.44748] → [26.44748:44831]

    for t in txn.iter_revtree(Inode::ROOT, None) {
        writeln!(f, "{:?}", t)?

[26.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.586748]

B:BD[26.44871] → [26.44871:44995]

pub fn debug_revtree_print<T: TxnT>(txn: &T) {
    for t in txn.iter_revtree(Inode::ROOT, None) {
        debug!("{:?}", t)

[26.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.586748]
B:BD[26.45024] → [26.45024:45064]
```
pub fn debug_inodes<T: TxnT>(txn: &T) {
```
[26.45024]
[26.45064]
```
pub fn debug_inodes<T: TreeTxnT>(txn: &T) {
```

Replacement in libpijul/src/pristine/mod.rs at line 733 [22.586748]

B:BD[26.45092] → [26.45092:45166]

    for t in txn.iter_inodes() {
        debug!("debug_inodes = {:?}", t)

[26.45092]

[26.45166]

    for t in txn.iter_inodes().unwrap() {
        debug!("debug_inodes = {:?}", t.unwrap())

Replacement in libpijul/src/pristine/mod.rs at line 740 [22.586748]
B:BD[41.1235] → [41.1235:1278]
```
pub fn debug_revinodes<T: TxnT>(txn: &T) {
```
[41.1235]
[41.1278]
```
pub fn debug_revinodes<T: TreeTxnT>(txn: &T) {
```

Replacement in libpijul/src/pristine/mod.rs at line 742 [22.586748]

B:BD[41.1309] → [41.1309:1389]

    for t in txn.iter_revinodes() {
        debug!("debug_revinodes = {:?}", t)

[41.1309]

[41.1389]

    for t in txn.iter_revinodes().unwrap() {
        debug!("debug_revinodes = {:?}", t.unwrap())

Replacement in libpijul/src/pristine/mod.rs at line 751 [22.586748]
B:BD[26.45354] → [26.45354:45387]
```
pub fn debug<W: Write, T: TxnT>(
```
[26.45354]
[26.45387]
```
pub fn debug<W: Write, T: GraphTxnT>(
```
Replacement in libpijul/src/pristine/mod.rs at line 753 [22.586748]
B:BD[26.45400] → [26.45400:45426]
```
    channel: &Channel<T>,
```
[26.45400]
[26.45426]
```
    channel: &T::Graph,
```
Replacement in libpijul/src/pristine/mod.rs at line 756 [22.586748]
∅:D[23.17878] → [55.294:351]
B:BD[26.45475] → [55.294:351]
```
    let cursor = txn.cursor_graph(&channel.graph, None);
```
[23.17878]
[26.45536]
```
    let cursor = txn.cursor_graph(&channel, None).unwrap();
```
Replacement in libpijul/src/pristine/mod.rs at line 760 [22.586748]
B:BD[26.45655] → [56.301:328]
```
    for (k, v) in cursor {
```
[26.45655]
[26.45700]
```
    for x in cursor {
        let (k, v) = x.unwrap();
```
Replacement in libpijul/src/pristine/mod.rs at line 773 [22.586748]
B:BD[26.45951] → [26.45951:45980]
```
pub fn check_alive<T: TxnT>(
```
[22.612336]
[26.45980]
```
pub fn check_alive<T: ChannelTxnT>(
```
Replacement in libpijul/src/pristine/mod.rs at line 775 [22.586748]
B:BD[26.45993] → [26.45993:46022]
```
    channel: &ChannelRef<T>,
```
[26.45993]
[26.46022]
```
    channel: &T::Graph,
```
Deletion in libpijul/src/pristine/mod.rs at line 780 [22.586748]
B:BD[26.46145] → [26.46145:46183]
∅:D[26.46183] → [22.613571:613572]
B:BD[22.613571] → [22.613571:613572]
```
    let channel = channel.r.borrow();
```

Replacement in libpijul/src/pristine/mod.rs at line 793 [22.586748]

B:BD[26.46586] → [26.46586:46598]

) {

[26.46586]

[26.46598]

        )
        .unwrap()
        {
            let e = e.unwrap();

Replacement in libpijul/src/pristine/mod.rs at line 804 [22.586748]
B:BD[26.46782] → [55.352:409]
```
    let cursor = txn.cursor_graph(&channel.graph, None);
```
[26.46782]
[26.46843]
```
    let cursor = txn.cursor_graph(&channel, None);
```
Replacement in libpijul/src/pristine/mod.rs at line 810 [22.586748]
B:BD[26.47042] → [56.329:356]
```
    for (k, v) in cursor {
```
[26.47042]
[26.47087]
```
    for x in cursor.unwrap() {
        let (k, v) = x.unwrap();
```

Replacement in libpijul/src/pristine/mod.rs at line 815 [22.586748]

B:BD[26.47231] → [26.47231:47331]

                reachable_pseudo.push((k0, find_file(txn, &channel, k0, &mut stack, &mut visited)))

[26.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.586748]

B:BD[39.4618] → [39.4618:4696]

            let file = find_file(txn, &channel, k, &mut stack, &mut visited);

[39.4618]

[39.4696]

            let file = find_file(txn, &channel, k, &mut stack, &mut visited).unwrap();

Replacement in libpijul/src/pristine/mod.rs at line 845 [22.586748]

B:BD[26.48127] → [26.48127:48220]

        reachable_pseudo.push((k0, find_file(txn, &channel, k0, &mut stack, &mut visited)));

[26.48127]

[26.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.586748]
B:BD[26.48285] → [26.48285:48308]
```
fn find_file<T: TxnT>(
```
[26.48272]
[26.48308]
```
fn find_file<T: GraphTxnT>(
```
Replacement in libpijul/src/pristine/mod.rs at line 856 [22.586748]
B:BD[26.48321] → [26.48321:48347]
```
    channel: &Channel<T>,
```
[26.48321]
[26.48347]
```
    channel: &T::Graph,
```
Replacement in libpijul/src/pristine/mod.rs at line 860 [22.586748]

Upgrading to Sanakirja 0.15 + version bump

Dependencies

In channels

Change contents

Deletion in pijul-macros/src/lib.rs at line 36 [22.445]

Insertion in pijul-macros/src/lib.rs at line 52 [22.445]

Replacement in pijul-macros/src/lib.rs at line 69 [22.445]

Replacement in pijul-macros/src/lib.rs at line 76 [22.445]

Replacement in pijul-macros/src/lib.rs at line 83 [22.445]

Insertion in pijul-macros/src/lib.rs at line 103 [22.445]

Replacement in pijul-macros/src/lib.rs at line 111 [22.445]

Replacement in pijul-macros/src/lib.rs at line 113 [22.445]

Insertion in pijul-macros/src/lib.rs at line 133 [22.445]

Replacement in pijul-macros/src/lib.rs at line 141 [22.445]

Insertion in pijul-macros/src/lib.rs at line 157 [22.445]

Replacement in pijul-macros/src/lib.rs at line 165 [22.445]

Insertion in pijul-macros/src/lib.rs at line 234 [22.445]

Replacement in pijul-macros/src/lib.rs at line 244 [22.445]

Replacement in pijul-macros/src/lib.rs at line 248 [22.445]

Deletion in pijul-macros/src/lib.rs at line 255 [22.445]

Deletion in pijul-macros/src/lib.rs at line 256 [22.445]

Replacement in pijul-macros/src/lib.rs at line 259 [22.445]

Replacement in pijul-macros/src/lib.rs at line 263 [22.445]

Deletion in pijul-macros/src/lib.rs at line 268 [22.445]

Replacement in pijul-macros/src/lib.rs at line 272 [22.445]

Deletion in pijul-macros/src/lib.rs at line 281 [22.445]

Deletion in pijul-macros/src/lib.rs at line 291 [22.445]

Deletion in pijul-macros/src/lib.rs at line 372 [22.445]

Replacement in pijul-macros/src/lib.rs at line 376 [22.445]

Deletion in pijul-macros/src/lib.rs at line 386 [22.445]

Replacement in pijul-macros/src/lib.rs at line 390 [22.445]

Replacement in pijul-macros/src/lib.rs at line 392 [22.445]

Deletion in pijul-macros/src/lib.rs at line 409 [22.445]

Replacement in pijul-macros/src/lib.rs at line 413 [22.445]

Replacement in pijul-macros/src/lib.rs at line 416 [22.445]

Replacement in pijul-macros/src/lib.rs at line 424 [22.445]

Replacement in pijul-macros/src/lib.rs at line 426 [22.445]

Replacement in pijul-macros/src/lib.rs at line 430 [22.445]

Deletion in pijul-macros/src/lib.rs at line 435 [22.445]

Deletion in pijul-macros/src/lib.rs at line 436 [22.445]

Replacement in pijul-macros/src/lib.rs at line 440 [22.445]

Replacement in pijul-macros/src/lib.rs at line 442 [22.445]

Replacement in pijul-macros/src/lib.rs at line 451 [22.445]

Deletion in pijul-macros/src/lib.rs at line 454 [22.445]

Replacement in pijul-macros/src/lib.rs at line 457 [22.445]

Deletion in pijul-macros/src/lib.rs at line 465 [22.445]

Replacement in pijul-macros/src/lib.rs at line 468 [22.445]

Insertion in pijul-macros/src/lib.rs at line 507 [22.445]

Replacement in pijul-macros/src/lib.rs at line 524 [22.445]

Replacement in pijul-macros/src/lib.rs at line 526 [22.445]

Replacement in pijul-macros/src/lib.rs at line 539 [22.445]

Replacement in pijul-macros/src/lib.rs at line 542 [22.445]

Replacement in pijul-macros/src/lib.rs at line 550 [22.445]

Replacement in pijul-macros/src/lib.rs at line 552 [22.445]

Insertion in pijul-macros/src/lib.rs at line 578 [22.445]

Deletion in pijul-macros/src/lib.rs at line 587 [22.445]

Replacement in pijul-macros/src/lib.rs at line 591 [22.445]

Replacement in pijul-macros/src/lib.rs at line 596 [22.445]

Insertion in pijul-macros/src/lib.rs at line 614 [22.445]

Insertion in pijul-macros/src/lib.rs at line 624 [22.445]

Insertion in pijul-macros/src/lib.rs at line 626 [22.445]

Deletion in pijul-macros/src/lib.rs at line 629 [22.445]

Replacement in pijul-macros/src/lib.rs at line 633 [22.445]

Deletion in pijul-macros/src/lib.rs at line 636 [22.445]

Replacement in pijul-macros/src/lib.rs at line 640 [22.445]

Deletion in pijul-macros/src/lib.rs at line 646 [22.445]

Replacement in pijul-macros/src/lib.rs at line 650 [22.445]

Replacement in pijul-macros/src/lib.rs at line 653 [22.445]

Deletion in pijul-macros/src/lib.rs at line 655 [22.445]

Replacement in pijul-macros/src/lib.rs at line 659 [22.445]

Replacement in pijul-macros/src/lib.rs at line 662 [22.445]

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

Insertion in pijul/src/repository.rs at line 4 [22.21431]

Replacement in pijul/src/repository.rs at line 8 [22.21431]

Replacement in pijul/src/repository.rs at line 45 [22.21431]

Replacement in pijul/src/repository.rs at line 74 [22.21431]

Replacement in pijul/src/repository.rs at line 114 [22.21431]

Deletion in pijul/src/remote/ssh.rs at line 21 [22.25380]

Replacement in pijul/src/remote/ssh.rs at line 103 [22.25380]

Replacement in pijul/src/remote/ssh.rs at line 561 [22.25380]