ilyagr/pijul - Change ZDK3GNDBWXJ2OXFDYB72ZCEBGLBF4MKE5K3PVHDZATHJ7HJIDPRQC

Tag transactions (including a massive refactoring of errors)

Created by pmeunier on December 9, 2021

ZDK3GNDBWXJ2OXFDYB72ZCEBGLBF4MKE5K3PVHDZATHJ7HJIDPRQC

Dependencies

In channels

main

Change contents

Insertion in pijul-macros/src/lib.rs at line 57 [13.445]

[12.178]

[13.2632]

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

Replacement in pijul-macros/src/lib.rs at line 65 [13.445]

B:BD[13.2682] → [14.563:696]

        fn #name_get <'txn> (&'txn self, key: &#key, value: Option<&#value>) -> Result<Option<&'txn #value>, TxnErr<Self::#error>> {

[13.2682]

[14.696]

        fn #name_get <'txn> (&'txn self, key: &#key, value: Option<&#value>) -> Result<Option<&'txn #value>, #txnerr<Self::#error>> {

Replacement in pijul-macros/src/lib.rs at line 71 [13.445]

B:BD[14.939] → [14.939:1004]

                    Err(TxnErr(SanakirjaError::PristineCorrupt))

[14.939]

[14.1004]

                    Err(#txnerr(SanakirjaError::PristineCorrupt))

Insertion in pijul-macros/src/lib.rs at line 96 [13.445]

[12.867]

[13.3586]

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

Replacement in pijul-macros/src/lib.rs at line 104 [13.445]

B:BD[13.3671] → [14.1037:1194]

        fn #name_get<'txn>(&'txn self, db: &Self::#name_capital, key: &#key, value: Option<&#value>) -> Result<Option<&'txn #value>, TxnErr<Self::#error>> {

[13.3671]

[14.1194]

        fn #name_get<'txn>(&'txn self, db: &Self::#name_capital, key: &#key, value: Option<&#value>) -> Result<Option<&'txn #value>, #txnerr<Self::#error>> {

Replacement in pijul-macros/src/lib.rs at line 110 [13.445]

B:BD[14.1428] → [14.1428:1493]

                    Err(TxnErr(SanakirjaError::PristineCorrupt))

[14.1428]

[14.1493]

                    Err(#txnerr(SanakirjaError::PristineCorrupt))

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

[12.1362]

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

Replacement in pijul-macros/src/lib.rs at line 142 [13.445]

B:BD[13.4594] → [14.1512:1642]

        fn #name_get<'txn>(&'txn self, key: &#key, value: Option<&#value>) -> Result<Option<&'txn #value>, TxnErr<Self::#error>>;

[13.4594]

[13.4709]

        fn #name_get<'txn>(&'txn self, key: &#key, value: Option<&#value>) -> Result<Option<&'txn #value>, #txnerr<Self::#error>>;

Insertion in pijul-macros/src/lib.rs at line 164 [13.445]

[12.1678]

[13.5398]

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

Replacement in pijul-macros/src/lib.rs at line 172 [13.445]

B:BD[13.5483] → [14.1643:1799]

        fn #name_get<'txn>(&'txn self, db: &Self::#name_capital, key: &#key, value: Option<&#value>) -> Result<Option<&'txn #value>, TxnErr<Self::#error>>;

[13.5483]

[13.5624]

        fn #name_get<'txn>(&'txn self, db: &Self::#name_capital, key: &#key, value: Option<&#value>) -> Result<Option<&'txn #value>, #txnerr<Self::#error>>;

Insertion in pijul-macros/src/lib.rs at line 259 [13.445]

[12.2019]

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

Replacement in pijul-macros/src/lib.rs at line 268 [13.445]

B:BD[13.8069] → [12.2021:2142]

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

[13.8069]

[13.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 272 [13.445]

B:BD[13.8200] → [12.2143:2261]

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

[13.8200]

[13.8288]

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

Replacement in pijul-macros/src/lib.rs at line 283 [13.445]

B:BD[13.8573] → [14.2378:2461]

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

[13.8573]

[13.8641]

            ) -> Result<Option<(&'txn #key, &'txn #value)>, #txnerr<Self::#error>>;

Replacement in pijul-macros/src/lib.rs at line 287 [13.445]

B:BD[13.8753] → [14.2462:2545]

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

[13.8753]

[13.8794]

            ) -> Result<Option<(&'txn #key, &'txn #value)>, #txnerr<Self::#error>>;

Replacement in pijul-macros/src/lib.rs at line 296 [13.445]

∅:D[14.2597] → [12.2406:2518]

B:BD[13.9053] → [12.2406:2518]

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

[14.2597]

[13.9135]

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

Insertion in pijul-macros/src/lib.rs at line 381 [13.445]

[13.11795]


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

Replacement in pijul-macros/src/lib.rs at line 395 [13.445]

∅:D[14.2773] → [15.0:110]

B:BD[13.12375] → [15.0:110]

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

[14.2773]

[13.12460]

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

Replacement in pijul-macros/src/lib.rs at line 409 [13.445]

∅:D[14.2829] → [15.111:213]

B:BD[13.12848] → [15.111:213]

            ) -> Result<Cursor<Self, RT, Self::#cursor_name, #key, #value>, TxnErr<SanakirjaError>> {

[14.2829]

[14.2830]

            ) -> Result<Cursor<Self, RT, Self::#cursor_name, #key, #value>, #txnerr<SanakirjaError>> {

Replacement in pijul-macros/src/lib.rs at line 433 [13.445]

∅:D[14.3317] → [12.3092:3212]

B:BD[13.13495] → [12.3092:3212]

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

[14.3317]

[14.3318]

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

Replacement in pijul-macros/src/lib.rs at line 455 [13.445]

∅:D[14.3775] → [15.247:357]

B:BD[13.14294] → [15.247:357]

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

[14.3775]

[14.3776]

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

Replacement in pijul-macros/src/lib.rs at line 472 [13.445]

B:BD[13.14808] → [14.4128:4214]

            ) -> Result<Option<(&'txn #key, &'txn #value)>, TxnErr<SanakirjaError>> {

[13.14808]

[14.4214]

            ) -> Result<Option<(&'txn #key, &'txn #value)>, #txnerr<SanakirjaError>> {

Replacement in pijul-macros/src/lib.rs at line 476 [13.445]

B:BD[12.4273] → [12.4273:4345]

                    return Err(TxnErr(SanakirjaError::PristineCorrupt))

[12.4273]

[12.4345]

                    return Err(#txnerr(SanakirjaError::PristineCorrupt))

Replacement in pijul-macros/src/lib.rs at line 483 [13.445]

B:BD[13.15095] → [14.4302:4388]

            ) -> Result<Option<(&'txn #key, &'txn #value)>, TxnErr<SanakirjaError>> {

[13.15095]

[14.4388]

            ) -> Result<Option<(&'txn #key, &'txn #value)>, #txnerr<SanakirjaError>> {

Replacement in pijul-macros/src/lib.rs at line 487 [13.445]

B:BD[12.4603] → [12.4603:4675]

                    return Err(TxnErr(SanakirjaError::PristineCorrupt))

[12.4603]

[12.4675]

                    return Err(#txnerr(SanakirjaError::PristineCorrupt))

Insertion in pijul-macros/src/lib.rs at line 534 [13.445]

[12.5203]

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

Replacement in pijul-macros/src/lib.rs at line 548 [13.445]

B:BD[13.16641] → [14.4589:4668]

                type Item = Result<(&'a #key, &'a #value), TxnErr<T::#error>>;

[13.16641]

[12.5422]

                type Item = Result<(&'a #key, &'a #value), #txnerr<T::#error>>;

Replacement in pijul-macros/src/lib.rs at line 563 [13.445]

B:BD[13.17061] → [14.4782:4884]

                pub fn prev(&mut self) -> Option<Result<(&'a #key, &'a #value), TxnErr<T::#error>>> {

[13.17061]

[12.5867]

                pub fn prev(&mut self) -> Option<Result<(&'a #key, &'a #value), #txnerr<T::#error>>> {

Replacement in pijul-macros/src/lib.rs at line 573 [13.445]

B:BD[13.17366] → [14.4995:5074]

                type Item = Result<(&'a #key, &'a #value), TxnErr<T::#error>>;

[13.17366]

[12.6305]

                type Item = Result<(&'a #key, &'a #value), #txnerr<T::#error>>;

Insertion in pijul-macros/src/lib.rs at line 605 [13.445]

[12.6774]

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

Replacement in pijul-macros/src/lib.rs at line 619 [13.445]
∅:D[14.5121] → [12.6782:6831]
B:BD[13.18449] → [12.6782:6831]
```
        ) -> Result<bool, TxnErr<Self::#error>>;
```
[14.5121]
[13.18514]
```
        ) -> Result<bool, #txnerr<Self::#error>>;
```
Replacement in pijul-macros/src/lib.rs at line 624 [13.445]
∅:D[14.5176] → [12.6832:6881]
B:BD[13.18606] → [12.6832:6881]
```
        ) -> Result<bool, TxnErr<Self::#error>>;
```
[14.5176]
[13.18648]
```
        ) -> Result<bool, #txnerr<Self::#error>>;
```

Insertion in pijul-macros/src/lib.rs at line 648 [13.445]

[12.7061]

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

Replacement in pijul-macros/src/lib.rs at line 662 [13.445]

B:BD[14.5306] → [14.5306:5451]

        ) -> Result<bool, TxnErr<Self::#error>> {
            Ok(::sanakirja::btree::put(&mut self.txn, &mut self.#name, k, v).map_err(TxnErr)?)

[14.5306]

[14.5451]

        ) -> Result<bool, #txnerr<Self::#error>> {
            Ok(::sanakirja::btree::put(&mut self.txn, &mut self.#name, k, v).map_err(#txnerr)?)

Replacement in pijul-macros/src/lib.rs at line 669 [13.445]

B:BD[14.5555] → [14.5555:5700]

        ) -> Result<bool, TxnErr<Self::#error>> {
            Ok(::sanakirja::btree::del(&mut self.txn, &mut self.#name, k, v).map_err(TxnErr)?)

[14.5555]

[14.5700]

        ) -> Result<bool, #txnerr<Self::#error>> {
            Ok(::sanakirja::btree::del(&mut self.txn, &mut self.#name, k, v).map_err(#txnerr)?)

Replacement in pijul/src/remote/mod.rs at line 433 [13.52474]

B:BD[13.56691] → [16.603:664]

    pub async fn update_changelist<T: MutTxnTExt + TxnTExt>(

[13.56691]

[13.56739]

    pub async fn update_changelist<T: MutTxnTExt + TxnTExt + 'static>(

Replacement in pijul/src/remote/mod.rs at line 771 [13.52474]
∅:D[4.1242] → [17.6651:6694]
B:BD[17.6651] → [17.6651:6694]
```
    async fn get_id<T: libpijul::TxnTExt>(
```
[4.1242]
[17.6694]
```
    async fn get_id<T: libpijul::TxnTExt + 'static>(
```

Replacement in pijul/src/remote/mod.rs at line 781 [13.52474]

B:BD[17.7116] → [4.1379:1435]

                    Ok(Some(*txn.id(&*channel.read())))

[17.7116]

[18.2110]

                    Ok(txn.id(&*channel.read()).cloned())

Replacement in pijul/src/remote/mod.rs at line 854 [13.52474]

B:BD[13.65147] → [19.10495:10543]

    pub async fn upload_changes<T: MutTxnTExt>(

[20.7]

[13.65180]

    pub async fn upload_changes<T: MutTxnTExt + 'static>(

Replacement in pijul/src/remote/mod.rs at line 935 [13.52474]

B:BD[13.68736] → [21.650:710]

    pub async fn pull<T: MutTxnTExt + TxnTExt + GraphIter>(

[13.68736]

[22.99]

    pub async fn pull<T: MutTxnTExt + TxnTExt + GraphIter + 'static>(

Replacement in pijul/src/remote/mod.rs at line 1049 [13.52474]

B:BD[13.70881] → [21.1406:1471]

    pub async fn clone_tag<T: MutTxnTExt + TxnTExt + GraphIter>(

[13.70881]

[13.70934]

    pub async fn clone_tag<T: MutTxnTExt + TxnTExt + GraphIter + 'static>(

Replacement in pijul/src/remote/mod.rs at line 1116 [13.52474]

B:BD[13.73029] → [21.1961:2028]

    pub async fn clone_state<T: MutTxnTExt + TxnTExt + GraphIter>(

[13.73029]

[13.73084]

    pub async fn clone_state<T: MutTxnTExt + TxnTExt + GraphIter + 'static>(

Replacement in pijul/src/remote/mod.rs at line 1232 [13.52474]

B:BD[13.77726] → [21.2672:2741]

    pub async fn clone_channel<T: MutTxnTExt + TxnTExt + GraphIter>(

[13.77726]

[13.77783]

    pub async fn clone_channel<T: MutTxnTExt + TxnTExt + GraphIter + 'static>(

Replacement in pijul/src/remote/local.rs at line 44 [13.79745]

B:BD[17.8812] → [23.648:690]

            Ok(*txn.id(&*channel.read()))

[17.8812]

[17.8869]

            Ok(*txn.id(&*channel.read()).unwrap())

Replacement in pijul/src/remote/local.rs at line 224 [13.79745]

B:BD[18.3753] → [16.970:1047]

pub fn upload_changes<T: MutTxnTExt, C: libpijul::changestore::ChangeStore>(

[18.3753]

[24.911]

pub fn upload_changes<T: MutTxnTExt + 'static, C: libpijul::changestore::ChangeStore>(

Replacement in pijul/src/commands/tag.rs at line 20 [25.74]

B:BD[25.700] → [25.700:722]

    /// Create a tag.

[25.700]

[25.722]

    /// Create a tag, which are compressed channels. Note that tags
    /// are not independent from the changes they contain.

Insertion in pijul/src/commands/tag.rs at line 53 [25.74]

[25.1459]

    },
    /// Restore a tag into a new channel.
    #[clap(name = "reset")]
    Reset {
        /// Set the repository where this command should run. Defaults to
        /// the first ancestor of the current directory that contains a
        /// `.pijul` directory.
        #[clap(long = "repository")]
        repo_path: Option<PathBuf>,
        tag: String,

Insertion in pijul/src/commands/tag.rs at line 152 [25.74]

[26.245]

[25.4565]

            }
            Some(SubCommand::Reset { repo_path, tag }) => {
                let repo = Repository::find_root(repo_path)?;
                let mut tag_path = repo.path.join(libpijul::DOT_DIR);
                tag_path.push("tags");
                let h = if let Some(h) = libpijul::Hash::from_base32(tag.as_bytes()) {
                    libpijul::changestore::filesystem::push_filename(&mut tag_path, &h);
                    h
                } else {
                    super::find_hash(&mut tag_path, &tag)?
                };
                let tag = libpijul::tag::txn::TagTxn::new(&tag_path).unwrap();
                let txn = libpijul::tag::txn::WithTag {
                    tag,
                    txn: repo.pristine.mut_txn_begin()?,
                };
                let channel = txn.channel();
                let txn = ArcTxn::new(txn);
                libpijul::output::output_repository_no_pending_(
                    &repo.working_copy,
                    &repo.changes,
                    &txn,
                    &channel,
                    "",
                    true,
                    None,
                    num_cpus::get(),
                    0,
                )?;
                if let Ok(txn) = std::sync::Arc::try_unwrap(txn.0) {
                    txn.into_inner().txn.commit()?
                }
                writeln!(stdout, "Reset to tag {}", h.to_base32())?;

Replacement in pijul/src/commands/log.rs at line 11 [13.134376]

B:BD[13.134460] → [27.0:93]

use libpijul::pristine::{sanakirja::Txn, ChannelRef, DepsTxnT, GraphTxnT, TreeTxnT, TxnErr};

[13.134460]

[16.3357]

use libpijul::pristine::{
    sanakirja::Txn, ChannelRef, DepsTxnT, GraphTxnT, TreeErr, TreeTxnT, TxnErr,
};

Replacement in pijul/src/commands/log.rs at line 106 [13.134376]

B:BD[27.2079] → [27.2079:2161]

    Fs(#[from] libpijul::FsError<libpijul::pristine::sanakirja::SanakirjaError>),

[27.2079]

[27.2161]

    TreeErr(#[from] TreeErr<libpijul::pristine::sanakirja::SanakirjaError>),
    #[error(transparent)]
    Fs(#[from] libpijul::FsError<libpijul::pristine::sanakirja::Txn>),

Replacement in pijul/src/commands/git.rs at line 733 [13.137210]

B:BD[13.160679] → [28.888:1006]

) -> Result<
    (usize, Option<libpijul::Hash>, libpijul::Merkle),
    libpijul::LocalApplyError<T::GraphError>,
> {

[13.160679]

[29.85]

) -> Result<(usize, Option<libpijul::Hash>, libpijul::Merkle), libpijul::LocalApplyError<T>> {

Replacement in pijul/Cargo.toml at line 53 [13.196374]
B:BD[13.197401] → [30.1709:1731]
```
clap = "3.0.0-beta.5"
```
[13.197401]
[13.197423]
```
clap = { version = "3.0.0-rc.0", features = [ "derive", "cargo" ] }
```

Replacement in libpijul/src/working_copy/filesystem.rs at line 2 [13.208900]

B:BD[13.208970] → [31.653:699]

use crate::pristine::{ArcTxn, InodeMetadata};

[13.208970]

[32.1191]

use crate::pristine::{ArcTxn, GraphTxnT, InodeMetadata, TreeErr, TreeTxnT, TxnErr};

Replacement in libpijul/src/working_copy/filesystem.rs at line 87 [13.208900]
B:BD[33.3253] → [33.3253:3277]
B:BD[33.3277] → [33.3277:3329]
```
#[derive(Debug, Error)]
pub enum AddError<T: std::error::Error + 'static> {
```
[33.3253]
[33.3329]
```
#[derive(Error)]
pub enum AddError<T: GraphTxnT + TreeTxnT> {
```

Replacement in libpijul/src/working_copy/filesystem.rs at line 97 [13.208900]

B:BD[13.209918] → [33.3514:3538]

B:BD[33.3538] → [33.3538:3619]

#[derive(Debug, Error)]
pub enum Error<C: std::error::Error + 'static, T: std::error::Error + 'static> {

[13.209918]

[33.3619]

impl<T: GraphTxnT + TreeTxnT> std::fmt::Debug for AddError<T> {
    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            AddError::Ignore(e) => std::fmt::Debug::fmt(e, fmt),
            AddError::Io(e) => std::fmt::Debug::fmt(e, fmt),
            AddError::Fs(e) => std::fmt::Debug::fmt(e, fmt),
        }
    }
}
#[derive(Error)]
pub enum Error<C: std::error::Error + 'static, T: GraphTxnT + TreeTxnT> {

Replacement in libpijul/src/working_copy/filesystem.rs at line 114 [13.208900]

B:BD[34.3046] → [34.3046:3066]

    Txn(#[from] T),

[34.3046]

[34.3066]

    Txn(#[from] TxnErr<T::GraphError>),
    #[error(transparent)]
    Tree(#[from] TreeErr<T::TreeError>),
}
impl<C: std::error::Error + 'static, T: GraphTxnT + TreeTxnT> std::fmt::Debug for Error<C, T> {
    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            Error::Add(e) => std::fmt::Debug::fmt(e, fmt),
            Error::Record(e) => std::fmt::Debug::fmt(e, fmt),
            Error::Txn(e) => std::fmt::Debug::fmt(e, fmt),
            Error::Tree(e) => std::fmt::Debug::fmt(e, fmt),
        }
    }

Replacement in libpijul/src/working_copy/filesystem.rs at line 170 [13.208900]
∅:D[35.1775] → [36.27831:27883]
B:BD[37.398] → [36.27831:27883]
```
    ) -> Result<(), Error<C::Error, T::GraphError>>
```
[35.1775]
[36.27883]
```
    ) -> Result<(), Error<C::Error, T>>
```
Replacement in libpijul/src/working_copy/filesystem.rs at line 208 [13.208900]
∅:D[35.1841] → [12.19632:19679]
B:BD[37.875] → [12.19632:19679]
```
    ) -> Result<(), AddError<T::GraphError>> {
```
[35.1841]
[34.3637]
```
    ) -> Result<(), AddError<T>> {
```
Replacement in libpijul/src/working_copy/filesystem.rs at line 315 [13.208900]
∅:D[35.1968] → [36.28356:28408]
B:BD[37.3130] → [36.28356:28408]
```
    ) -> Result<(), Error<C::Error, T::GraphError>>
```
[35.1968]
[36.28408]
```
    ) -> Result<(), Error<C::Error, T>>
```

Replacement in libpijul/src/working_copy/filesystem.rs at line 324 [13.208900]

B:BD[29.1238] → [29.1238:1294]

                if !txn.read().is_tracked(&path_str)? {

[29.1238]

[29.1294]

                if !crate::fs::is_tracked(&*txn.read(), &path_str)? {

Replacement in libpijul/src/unrecord/working_copy.rs at line 6 [13.225940]
B:BD[38.1] → [12.19820:19847]
B:BD[12.19847] → [12.19847:19924]
B:BD[12.19924] → [12.19924:19927]
```
pub fn undo_file_addition<
    T: GraphMutTxnT + TreeMutTxnT<TreeError = <T as GraphTxnT>::GraphError>,
>(
```
[38.1]
[13.226191]
```
pub fn undo_file_addition<T: TreeMutTxnT>(
```
Replacement in libpijul/src/unrecord/working_copy.rs at line 10 [13.225940]
B:BD[13.226275] → [12.19928:19969]
```
) -> Result<(), TxnErr<T::GraphError>> {
```
[13.226275]
[13.226308]
```
) -> Result<(), TreeErr<T::TreeError>> {
```

Replacement in libpijul/src/unrecord/working_copy.rs at line 23 [13.225940]

B:BD[38.3] → [12.20032:20059]

B:BD[12.20059] → [12.20059:20146]

B:BD[12.20146] → [12.20146:20169]

pub fn undo_file_deletion<
    T: ChannelTxnT + TreeMutTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
    P: ChangeStore,
>(

[38.3]

[13.226784]

pub fn undo_file_deletion<T: ChannelTxnT + TreeMutTxnT + TreeTxnT, P: ChangeStore>(

Replacement in libpijul/src/unrecord/working_copy.rs at line 30 [13.225940]
∅:D[35.2060] → [12.20170:20234]
B:BD[13.226907] → [12.20170:20234]
```
) -> Result<(), super::UnrecordError<P::Error, T::TreeError>> {
```
[35.2060]
[13.226940]
```
) -> Result<(), super::UnrecordError<P::Error, T>> {
```

Replacement in libpijul/src/unrecord/working_copy.rs at line 43 [13.225940]

B:BD[38.5] → [12.20335:20347]

B:BD[12.20347] → [12.20347:20434]

B:BD[12.20434] → [12.20434:20457]

fn restore<
    T: ChannelTxnT + TreeMutTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
    P: ChangeStore,
>(

[38.5]

[13.227468]

fn restore<T: ChannelTxnT + TreeMutTxnT + TreeTxnT, P: ChangeStore>(

Replacement in libpijul/src/unrecord/working_copy.rs at line 50 [13.225940]
∅:D[35.2141] → [12.20458:20522]
B:BD[13.227588] → [12.20458:20522]
```
) -> Result<(), super::UnrecordError<P::Error, T::TreeError>> {
```
[35.2141]
[13.227621]
```
) -> Result<(), super::UnrecordError<P::Error, T>> {
```

Replacement in libpijul/src/unrecord/working_copy.rs at line 96 [13.225940]

B:BD[38.9] → [12.20957:20975]

B:BD[12.20975] → [12.20975:21060]

B:BD[12.21060] → [12.21060:21083]

fn restore_inode<
    T: TreeMutTxnT + GraphTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
    P: ChangeStore,
>(

[38.9]

[13.228969]

fn restore_inode<T: TreeMutTxnT + GraphTxnT + TreeTxnT, P: ChangeStore>(

Replacement in libpijul/src/unrecord/working_copy.rs at line 103 [13.225940]
∅:D[35.2429] → [39.424:499]
B:BD[13.229088] → [39.424:499]
```
) -> Result<Option<Inode>, super::UnrecordError<P::Error, T::TreeError>> {
```
[35.2429]
[13.229174]
```
) -> Result<Option<Inode>, super::UnrecordError<P::Error, T>> {
```
Replacement in libpijul/src/unrecord/working_copy.rs at line 185 [13.225940]
B:BD[13.230916] → [12.21983:22047]
```
) -> Result<(), super::UnrecordError<P::Error, T::TreeError>> {
```
[13.230916]
[13.230949]
```
) -> Result<(), super::UnrecordError<P::Error, T>> {
```

Replacement in libpijul/src/unrecord/mod.rs at line 11 [13.231493]

B:BD[13.231752] → [33.7674:7773]

B:BD[33.7773] → [33.7773:7816]

B:BD[33.7816] → [33.7816:7820]

#[derive(Debug, Error)]
pub enum UnrecordError<
    ChangestoreError: std::error::Error + 'static,
    TxnError: std::error::Error + 'static,
> {

[13.231752]

[33.7820]

#[derive(Error)]
pub enum UnrecordError<ChangestoreError: std::error::Error + 'static, T: GraphTxnT + TreeTxnT> {

Replacement in libpijul/src/unrecord/mod.rs at line 16 [13.231493]

B:BD[33.7920] → [33.7920:7939]

    Txn(TxnError),

[33.7920]

[33.7939]

    Txn(#[from] TxnErr<T::GraphError>),
    #[error(transparent)]
    Tree(#[from] TreeErr<T::TreeError>),

Replacement in libpijul/src/unrecord/mod.rs at line 20 [13.231493]

B:BD[33.7965] → [12.22179:22237]

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

[33.7965]

[33.8013]

    Block(#[from] crate::pristine::BlockError<T::GraphError>),

Replacement in libpijul/src/unrecord/mod.rs at line 22 [13.231493]

B:BD[33.8039] → [12.22238:22317]

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

[33.8039]

[33.8108]

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

Replacement in libpijul/src/unrecord/mod.rs at line 31 [13.231493]

B:BD[33.8352] → [33.8352:8421]

    Missing(#[from] crate::missing_context::MissingError<TxnError>),

[33.8352]

[33.8421]

    Missing(#[from] crate::missing_context::MissingError<T::GraphError>),

Replacement in libpijul/src/unrecord/mod.rs at line 33 [13.231493]

B:BD[33.8447] → [33.8447:8512]

    LocalApply(#[from] crate::apply::LocalApplyError<TxnError>),

[33.8447]

[33.8512]

    LocalApply(#[from] crate::apply::LocalApplyError<T>),

Replacement in libpijul/src/unrecord/mod.rs at line 35 [13.231493]

B:BD[33.8538] → [33.8538:8611]

    Apply(#[from] crate::apply::ApplyError<ChangestoreError, TxnError>),

[33.8538]

[12.22318]

    Apply(#[from] crate::apply::ApplyError<ChangestoreError, T>),

Replacement in libpijul/src/unrecord/mod.rs at line 38 [13.231493]

B:BD[12.22321] → [12.22321:22518]

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)

[12.22321]

[12.22518]

impl<C: std::error::Error, T: GraphTxnT + TreeTxnT> std::fmt::Debug for UnrecordError<C, T> {
    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            UnrecordError::Changestore(e) => std::fmt::Debug::fmt(e, fmt),
            UnrecordError::Txn(e) => std::fmt::Debug::fmt(e, fmt),
            UnrecordError::Tree(e) => std::fmt::Debug::fmt(e, fmt),
            UnrecordError::Block(e) => std::fmt::Debug::fmt(e, fmt),
            UnrecordError::InconsistentChange(e) => std::fmt::Debug::fmt(e, fmt),
            UnrecordError::ChangeNotInChannel { hash } => {
                write!(fmt, "Change not in channel: {}", hash.to_base32())
            }
            UnrecordError::ChangeIsDependedUpon {
                change_id,
                dependent,
            } => write!(
                fmt,
                "Change {} is depended upon: {}",
                change_id.to_base32(),
                dependent.to_base32()
            ),
            UnrecordError::Missing(e) => std::fmt::Debug::fmt(e, fmt),
            UnrecordError::LocalApply(e) => std::fmt::Debug::fmt(e, fmt),
            UnrecordError::Apply(e) => std::fmt::Debug::fmt(e, fmt),
        }

Replacement in libpijul/src/unrecord/mod.rs at line 71 [13.231493]
∅:D[35.2521] → [12.22525:22585]
B:BD[13.231881] → [12.22525:22585]
```
) -> Result<bool, UnrecordError<P::Error, T::GraphError>> {
```
[35.2521]
[33.8670]
```
) -> Result<bool, UnrecordError<P::Error, T>> {
```

Replacement in libpijul/src/unrecord/mod.rs at line 103 [13.231493]

B:BD[12.23047] → [12.23047:23123]

    T: ChannelMutTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>,

[12.23047]

[12.23123]

    T: ChannelMutTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError> + TreeTxnT,

Replacement in libpijul/src/unrecord/mod.rs at line 109 [13.231493]
B:BD[13.232905] → [12.23147:23205]
```
) -> Result<(), UnrecordError<P::Error, T::GraphError>> {
```
[13.232905]
[14.16307]
```
) -> Result<(), UnrecordError<P::Error, T>> {
```
Replacement in libpijul/src/unrecord/mod.rs at line 163 [13.231493]
∅:D[35.2606] → [12.23858:23916]
B:BD[13.234187] → [12.23858:23916]
```
) -> Result<(), UnrecordError<C::Error, T::GraphError>> {
```
[35.2606]
[13.234220]
```
) -> Result<(), UnrecordError<C::Error, T>> {
```
Replacement in libpijul/src/unrecord/mod.rs at line 255 [13.231493]
B:BD[13.235980] → [12.24790:24845]
```
fn unapply_newvertex<T: GraphMutTxnT, C: ChangeStore>(
```
[13.235980]
[13.236239]
```
fn unapply_newvertex<T: GraphMutTxnT + TreeTxnT, C: ChangeStore>(
```
Replacement in libpijul/src/unrecord/mod.rs at line 261 [13.231493]
B:BD[13.236377] → [12.24875:24933]
```
) -> Result<(), UnrecordError<C::Error, T::GraphError>> {
```
[13.236377]
[13.236410]
```
) -> Result<(), UnrecordError<C::Error, T>> {
```

Replacement in libpijul/src/unrecord/mod.rs at line 300 [13.231493]

B:BD[40.1166] → [12.25014:25067]

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

[40.1166]

[40.1214]

    fn perform_del<C: ChangeStore, T: GraphMutTxnT + TreeTxnT>(

Replacement in libpijul/src/unrecord/mod.rs at line 305 [13.231493]

B:BD[40.1322] → [12.25101:25163]

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

[40.1322]

[40.1379]

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

Replacement in libpijul/src/unrecord/mod.rs at line 325 [13.231493]

B:BD[13.238934] → [12.25181:25244]

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

[13.238934]

[13.238976]

fn repair_newvertex_contexts<T: GraphMutTxnT + TreeTxnT, C: ChangeStore>(

Replacement in libpijul/src/unrecord/mod.rs at line 330 [13.231493]
B:BD[40.1508] → [12.25274:25332]
```
) -> Result<(), UnrecordError<C::Error, T::GraphError>> {
```
[40.1508]
[13.239080]
```
) -> Result<(), UnrecordError<C::Error, T>> {
```
Replacement in libpijul/src/unrecord/mod.rs at line 380 [13.231493]
B:BD[33.10239] → [12.25474:25525]
```
fn unapply_edges<T: GraphMutTxnT, P: ChangeStore>(
```
[33.10239]
[13.240406]
```
fn unapply_edges<T: GraphMutTxnT + TreeTxnT, P: ChangeStore>(
```
Replacement in libpijul/src/unrecord/mod.rs at line 388 [13.231493]
B:BD[13.240557] → [12.25555:25613]
```
) -> Result<(), UnrecordError<P::Error, T::GraphError>> {
```
[13.240557]
[13.240590]
```
) -> Result<(), UnrecordError<P::Error, T>> {
```
Replacement in libpijul/src/unrecord/mod.rs at line 448 [13.231493]
B:BD[13.241975] → [12.25746:25797]
```
fn must_reintroduce<T: GraphTxnT, C: ChangeStore>(
```
[13.241975]
[13.242021]
```
fn must_reintroduce<T: GraphTxnT + TreeTxnT, C: ChangeStore>(
```
Replacement in libpijul/src/unrecord/mod.rs at line 457 [13.231493]
B:BD[40.1958] → [12.25823:25883]
```
) -> Result<bool, UnrecordError<C::Error, T::GraphError>> {
```
[40.1958]
[13.242203]
```
) -> Result<bool, UnrecordError<C::Error, T>> {
```
Replacement in libpijul/src/unrecord/mod.rs at line 487 [13.231493]
B:BD[13.243264] → [12.26210:26263]
```
fn edge_is_in_channel<T: GraphTxnT, C: ChangeStore>(
```
[13.243264]
[13.243312]
```
fn edge_is_in_channel<T: GraphTxnT + TreeTxnT, C: ChangeStore>(
```
Replacement in libpijul/src/unrecord/mod.rs at line 493 [13.231493]
B:BD[13.243431] → [12.26264:26324]
```
) -> Result<bool, UnrecordError<C::Error, T::GraphError>> {
```
[13.243431]
[13.243466]
```
) -> Result<bool, UnrecordError<C::Error, T>> {
```
Replacement in libpijul/src/unrecord/mod.rs at line 514 [13.231493]
B:BD[13.243938] → [12.26556:26608]
```
fn remove_zombies<T: GraphMutTxnT, C: ChangeStore>(
```
[13.243938]
[13.243969]
```
fn remove_zombies<T: GraphMutTxnT + TreeTxnT, C: ChangeStore>(
```
Replacement in libpijul/src/unrecord/mod.rs at line 520 [13.231493]
B:BD[13.244079] → [12.26638:26696]
```
) -> Result<(), UnrecordError<C::Error, T::GraphError>> {
```
[13.244079]
[13.244208]
```
) -> Result<(), UnrecordError<C::Error, T>> {
```

Replacement in libpijul/src/unrecord/mod.rs at line 575 [13.231493]

B:BD[40.3886] → [12.27056:27114]

fn repair_edges_context<T: GraphMutTxnT, P: ChangeStore>(

[40.3886]

[13.246914]

fn repair_edges_context<T: GraphMutTxnT + TreeTxnT, P: ChangeStore>(

Replacement in libpijul/src/unrecord/mod.rs at line 582 [13.231493]
B:BD[13.247082] → [12.27144:27202]
```
) -> Result<(), UnrecordError<P::Error, T::GraphError>> {
```
[13.247082]
[41.461]
```
) -> Result<(), UnrecordError<P::Error, T>> {
```
Replacement in libpijul/src/tests/unrecord.rs at line 335 [13.248807]
B:BD[31.6130] → [11.50:90]
```
    )?.into_iter().collect::<Vec<_>>();
```
[31.6130]
[13.260719]
```
    )?
    .into_iter()
    .collect::<Vec<_>>();
```
Insertion in libpijul/src/tests/text_changes.rs at line 74 [42.550]
[42.7713]
[42.7713]
```
use crate::quickcheck::{Arbitrary, Gen};
```

Replacement in libpijul/src/tests/text_changes.rs at line 80 [42.550]

B:BD[42.7782] → [42.7782:7815]

    fn go(hunk: PrintableHunk) {

[42.7782]

[42.7815]

    fn go(mut hunk: PrintableHunk) {
        match hunk {
            PrintableHunk::FileAddition {
                ref perms,
                ref mut contents,
                ..
            } => {
                if let PrintablePerms::IsDir = perms {
                    contents.clear()
                }
            }
            PrintableHunk::FileDel {
                ref mut del_edges, ..
            } => {
                if del_edges.is_empty() {
                    del_edges.push(PrintableEdge::arbitrary(&mut Gen::new(3)))
                }
            }
            PrintableHunk::FileUndel {
                ref mut undel_edges,
                ..
            } => {
                if undel_edges.is_empty() {
                    undel_edges.push(PrintableEdge::arbitrary(&mut Gen::new(3)))
                }
            }
            PrintableHunk::Replace {
                ref mut change_contents,
                ref mut replacement_contents,
                ..
            } => {
                if change_contents.is_empty() {
                    change_contents.push(b'a')
                }
                if replacement_contents.is_empty() {
                    replacement_contents.push(b'b')
                }
            }
            PrintableHunk::Edit {
                ref mut change,
                ref mut contents,
                ..
            } => {
                if let PrintableAtom::Edges(ref mut change) = change {
                    if change.is_empty() {
                        change.push(PrintableEdge::arbitrary(&mut Gen::new(3)))
                    }
                }
                if std::str::from_utf8(contents).is_err() {
                    contents.clear();
                    contents.extend(b"bla\n".iter().cloned())
                }
            }
            _ => {}
        }

Replacement in libpijul/src/tests/file_conflicts.rs at line 918 [13.305506]
B:BD[31.40603] → [11.291:331]
```
    )?.into_iter().collect::<Vec<_>>();
```
[31.40603]
[13.335741]
```
    )?
    .into_iter()
    .collect::<Vec<_>>();
```
Replacement in libpijul/src/tests/file_conflicts.rs at line 966 [13.305506]
B:BD[31.41437] → [11.332:372]
```
    )?.into_iter().collect::<Vec<_>>();
```
[31.41437]
[31.41438]
```
    )?
    .into_iter()
    .collect::<Vec<_>>();
```
Replacement in libpijul/src/tests/file_conflicts.rs at line 1002 [13.305506]
B:BD[31.41902] → [11.421:461]
```
    )?.into_iter().collect::<Vec<_>>();
```
[31.41902]
[11.461]
```
    )?
    .into_iter()
    .collect::<Vec<_>>();
```
Insertion in libpijul/src/tag.rs at line 9 [25.6397]
[25.6585]
[25.6585]
```
use std::io::{Seek, SeekFrom};
```

Replacement in libpijul/src/tag.rs at line 13 [25.6397]

B:BD[25.6637] → [25.6637:6687]

#[derive(Debug, Serialize, Deserialize, Default)]

[25.6637]

[7.0]

pub mod txn;
#[derive(Debug, Serialize, Deserialize, Default, Clone)]

Replacement in libpijul/src/tag.rs at line 26 [25.6397]

B:BD[25.6841] → [25.6841:6891]

#[derive(Debug, Serialize, Deserialize, Default)]

[25.6841]

[7.184]

#[derive(Debug, Serialize, Deserialize, Default, Clone)]

Insertion in libpijul/src/tag.rs at line 66 [25.6397]

[25.7675]

impl From<TxnErr<SanakirjaError>> for TxnErr<TagError> {
    fn from(e: TxnErr<SanakirjaError>) -> Self {
        TxnErr(TagError::Txn(e.0))
    }
}

Deletion in libpijul/src/tag.rs at line 82 [25.6397]
B:BD[26.1749] → [26.1749:1788]
```
        use std::io::{Seek, SeekFrom};
```
Deletion in libpijul/src/tag.rs at line 101 [25.6397]
B:BD[25.8219] → [25.8219:8254]
```
    use std::io::{Seek, SeekFrom};
```

Replacement in libpijul/src/record.rs at line 16 [13.488880]

B:BD[33.11034] → [33.11034:11142]

B:BD[33.11142] → [33.11142:11178]

B:BD[33.11178] → [33.11178:11182]

#[derive(Debug, Error)]
pub enum RecordError<
    C: std::error::Error + 'static,
    W: std::error::Error,
    T: std::error::Error + 'static,
> {

[33.11034]

[33.11182]

#[derive(Error)]
pub enum RecordError<C: std::error::Error + 'static, W: std::error::Error, T: GraphTxnT + TreeTxnT>
{

Replacement in libpijul/src/record.rs at line 26 [13.488880]

B:BD[33.11423] → [33.11423:11435]

    Txn(T),

[33.11423]

[33.11435]

    Txn(#[from] TxnErr<T::GraphError>),
    #[error(transparent)]
    Tree(#[from] TreeErr<T::TreeError>),

Replacement in libpijul/src/record.rs at line 37 [13.488880]

B:BD[13.489268] → [12.31822:32009]

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>

[13.489268]

[12.32009]

impl<C: std::error::Error, W: std::error::Error, T: GraphTxnT + TreeTxnT> std::fmt::Debug
    for RecordError<C, W, T>

Replacement in libpijul/src/record.rs at line 40 [13.488880]

B:BD[12.32011] → [12.32011:32077]

    fn from(e: TxnErr<T>) -> Self {
        RecordError::Txn(e.0)

[12.32011]

[12.32077]

    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            RecordError::Changestore(e) => std::fmt::Debug::fmt(e, fmt),
            RecordError::WorkingCopy(e) => std::fmt::Debug::fmt(e, fmt),
            RecordError::SystemTimeError(e) => std::fmt::Debug::fmt(e, fmt),
            RecordError::Txn(e) => std::fmt::Debug::fmt(e, fmt),
            RecordError::Tree(e) => std::fmt::Debug::fmt(e, fmt),
            RecordError::Diff(e) => std::fmt::Debug::fmt(e, fmt),
            RecordError::PathNotInRepo(p) => write!(fmt, "Path not in repository: {}", p),
            RecordError::Io(e) => std::fmt::Debug::fmt(e, fmt),
        }

Replacement in libpijul/src/record.rs at line 54 [13.488880]

B:BD[12.32086] → [43.0:86]

B:BD[43.86] → [43.86:126]

B:BD[43.126] → [43.126:208]

impl<
        C: std::error::Error + 'static,
        W: std::error::Error + 'static,
        T: std::error::Error + 'static,
    > std::convert::From<crate::output::FileError<C, T>> for RecordError<C, W, T>

[12.32086]

[43.208]

impl<C: std::error::Error + 'static, W: std::error::Error + 'static, T: GraphTxnT + TreeTxnT>
    std::convert::From<crate::output::FileError<C, T>> for RecordError<C, W, T>

Replacement in libpijul/src/record.rs at line 103 [13.488880]

B:BD[36.41250] → [36.41250:41310]

    pub redundant: Vec<(Vertex<ChangeId>, SerializedEdge)>,

[36.41250]

[36.41310]

    pub redundant: Vec<crate::alive::Redundant>,

Replacement in libpijul/src/record.rs at line 234 [13.488880]

B:BD[13.492241] → [36.43650:43735]

fn get_inodes_<T: ChannelTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>>(

[13.492241]

[31.96378]

fn get_inodes_<T: ChannelTxnT + TreeTxnT, C: ChangeStore, W: WorkingCopyRead>(

Replacement in libpijul/src/record.rs at line 238 [13.488880]

B:BD[36.43807] → [36.43807:43872]

) -> Result<Option<Position<ChangeId>>, TxnErr<T::GraphError>> {

[36.43807]

[31.96429]

) -> Result<Option<Position<ChangeId>>, RecordError<C::Error, W::Error, T>> {

Replacement in libpijul/src/record.rs at line 241 [13.488880]
∅:D[31.96491] → [36.43952:44009]
B:BD[36.43952] → [36.43952:44009]
```
    Ok(get_inodes(&*txn, &*channel, inode)?.map(|x| *x))
```
[31.96491]
[36.44009]
```
    Ok(get_inodes::<_, C, W>(&*txn, &*channel, inode)?.map(|x| *x))
```

Replacement in libpijul/src/record.rs at line 244 [13.488880]

∅:D[36.44012] → [14.48837:48925]

B:BD[13.492241] → [14.48837:48925]

fn get_inodes<'a, T: ChannelTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>>(

[36.44012]

[14.48925]

fn get_inodes<'a, T: ChannelTxnT + TreeTxnT, C: ChangeStore, W: WorkingCopyRead>(

Replacement in libpijul/src/record.rs at line 248 [13.488880]

B:BD[14.48961] → [14.48961:49030]

) -> Result<Option<&'a Position<ChangeId>>, TxnErr<T::GraphError>> {

[14.48961]

[12.32293]

) -> Result<Option<&'a Position<ChangeId>>, RecordError<C::Error, W::Error, T>> {

Replacement in libpijul/src/record.rs at line 295 [13.488880]
∅:D[36.44783] → [12.32586:32654]
B:BD[13.492891] → [12.32586:32654]
```
    ) -> Result<(), RecordError<C::Error, W::Error, T::GraphError>>
```
[36.44783]
[12.32654]
```
    ) -> Result<(), RecordError<C::Error, W::Error, T>>
```

Replacement in libpijul/src/record.rs at line 297 [13.488880]

B:BD[12.32664] → [36.44784:44810]

B:BD[36.44810] → [36.44810:44875]

B:BD[36.44875] → [36.44875:44936]

        T: ChannelMutTxnT
            + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>
            + Send
            + Sync
            + 'static,

[12.32664]

[36.44936]

        T: ChannelMutTxnT + TreeTxnT + Send + Sync + 'static,

Replacement in libpijul/src/record.rs at line 343 [13.488880]

B:BD[36.46611] → [44.1348:1424]

                Ok::<_, RecordError<C::Error, W::Error, T::GraphError>>(())

[36.46611]

                Ok::<_, RecordError<C::Error, W::Error, T>>(())

Replacement in libpijul/src/record.rs at line 408 [13.488880]

∅:D[45.2980] → [31.97041:97126]

B:BD[13.493753] → [31.97041:97126]

            } else if let Some(vertex) = get_inodes_(&txn, &channel, &item.inode)? {

[45.2980]

[36.47563]

            } else if let Some(vertex) = get_inodes_::<_, C, W>(&txn, &channel, &item.inode)? {

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

B:BD[46.1] → [36.50500:50533]

B:BD[36.50533] → [36.50533:50608]

B:BD[36.50608] → [47.1600:1628]

∅:D[47.1628] → [36.50632:50663]

B:BD[36.50632] → [36.50632:50663]

    fn delete_obsolete_children<
        T: GraphTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
        W: WorkingCopyRead,
        C: ChangeStore,
    >(

[46.1]

[36.50663]

    fn delete_obsolete_children<T: GraphTxnT + TreeTxnT, W: WorkingCopyRead, C: ChangeStore>(

Replacement in libpijul/src/record.rs at line 552 [13.488880]

B:BD[36.50830] → [36.50830:50898]

    ) -> Result<(), RecordError<C::Error, W::Error, T::GraphError>>

[36.50830]

[36.50898]

    ) -> Result<(), RecordError<C::Error, W::Error, T>>

Replacement in libpijul/src/record.rs at line 615 [13.488880]

B:BD[36.53353] → [36.53353:53387]

B:BD[36.53387] → [36.53387:53464]

B:BD[36.53464] → [47.1678:1706]

∅:D[47.1706] → [36.53488:53519]

B:BD[36.53488] → [36.53488:53519]

    fn push_children<
        'a,
        T: ChannelTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
        W: WorkingCopyRead,
        C: ChangeStore,
    >(

[36.53353]

[36.53519]

    fn push_children<'a, T: ChannelTxnT + TreeTxnT, W: WorkingCopyRead, C: ChangeStore>(

Replacement in libpijul/src/record.rs at line 626 [13.488880]
∅:D[48.787] → [36.53804:53872]
B:BD[36.53804] → [36.53804:53872]
```
    ) -> Result<(), RecordError<C::Error, W::Error, T::GraphError>>
```
[48.787]
[36.53872]
```
    ) -> Result<(), RecordError<C::Error, W::Error, T>>
```

Replacement in libpijul/src/record.rs at line 674 [13.488880]

B:BD[36.55614] → [36.55614:55697]

            } else if let Some(vertex) = get_inodes(txn, &channel, child_inode)? {

[36.55614]

[36.55697]

            } else if let Some(vertex) = get_inodes::<_, C, W>(txn, &channel, child_inode)? {

Replacement in libpijul/src/record.rs at line 886 [13.488880]

B:BD[13.499383] → [12.32948:32977]

B:BD[12.32977] → [36.57910:57987]

B:BD[36.57987] → [47.1883:1919]

∅:D[47.1919] → [12.33078:33109]

∅:D[31.98042] → [12.33078:33109]

B:BD[12.33078] → [12.33078:33109]

    fn record_existing_file<
        T: ChannelTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
        W: WorkingCopyRead + Clone,
        C: ChangeStore,
    >(

[13.499383]

[13.499456]

    fn record_existing_file<T: ChannelTxnT + TreeTxnT, W: WorkingCopyRead + Clone, C: ChangeStore>(

Replacement in libpijul/src/record.rs at line 898 [13.488880]

B:BD[13.499681] → [12.33110:33178]

    ) -> Result<(), RecordError<C::Error, W::Error, T::GraphError>>

[13.499681]

[12.33178]

    ) -> Result<(), RecordError<C::Error, W::Error, T>>

Replacement in libpijul/src/record.rs at line 946 [13.488880]

B:BD[45.7302] → [45.7302:7328]

B:BD[45.7328] → [45.7328:7405]

B:BD[45.7405] → [45.7405:7472]

    fn record_nondeleted<
        T: ChannelTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
        W: WorkingCopyRead + Clone,
        C: ChangeStore,
    >(

[45.7302]

[45.7472]

    fn record_nondeleted<T: ChannelTxnT + TreeTxnT, W: WorkingCopyRead + Clone, C: ChangeStore>(

Replacement in libpijul/src/record.rs at line 961 [13.488880]

B:BD[45.7876] → [45.7876:7944]

    ) -> Result<(), RecordError<C::Error, W::Error, T::GraphError>>

[45.7876]

[45.7944]

    ) -> Result<(), RecordError<C::Error, W::Error, T>>

Replacement in libpijul/src/record.rs at line 1025 [13.488880]

B:BD[13.503333] → [47.1990:2068]

    fn record_moved_file<T: ChannelTxnT, C: ChangeStore, W: WorkingCopyRead>(

[13.503333]

[13.507676]

    fn record_moved_file<T: ChannelTxnT + TreeTxnT, C: ChangeStore, W: WorkingCopyRead>(

Replacement in libpijul/src/record.rs at line 1034 [13.488880]
∅:D[49.2779] → [12.35880:35948]
B:BD[13.507905] → [12.35880:35948]
```
    ) -> Result<(), RecordError<C::Error, W::Error, T::GraphError>>
```
[49.2779]
[12.35948]
```
    ) -> Result<(), RecordError<C::Error, W::Error, T>>
```

Replacement in libpijul/src/record.rs at line 1165 [13.488880]

B:BD[46.5] → [45.10068:10147]

fn collect_former_parents<C: ChangeStore, W: WorkingCopyRead, T: ChannelTxnT>(

[46.5]

[45.10147]

fn collect_former_parents<C: ChangeStore, W: WorkingCopyRead, T: ChannelTxnT + TreeTxnT>(

Replacement in libpijul/src/record.rs at line 1170 [13.488880]

B:BD[45.10235] → [45.10235:10316]

) -> Result<(Vec<Parent>, bool), RecordError<C::Error, W::Error, T::GraphError>>

[45.10235]

[45.10316]

) -> Result<(Vec<Parent>, bool), RecordError<C::Error, W::Error, T>>

Replacement in libpijul/src/record.rs at line 1233 [13.488880]

B:BD[13.510763] → [47.2139:2213]

fn collect_moved_edges<T: GraphTxnT, C: ChangeStore, W: WorkingCopyRead>(

[13.510763]

[13.510812]

fn collect_moved_edges<T: GraphTxnT + TreeTxnT, C: ChangeStore, W: WorkingCopyRead>(

Replacement in libpijul/src/record.rs at line 1241 [13.488880]
∅:D[50.1031] → [12.36183:36255]
B:BD[13.511024] → [12.36183:36255]
```
) -> Result<MovedEdges, RecordError<C::Error, W::Error, T::GraphError>>
```
[50.1031]
[12.36255]
```
) -> Result<MovedEdges, RecordError<C::Error, W::Error, T>>
```
Replacement in libpijul/src/record.rs at line 1485 [13.488880]
∅:D[36.60939] → [12.37155:37183]
B:BD[13.518341] → [12.37155:37183]
B:BD[12.37183] → [12.37183:37258]
B:BD[12.37258] → [47.2280:2308]
∅:D[47.2308] → [49.2864:2888]
B:BD[12.37282] → [49.2864:2888]
∅:D[49.2888] → [12.37282:37289]
B:BD[12.37282] → [12.37282:37289]
```
    fn record_deleted_file<
        T: GraphTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
        W: WorkingCopyRead,
        C: ChangeStore,
    >(
```
[36.60939]
[13.518394]
```
    fn record_deleted_file<T: GraphTxnT + TreeTxnT, W: WorkingCopyRead, C: ChangeStore>(
```

Replacement in libpijul/src/record.rs at line 1493 [13.488880]

B:BD[49.2910] → [49.2910:2978]

    ) -> Result<(), RecordError<C::Error, W::Error, T::GraphError>>

[49.2910]

[49.2978]

    ) -> Result<(), RecordError<C::Error, W::Error, T>>

Replacement in libpijul/src/record.rs at line 1574 [13.488880]

B:BD[13.521266] → [47.2358:2436]

    fn delete_inode_vertex<T: GraphTxnT, C: ChangeStore, W: WorkingCopyRead>(

[13.521266]

[13.521303]

    fn delete_inode_vertex<T: GraphTxnT + TreeTxnT, C: ChangeStore, W: WorkingCopyRead>(

Replacement in libpijul/src/record.rs at line 1582 [13.488880]

B:BD[13.521458] → [51.392:460]

    ) -> Result<(), RecordError<C::Error, W::Error, T::GraphError>>

[13.521458]

[51.460]

    ) -> Result<(), RecordError<C::Error, W::Error, T>>

Insertion in libpijul/src/pristine/sanakirja.rs at line 53 [13.531056]

[12.39299]

impl std::convert::From<::sanakirja::Error> for TreeErr<SanakirjaError> {
    fn from(e: ::sanakirja::Error) -> Self {
        TreeErr(e.into())
    }
}

Insertion in libpijul/src/pristine/sanakirja.rs at line 65 [13.531056]

[33.12927]

[13.531485]

impl std::convert::From<TreeErr<::sanakirja::Error>> for TreeErr<SanakirjaError> {
    fn from(e: TreeErr<::sanakirja::Error>) -> Self {
        TreeErr(e.0.into())
    }
}

Replacement in libpijul/src/pristine/sanakirja.rs at line 459 [13.531056]
∅:D[14.66347] → [15.31406:31437]
B:BD[15.31406] → [15.31406:31437]
```
        next_adj(&self.txn, a)
```
[14.66347]
[15.31437]
```
        next_adj(&self.txn, a).map(|x| x.map_err(|x| TxnErr(x.into())))
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 467 [13.531056]
B:BD[14.66415] → [6.1103:1150]
```
        find_block(&self.txn, &graph.graph, p)
```
[14.66415]
[15.31644]
```
        Ok(find_block(&self.txn, &graph.graph, p)?)
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 475 [13.531056]

B:BD[14.66483] → [6.1151:1202]

        find_block_end(&self.txn, &graph.graph, p)

[14.66483]

[15.31859]

        Ok(find_block_end(&self.txn, &graph.graph, p)?)
    }
}
impl std::convert::From<BlockError<::sanakirja::Error>> for BlockError<SanakirjaError> {
    fn from(e: BlockError<::sanakirja::Error>) -> Self {
        match e {
            BlockError::Txn(t) => BlockError::Txn(t.into()),
            BlockError::Block { block } => BlockError::Block { block },
        }

Replacement in libpijul/src/pristine/sanakirja.rs at line 489 [13.531056]
B:BD[15.32641] → [14.66484:66559]
```
pub fn next_adj<'a, T: ::sanakirja::LoadPage<Error = ::sanakirja::Error>>(
```
[15.32641]
[14.66559]
```
pub fn next_adj<'a, T: ::sanakirja::LoadPage>(
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 492 [13.531056]

B:BD[15.32717] → [14.66576:66642]

) -> Option<Result<&'a SerializedEdge, TxnErr<SanakirjaError>>> {

[15.32717]

[15.32769]

) -> Option<Result<&'a SerializedEdge, T::Error>>
where
    T::Error: std::error::Error,
{

Replacement in libpijul/src/pristine/sanakirja.rs at line 512 [13.531056]

B:BD[15.33418] → [15.33418:33476]

            Err(e) => return Some(Err(TxnErr(e.into()))),

[15.33418]

[15.33476]

            Err(e) => return Some(Err(e.into())),

Replacement in libpijul/src/pristine/sanakirja.rs at line 521 [13.531056]
B:BD[15.33630] → [14.66911:66988]
```
pub fn find_block<'a, T: ::sanakirja::LoadPage<Error = ::sanakirja::Error>>(
```
[15.33630]
[14.66988]
```
pub fn find_block<'a, T: ::sanakirja::LoadPage>(
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 525 [13.531056]

B:BD[15.33771] → [14.67075:67139]

) -> Result<&'a Vertex<ChangeId>, BlockError<SanakirjaError>> {

[15.33771]

[15.33831]

) -> Result<&'a Vertex<ChangeId>, BlockError<T::Error>>
where
    T::Error: std::error::Error,
{

Replacement in libpijul/src/pristine/sanakirja.rs at line 581 [13.531056]

B:BD[15.35630] → [14.67896:67977]

pub fn find_block_end<'a, T: ::sanakirja::LoadPage<Error = ::sanakirja::Error>>(

[15.35630]

[14.67977]

pub fn find_block_end<'a, T: ::sanakirja::LoadPage>(

Replacement in libpijul/src/pristine/sanakirja.rs at line 585 [13.531056]

B:BD[15.35775] → [14.68064:68128]

) -> Result<&'a Vertex<ChangeId>, BlockError<SanakirjaError>> {

[15.35775]

[15.35835]

) -> Result<&'a Vertex<ChangeId>, BlockError<T::Error>>
where
    T::Error: std::error::Error,
{

Replacement in libpijul/src/pristine/sanakirja.rs at line 744 [13.531056]

B:BD[17.26309] → [17.26309:26384]

    fn id<'a>(&self, c: &'a Self::Channel) -> &'a RemoteId {
        &c.id

[17.26309]

[15.39395]

    fn id<'a>(&self, c: &'a Self::Channel) -> Option<&'a RemoteId> {
        Some(&c.id)

Replacement in libpijul/src/pristine/sanakirja.rs at line 1103 [13.531056]

B:BD[52.617] → [12.43312:43459]

∅:D[12.43459] → [13.545701:545759]

B:BD[13.545701] → [13.545701:545759]

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

[52.617]

[36.62859]

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

Replacement in libpijul/src/pristine/sanakirja.rs at line 1107 [13.531056]
∅:D[36.62891] → [52.647:708]
B:BD[52.647] → [52.647:708]
```
    sanakirja_cursor!(revinodes, Position<ChangeId>, Inode);
```
[36.62891]
[13.545759]
```
    sanakirja_cursor!(revinodes, Position<ChangeId>, Inode, TreeErr);
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1110 [13.531056]

B:BD[14.74910] → [14.74910:74969]

    sanakirja_table_get!(tree, PathId, Inode, TreeError,);

[14.74910]

[53.8062]

    sanakirja_table_get!(tree, PathId, Inode, TreeError, TreeErr);

Replacement in libpijul/src/pristine/sanakirja.rs at line 1112 [13.531056]
∅:D[53.8154] → [14.75069:75112]
B:BD[14.75069] → [14.75069:75112]
```
    sanakirja_iter!(tree, PathId, Inode,);
```
[53.8154]
[53.8155]
```
    sanakirja_iter!(tree, PathId, Inode, TreeErr);
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 1114 [13.531056]
∅:D[53.8250] → [14.75215:75260]
B:BD[14.75215] → [14.75215:75260]
```
    sanakirja_iter!(revtree, Inode, PathId);
```
[53.8250]
[16.36941]
```
    sanakirja_iter!(revtree, Inode, PathId, TreeErr);
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1117 [13.531056]

B:BD[14.75300] → [14.75300:75362]

    sanakirja_table_get!(revtree, Inode, PathId, TreeError,);

[14.75300]

[16.36945]

    sanakirja_table_get!(revtree, Inode, PathId, TreeError, TreeErr);

Replacement in libpijul/src/pristine/sanakirja.rs at line 1125 [13.531056]

B:BD[14.75548] → [14.75548:75612]

    sanakirja_cursor!(partials, SmallStr, Position<ChangeId>,);

[14.75548]

[14.75612]

    sanakirja_cursor!(partials, SmallStr, Position<ChangeId>, TreeErr);

Replacement in libpijul/src/pristine/sanakirja.rs at line 1132 [13.531056]
B:BD[12.43762] → [12.43762:43795]
```
        TxnErr<Self::TreeError>,
```
[12.43762]
[12.43795]
```
        TreeErr<Self::TreeError>,
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 1145 [13.531056]
B:BD[12.44027] → [12.44027:44059]
```
        TxnErr<SanakirjaError>,
```
[12.44027]
[12.44059]
```
        TreeErr<SanakirjaError>,
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 1155 [13.531056]
∅:D[14.75989] → [12.44305:44337]
B:BD[12.44305] → [12.44305:44337]
```
        TxnErr<SanakirjaError>,
```
[14.75989]
[12.44337]
```
        TreeErr<SanakirjaError>,
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1749 [13.531056]

B:BD[12.51297] → [12.51297:51440]

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

[12.51297]

[12.51440]

    sanakirja_put_del!(inodes, Inode, Position<ChangeId>, TreeError, TreeErr);
    sanakirja_put_del!(revinodes, Position<ChangeId>, Inode, TreeError, TreeErr);

Replacement in libpijul/src/pristine/sanakirja.rs at line 1752 [13.531056]

B:BD[12.51441] → [14.85416:85533]

    sanakirja_put_del!(tree, PathId, Inode, TreeError,);
    sanakirja_put_del!(revtree, Inode, PathId, TreeError,);

[12.51441]

[12.51730]

    sanakirja_put_del!(tree, PathId, Inode, TreeError, TreeErr);
    sanakirja_put_del!(revtree, Inode, PathId, TreeError, TreeErr);

Replacement in libpijul/src/pristine/sanakirja.rs at line 1759 [13.531056]
B:BD[12.51819] → [12.51819:51868]
```
    ) -> Result<bool, TxnErr<Self::TreeError>> {
```
[12.51819]
[12.51868]
```
    ) -> Result<bool, TreeErr<Self::TreeError>> {
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1761 [13.531056]

B:BD[12.51910] → [14.85534:85601]

        Ok(btree::put(&mut self.txn, &mut self.partials, &k, &e)?)

[12.51910]

[13.562193]

        btree::put(&mut self.txn, &mut self.partials, &k, &e).map_err(|e| TreeErr(e.into()))

Replacement in libpijul/src/pristine/sanakirja.rs at line 1768 [13.531056]
B:BD[12.52180] → [12.52180:52229]
```
    ) -> Result<bool, TxnErr<Self::TreeError>> {
```
[12.52180]
[12.52229]
```
    ) -> Result<bool, TreeErr<Self::TreeError>> {
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 1770 [13.531056]
B:BD[12.52271] → [14.85602:85625]
B:BD[14.85625] → [14.85625:85652]
∅:D[14.85652] → [12.52323:52355]
B:BD[12.52323] → [12.52323:52355]
B:BD[12.52355] → [14.85653:85693]
∅:D[14.85693] → [12.52432:52444]
B:BD[12.52432] → [12.52432:52444]
```
        Ok(btree::del(
            &mut self.txn,
            &mut self.partials,
            &k,
            e.as_ref(),
        )?)
```
[12.52271]
[12.52444]
```
        btree::del(&mut self.txn, &mut self.partials, &k, e.as_ref()).map_err(|e| TreeErr(e.into()))
```

Insertion in libpijul/src/pristine/mod.rs at line 157 [13.586748]

[31.100495]

impl<T: ChannelTxnT> ChannelRef<T> {
    pub fn new(t: T::Channel) -> Self {
        ChannelRef {
            r: Arc::new(RwLock::new(t)),
        }
    }
}

Insertion in libpijul/src/pristine/mod.rs at line 166 [13.586748]

[31.100537]


impl<T> ArcTxn<T> {
    pub fn new(t: T) -> Self {
        ArcTxn(Arc::new(RwLock::new(t)))
    }
}

Replacement in libpijul/src/pristine/mod.rs at line 317 [13.586748]

B:BD[12.54262] → [12.54262:54320]

pub struct TxnErr<E: std::error::Error + 'static>(pub E);

[12.54262]

[12.54320]

pub struct TxnErr<E: std::error::Error + std::fmt::Debug + 'static>(pub E);

Replacement in libpijul/src/pristine/mod.rs at line 320 [13.586748]

B:BD[12.54350] → [12.54350:54414]

    type GraphError: std::error::Error + Send + Sync + 'static;

[12.54350]

[13.589205]

    type GraphError: std::error::Error + std::fmt::Debug + Send + Sync + 'static;

Replacement in libpijul/src/pristine/mod.rs at line 369 [13.586748]

B:BD[54.2520] → [17.36406:36466]

    fn id<'a>(&self, c: &'a Self::Channel) -> &'a RemoteId;

[54.2520]

    fn id<'a>(&self, c: &'a Self::Channel) -> Option<&'a RemoteId>;

Insertion in libpijul/src/pristine/mod.rs at line 587 [13.586748]

[13.589629]

[12.56829]

#[derive(Debug, Error)]
#[error(transparent)]
pub struct TreeErr<E: std::error::Error + std::fmt::Debug + 'static>(pub E);

Replacement in libpijul/src/pristine/mod.rs at line 592 [13.586748]

B:BD[12.56857] → [12.56857:56920]

    type TreeError: std::error::Error + Send + Sync + 'static;

[12.56857]

[13.589629]

    type TreeError: std::error::Error + std::fmt::Debug + Send + Sync + 'static;

Replacement in libpijul/src/pristine/mod.rs at line 594 [13.586748]

B:BD[13.589647] → [12.56921:56969]

B:BD[12.56969] → [14.102846:102889]

    table_get!(tree, PathId, Inode, TreeError);
    iter!(tree, PathId, Inode, TreeError);

[13.589647]

[13.589721]

    table_get!(tree, PathId, Inode, TreeError, TreeErr);
    iter!(tree, PathId, Inode, TreeError, TreeErr);

Replacement in libpijul/src/pristine/mod.rs at line 598 [13.586748]

B:BD[13.589743] → [12.57018:57069]

B:BD[12.57069] → [14.102890:102936]

    table_get!(revtree, Inode, PathId, TreeError);
    iter!(revtree, Inode, PathId, TreeError);

[13.589743]

[13.589823]

    table_get!(revtree, Inode, PathId, TreeError, TreeErr);
    iter!(revtree, Inode, PathId, TreeError, TreeErr);

Replacement in libpijul/src/pristine/mod.rs at line 603 [13.586748]

B:BD[52.964] → [12.57121:57248]

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

[52.964]

[13.589949]

    table_get!(inodes, Inode, Position<ChangeId>, TreeError, TreeErr);
    table_get!(revinodes, Position<ChangeId>, Inode, TreeError, TreeErr);

Replacement in libpijul/src/pristine/mod.rs at line 607 [13.586748]

B:BD[13.589972] → [14.102937:103001]

∅:D[14.103001] → [12.57316:57375]

B:BD[12.57316] → [12.57316:57375]

    cursor!(partials, SmallStr, Position<ChangeId>, TreeError);
    cursor!(inodes, Inode, Position<ChangeId>, TreeError);

[13.589972]

[12.57375]

    cursor!(partials, SmallStr, Position<ChangeId>, TreeError, TreeErr);
    cursor!(inodes, Inode, Position<ChangeId>, TreeError, TreeErr);

Replacement in libpijul/src/pristine/mod.rs at line 613 [13.586748]
B:BD[12.57503] → [12.57503:57536]
```
        TxnErr<Self::TreeError>,
```
[12.57503]
[12.57536]
```
        TreeErr<Self::TreeError>,
```
Replacement in libpijul/src/pristine/mod.rs at line 617 [13.586748]
∅:D[36.69547] → [12.57573:57635]
B:BD[12.57573] → [12.57573:57635]
```
    cursor!(revinodes, Position<ChangeId>, Inode, TreeError);
```
[36.69547]
[36.69548]
```
    cursor!(revinodes, Position<ChangeId>, Inode, TreeError, TreeErr);
```
Replacement in libpijul/src/pristine/mod.rs at line 623 [13.586748]
B:BD[12.57798] → [12.57798:57831]
```
        TxnErr<Self::TreeError>,
```
[12.57798]
[12.57831]
```
        TreeErr<Self::TreeError>,
```
Replacement in libpijul/src/pristine/mod.rs at line 630 [13.586748]
∅:D[14.103088] → [12.57945:57978]
B:BD[12.57945] → [12.57945:57978]
```
        TxnErr<Self::TreeError>,
```
[14.103088]
[12.57978]
```
        TreeErr<Self::TreeError>,
```
Replacement in libpijul/src/pristine/mod.rs at line 799 [13.586748]
∅:D[14.103823] → [12.61009:61061]
B:BD[12.61009] → [12.61009:61061]
```
) -> Result<Option<String>, TxnErr<T::TreeError>> {
```
[14.103823]
[12.61061]
```
) -> Result<Option<String>, TreeErr<T::TreeError>> {
```

Replacement in libpijul/src/pristine/mod.rs at line 1462 [13.586748]

B:BD[12.68035] → [14.108058:108187]

initialized_cursor!(tree, PathId, Inode, TreeTxnT, TreeError);
initialized_cursor!(revtree, Inode, PathId, TreeTxnT, TreeError);

[12.68035]

[12.68174]

initialized_cursor!(tree, PathId, Inode, TreeTxnT, TreeError, TreeErr);
initialized_cursor!(revtree, Inode, PathId, TreeTxnT, TreeError, TreeErr);

Replacement in libpijul/src/pristine/mod.rs at line 1465 [13.586748]

B:BD[12.68241] → [53.15553:15635]

initialized_cursor!(partials, SmallStr, Position<ChangeId>, TreeTxnT, TreeError);

[12.68241]

initialized_cursor!(
    partials,
    SmallStr,
    Position<ChangeId>,
    TreeTxnT,
    TreeError,
    TreeErr
);

Replacement in libpijul/src/pristine/mod.rs at line 1489 [13.586748]

∅:D[14.108355] → [12.68571:68648]

B:BD[13.621464] → [12.68571:68648]

∅:D[36.70159] → [12.68649:68729]

B:BD[52.1456] → [12.68649:68729]

initialized_cursor!(inodes, Inode, Position<ChangeId>, TreeTxnT, TreeError);
initialized_cursor!(revinodes, Position<ChangeId>, Inode, TreeTxnT, TreeError);

[14.108355]

[26.3540]

initialized_cursor!(
    inodes,
    Inode,
    Position<ChangeId>,
    TreeTxnT,
    TreeError,
    TreeErr
);
initialized_cursor!(
    revinodes,
    Position<ChangeId>,
    Inode,
    TreeTxnT,
    TreeError,
    TreeErr
);

Replacement in libpijul/src/pristine/mod.rs at line 1777 [13.586748]

B:BD[12.73435] → [12.73435:73653]

    put_del!(inodes, Inode, Position<ChangeId>, TreeError);
    put_del!(revinodes, Position<ChangeId>, Inode, TreeError);
    put_del!(tree, PathId, Inode, TreeError);
    put_del!(revtree, Inode, PathId, TreeError);

[12.73435]

[12.73653]

    put_del!(inodes, Inode, Position<ChangeId>, TreeError, TreeErr);
    put_del!(revinodes, Position<ChangeId>, Inode, TreeError, TreeErr);
    put_del!(tree, PathId, Inode, TreeError, TreeErr);
    put_del!(revtree, Inode, PathId, TreeError, TreeErr);

Replacement in libpijul/src/pristine/mod.rs at line 1785 [13.586748]
B:BD[12.73741] → [12.73741:73789]
```
    ) -> Result<bool, TxnErr<Self::TreeError>>;
```
[12.73741]
[12.73789]
```
    ) -> Result<bool, TreeErr<Self::TreeError>>;
```
Replacement in libpijul/src/pristine/mod.rs at line 1791 [13.586748]
B:BD[12.73886] → [12.73886:73934]
```
    ) -> Result<bool, TxnErr<Self::TreeError>>;
```
[12.73886]
[12.73934]
```
    ) -> Result<bool, TreeErr<Self::TreeError>>;
```
Replacement in libpijul/src/pristine/mod.rs at line 1861 [13.586748]
∅:D[14.110025] → [12.75029:75069]
B:BD[16.50207] → [12.75029:75069]
```
) -> Result<(), TxnErr<T::TreeError>> {
```
[14.110025]
[16.50240]
```
) -> Result<(), TreeErr<T::TreeError>> {
```
Replacement in libpijul/src/pristine/mod.rs at line 1871 [13.586748]
∅:D[14.110080] → [12.75122:75164]
B:BD[52.1646] → [12.75122:75164]
```
) -> Result<bool, TxnErr<T::TreeError>> {
```
[14.110080]
[52.1681]
```
) -> Result<bool, TreeErr<T::TreeError>> {
```
Replacement in libpijul/src/pristine/mod.rs at line 1884 [13.586748]
∅:D[14.110122] → [12.75215:75255]
B:BD[52.1947] → [12.75215:75255]
```
) -> Result<(), TxnErr<T::TreeError>> {
```
[14.110122]
[2.0]
```
) -> Result<(), TreeErr<T::TreeError>> {
```
Replacement in libpijul/src/pristine/mod.rs at line 1895 [13.586748]
∅:D[14.110164] → [12.75306:75348]
B:BD[52.2155] → [12.75306:75348]
```
) -> Result<bool, TxnErr<T::TreeError>> {
```
[14.110164]
[52.2190]
```
) -> Result<bool, TreeErr<T::TreeError>> {
```
Insertion in libpijul/src/output/output.rs at line 5 [13.671807]
[13.672066]
[13.672066]
```
use crate::alive::Redundant;
```

Replacement in libpijul/src/output/output.rs at line 50 [13.671807]

B:BD[36.73532] → [36.73532:73572]

    T: MutTxnT + Send + Sync + 'static,

[36.73532]

[31.101669]

    T: ChannelMutTxnT + TreeMutTxnT<TreeError = T::GraphError> + Send + Sync + 'static,
    R: WorkingCopy + Send + Clone + Sync + 'static,
    P: ChangeStore + Send + Clone + 'static,
>(
    repo: &R,
    changes: &P,
    txn: &ArcTxn<T>,
    channel: &ChannelRef<T>,
    prefix: &str,
    output_name_conflicts: bool,
    if_modified_since: Option<std::time::SystemTime>,
    n_workers: usize,
    salt: u64,
) -> Result<BTreeSet<Conflict>, OutputError<P::Error, T, R::Error>>
where
    T::Channel: Send + Sync + 'static,
{
    debug!("output_repository_no_pending: {:?}", prefix);
    let (c, f) = output_repository(
        repo,
        changes,
        txn.clone(),
        channel.clone(),
        ChangeId::ROOT,
        &mut crate::path::components(prefix),
        output_name_conflicts,
        if_modified_since,
        n_workers,
        salt,
    )?;
    del_redundant(txn.clone(), channel.clone(), &f)?;
    Ok(c)
}
/// Output updates the working copy after applying changes, including
/// the graph-file correspondence.
///
/// **WARNING:** This overwrites the working copy, cancelling any
/// unrecorded change.
pub fn output_repository_no_pending_<
    T: ChannelTxnT + TreeMutTxnT + Send + Sync + 'static,

Replacement in libpijul/src/output/output.rs at line 103 [13.671807]

B:BD[35.3573] → [8.102:182]

) -> Result<BTreeSet<Conflict>, OutputError<P::Error, T::GraphError, R::Error>>

[35.3573]

[36.73834]

) -> Result<BTreeSet<Conflict>, OutputError<P::Error, T, R::Error>>

Replacement in libpijul/src/output/output.rs at line 108 [13.671807]
∅:D[5.573] → [13.673269:673292]
∅:D[33.20153] → [13.673269:673292]
∅:D[36.73881] → [13.673269:673292]
∅:D[12.81983] → [13.673269:673292]
B:BD[13.673269] → [13.673269:673292]
```
    output_repository(
```
[5.573]
[13.673292]
```
    let (c, _) = output_repository(
```
Replacement in libpijul/src/output/output.rs at line 119 [13.671807]
∅:D[55.1643] → [13.673474:673480]
∅:D[35.3588] → [13.673474:673480]
∅:D[36.73919] → [13.673474:673480]
B:BD[13.673474] → [13.673474:673480]
```
    )
```
[35.3588]
[13.673480]
```
    )?;
    Ok(c)
```

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

B:BD[36.73936] → [36.73936:74029]

    T: TreeMutTxnT + ChannelMutTxnT + GraphMutTxnT<GraphError = <T as TreeTxnT>::TreeError>,

[36.73936]

[31.101835]

    T: TreeMutTxnT + ChannelTxnT + GraphTxnT,

Replacement in libpijul/src/output/output.rs at line 135 [13.671807]

B:BD[36.74309] → [56.0:77]

) -> Result<Vec<Conflict>, OutputError<P::Error, T::GraphError, R::Error>> {

[36.74309]

[36.74375]

) -> Result<(Vec<Conflict>, Vec<Redundant>), OutputError<P::Error, T, R::Error>> {

Insertion in libpijul/src/output/output.rs at line 140 [13.671807]
[56.114]
[36.74522]
```
    let mut forward = Vec::new();
```
Insertion in libpijul/src/output/output.rs at line 155 [13.671807]
[57.343]
[36.74977]
```
                    &mut forward,
```
Replacement in libpijul/src/output/output.rs at line 170 [13.671807]
B:BD[36.75449] → [56.115:133]
```
    Ok(conflicts)
```
[36.75449]
[36.75460]
```
    Ok((conflicts, forward))
```

Replacement in libpijul/src/output/output.rs at line 175 [13.671807]

B:BD[13.673568] → [36.75464:75621]

    T: TreeMutTxnT
        + ChannelMutTxnT
        + GraphMutTxnT<GraphError = <T as TreeTxnT>::TreeError>
        + Send
        + Sync
        + 'static,

[13.673568]

[31.101910]

    T: TreeMutTxnT + ChannelTxnT + GraphTxnT + Send + Sync + 'static,

Replacement in libpijul/src/output/output.rs at line 190 [13.671807]

B:BD[35.3604] → [8.183:262]

) -> Result<BTreeSet<Conflict>, OutputError<P::Error, T::TreeError, R::Error>>

[35.3604]

[36.75880]

) -> Result<(BTreeSet<Conflict>, Vec<Redundant>), OutputError<P::Error, T, R::Error>>

Insertion in libpijul/src/output/output.rs at line 221 [13.671807]
[45.13466]
[45.13466]
```
        redundant: Vec::new(),
```

Replacement in libpijul/src/output/output.rs at line 258 [13.671807]

B:BD[45.13998] → [8.300:350]

        for x in t.join().unwrap()?.into_iter() {

[45.13998]

[8.350]

        let (a, b) = t.join().unwrap()?;
        for x in a.into_iter() {

Insertion in libpijul/src/output/output.rs at line 262 [13.671807]

[8.399]

[45.14062]

        for x in b.into_iter() {
            state.redundant.push(x);
        }

Replacement in libpijul/src/output/output.rs at line 266 [13.671807]
B:BD[45.14068] → [8.400:430]
```
    for x in o?.into_iter() {
```
[45.14068]
[8.430]
```
    let (a, b) = o?;
    for x in a.into_iter() {
```

Insertion in libpijul/src/output/output.rs at line 269 [13.671807]

[8.465]

    }
    for x in b.into_iter() {
        state.redundant.push(x);

Replacement in libpijul/src/output/output.rs at line 276 [13.671807]
B:BD[45.14225] → [45.14225:14249]
```
    Ok(state.conflicts)
```
[45.14225]
[45.14249]
```
    Ok((state.conflicts, state.redundant))
```
Insertion in libpijul/src/output/output.rs at line 309 [13.671807]
[45.15264]
[45.15264]
```
    redundant: Vec<Redundant>,
```

Replacement in libpijul/src/output/output.rs at line 314 [13.671807]

B:BD[45.15318] → [45.15318:15499]

        T: TreeMutTxnT
            + ChannelMutTxnT
            + GraphMutTxnT<GraphError = <T as TreeTxnT>::TreeError>
            + Send
            + Sync
            + 'static,

[45.15318]

[45.15499]

        T: TreeMutTxnT + ChannelTxnT + GraphTxnT + Send + Sync + 'static,

Replacement in libpijul/src/output/output.rs at line 322 [13.671807]

B:BD[45.15699] → [45.15699:15768]

    ) -> Result<(), OutputError<P::Error, T::TreeError, R::Error>> {

[45.15699]

[45.15768]

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

Replacement in libpijul/src/output/output.rs at line 328 [13.671807]

B:BD[45.15961] → [45.15961:16049]

                collect_dead_files(&*txn_, graph, self.pending_change_id, Inode::ROOT)?

[45.15961]

[45.16049]

                collect_dead_files::<_, R, P>(&*txn_, graph, self.pending_change_id, Inode::ROOT)?

Replacement in libpijul/src/output/output.rs at line 395 [13.671807]

B:BD[45.18329] → [45.18329:18510]

        T: TreeMutTxnT
            + ChannelMutTxnT
            + GraphMutTxnT<GraphError = <T as TreeTxnT>::TreeError>
            + Send
            + Sync
            + 'static,

[45.18329]

[45.18510]

        T: TreeMutTxnT + ChannelTxnT + GraphTxnT + Send + Sync + 'static,

Replacement in libpijul/src/output/output.rs at line 407 [13.671807]

B:BD[45.18884] → [45.18884:18953]

    ) -> Result<(), OutputError<P::Error, T::TreeError, R::Error>> {

[45.18884]

[45.18953]

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

Replacement in libpijul/src/output/output.rs at line 518 [13.671807]
∅:D[58.1502] → [12.82825:82892]
B:BD[33.21084] → [12.82825:82892]
```
fn move_or_create<T: TreeMutTxnT, R: WorkingCopy, C: ChangeStore>(
```
[58.1502]
[31.102957]
```
fn move_or_create<T: GraphTxnT + TreeMutTxnT, R: WorkingCopy, C: ChangeStore>(
```
Replacement in libpijul/src/output/output.rs at line 528 [13.671807]
∅:D[35.3647] → [12.82954:83022]
B:BD[13.679880] → [12.82954:83022]
```
) -> Result<Inode, OutputError<C::Error, T::TreeError, R::Error>> {
```
[35.3647]
[13.679916]
```
) -> Result<Inode, OutputError<C::Error, T, R::Error>> {
```

Replacement in libpijul/src/output/output.rs at line 629 [13.671807]

B:BD[33.22422] → [36.81259:81341]

fn output_item<T: ChannelMutTxnT + GraphMutTxnT, P: ChangeStore, W: WorkingCopy>(

[33.22422]

[31.103147]

fn output_item<T: ChannelTxnT + TreeTxnT, P: ChangeStore, W: WorkingCopy>(

Replacement in libpijul/src/output/output.rs at line 638 [13.671807]

∅:D[36.81425] → [12.84030:84096]

B:BD[13.683171] → [12.84030:84096]

B:BD[13.683347] → [13.683347:683381]

B:BD[13.683381] → [36.81426:81432]

B:BD[36.81432] → [31.103168:103236]

∅:D[31.103236] → [36.81518:81595]

B:BD[36.81518] → [36.81518:81595]

B:BD[36.81595] → [59.688:796]

∅:D[59.796] → [31.103237:103315]

B:BD[36.81670] → [31.103237:103315]

∅:D[31.103315] → [36.81760:81895]

B:BD[36.81760] → [36.81760:81895]

B:BD[36.81895] → [59.797:859]

∅:D[59.859] → [36.81895:81901]

B:BD[36.81895] → [36.81895:81901]

) -> Result<(), OutputError<P::Error, T::GraphError, W::Error>> {
    let mut forward = Vec::new();
    {
        let txn = txn.read();
        let channel = channel.read();
        let mut l = retrieve(&*txn, txn.graph(&*channel), output_item.pos)?;
        let w = repo
            .write_file(&path, inode)
            .map_err(OutputError::WorkingCopy)?;
        let mut f = vertex_buffer::ConflictsWriter::new(w, &path, conflicts);
        alive::output_graph(changes, &*txn, &*channel, &mut f, &mut l, &mut forward)
            .map_err(PristineOutputError::from)?;
        use std::io::Write;
        f.w.flush().unwrap_or(())
    }

[36.81425]

[36.81901]

    forward: &mut Vec<Redundant>,
) -> Result<(), OutputError<P::Error, T, W::Error>> {
    let txn = txn.read();
    let channel = channel.read();
    let mut l = retrieve(&*txn, txn.graph(&*channel), output_item.pos)?;
    let w = repo
        .write_file(&path, inode)
        .map_err(OutputError::WorkingCopy)?;
    let mut f = vertex_buffer::ConflictsWriter::new(w, &path, conflicts);
    alive::output_graph(changes, &*txn, &*channel, &mut f, &mut l, forward)
        .map_err(PristineOutputError::from)?;
    use std::io::Write;
    f.w.flush().unwrap_or(());
    Ok(())
}
fn del_redundant<T: ChannelMutTxnT + GraphMutTxnT>(
    txn: ArcTxn<T>,
    channel: ChannelRef<T>,
    forward: &[Redundant],
) -> Result<(), TxnErr<T::GraphError>> {

Replacement in libpijul/src/output/output.rs at line 664 [13.671807]
∅:D[33.22668] → [13.683460:683504]
∅:D[36.82046] → [13.683460:683504]
∅:D[31.103386] → [13.683460:683504]
B:BD[13.683460] → [13.683460:683504]
```
    for &(vertex, edge) in forward.iter() {
```
[31.103386]
[13.683504]
```
    for ve in forward.iter() {
```
Replacement in libpijul/src/output/output.rs at line 666 [13.671807]
B:BD[13.683557] → [36.82047:82127]
∅:D[54.5032] → [13.683622:683698]
∅:D[16.55839] → [13.683622:683698]
∅:D[15.58453] → [13.683622:683698]
∅:D[36.82127] → [13.683622:683698]
∅:D[12.84234] → [13.683622:683698]
∅:D[14.121264] → [13.683622:683698]
B:BD[13.683622] → [13.683622:683698]
```
        let dest = *txn.find_block(txn.graph(&*channel), edge.dest()).unwrap();
        debug!("deleting forward edge {:?} {:?} {:?}", vertex, dest, edge);
```
[13.683557]
[12.84235]
```
        let dest = *txn.find_block(txn.graph(&*channel), ve.e.dest()).unwrap();
        debug!("deleting forward edge {:?} {:?} {:?}", ve.v, dest, ve.e);
```
Replacement in libpijul/src/output/output.rs at line 671 [13.671807]
∅:D[36.82192] → [14.121265:121290]
B:BD[15.58489] → [14.121265:121290]
∅:D[14.121290] → [12.84335:84355]
B:BD[12.84335] → [12.84335:84355]
```
            edge.flag(),
            vertex,
```
[36.82192]
[12.84355]
```
            ve.e.flag(),
            ve.v,
```
Replacement in libpijul/src/output/output.rs at line 674 [13.671807]
B:BD[12.84373] → [14.121291:121325]
```
            edge.introduced_by(),
```
[12.84373]
[12.84405]
```
            ve.e.introduced_by(),
```

Replacement in libpijul/src/output/output.rs at line 706 [13.671807]

∅:D[3.596] → [36.82193:82282]

B:BD[33.22806] → [36.82193:82282]

fn collect_dead_files<T: TreeTxnT + GraphTxnT<GraphError = <T as TreeTxnT>::TreeError>>(

[3.596]

[36.82282]

fn collect_dead_files<T: TreeTxnT + GraphTxnT, W: WorkingCopy + Clone, C: ChangeStore>(

Replacement in libpijul/src/output/output.rs at line 711 [13.671807]

B:BD[13.683988] → [12.84536:84620]

) -> Result<HashMap<OwnedPathId, (Inode, Option<String>)>, TxnErr<T::GraphError>> {

[13.683988]

[13.684041]

) -> Result<HashMap<OwnedPathId, (Inode, Option<String>)>, OutputError<C::Error, T, W::Error>> {

Replacement in libpijul/src/output/output.rs at line 751 [13.671807]

B:BD[33.22808] → [60.404:536]

fn kill_dead_files<
    T: ChannelTxnT<GraphError = T::TreeError> + TreeMutTxnT,
    W: WorkingCopy + Clone,
    C: ChangeStore,
>(

[33.22808]

[13.685451]

fn kill_dead_files<T: ChannelTxnT + TreeMutTxnT, W: WorkingCopy + Clone, C: ChangeStore>(

Replacement in libpijul/src/output/output.rs at line 756 [13.671807]
B:BD[13.685544] → [60.537:602]
```
) -> Result<(), OutputError<C::Error, T::TreeError, W::Error>> {
```
[13.685544]
[61.379]
```
) -> Result<(), OutputError<C::Error, T, W::Error>> {
```
Replacement in libpijul/src/output/mod.rs at line 11 [13.686190]
B:BD[13.686366] → [33.23194:23218]
```
#[derive(Debug, Error)]
```
[13.686366]
[33.23218]
```
#[derive(Error)]
```
Replacement in libpijul/src/output/mod.rs at line 14 [13.686190]
B:BD[33.23291] → [33.23291:23329]
```
    Txn: std::error::Error + 'static,
```
[33.23291]
[36.82376]
```
    T: GraphTxnT + TreeTxnT,
```
Deletion in libpijul/src/output/mod.rs at line 17 [13.686190]
B:BD[33.23369] → [33.23369:23409]
```
    #[error("Working copy error: {0}")]
```

Replacement in libpijul/src/output/mod.rs at line 18 [13.686190]

B:BD[33.23429] → [33.23429:23455]

B:BD[33.23455] → [33.23455:23521]

    #[error(transparent)]
    Pristine(#[from] PristineOutputError<ChangestoreError, Txn>),

[33.23429]

[33.23521]

    Pristine(#[from] PristineOutputError<ChangestoreError, T>),

Replacement in libpijul/src/output/mod.rs at line 21 [13.686190]

B:BD[33.23524] → [33.23524:23548]

B:BD[33.23548] → [33.23548:23648]

#[derive(Debug, Error)]
pub enum PristineOutputError<ChangestoreError: std::error::Error, Txn: std::error::Error + 'static>

[33.23524]

[33.23648]

impl<C: std::error::Error, T: GraphTxnT + TreeTxnT, W: std::error::Error + Send> std::fmt::Debug
    for OutputError<C, T, W>

Replacement in libpijul/src/output/mod.rs at line 24 [13.686190]

B:BD[33.23650] → [33.23650:23676]

B:BD[33.23676] → [33.23676:23690]

B:BD[33.23690] → [33.23690:23729]

    #[error(transparent)]
    Txn(Txn),
    #[error("Changestore error: {0}")]

[33.23650]

[33.23729]

    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            OutputError::WorkingCopy(e) => std::fmt::Debug::fmt(e, fmt),
            OutputError::Pristine(e) => std::fmt::Debug::fmt(e, fmt),
        }
    }
}
impl<C: std::error::Error, T: GraphTxnT + TreeTxnT, W: std::error::Error + Send> std::fmt::Display
    for OutputError<C, T, W>
{
    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            OutputError::WorkingCopy(e) => std::fmt::Display::fmt(e, fmt),
            OutputError::Pristine(e) => std::fmt::Display::fmt(e, fmt),
        }
    }
}
#[derive(Error)]
pub enum PristineOutputError<ChangestoreError: std::error::Error, T: GraphTxnT + TreeTxnT> {
    Channel(#[from] TxnErr<T::GraphError>),
    Tree(#[from] TreeErr<T::TreeError>),

Deletion in libpijul/src/output/mod.rs at line 48 [13.686190]
B:BD[33.23764] → [33.23764:23790]
```
    #[error(transparent)]
```
Replacement in libpijul/src/output/mod.rs at line 49 [13.686190]
B:BD[33.23822] → [33.23822:23848]
B:BD[33.23848] → [33.23848:23889]
```
    #[error(transparent)]
    Fs(#[from] crate::fs::FsError<Txn>),
```
[33.23822]
[12.85295]
```
    Fs(#[from] crate::fs::FsError<T>),
```

Replacement in libpijul/src/output/mod.rs at line 52 [13.686190]

B:BD[12.85298] → [12.85298:85373]

impl<C: std::error::Error, T: std::error::Error + 'static> From<TxnErr<T>>

[12.85298]

[12.85373]

impl<C: std::error::Error, T: GraphTxnT + TreeTxnT> std::fmt::Debug for PristineOutputError<C, T> {
    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            PristineOutputError::Channel(e) => std::fmt::Debug::fmt(e, fmt),
            PristineOutputError::Tree(e) => std::fmt::Debug::fmt(e, fmt),
            PristineOutputError::Changestore(e) => std::fmt::Debug::fmt(e, fmt),
            PristineOutputError::Io(e) => std::fmt::Debug::fmt(e, fmt),
            PristineOutputError::Fs(e) => std::fmt::Debug::fmt(e, fmt),
        }
    }
}
impl<C: std::error::Error, T: GraphTxnT + TreeTxnT> std::fmt::Display

Replacement in libpijul/src/output/mod.rs at line 67 [13.686190]

B:BD[12.85409] → [12.85409:85483]

    fn from(e: TxnErr<T>) -> Self {
        PristineOutputError::Txn(e.0)

[12.85409]

[12.85483]

    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            PristineOutputError::Channel(e) => std::fmt::Display::fmt(e, fmt),
            PristineOutputError::Tree(e) => std::fmt::Display::fmt(e, fmt),
            PristineOutputError::Changestore(e) => std::fmt::Display::fmt(e, fmt),
            PristineOutputError::Io(e) => std::fmt::Display::fmt(e, fmt),
            PristineOutputError::Fs(e) => std::fmt::Display::fmt(e, fmt),
        }

Replacement in libpijul/src/output/mod.rs at line 78 [13.686190]

B:BD[12.85492] → [36.82420:82553]

impl<C: std::error::Error, T: std::error::Error + 'static, W: std::error::Error + Send>
    From<TxnErr<T>> for OutputError<C, T, W>

[12.85492]

[12.85618]

impl<C: std::error::Error, T: GraphTxnT + TreeTxnT, W: std::error::Error + Send>
    From<TxnErr<T::GraphError>> for OutputError<C, T, W>

Replacement in libpijul/src/output/mod.rs at line 81 [13.686190]
B:BD[12.85620] → [12.85620:85656]
```
    fn from(e: TxnErr<T>) -> Self {
```
[12.85620]
[12.85656]
```
    fn from(e: TxnErr<T::GraphError>) -> Self {
```

Replacement in libpijul/src/output/mod.rs at line 86 [13.686190]

B:BD[33.24237] → [33.24237:24261]

B:BD[33.24261] → [12.85697:85797]

#[derive(Debug, Error)]
pub enum FileError<ChangestoreError: std::error::Error + 'static, T: std::error::Error + 'static> {

[33.24237]

[33.24329]

impl<C: std::error::Error, T: GraphTxnT + TreeTxnT, W: std::error::Error + Send>
    From<TreeErr<T::TreeError>> for OutputError<C, T, W>
{
    fn from(e: TreeErr<T::TreeError>) -> Self {
        OutputError::Pristine(e.into())
    }
}
#[derive(Error)]
pub enum FileError<ChangestoreError: std::error::Error + std::fmt::Debug + 'static, T: GraphTxnT> {

Replacement in libpijul/src/output/mod.rs at line 99 [13.686190]
B:BD[12.85824] → [12.85824:85836]
```
    Txn(T),
```
[12.85824]
[33.24390]
```
    Txn(#[from] TxnErr<T::GraphError>),
```

Replacement in libpijul/src/output/mod.rs at line 104 [13.686190]

B:BD[33.24451] → [12.85837:85918]

impl<C: std::error::Error, T: std::error::Error + 'static> From<FileError<C, T>>

[33.24451]

[33.24529]

// Why can't I just derive Debug for `FileError`? The following is
// what I expect the derived impl would be.
impl<ChangestoreError: std::error::Error + std::fmt::Debug + 'static, T: GraphTxnT> std::fmt::Debug
    for FileError<ChangestoreError, T>
{
    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            FileError::Changestore(ref c) => std::fmt::Debug::fmt(c, fmt),
            FileError::Txn(ref c) => std::fmt::Debug::fmt(c, fmt),
            FileError::Io(ref c) => std::fmt::Debug::fmt(c, fmt),
        }
    }
}
impl<C: std::error::Error, T: GraphTxnT + TreeTxnT> From<FileError<C, T>>

Replacement in libpijul/src/output/mod.rs at line 125 [13.686190]

B:BD[33.24760] → [12.85962:86024]

            FileError::Txn(t) => PristineOutputError::Txn(t),

[33.24760]

            FileError::Txn(t) => PristineOutputError::Channel(t),

Deletion in libpijul/src/output/mod.rs at line 127 [13.686190]

B:BD[33.24770] → [33.24770:24779]

B:BD[33.24779] → [12.86025:86186]

    }
}
impl<C: std::error::Error, T: std::error::Error + 'static> From<TxnErr<T>> for FileError<C, T> {
    fn from(e: TxnErr<T>) -> Self {
        FileError::Txn(e.0)

Replacement in libpijul/src/output/mod.rs at line 140 [13.686190]
B:BD[13.686566] → [12.86196:86247]
```
fn collect_children<T: GraphTxnT, P: ChangeStore>(
```
[13.686566]
[13.686612]
```
fn collect_children<T: GraphTxnT + TreeTxnT, P: ChangeStore>(
```
Replacement in libpijul/src/output/mod.rs at line 150 [13.686190]
B:BD[13.686842] → [12.86273:86337]
```
) -> Result<(), PristineOutputError<P::Error, T::GraphError>> {
```
[13.686842]
[45.21518]
```
) -> Result<(), PristineOutputError<P::Error, T>> {
```
Replacement in libpijul/src/output/mod.rs at line 214 [13.686190]
B:BD[13.689116] → [45.22847:22889]
```
fn collect<T: GraphTxnT, P: ChangeStore>(
```
[13.689116]
[45.22889]
```
fn collect<T: GraphTxnT + TreeTxnT, P: ChangeStore>(
```
Replacement in libpijul/src/output/mod.rs at line 224 [13.686190]
B:BD[45.23141] → [45.23141:23205]
```
) -> Result<(), PristineOutputError<P::Error, T::GraphError>> {
```
[45.23141]
[5.671]
```
) -> Result<(), PristineOutputError<P::Error, T>> {
```
Replacement in libpijul/src/output/mod.rs at line 320 [13.686190]
B:BD[36.82820] → [36.82820:82874]
```
) -> Result<(), FileError<C::Error, T::GraphError>> {
```
[36.82820]
[36.82874]
```
) -> Result<(), FileError<C::Error, T>> {
```
Replacement in libpijul/src/output/archive.rs at line 98 [13.690044]
B:BD[33.25223] → [33.25223:25247]
```
#[derive(Debug, Error)]
```
[33.25223]
[33.25247]
```
#[derive(Error)]
```
Replacement in libpijul/src/output/archive.rs at line 101 [13.690044]
B:BD[33.25306] → [33.25306:25342]
```
    T: std::error::Error + 'static,
```
[33.25306]
[33.25342]
```
    T: GraphTxnT + TreeTxnT,
```

Replacement in libpijul/src/output/archive.rs at line 109 [13.690044]

B:BD[33.25444] → [33.25444:25456]

    Txn(T),

[33.25444]

[33.25456]

    Txn(#[from] TxnErr<T::GraphError>),
    #[error(transparent)]
    Tree(#[from] TreeErr<T::TreeError>),

Replacement in libpijul/src/output/archive.rs at line 124 [13.690044]

B:BD[13.692169] → [12.87545:87733]

impl<
        P: std::error::Error + 'static,
        T: std::error::Error + 'static,
        A: std::error::Error + 'static,
    > std::convert::From<TxnErr<T>> for ArchiveError<P, T, A>

[13.692169]

[12.87733]

impl<P: std::error::Error + 'static, T: GraphTxnT + TreeTxnT, A: std::error::Error + 'static>
    std::fmt::Debug for ArchiveError<P, T, A>

Replacement in libpijul/src/output/archive.rs at line 127 [13.690044]

B:BD[12.87735] → [12.87735:87802]

    fn from(e: TxnErr<T>) -> Self {
        ArchiveError::Txn(e.0)

[12.87735]

[12.87802]

    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            ArchiveError::A(e) => std::fmt::Debug::fmt(e, fmt),
            ArchiveError::P(e) => std::fmt::Debug::fmt(e, fmt),
            ArchiveError::Txn(e) => std::fmt::Debug::fmt(e, fmt),
            ArchiveError::Tree(e) => std::fmt::Debug::fmt(e, fmt),
            ArchiveError::Unrecord(e) => std::fmt::Debug::fmt(e, fmt),
            ArchiveError::Apply(e) => std::fmt::Debug::fmt(e, fmt),
            ArchiveError::File(e) => std::fmt::Debug::fmt(e, fmt),
            ArchiveError::Output(e) => std::fmt::Debug::fmt(e, fmt),
            ArchiveError::StateNotFound { state } => write!(fmt, "State not found: {:?}", state),
        }

Replacement in libpijul/src/output/archive.rs at line 144 [13.690044]

B:BD[12.87842] → [62.246:319]

    T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>,

[12.87842]

[12.87862]

    T: ChannelTxnT + TreeTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>,

Replacement in libpijul/src/output/archive.rs at line 154 [13.690044]

B:BD[13.692359] → [12.87935:88013]

) -> Result<Vec<Conflict>, ArchiveError<P::Error, T::GraphError, A::Error>> {

[13.692359]

[31.103479]

) -> Result<Vec<Conflict>, ArchiveError<P::Error, T, A::Error>> {

Replacement in libpijul/src/lib.rs at line 111 [13.717381]

B:BD[9.74] → [9.74:136]

        crate::apply::ApplyError<C::Error, Self::GraphError>,

[9.74]

[9.136]

        crate::apply::ApplyError<C::Error, Self>,

Replacement in libpijul/src/lib.rs at line 122 [13.717381]

B:BD[13.720799] → [12.93117:93214]

    ) -> Result<(u64, pristine::Merkle), crate::apply::ApplyError<C::Error, Self::GraphError>> {

[13.720799]

[13.720857]

    ) -> Result<(u64, pristine::Merkle), crate::apply::ApplyError<C::Error, Self>> {

Replacement in libpijul/src/lib.rs at line 132 [13.717381]

B:BD[13.721167] → [12.93215:93291]

    ) -> Result<(), crate::apply::ApplyError<C::Error, Self::GraphError>> {

[13.721167]

[13.721204]

    ) -> Result<(), crate::apply::ApplyError<C::Error, Self>> {

Replacement in libpijul/src/lib.rs at line 141 [13.717381]

∅:D[14.126039] → [12.93292:93389]

B:BD[13.721471] → [12.93292:93389]

    ) -> Result<(u64, pristine::Merkle), crate::apply::ApplyError<C::Error, Self::GraphError>> {

[14.126039]

[13.721529]

    ) -> Result<(u64, pristine::Merkle), crate::apply::ApplyError<C::Error, Self>> {

Replacement in libpijul/src/lib.rs at line 150 [13.717381]
∅:D[14.126071] → [12.93390:93466]
B:BD[13.721775] → [12.93390:93466]
```
    ) -> Result<(), crate::apply::ApplyError<C::Error, Self::GraphError>> {
```
[14.126071]
[13.721812]
```
    ) -> Result<(), crate::apply::ApplyError<C::Error, Self>> {
```
Replacement in libpijul/src/lib.rs at line 159 [13.717381]
∅:D[14.126103] → [12.93467:93543]
B:BD[13.722067] → [12.93467:93543]
```
    ) -> Result<(), crate::apply::ApplyError<C::Error, Self::GraphError>> {
```
[14.126103]
[13.722104]
```
    ) -> Result<(), crate::apply::ApplyError<C::Error, Self>> {
```

Replacement in libpijul/src/lib.rs at line 170 [13.717381]

B:BD[13.722441] → [12.93544:93636]

    ) -> Result<(u64, pristine::Merkle), crate::apply::LocalApplyError<Self::GraphError>> {

[13.722441]

[13.722499]

    ) -> Result<(u64, pristine::Merkle), crate::apply::LocalApplyError<Self>> {

Replacement in libpijul/src/lib.rs at line 180 [13.717381]

B:BD[13.722831] → [12.93637:93729]

    ) -> Result<(u64, pristine::Merkle), crate::apply::LocalApplyError<Self::GraphError>> {

[13.722831]

[13.722889]

    ) -> Result<(u64, pristine::Merkle), crate::apply::LocalApplyError<Self>> {

Replacement in libpijul/src/lib.rs at line 189 [13.717381]

B:BD[13.724094] → [12.94455:94543]

    ) -> Result<pristine::Hash, crate::apply::ApplyError<C::Error, Self::GraphError>> {

[13.724094]

[13.724183]

    ) -> Result<pristine::Hash, crate::apply::ApplyError<C::Error, Self>> {

Replacement in libpijul/src/lib.rs at line 218 [13.717381]

B:BD[33.28705] → [14.126168:126257]

        apply::apply_local_change(self, channel, &change, &hash, &recorded.updatables)?;

[33.28705]

[13.725172]

        apply::apply_local_change(self, channel, &change, &hash, &recorded.updatables)
            .map_err(ApplyError::LocalChange)?;

Replacement in libpijul/src/lib.rs at line 229 [13.717381]

∅:D[35.4209] → [12.94606:94683]

B:BD[13.725363] → [12.94606:94683]

    ) -> Result<bool, unrecord::UnrecordError<C::Error, Self::GraphError>> {

[35.4209]

[35.4210]

    ) -> Result<bool, unrecord::UnrecordError<C::Error, Self>> {

Replacement in libpijul/src/lib.rs at line 236 [13.717381]

B:BD[13.726194] → [63.610:710]

    fn add_file(&mut self, path: &str, salt: u64) -> Result<Inode, fs::FsError<Self::GraphError>> {

[13.726194]

[35.4371]

    fn add_file(&mut self, path: &str, salt: u64) -> Result<Inode, fs::FsError<Self>> {

Replacement in libpijul/src/lib.rs at line 244 [13.717381]

B:BD[13.726545] → [63.711:810]

    fn add_dir(&mut self, path: &str, salt: u64) -> Result<Inode, fs::FsError<Self::GraphError>> {

[13.726545]

[35.4521]

    fn add_dir(&mut self, path: &str, salt: u64) -> Result<Inode, fs::FsError<Self>> {

Replacement in libpijul/src/lib.rs at line 251 [13.717381]

B:BD[13.726871] → [64.3163:3255]

B:BD[64.3255] → [63.811:867]

    fn add(
        &mut self,
        path: &str,
        is_dir: bool,
        salt: u64,
    ) -> Result<Inode, fs::FsError<Self::GraphError>> {

[13.726871]

[35.4680]

    fn add(&mut self, path: &str, is_dir: bool, salt: u64) -> Result<Inode, fs::FsError<Self>> {

Replacement in libpijul/src/lib.rs at line 255 [13.717381]

B:BD[13.727005] → [64.3309:3399]

B:BD[64.3399] → [64.3399:3452]

    fn move_file(
        &mut self,
        a: &str,
        b: &str,
        salt: u64,
    ) -> Result<(), fs::FsError<Self::GraphError>> {

[13.727005]

[35.4839]

    fn move_file(&mut self, a: &str, b: &str, salt: u64) -> Result<(), fs::FsError<Self>> {

Replacement in libpijul/src/lib.rs at line 259 [13.717381]

B:BD[13.727123] → [12.95152:95238]

    fn remove_file(&mut self, a: &str) -> Result<(), fs::FsError<Self::GraphError>> {

[13.727123]

[13.727193]

    fn remove_file(&mut self, a: &str) -> Result<(), fs::FsError<Self>> {

Replacement in libpijul/src/lib.rs at line 271 [13.717381]

∅:D[35.4899] → [12.95357:95456]

B:BD[13.728008] → [12.95357:95456]

B:BD[12.95456] → [12.95456:95462]

    ) -> Result<Vec<output::Conflict>, output::ArchiveError<P::Error, Self::GraphError, A::Error>>
    {

[35.4899]

[13.728064]

    ) -> Result<Vec<output::Conflict>, output::ArchiveError<P::Error, Self, A::Error>> {

Replacement in libpijul/src/lib.rs at line 300 [13.717381]

∅:D[35.4938] → [12.95463:95562]

B:BD[13.728757] → [12.95463:95562]

B:BD[12.95562] → [12.95562:95568]

    ) -> Result<Vec<output::Conflict>, output::ArchiveError<P::Error, Self::GraphError, A::Error>>
    {

[35.4938]

[13.728813]

    ) -> Result<Vec<output::Conflict>, output::ArchiveError<P::Error, Self, A::Error>> {

Replacement in libpijul/src/lib.rs at line 494 [13.717381]

B:BD[14.128217] → [65.2074:2163]

    ) -> Result<Option<(String, bool)>, output::FileError<C::Error, Self::GraphError>> {

[14.128217]

[13.732030]

    ) -> Result<Option<(String, bool)>, output::FileError<C::Error, Self>> {

Replacement in libpijul/src/lib.rs at line 507 [13.717381]

B:BD[13.732453] → [65.2164:2253]

    ) -> Result<Option<(String, bool)>, output::FileError<C::Error, Self::GraphError>> {

[13.732453]

[13.732502]

    ) -> Result<Option<(String, bool)>, output::FileError<C::Error, Self>> {

Replacement in libpijul/src/lib.rs at line 520 [13.717381]

B:BD[13.732890] → [12.98802:98875]

B:BD[12.98875] → [12.98875:98925]

B:BD[12.98925] → [12.98925:98933]

    ) -> Result<
        (pristine::Position<pristine::ChangeId>, bool),
        fs::FsErrorC<C::Error, Self::GraphError>,
    > {

[13.732890]

[31.104363]

    ) -> Result<(pristine::Position<pristine::ChangeId>, bool), fs::FsErrorC<C::Error, Self>> {

Replacement in libpijul/src/lib.rs at line 529 [13.717381]

B:BD[13.733724] → [12.99144:99243]

B:BD[12.99243] → [12.99243:99249]

    ) -> Result<Vec<output::Conflict>, output::ArchiveError<C::Error, Self::GraphError, A::Error>>
    {

[13.733724]

[13.733780]

    ) -> Result<Vec<output::Conflict>, output::ArchiveError<C::Error, Self, A::Error>> {

Replacement in libpijul/src/lib.rs at line 539 [13.717381]

B:BD[13.734091] → [12.99250:99349]

B:BD[12.99349] → [12.99349:99355]

    ) -> Result<Vec<output::Conflict>, output::ArchiveError<C::Error, Self::GraphError, A::Error>>
    {

[13.734091]

[13.734147]

    ) -> Result<Vec<output::Conflict>, output::ArchiveError<C::Error, Self, A::Error>> {

Replacement in libpijul/src/fs.rs at line 23 [13.737429]
B:BD[66.1] → [33.30426:30450]
B:BD[33.30450] → [33.30450:30501]
```
#[derive(Debug, Error)]
pub enum FsError<T: std::error::Error + 'static> {
```
[66.1]
[12.101531]
```
#[derive(Error)]
pub enum FsError<T: TreeTxnT> {
```
Replacement in libpijul/src/fs.rs at line 30 [13.737429]
B:BD[12.101618] → [12.101618:101630]
```
    Txn(T),
```
[12.101618]
[63.868]
```
    Tree(#[from] TreeErr<T::TreeError>),
```

Replacement in libpijul/src/fs.rs at line 35 [13.737429]

B:BD[12.101633] → [12.101633:101657]

B:BD[12.101657] → [12.101657:101741]

#[derive(Debug, Error)]
pub enum FsErrorC<C: std::error::Error + 'static, T: std::error::Error + 'static> {

[12.101633]

[33.30634]

impl<T: TreeTxnT> std::fmt::Debug for FsError<T> {
    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            FsError::NotFound(e) => std::fmt::Debug::fmt(e, fmt),
            FsError::AlreadyInRepo(e) => write!(fmt, "File already in repository: {}", e),
            FsError::Tree(e) => std::fmt::Debug::fmt(e, fmt),
            FsError::InvalidPath(e) => write!(fmt, "Invalid path: {}", e),
        }
    }
}
#[derive(Error)]
pub enum FsErrorC<C: std::error::Error + 'static, T: GraphTxnT> {

Replacement in libpijul/src/fs.rs at line 49 [13.737429]
B:BD[33.30660] → [33.30660:30672]
```
    Txn(T),
```
[33.30660]
[12.101742]
```
    Txn(#[from] TxnErr<T::GraphError>),
```

Insertion in libpijul/src/fs.rs at line 56 [13.737429]

[12.101851]

impl<C: std::error::Error + 'static, T: GraphTxnT> std::fmt::Debug for FsErrorC<C, T> {
    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            FsErrorC::Txn(e) => std::fmt::Debug::fmt(e, fmt),
            FsErrorC::Changestore(e) => std::fmt::Debug::fmt(e, fmt),
            FsErrorC::NotFound(e) => std::fmt::Debug::fmt(e, fmt),
        }
    }
}

Deletion in libpijul/src/fs.rs at line 70 [13.737429]

B:BD[12.101939] → [12.101939:102093]

B:BD[12.102093] → [12.102093:102094]

B:BD[12.102094] → [12.102094:102287]

∅:D[12.102287] → [33.30672:30675]

B:BD[33.30672] → [33.30672:30675]

impl<T: std::error::Error + 'static> std::convert::From<TxnErr<T>> for FsError<T> {
    fn from(e: TxnErr<T>) -> Self {
        FsError::Txn(e.0)
    }
}
impl<C: std::error::Error + 'static, T: std::error::Error + 'static> std::convert::From<TxnErr<T>>
    for FsErrorC<C, T>
{
    fn from(e: TxnErr<T>) -> Self {
        FsErrorC::Txn(e.0)
    }
}

Replacement in libpijul/src/fs.rs at line 74 [13.737429]
B:BD[64.3557] → [64.3557:3600]
```
) -> Result<Inode, TxnErr<T::TreeError>> {
```
[64.3557]
[35.5132]
```
) -> Result<Inode, TreeErr<T::TreeError>> {
```

Replacement in libpijul/src/fs.rs at line 89 [13.737429]

B:BD[13.738959] → [12.102471:102567]

pub fn is_directory<T: TreeTxnT>(txn: &T, inode: Inode) -> Result<bool, TxnErr<T::TreeError>> {

[13.738959]

[13.739021]

pub fn is_directory<T: TreeTxnT>(txn: &T, inode: Inode) -> Result<bool, TreeErr<T::TreeError>> {

Replacement in libpijul/src/fs.rs at line 108 [13.737429]

B:BD[13.739519] → [12.102762:102857]

) -> Result<(Inode, std::iter::Peekable<crate::path::Components<'a>>), TxnErr<T::TreeError>> {

[13.739519]

[13.739584]

) -> Result<(Inode, std::iter::Peekable<crate::path::Components<'a>>), TreeErr<T::TreeError>> {

Replacement in libpijul/src/fs.rs at line 143 [13.737429]

B:BD[33.30737] → [12.102992:103086]

pub fn find_inode<T: TreeTxnT>(txn: &T, path: &str) -> Result<Inode, FsError<T::TreeError>> {

[33.30737]

[13.740814]

pub fn find_inode<T: TreeTxnT>(txn: &T, path: &str) -> Result<Inode, FsError<T>> {

Replacement in libpijul/src/fs.rs at line 156 [13.737429]

B:BD[13.741242] → [12.103225:103317]

pub fn is_tracked<T: TreeTxnT>(txn: &T, path: &str) -> Result<bool, TxnErr<T::TreeError>> {

[13.741242]

[13.741300]

pub fn is_tracked<T: TreeTxnT>(txn: &T, path: &str) -> Result<bool, TreeErr<T::TreeError>> {

Replacement in libpijul/src/fs.rs at line 167 [13.737429]
B:BD[12.103521] → [12.103521:103573]
```
) -> Result<Option<String>, TxnErr<T::TreeError>> {
```
[12.103521]
[13.741691]
```
) -> Result<Option<String>, TreeErr<T::TreeError>> {
```
Replacement in libpijul/src/fs.rs at line 205 [13.737429]
∅:D[35.5473] → [12.103713:103757]
B:BD[13.742759] → [12.103713:103757]
```
) -> Result<Inode, FsError<T::TreeError>> {
```
[35.5473]
[13.742795]
```
) -> Result<Inode, FsError<T>> {
```
Replacement in libpijul/src/fs.rs at line 253 [13.737429]
B:BD[35.5552] → [63.963:1007]
```
) -> Result<Inode, FsError<T::TreeError>> {
```
[35.5552]
[13.744815]
```
) -> Result<Inode, FsError<T>> {
```
Replacement in libpijul/src/fs.rs at line 282 [13.737429]
∅:D[35.5733] → [12.104492:104533]
B:BD[13.745846] → [12.104492:104533]
```
) -> Result<(), FsError<T::TreeError>> {
```
[35.5733]
[13.745879]
```
) -> Result<(), FsError<T>> {
```
Replacement in libpijul/src/fs.rs at line 293 [13.737429]
∅:D[35.5825] → [12.104578:104619]
B:BD[13.746112] → [12.104578:104619]
```
) -> Result<(), FsError<T::TreeError>> {
```
[35.5825]
[14.130469]
```
) -> Result<(), FsError<T>> {
```
Replacement in libpijul/src/fs.rs at line 316 [13.737429]
∅:D[67.653] → [12.104803:104844]
B:BD[13.747021] → [12.104803:104844]
```
) -> Result<(), FsError<T::TreeError>> {
```
[67.653]
[13.747079]
```
) -> Result<(), FsError<T>> {
```

Replacement in libpijul/src/fs.rs at line 359 [13.737429]

B:BD[13.748753] → [12.105212:105311]

pub fn remove_file<T: TreeMutTxnT>(txn: &mut T, path: &str) -> Result<(), FsError<T::TreeError>> {

[13.748753]

[13.748840]

pub fn remove_file<T: TreeMutTxnT>(txn: &mut T, path: &str) -> Result<(), FsError<T>> {

Replacement in libpijul/src/fs.rs at line 849 [13.737429]

B:BD[13.759162] → [12.113217:113294]

) -> Result<(Position<ChangeId>, bool), FsErrorC<C::Error, T::GraphError>> {

[13.759162]

[13.759219]

) -> Result<(Position<ChangeId>, bool), FsErrorC<C::Error, T>> {

Replacement in libpijul/src/fs.rs at line 924 [13.737429]

B:BD[13.761102] → [65.2254:2343]

) -> Result<Option<(String, bool)>, crate::output::FileError<C::Error, T::GraphError>> {

[13.761102]

[13.761147]

) -> Result<Option<(String, bool)>, crate::output::FileError<C::Error, T>> {

Replacement in libpijul/src/fs.rs at line 941 [13.737429]

∅:D[68.798] → [65.2651:2736]

B:BD[65.2651] → [65.2651:2736]

            Err(BlockError::Txn(t)) => return Err(crate::output::FileError::Txn(t)),

[68.798]

[65.2736]

            Err(BlockError::Txn(t)) => return Err(crate::output::FileError::Txn(TxnErr(t))),

Replacement in libpijul/src/diff/mod.rs at line 61 [13.793247]

B:BD[33.33220] → [33.33220:33244]

B:BD[33.33244] → [12.115465:115550]

#[derive(Debug, Error)]
pub enum DiffError<P: std::error::Error + 'static, T: std::error::Error + 'static> {

[33.33220]

[12.115550]

#[derive(Error)]
pub enum DiffError<P: std::error::Error + 'static, T: GraphTxnT> {

Replacement in libpijul/src/diff/mod.rs at line 66 [13.793247]
B:BD[33.33323] → [12.115629:115641]
```
    Txn(T),
```
[33.33323]
[12.115641]
```
    Txn(#[from] TxnErr<T::GraphError>),
```

Replacement in libpijul/src/diff/mod.rs at line 69 [13.793247]

B:BD[12.115644] → [12.115644:115833]

impl<T: std::error::Error + 'static, C: std::error::Error + 'static> std::convert::From<TxnErr<T>>
    for DiffError<C, T>
{
    fn from(e: TxnErr<T>) -> Self {
        DiffError::Txn(e.0)

[12.115644]

[12.115833]

impl<P: std::error::Error, T: GraphTxnT> std::fmt::Debug for DiffError<P, T> {
    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            DiffError::Output(e) => std::fmt::Debug::fmt(e, fmt),
            DiffError::Txn(e) => std::fmt::Debug::fmt(e, fmt),
        }

Replacement in libpijul/src/diff/mod.rs at line 143 [13.793247]
∅:D[69.715] → [12.115897:115955]
∅:D[70.1928] → [12.115897:115955]
B:BD[13.794388] → [12.115897:115955]
```
    ) -> Result<(), DiffError<P::Error, T::GraphError>> {
```
[70.1928]
[36.86435]
```
    ) -> Result<(), DiffError<P::Error, T>> {
```

Replacement in libpijul/src/apply.rs at line 14 [13.944089]

B:BD[33.93418] → [33.93418:93442]

B:BD[33.93442] → [33.93442:93540]

B:BD[33.93540] → [33.93540:93579]

#[derive(Debug, Error)]
pub enum ApplyError<ChangestoreError: std::error::Error, TxnError: std::error::Error + 'static> {
    #[error("Changestore error: {0}")]

[33.93418]

[33.93579]

pub enum ApplyError<ChangestoreError: std::error::Error, T: GraphTxnT + TreeTxnT> {

Replacement in libpijul/src/apply.rs at line 16 [13.944089]

B:BD[33.93614] → [33.93614:93690]

B:BD[33.93690] → [33.93690:93730]

B:BD[33.93730] → [33.93730:93737]

    #[error("Local change error: {err}")]
    LocalChange {
        #[from]
        err: LocalApplyError<TxnError>,
    },

[33.93614]

[33.93737]

    LocalChange(LocalApplyError<T>),
}
impl<C: std::error::Error, T: GraphTxnT + TreeTxnT> std::fmt::Debug for ApplyError<C, T> {
    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            ApplyError::Changestore(e) => std::fmt::Debug::fmt(e, fmt),
            ApplyError::LocalChange(e) => std::fmt::Debug::fmt(e, fmt),
        }
    }
}
impl<C: std::error::Error, T: GraphTxnT + TreeTxnT> std::fmt::Display for ApplyError<C, T> {
    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            ApplyError::Changestore(e) => std::fmt::Display::fmt(e, fmt),
            ApplyError::LocalChange(e) => std::fmt::Display::fmt(e, fmt),
        }
    }

Insertion in libpijul/src/apply.rs at line 36 [13.944089]

[33.93739]


impl<C: std::error::Error, T: GraphTxnT + TreeTxnT> std::error::Error for ApplyError<C, T> {}

Replacement in libpijul/src/apply.rs at line 39 [13.944089]
B:BD[33.93740] → [33.93740:93764]
B:BD[33.93764] → [12.123034:123100]
∅:D[12.123100] → [33.93820:93867]
B:BD[33.93820] → [33.93820:93867]
```
#[derive(Debug, Error)]
pub enum LocalApplyError<TxnError: std::error::Error + 'static> {
    #[error("Dependency missing: {:?}", hash)]
```
[33.93740]
[33.93867]
```
#[derive(Error)]
pub enum LocalApplyError<T: GraphTxnT + TreeTxnT> {
```
Deletion in libpijul/src/apply.rs at line 42 [13.944089]
B:BD[33.93922] → [33.93922:93976]
```
    #[error("Change already on channel: {:?}", hash)]
```

Replacement in libpijul/src/apply.rs at line 43 [13.944089]

B:BD[33.94036] → [33.94036:94075]

B:BD[33.94075] → [33.94075:94094]

B:BD[33.94094] → [12.123101:123142]

    #[error("Transaction error: {0}")]
    Txn(TxnError),
    #[error("Block error: {:?}", block)]

[33.94036]

[12.123142]

    Txn(#[from] TxnErr<T::GraphError>),
    Tree(#[from] TreeErr<T::TreeError>),

Deletion in libpijul/src/apply.rs at line 46 [13.944089]
B:BD[12.123183] → [12.123183:123214]
```
    #[error("Invalid change")]
```

Replacement in libpijul/src/apply.rs at line 49 [13.944089]

∅:D[40.17434] → [33.94266:94387]

B:BD[33.94266] → [33.94266:94387]

B:BD[33.94387] → [33.94387:94407]

B:BD[33.94407] → [33.94407:94468]

B:BD[33.94468] → [12.123234:123359]

impl<TxnError: std::error::Error> LocalApplyError<TxnError> {
    fn from_missing(err: MissingError<TxnError>) -> Self {
        match err {
            MissingError::Txn(e) => LocalApplyError::Txn(e),
            MissingError::Block(e) => e.into(),
            MissingError::Inconsistent(_) => LocalApplyError::InvalidChange,

[33.94266]

[12.123359]

impl<T: GraphTxnT + TreeTxnT> std::fmt::Debug for LocalApplyError<T> {
    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            LocalApplyError::DependencyMissing { hash } => {
                write!(fmt, "Dependency missing: {:?}", hash)
            }
            LocalApplyError::ChangeAlreadyOnChannel { hash } => {
                write!(fmt, "Change already on channel: {:?}", hash)
            }
            LocalApplyError::Txn(e) => std::fmt::Debug::fmt(e, fmt),
            LocalApplyError::Tree(e) => std::fmt::Debug::fmt(e, fmt),
            LocalApplyError::Block { block } => write!(fmt, "Block error: {:?}", block),
            LocalApplyError::InvalidChange => write!(fmt, "Invalid change"),

Replacement in libpijul/src/apply.rs at line 66 [13.944089]

B:BD[12.123378] → [12.123378:123542]

B:BD[12.123542] → [12.123542:123562]

B:BD[12.123562] → [12.123562:123629]

B:BD[12.123629] → [12.123629:123678]

impl<T: std::error::Error> From<crate::pristine::InconsistentChange<T>> for LocalApplyError<T> {
    fn from(err: crate::pristine::InconsistentChange<T>) -> Self {
        match err {
            InconsistentChange::Txn(e) => LocalApplyError::Txn(e),
            _ => LocalApplyError::InvalidChange,

[12.123378]

[12.123678]

impl<T: GraphTxnT + TreeTxnT> std::fmt::Display for LocalApplyError<T> {
    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            LocalApplyError::DependencyMissing { hash } => {
                write!(fmt, "Dependency missing: {:?}", hash)
            }
            LocalApplyError::ChangeAlreadyOnChannel { hash } => {
                write!(fmt, "Change already on channel: {:?}", hash)
            }
            LocalApplyError::Txn(e) => std::fmt::Display::fmt(e, fmt),
            LocalApplyError::Tree(e) => std::fmt::Display::fmt(e, fmt),
            LocalApplyError::Block { block } => write!(fmt, "Block error: {:?}", block),
            LocalApplyError::InvalidChange => write!(fmt, "Invalid change"),

Replacement in libpijul/src/apply.rs at line 83 [13.944089]

B:BD[12.123697] → [12.123697:123873]

impl<T: std::error::Error> From<crate::pristine::TxnErr<T>> for LocalApplyError<T> {
    fn from(err: crate::pristine::TxnErr<T>) -> Self {
        LocalApplyError::Txn(err.0)

[12.123697]

[12.123873]

impl<C: std::error::Error, T: GraphTxnT + TreeTxnT> From<crate::pristine::TxnErr<T::GraphError>>
    for ApplyError<C, T>
{
    fn from(err: crate::pristine::TxnErr<T::GraphError>) -> Self {
        ApplyError::LocalChange(LocalApplyError::Txn(err))

Replacement in libpijul/src/apply.rs at line 91 [13.944089]

B:BD[12.123882] → [12.123882:123964]

impl<C: std::error::Error, T: std::error::Error> From<crate::pristine::TxnErr<T>>

[12.123882]

[12.123964]

impl<C: std::error::Error, T: GraphTxnT + TreeTxnT> From<crate::pristine::TreeErr<T::TreeError>>

Replacement in libpijul/src/apply.rs at line 94 [13.944089]

B:BD[12.123991] → [12.123991:124089]

    fn from(err: crate::pristine::TxnErr<T>) -> Self {
        LocalApplyError::Txn(err.0).into()

[12.123991]

[12.124089]

    fn from(err: crate::pristine::TreeErr<T::TreeError>) -> Self {
        ApplyError::LocalChange(LocalApplyError::Tree(err))

Replacement in libpijul/src/apply.rs at line 99 [13.944089]

B:BD[12.124098] → [12.124098:124246]

impl<T: std::error::Error> From<crate::pristine::BlockError<T>> for LocalApplyError<T> {
    fn from(err: crate::pristine::BlockError<T>) -> Self {

[12.124098]

[12.124246]

impl<T: GraphTxnT + TreeTxnT> LocalApplyError<T> {
    fn from_missing(err: MissingError<T::GraphError>) -> Self {

Replacement in libpijul/src/apply.rs at line 102 [13.944089]

B:BD[12.124266] → [12.124266:124325]

            BlockError::Txn(e) => LocalApplyError::Txn(e),

[12.124266]

[12.124325]

            MissingError::Txn(e) => LocalApplyError::Txn(TxnErr(e)),
            MissingError::Block(e) => e.into(),
            MissingError::Inconsistent(_) => LocalApplyError::InvalidChange,
        }
    }
}
impl<T: GraphTxnT + TreeTxnT> From<crate::pristine::InconsistentChange<T::GraphError>>
    for LocalApplyError<T>
{
    fn from(err: crate::pristine::InconsistentChange<T::GraphError>) -> Self {
        match err {
            InconsistentChange::Txn(e) => LocalApplyError::Txn(TxnErr(e)),
            _ => LocalApplyError::InvalidChange,
        }
    }
}
impl<T: GraphTxnT + TreeTxnT> From<crate::pristine::BlockError<T::GraphError>>
    for LocalApplyError<T>
{
    fn from(err: crate::pristine::BlockError<T::GraphError>) -> Self {
        match err {
            BlockError::Txn(e) => LocalApplyError::Txn(TxnErr(e)),

Insertion in libpijul/src/apply.rs at line 131 [13.944089]

[33.94637]

[13.944459]

impl<C: std::error::Error, T: GraphTxnT + TreeTxnT> From<crate::pristine::BlockError<T::GraphError>>
    for ApplyError<C, T>
{
    fn from(err: crate::pristine::BlockError<T::GraphError>) -> Self {
        ApplyError::LocalChange(LocalApplyError::from(err))
    }
}

Replacement in libpijul/src/apply.rs at line 149 [13.944089]
B:BD[13.944880] → [12.124403:124469]
```
) -> Result<(u64, Merkle), ApplyError<P::Error, T::GraphError>> {
```
[13.944880]
[13.944924]
```
) -> Result<(u64, Merkle), ApplyError<P::Error, T>> {
```

Replacement in libpijul/src/apply.rs at line 163 [13.944089]

B:BD[13.945379] → [14.143355:143436]

        return Err((LocalApplyError::DependencyMissing { hash: *hash }).into());

[13.945379]

[13.945443]

        return Err(ApplyError::LocalChange(
            LocalApplyError::DependencyMissing { hash: *hash },
        ));

Replacement in libpijul/src/apply.rs at line 176 [13.944089]

B:BD[13.945713] → [33.94941:94973]

B:BD[33.94973] → [64.4296:4355]

∅:D[64.4355] → [33.95077:95085]

B:BD[33.95077] → [33.95077:95085]

    Ok(apply_change_to_channel(
        txn, channel, internal, &hash, &change, workspace,
    )?)

[13.945713]

[13.945917]

    Ok(
        apply_change_to_channel(txn, channel, internal, &hash, &change, workspace)
            .map_err(ApplyError::LocalChange)?,
    )

Replacement in libpijul/src/apply.rs at line 189 [13.944089]
B:BD[13.946111] → [12.124780:124835]
```
) -> Result<(), ApplyError<P::Error, T::GraphError>> {
```
[13.946111]
[13.946144]
```
) -> Result<(), ApplyError<P::Error, T>> {
```

Replacement in libpijul/src/apply.rs at line 233 [13.944089]

B:BD[13.947384] → [71.6246:6339]

                apply_change_to_channel(txn, channel, internal, &hash, &change, workspace)?;

[13.947384]

[13.947698]

                apply_change_to_channel(txn, channel, internal, &hash, &change, workspace)
                    .map_err(ApplyError::LocalChange)?;

Replacement in libpijul/src/apply.rs at line 247 [13.944089]
∅:D[14.144002] → [12.125335:125401]
B:BD[13.947938] → [12.125335:125401]
```
) -> Result<(u64, Merkle), ApplyError<P::Error, T::GraphError>> {
```
[14.144002]
[13.947982]
```
) -> Result<(u64, Merkle), ApplyError<P::Error, T>> {
```
Replacement in libpijul/src/apply.rs at line 257 [13.944089]
B:BD[31.105988] → [31.105988:106054]
```
) -> Result<(u64, Merkle), ApplyError<P::Error, T::GraphError>> {
```
[31.105988]
[31.106054]
```
) -> Result<(u64, Merkle), ApplyError<P::Error, T>> {
```
Replacement in libpijul/src/apply.rs at line 274 [13.944089]
B:BD[13.948278] → [12.125402:125457]
```
) -> Result<(), ApplyError<P::Error, T::GraphError>> {
```
[13.948278]
[13.948311]
```
) -> Result<(), ApplyError<P::Error, T>> {
```
Replacement in libpijul/src/apply.rs at line 285 [13.944089]
B:BD[13.948456] → [12.125458:125505]
```
fn apply_change_to_channel<T: ChannelMutTxnT>(
```
[13.948456]
[13.948727]
```
fn apply_change_to_channel<T: ChannelMutTxnT + TreeTxnT>(
```
Replacement in libpijul/src/apply.rs at line 292 [13.944089]
B:BD[13.948861] → [12.125506:125567]
```
) -> Result<(u64, Merkle), LocalApplyError<T::GraphError>> {
```
[13.948861]
[13.948905]
```
) -> Result<(u64, Merkle), LocalApplyError<T>> {
```

Replacement in libpijul/src/apply.rs at line 377 [13.944089]

B:BD[12.126768] → [12.126768:126854]

B:BD[12.126854] → [12.126854:126919]

    T: ChannelMutTxnT
        + DepsMutTxnT<DepsError = <T as GraphTxnT>::GraphError>
        + TreeMutTxnT<TreeError = <T as GraphTxnT>::GraphError>,

[12.126768]

[12.126919]

    T: ChannelMutTxnT + DepsMutTxnT<DepsError = <T as GraphTxnT>::GraphError> + TreeMutTxnT,

Replacement in libpijul/src/apply.rs at line 385 [13.944089]
B:BD[13.952657] → [12.126923:126984]
```
) -> Result<(u64, Merkle), LocalApplyError<T::GraphError>> {
```
[13.952657]
[31.106202]
```
) -> Result<(u64, Merkle), LocalApplyError<T>> {
```

Replacement in libpijul/src/apply.rs at line 413 [13.944089]

B:BD[12.127315] → [12.127315:127401]

B:BD[12.127401] → [12.127401:127466]

    T: ChannelMutTxnT
        + DepsMutTxnT<DepsError = <T as GraphTxnT>::GraphError>
        + TreeMutTxnT<TreeError = <T as GraphTxnT>::GraphError>,

[12.127315]

[12.127466]

    T: ChannelMutTxnT + DepsMutTxnT<DepsError = <T as GraphTxnT>::GraphError> + TreeMutTxnT,

Replacement in libpijul/src/apply.rs at line 420 [13.944089]
B:BD[13.953616] → [12.127470:127531]
```
) -> Result<(u64, Merkle), LocalApplyError<T::GraphError>> {
```
[13.953616]
[13.953660]
```
) -> Result<(u64, Merkle), LocalApplyError<T>> {
```
Replacement in libpijul/src/apply.rs at line 431 [13.944089]
∅:D[35.5889] → [54.7939:8028]
B:BD[52.3408] → [54.7939:8028]
```
fn update_inode<T: ChannelTxnT + TreeMutTxnT<TreeError = <T as GraphTxnT>::GraphError>>(
```
[52.3408]
[13.953893]
```
fn update_inode<T: ChannelTxnT + TreeMutTxnT>(
```
Replacement in libpijul/src/apply.rs at line 436 [13.944089]
B:BD[13.953986] → [12.127645:127694]
```
) -> Result<(), LocalApplyError<T::TreeError>> {
```
[13.953986]
[13.954019]
```
) -> Result<(), LocalApplyError<T>> {
```

Replacement in libpijul/src/apply.rs at line 509 [13.944089]

B:BD[72.1058] → [12.132243:132303]

pub(crate) fn clean_obsolete_pseudo_edges<T: GraphMutTxnT>(

[33.97504]

[13.971306]

pub(crate) fn clean_obsolete_pseudo_edges<T: GraphMutTxnT + TreeTxnT>(

Replacement in libpijul/src/apply.rs at line 514 [13.944089]
B:BD[40.20894] → [12.132333:132383]
```
) -> Result<(), LocalApplyError<T::GraphError>> {
```
[40.20894]
[13.971451]
```
) -> Result<(), LocalApplyError<T>> {
```
Replacement in libpijul/src/apply.rs at line 576 [13.944089]
B:BD[72.1060] → [12.132504:132549]
```
fn repair_missing_contexts<T: GraphMutTxnT>(
```
[72.1060]
[13.974346]
```
fn repair_missing_contexts<T: GraphMutTxnT + TreeTxnT>(
```
Replacement in libpijul/src/apply.rs at line 582 [13.944089]
B:BD[13.974463] → [12.132579:132629]
```
) -> Result<(), LocalApplyError<T::GraphError>> {
```
[13.974463]
[13.974496]
```
) -> Result<(), LocalApplyError<T>> {
```
Replacement in libpijul/src/apply.rs at line 609 [13.944089]
B:BD[72.1062] → [12.132630:132680]
```
fn repair_new_vertex_context_up<T: GraphMutTxnT>(
```
[72.1062]
[40.22151]
```
fn repair_new_vertex_context_up<T: GraphMutTxnT + TreeTxnT>(
```
Replacement in libpijul/src/apply.rs at line 616 [13.944089]
B:BD[40.22310] → [12.132710:132760]
```
) -> Result<(), LocalApplyError<T::GraphError>> {
```
[40.22310]
[40.22355]
```
) -> Result<(), LocalApplyError<T>> {
```
Replacement in libpijul/src/apply.rs at line 636 [13.944089]
B:BD[40.22912] → [12.132804:132856]
```
fn repair_new_vertex_context_down<T: GraphMutTxnT>(
```
[40.22912]
[40.22959]
```
fn repair_new_vertex_context_down<T: GraphMutTxnT + TreeTxnT>(
```
Replacement in libpijul/src/apply.rs at line 643 [13.944089]
B:BD[40.23118] → [12.132886:132936]
```
) -> Result<(), LocalApplyError<T::GraphError>> {
```
[40.23118]
[40.23163]
```
) -> Result<(), LocalApplyError<T>> {
```
Replacement in libpijul/src/apply.rs at line 676 [13.944089]
B:BD[40.24008] → [12.133150:133191]
```
fn repair_edge_context<T: GraphMutTxnT>(
```
[40.24008]
[13.978666]
```
fn repair_edge_context<T: GraphMutTxnT + TreeTxnT>(
```
Replacement in libpijul/src/apply.rs at line 683 [13.944089]
B:BD[40.24076] → [12.133221:133271]
```
) -> Result<(), LocalApplyError<T::GraphError>> {
```
[40.24076]
[40.24121]
```
) -> Result<(), LocalApplyError<T>> {
```
Replacement in libpijul/src/apply.rs at line 707 [13.944089]
B:BD[40.25019] → [12.133272:133324]
```
pub(crate) fn repair_cyclic_paths<T: GraphMutTxnT>(
```
[40.25019]
[40.25066]
```
pub(crate) fn repair_cyclic_paths<T: GraphMutTxnT + TreeTxnT>(
```
Replacement in libpijul/src/apply.rs at line 711 [13.944089]
B:BD[40.25137] → [12.133354:133404]
```
) -> Result<(), LocalApplyError<T::GraphError>> {
```
[40.25137]
[13.978816]
```
) -> Result<(), LocalApplyError<T>> {
```
Replacement in libpijul/src/apply.rs at line 737 [13.944089]
B:BD[13.979487] → [12.133551:133584]
```
fn repair_edge<T: GraphMutTxnT>(
```
[13.979487]
[13.979515]
```
fn repair_edge<T: GraphMutTxnT + TreeTxnT>(
```
Replacement in libpijul/src/apply.rs at line 742 [13.944089]
B:BD[13.979642] → [12.133614:133664]
```
) -> Result<(), LocalApplyError<T::GraphError>> {
```
[13.979642]
[40.25855]
```
) -> Result<(), LocalApplyError<T>> {
```
Replacement in libpijul/src/apply.rs at line 813 [13.944089]
B:BD[13.980815] → [12.134020:134048]
```
fn is_rooted<T: GraphTxnT>(
```
[13.980815]
[13.980838]
```
fn is_rooted<T: GraphTxnT + TreeTxnT>(
```
Replacement in libpijul/src/apply.rs at line 818 [13.944089]
B:BD[13.980926] → [12.134074:134126]
```
) -> Result<bool, LocalApplyError<T::GraphError>> {
```
[13.980926]
[40.27818]
```
) -> Result<bool, LocalApplyError<T>> {
```

Replacement in libpijul/src/apply.rs at line 891 [13.944089]

B:BD[73.621] → [73.621:701]

) -> Result<Option<(Hash, u64, Merkle)>, ApplyError<P::Error, T::GraphError>> {

[73.621]

[73.701]

) -> Result<Option<(Hash, u64, Merkle)>, ApplyError<P::Error, T>> {

Replacement in libpijul/src/apply.rs at line 904 [13.944089]

B:BD[9.360] → [9.360:489]

                let v = txn
                    .find_block(gr, v?.dest())
                    .map_err(LocalApplyError::from)?;

[9.360]

[73.1068]

                let v = txn.find_block(gr, v?.dest())?;

Replacement in libpijul/src/apply/vertex.rs at line 6 [36.90459]
B:BD[36.90614] → [36.90614:90653]
```
pub fn put_newvertex<T: GraphMutTxnT>(
```
[36.90614]
[36.90653]
```
pub fn put_newvertex<T: GraphMutTxnT + TreeTxnT>(
```
Replacement in libpijul/src/apply/vertex.rs at line 13 [36.90459]
B:BD[36.90792] → [36.90792:90842]
```
) -> Result<(), LocalApplyError<T::GraphError>> {
```
[36.90792]
[36.90842]
```
) -> Result<(), LocalApplyError<T>> {
```
Replacement in libpijul/src/apply/vertex.rs at line 73 [36.90459]
B:BD[36.92874] → [36.92874:92910]
```
fn put_up_context<T: GraphMutTxnT>(
```
[36.92874]
[36.92910]
```
fn put_up_context<T: GraphMutTxnT + TreeTxnT>(
```
Replacement in libpijul/src/apply/vertex.rs at line 79 [36.90459]
B:BD[36.93022] → [36.93022:93074]
```
) -> Result<bool, LocalApplyError<T::GraphError>> {
```
[36.93022]
[36.93074]
```
) -> Result<bool, LocalApplyError<T>> {
```
Replacement in libpijul/src/apply/vertex.rs at line 122 [36.90459]
B:BD[36.94588] → [36.94588:94626]
```
fn put_down_context<T: GraphMutTxnT>(
```
[36.94588]
[36.94626]
```
fn put_down_context<T: GraphMutTxnT + TreeTxnT>(
```
Replacement in libpijul/src/apply/vertex.rs at line 128 [36.90459]
B:BD[36.94740] → [36.94740:94792]
```
) -> Result<bool, LocalApplyError<T::GraphError>> {
```
[36.94740]
[36.94792]
```
) -> Result<bool, LocalApplyError<T>> {
```
Replacement in libpijul/src/apply/edge.rs at line 15 [36.96160]
B:BD[36.96505] → [74.1356:1404]
```
) -> Result<(), LocalApplyError<T::GraphError>>
```
[36.96505]
[36.96524]
```
) -> Result<(), LocalApplyError<T>>
```
Replacement in libpijul/src/apply/edge.rs at line 17 [36.96160]
B:BD[36.96530] → [36.96530:96551]
```
    T: GraphMutTxnT,
```
[36.96530]
[74.1405]
```
    T: GraphMutTxnT + TreeTxnT,
```
Replacement in libpijul/src/apply/edge.rs at line 105 [36.96160]
B:BD[36.99461] → [74.1590:1638]
```
) -> Result<(), LocalApplyError<T::GraphError>>
```
[36.99461]
[36.99480]
```
) -> Result<(), LocalApplyError<T>>
```
Replacement in libpijul/src/apply/edge.rs at line 107 [36.96160]
B:BD[36.99486] → [36.99486:99507]
```
    T: GraphMutTxnT,
```
[36.99486]
[36.99582]
```
    T: GraphMutTxnT + TreeTxnT,
```
Replacement in libpijul/src/apply/edge.rs at line 133 [36.96160]
B:BD[36.100307] → [36.100307:100340]
```
fn check_valid<T: GraphMutTxnT>(
```
[36.100307]
[36.100340]
```
fn check_valid<T: GraphMutTxnT + TreeTxnT>(
```
Replacement in libpijul/src/apply/edge.rs at line 139 [36.96160]
B:BD[36.100480] → [36.100480:100530]
```
) -> Result<(), LocalApplyError<T::GraphError>> {
```
[36.100480]
[36.100530]
```
) -> Result<(), LocalApplyError<T>> {
```
Replacement in libpijul/src/apply/edge.rs at line 156 [36.96160]
B:BD[36.100992] → [74.1639:1690]
```
pub(crate) fn find_source_vertex<T: GraphMutTxnT>(
```
[36.100992]
[36.101032]
```
pub(crate) fn find_source_vertex<T: GraphMutTxnT + TreeTxnT>(
```
Replacement in libpijul/src/apply/edge.rs at line 164 [36.96160]
B:BD[36.101221] → [36.101221:101285]
```
) -> Result<Vertex<ChangeId>, LocalApplyError<T::GraphError>> {
```
[36.101221]
[36.101285]
```
) -> Result<Vertex<ChangeId>, LocalApplyError<T>> {
```
Replacement in libpijul/src/apply/edge.rs at line 177 [36.96160]
B:BD[36.101745] → [74.1691:1742]
```
pub(crate) fn find_target_vertex<T: GraphMutTxnT>(
```
[36.101745]
[36.101785]
```
pub(crate) fn find_target_vertex<T: GraphMutTxnT + TreeTxnT>(
```
Replacement in libpijul/src/apply/edge.rs at line 185 [36.96160]
B:BD[36.101970] → [36.101970:102034]
```
) -> Result<Vertex<ChangeId>, LocalApplyError<T::GraphError>> {
```
[36.101970]
[36.102034]
```
) -> Result<Vertex<ChangeId>, LocalApplyError<T>> {
```
Replacement in libpijul/src/apply/edge.rs at line 199 [36.96160]
B:BD[36.102516] → [36.102516:102558]
```
fn collect_pseudo_edges<T: GraphMutTxnT>(
```
[36.102516]
[36.102558]
```
fn collect_pseudo_edges<T: GraphMutTxnT + TreeTxnT>(
```
Replacement in libpijul/src/apply/edge.rs at line 205 [36.96160]
B:BD[36.102697] → [36.102697:102747]
```
) -> Result<(), LocalApplyError<T::GraphError>> {
```
[36.102697]
[36.102747]
```
) -> Result<(), LocalApplyError<T>> {
```
Replacement in libpijul/src/apply/edge.rs at line 238 [36.96160]
B:BD[36.103722] → [36.103722:103766]
```
fn reconnect_pseudo_edges<T: GraphMutTxnT>(
```
[36.103722]
[36.103766]
```
fn reconnect_pseudo_edges<T: GraphMutTxnT + TreeTxnT>(
```
Replacement in libpijul/src/apply/edge.rs at line 244 [36.96160]
B:BD[36.103907] → [36.103907:103957]
```
) -> Result<(), LocalApplyError<T::GraphError>> {
```
[36.103907]
[36.103957]
```
) -> Result<(), LocalApplyError<T>> {
```

Replacement in libpijul/src/alive/retrieve.rs at line 120 [13.984582]

∅:D[12.135533] → [13.988093:988137]

B:BD[13.988093] → [13.988093:988137]

B:BD[13.988137] → [14.148676:148743]

∅:D[15.67154] → [13.988202:988306]

∅:D[16.74065] → [13.988202:988306]

∅:D[12.135616] → [13.988202:988306]

∅:D[14.148743] → [13.988202:988306]

B:BD[13.988202] → [13.988202:988306]

B:BD[13.988306] → [53.22079:22145]

B:BD[53.22145] → [53.22145:22190]

B:BD[53.22190] → [53.22190:22208]

B:BD[53.22208] → [53.22208:22242]

B:BD[53.22242] → [53.22242:22254]

    for &(vertex, edge) in forward.iter() {
        let dest = *txn.find_block(channel, edge.dest()).unwrap();
        debug!(target:"libpijul::forward", "deleting forward edge {:?} {:?} {:?}", vertex, dest, edge);
        del_graph_with_rev(
            txn,
            channel,
            edge.flag(),
            vertex,
            dest,
            edge.introduced_by(),
        )?;

[12.135533]

[13.988393]

    for ve in forward.iter() {
        let dest = *txn.find_block(channel, ve.e.dest()).unwrap();
        debug!(target:"libpijul::forward", "deleting forward edge {:?} {:?} {:?}", ve.v, dest, ve.e);
        del_graph_with_rev(txn, channel, ve.e.flag(), ve.v, dest, ve.e.introduced_by())?;

Replacement in libpijul/src/alive/output.rs at line 24 [13.988425]
B:BD[13.989052] → [12.135687:135741]
```
) -> Result<(), FileError<P::Error, T::GraphError>> {
```
[13.989052]
[13.989085]
```
) -> Result<(), FileError<P::Error, T>> {
```
Replacement in libpijul/src/alive/output.rs at line 191 [13.988425]
B:BD[13.993081] → [12.137317:137371]
```
) -> Result<(), FileError<P::Error, T::GraphError>> {
```
[13.993081]
[10.7474]
```
) -> Result<(), FileError<P::Error, T>> {
```

Replacement in libpijul/src/alive/output.rs at line 246 [13.988425]

B:BD[13.994445] → [14.149218:149277]

∅:D[14.149277] → [12.137521:137590]

B:BD[13.994494] → [12.137521:137590]

    forward: &mut Vec<(Vertex<ChangeId>, SerializedEdge)>,
) -> Result<(), crate::output::FileError<P::Error, T::GraphError>> {

[13.994445]

[13.994527]

    forward: &mut Vec<super::Redundant>,
) -> Result<(), crate::output::FileError<P::Error, T>> {

Insertion in libpijul/src/alive/mod.rs at line 24 [13.995164]

[13.995652]

pub struct Redundant {
    pub(crate) v: Vertex<ChangeId>,
    pub(crate) e: SerializedEdge,
}

Replacement in libpijul/src/alive/dfs.rs at line 369 [13.1000429]
B:BD[13.1013332] → [14.149918:149981]
```
        forward: &mut Vec<(Vertex<ChangeId>, SerializedEdge)>,
```
[13.1013332]
[12.137761]
```
        forward: &mut Vec<super::Redundant>,
```

Replacement in libpijul/src/alive/dfs.rs at line 391 [13.1000429]

B:BD[13.1014350] → [13.1014350:1014421]

                            forward.push((self[*cousin].vertex, edge))

[13.1014350]

[13.1014421]

                            forward.push(super::Redundant {
                                v: self[*cousin].vertex,
                                e: edge,
                            })

Insertion in libpijul/Cargo.toml at line 62 [13.1020742]
[53.22963]
[75.231]
```
"src/tag/txn.rs",
```
Replacement in Cargo.lock at line 273 [13.1030385]
B:BD[76.3116] → [30.1732:1757]
```
version = "3.0.0-beta.5"
```
[76.3116]
[76.3141]
```
version = "3.0.0-rc.0"
```

Replacement in Cargo.lock at line 275 [13.1030385]

B:BD[76.3206] → [30.1758:1836]

checksum = "feff3878564edb93745d58cf63e17b63f24142506e7a20c87a5521ed7bfb1d63"

[76.3206]

[76.3284]

checksum = "79b70f999da60e6619a29b131739d2211ed4d4301f40372e94a8081422e9d6c7"

Deletion in Cargo.lock at line 286 [13.1030385]
B:BD[76.3423] → [30.1837:1849]
```
 "unicase",
```
Replacement in Cargo.lock at line 290 [13.1030385]
B:BD[76.3489] → [30.1850:1875]
```
version = "3.0.0-beta.5"
```
[76.3489]
[76.3514]
```
version = "3.0.0-rc.0"
```

Replacement in Cargo.lock at line 292 [13.1030385]

B:BD[76.3579] → [30.1876:1954]

checksum = "8b15c6b4f786ffb6192ffe65a36855bc1fc2444bcd0945ae16748dcd6ed7d0d3"

[76.3579]

[76.3657]

checksum = "fe8c0f28022faaef0387fa54f8e33fee22b804a88bbd91303197da2ff8ca6a5d"

Replacement in Cargo.lock at line 1405 [13.1030385]
B:BD[76.30867] → [30.1955:1973]
```
version = "4.2.0"
```
[76.30867]
[76.30885]
```
version = "6.0.0"
```

Replacement in Cargo.lock at line 1407 [13.1030385]

B:BD[76.30950] → [30.1974:2052]

checksum = "addaa943333a514159c80c97ff4a93306530d965d27e139188283cd13e06a799"

[76.30950]

[30.2052]

checksum = "8e22443d1643a904602595ba1cd8f7d896afe56d26712531c5ff73a15b2fbf64"

Deletion in Cargo.lock at line 2102 [13.1030385]
∅:D[77.5819] → [76.48295:48332]
B:BD[76.48295] → [76.48295:48332]
```
dependencies = [
 "unicode-width",
]
```

Deletion in Cargo.lock at line 2373 [13.1030385]

B:BD[30.2323] → [30.2323:2538]

∅:D[30.2538] → [76.54292:54305]

B:BD[76.54292] → [76.54292:54305]

name = "unicase"
version = "2.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "50f37be617794602aabbeee0be4f259dc1778fabe05e2d67ee8f79326d5cb4f6"
dependencies = [
 "version_check",
]
[[package]]

Deletion in Cargo.lock at line 2394 [13.1030385]
B:BD[76.54973] → [76.54973:54996]
B:BD[76.54996] → [78.9304:9322]
∅:D[78.9322] → [76.55014:55079]
B:BD[76.55014] → [76.55014:55079]
B:BD[76.55079] → [78.9323:9401]
∅:D[78.9401] → [76.55157:55170]
B:BD[76.55157] → [76.55157:55170]
```
name = "unicode-width"
version = "0.1.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3ed742d4ea2bd1176e236172c8429aaf54486e7ac098db29ffe6529e0ce50973"
[[package]]
```