pijul/pijul - Change VO5OQW4W2656DIYYRNZ3PO7TQ4JOKQ3GVWE5ALUTYVMX3WMXJOYQC

Removing anyhow in libpijul

Created by pmeunier on December 6, 2020

VO5OQW4W2656DIYYRNZ3PO7TQ4JOKQ3GVWE5ALUTYVMX3WMXJOYQC

Dependencies

In channels

main

In discussions

#214 Minor cleanup

#219 Minor cleanup, redux

#243 Better Remotes

#143 Clippy Lints

Change contents

Replacement in pijul-macros/src/lib.rs at line 511 [17.445]
B:BD[17.18449] → [17.18449:18491]
```
        ) -> Result<bool, anyhow::Error>;
```
[17.18449]
[17.18491]
```
        ) -> Result<bool, Self::Error>;
```
Replacement in pijul-macros/src/lib.rs at line 517 [17.445]
B:BD[17.18606] → [17.18606:18648]
```
        ) -> Result<bool, anyhow::Error>;
```
[17.18606]
[17.18648]
```
        ) -> Result<bool, Self::Error>;
```

Replacement in pijul-macros/src/lib.rs at line 546 [17.445]

B:BD[17.19827] → [17.19827:19874]

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

[17.19827]

[17.19874]

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

Replacement in pijul-macros/src/lib.rs at line 554 [17.445]

B:BD[17.20095] → [17.20095:20142]

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

[17.20095]

[17.20142]

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

Replacement in pijul-macros/src/lib.rs at line 565 [17.445]

B:BD[17.20426] → [17.20426:20473]

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

[17.20426]

[17.20473]

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

Replacement in pijul-macros/src/lib.rs at line 575 [17.445]

B:BD[17.20764] → [17.20764:20811]

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

[17.20764]

[17.20811]

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

Deletion in pijul/src/main.rs at line 108 [17.83981]
B:BD[17.85778] → [3.159:203]
∅:D[3.203] → [17.85845:85867]
∅:D[18.866] → [17.85845:85867]
B:BD[17.85845] → [17.85845:85867]
```
    #[clap(setting = AppSettings::Hidden)]
    Upgrade(Upgrade),
```
Deletion in pijul/src/main.rs at line 241 [17.83981]
B:BD[17.89650] → [17.89650:89705]
```
        SubCommand::Upgrade(upgrade) => upgrade.run(),
```

File deletion: upgrade.rs

BF:BFD[17.93386] → [17.93387:93399]

BF:BFD[17.93399] → [17.93400:93400]

B:BD[17.93400] → [18.1022:1105]

∅:BD[18.1105] → [17.93436:93476]

B:BD[17.93436] → [17.93436:93476]

B:BD[17.93476] → [19.1752:1810]

∅:BD[19.1810] → [18.1106:1142]

B:BD[17.93560] → [18.1106:1142]

∅:BD[18.1142] → [17.93626:93671]

B:BD[17.93626] → [17.93626:93671]

∅:BD[20.150] → [17.93671:94167]

∅:BD[21.149] → [17.93671:94167]

∅:BD[22.149] → [17.93671:94167]

B:BD[17.93671] → [17.93671:94167]

B:BD[17.94167] → [23.454:537]

∅:BD[23.537] → [17.94247:95615]

B:BD[17.94247] → [17.94247:95615]

B:BD[17.93671] → [20.0:150]

use std::collections::{HashMap, HashSet};
use std::path::PathBuf;
use clap::Clap;
use libpijul::changestore::ChangeStore;
use libpijul::{Hash, MutTxnT, MutTxnTExt, TxnT, TxnTExt};
use crate::repository::Repository;
#[derive(Clap, Debug)]
pub struct Upgrade {
    #[clap(long = "repository")]
    repo_path: Option<PathBuf>,
}
impl Upgrade {
    pub fn run(self) -> Result<(), anyhow::Error> {
        let mut channels = HashMap::new();
        {
            let repo = Repository::find_root(self.repo_path.clone())?;
            let txn = repo.pristine.txn_begin()?;
            let mut hashes = HashSet::new();
            for channel in txn.iter_channels("") {
                let channel = channel.borrow();
                let name = channel.name();
                let e = channels.entry(name.to_string()).or_insert_with(Vec::new);
                hashes.clear();
                for (_, (h, _)) in txn.reverse_log(&channel, None) {
                    if !hashes.insert(h) {
                        continue;
                    }
                    let path = repo.changes.filename(&h);
                    let change = libpijul::change::v3::LocalChange3::deserialize(
                        path.to_str().unwrap(),
                        Some(&h),
                    )
                    .unwrap();
                    e.push((h, change))
                }
            }
            std::fs::rename(repo.path.join(".pijul"), repo.path.join(".pijul.old"))?;
        }
        let repo2 = Repository::init(self.repo_path)?;
        let mut txn2 = repo2.pristine.mut_txn_begin();
        let mut translations = HashMap::new();
        translations.insert(None, None);
        translations.insert(Some(Hash::None), Some(Hash::None));
        for (channel_name, mut changes) in channels {
            let mut channel = txn2.open_or_create_channel(&channel_name)?;
            while let Some((old_h, c)) = changes.pop() {
                let h = repo2.changes.save_change(&c.to_v4(&translations))?;
                translations.insert(Some(old_h), Some(h));
                txn2.apply_change(&repo2.changes, &mut channel, h)?;
            }
        }
        txn2.commit()?;
        Ok(())
    }
}
    /// Set the repository where this command should run. Defaults to the first ancestor of the current directory that contains a `.pijul` directory.

Deletion in pijul/src/commands/mod.rs at line 59 [17.133619]
B:BD[17.134333] → [17.134333:134366]
B:BD[17.134366] → [4.1575:1576]
```
mod upgrade;
pub use upgrade::*;
```

Replacement in pijul/src/commands/git.rs at line 648 [17.137210]

B:BD[17.159258] → [17.159258:159611]

        Err(e) => match e.downcast() {
            Ok(libpijul::Error::ChangeAlreadyOnChannel { hash }) => {
                error!("change already on channel: {:?}", hash);
                return Ok(txn.current_state(&channel.borrow()).unwrap());
            }
            Ok(e) => return Err(e.into()),
            Err(e) => return Err(e),
        },

[17.159258]

[17.159611]

        Err(libpijul::LocalApplyError::ChangeAlreadyOnChannel { hash }) => {
            error!("change already on channel: {:?}", hash);
            return Ok(txn.current_state(&channel.borrow()).unwrap());
        }
        Err(e) => return Err(e.into()),

Replacement in pijul/src/commands/git.rs at line 692 [17.137210]

B:BD[17.160679] → [19.3959:4047]

) -> Result<(usize, Option<libpijul::Hash>, Option<libpijul::Merkle>), anyhow::Error> {

[17.160679]

[17.160829]

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

Replacement in pijul/src/commands/git.rs at line 699 [17.137210]

B:BD[24.317] → [24.317:535]

        if let Err(e) = result {
            match e.downcast() {
                Ok(libpijul::Error::FileNotInRepo { .. }) => {}
                Ok(e) => return Err(e.into()),
                Err(e) => return Err(e),

[24.317]

[24.535]

        use libpijul::working_copy::filesystem::*;
        match result {
            Ok(_) => {}
            Err(Error::Add(AddError::Fs(FsError::NotFound(_)))) => {}
            Err(Error::Add(AddError::Fs(FsError::AlreadyInRepo(_)))) => {}
            Err(e) => {
                error!("While adding {:?}: {}", p, e);

Replacement in pijul/src/commands/credit.rs at line 88 [17.178684]
∅:D[19.6159] → [17.181047:181121]
B:BD[17.181047] → [17.181047:181121]
```
    fn output_line<C: FnOnce(&mut Vec<u8>) -> Result<(), anyhow::Error>>(
```
[19.6159]
[17.181121]
```
    fn output_line<E, C: FnOnce(&mut Vec<u8>) -> Result<(), E>>(
```

Replacement in pijul/src/commands/credit.rs at line 92 [17.178684]

B:BD[17.181183] → [17.181183:181220]

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

[17.181183]

[17.181220]

    ) -> Result<(), E>
    where
        E: From<std::io::Error>,
    {

Replacement in pijul/src/commands/credit.rs at line 142 [17.178684]

B:BD[17.182632] → [17.182632:182713]

    fn output_conflict_marker(&mut self, s: &str) -> Result<(), anyhow::Error> {

[17.182632]

[17.182713]

    fn output_conflict_marker(&mut self, s: &str) -> Result<(), std::io::Error> {

Insertion in libpijul/src/working_copy/mod.rs at line 11 [17.198172]

[17.198424]


#[derive(Debug, Error)]
pub enum WriteError<E: std::error::Error + 'static> {
    #[error(transparent)]
    E(E),
    #[error(transparent)]
    Io(#[from] std::io::Error),
}

Replacement in libpijul/src/working_copy/mod.rs at line 21 [17.198172]

B:BD[17.198449] → [17.198449:199114]

    fn create_dir_all(&mut self, path: &str) -> Result<(), anyhow::Error>;
    fn file_metadata(&self, file: &str) -> Result<InodeMetadata, anyhow::Error>;
    fn read_file(&self, file: &str, buffer: &mut Vec<u8>) -> Result<(), anyhow::Error>;
    fn modified_time(&self, file: &str) -> Result<std::time::SystemTime, anyhow::Error>;
    fn remove_path(&mut self, name: &str) -> Result<(), anyhow::Error>;
    fn rename(&mut self, former: &str, new: &str) -> Result<(), anyhow::Error>;
    fn set_permissions(&mut self, name: &str, permissions: u16) -> Result<(), anyhow::Error>;
    fn write_file<A, F: FnOnce(&mut dyn std::io::Write) -> Result<A, anyhow::Error>>(

[17.198449]

[17.199114]

    type Error: std::error::Error;
    fn create_dir_all(&mut self, path: &str) -> Result<(), Self::Error>;
    fn file_metadata(&self, file: &str) -> Result<InodeMetadata, Self::Error>;
    fn read_file(&self, file: &str, buffer: &mut Vec<u8>) -> Result<(), Self::Error>;
    fn modified_time(&self, file: &str) -> Result<std::time::SystemTime, Self::Error>;
    fn remove_path(&mut self, name: &str) -> Result<(), Self::Error>;
    fn rename(&mut self, former: &str, new: &str) -> Result<(), Self::Error>;
    fn set_permissions(&mut self, name: &str, permissions: u16) -> Result<(), Self::Error>;
    fn write_file<A, E: std::error::Error, F: FnOnce(&mut dyn std::io::Write) -> Result<A, E>>(

Replacement in libpijul/src/working_copy/mod.rs at line 33 [17.198172]
B:BD[17.199172] → [17.199172:199207]
```
    ) -> Result<A, anyhow::Error>;
```
[17.199172]
[17.199207]
```
    ) -> Result<A, WriteError<E>>;
```

Insertion in libpijul/src/working_copy/memory.rs at line 197 [17.199222]

[17.205401]

}
#[derive(Debug, Error)]
pub enum Error {
    #[error("Path not found: {path}")]
    NotFound { path: String },

Replacement in libpijul/src/working_copy/memory.rs at line 206 [17.199222]

B:BD[17.205434] → [17.205434:205510]

    fn create_dir_all(&mut self, file: &str) -> Result<(), anyhow::Error> {

[17.205434]

[17.205510]

    type Error = Error;
    fn create_dir_all(&mut self, file: &str) -> Result<(), Self::Error> {

Replacement in libpijul/src/working_copy/memory.rs at line 223 [17.199222]

B:BD[17.205959] → [17.205959:206041]

    fn file_metadata(&self, file: &str) -> Result<InodeMetadata, anyhow::Error> {

[17.205959]

[17.206041]

    fn file_metadata(&self, file: &str) -> Result<InodeMetadata, Self::Error> {

Replacement in libpijul/src/working_copy/memory.rs at line 227 [17.199222]
B:BD[17.206196] → [17.206196:206250]
```
            None => Err((crate::Error::FileNotFound {
```
[17.206196]
[17.206250]
```
            None => Err(Error::NotFound {
```
Replacement in libpijul/src/working_copy/memory.rs at line 229 [17.199222]
B:BD[17.206290] → [17.206290:206327]
```
            })
            .into()),
```
[17.206290]
[17.206327]
```
            }),
```

Replacement in libpijul/src/working_copy/memory.rs at line 232 [17.199222]

B:BD[17.206343] → [17.206343:206432]

    fn read_file(&self, file: &str, buffer: &mut Vec<u8>) -> Result<(), anyhow::Error> {

[17.206343]

[17.206432]

    fn read_file(&self, file: &str, buffer: &mut Vec<u8>) -> Result<(), Self::Error> {

Replacement in libpijul/src/working_copy/memory.rs at line 239 [17.199222]
B:BD[17.206862] → [25.186:240]
```
            None => Err((crate::Error::FileNotFound {
```
[17.206862]
[25.240]
```
            None => Err(Error::NotFound {
```
Replacement in libpijul/src/working_copy/memory.rs at line 241 [17.199222]
B:BD[25.280] → [25.280:317]
```
            })
            .into()),
```
[25.280]
[17.206862]
```
            }),
```

Replacement in libpijul/src/working_copy/memory.rs at line 244 [17.199222]

B:BD[17.206878] → [17.206878:206969]

    fn modified_time(&self, _file: &str) -> Result<std::time::SystemTime, anyhow::Error> {

[17.206878]

[17.206969]

    fn modified_time(&self, _file: &str) -> Result<std::time::SystemTime, Self::Error> {

Replacement in libpijul/src/working_copy/memory.rs at line 248 [17.199222]

B:BD[17.207007] → [17.207007:207080]

    fn remove_path(&mut self, path: &str) -> Result<(), anyhow::Error> {

[17.207007]

[17.207080]

    fn remove_path(&mut self, path: &str) -> Result<(), Self::Error> {

Replacement in libpijul/src/working_copy/memory.rs at line 253 [17.199222]

B:BD[17.207135] → [17.207135:207213]

    fn rename(&mut self, old: &str, new: &str) -> Result<(), anyhow::Error> {

[17.207135]

[17.207213]

    fn rename(&mut self, old: &str, new: &str) -> Result<(), Self::Error> {

Replacement in libpijul/src/working_copy/memory.rs at line 260 [17.199222]

B:BD[17.207386] → [17.207386:207481]

    fn set_permissions(&mut self, file: &str, permissions: u16) -> Result<(), anyhow::Error> {

[17.207386]

[17.207481]

    fn set_permissions(&mut self, file: &str, permissions: u16) -> Result<(), Self::Error> {

Replacement in libpijul/src/working_copy/memory.rs at line 273 [17.199222]

B:BD[17.207946] → [17.207946:208032]

    fn write_file<A, F: FnOnce(&mut dyn std::io::Write) -> Result<A, anyhow::Error>>(

[17.207946]

[17.208032]

    fn write_file<A, E: std::error::Error, F: FnOnce(&mut dyn std::io::Write) -> Result<A, E>>(

Replacement in libpijul/src/working_copy/memory.rs at line 277 [17.199222]
B:BD[17.208090] → [17.208090:208126]
```
    ) -> Result<A, anyhow::Error> {
```
[17.208090]
[17.208126]
```
    ) -> Result<A, WriteError<E>> {
```
Replacement in libpijul/src/working_copy/memory.rs at line 283 [17.199222]
B:BD[17.208288] → [17.208288:208321]
```
                writer(contents)
```
[17.208288]
[17.208321]
```
                writer(contents).map_err(WriteError::E)
```

Replacement in libpijul/src/working_copy/memory.rs at line 288 [17.199222]

B:BD[17.208459] → [17.208459:208507]

                let a = writer(&mut contents)?;

[17.208459]

[17.208507]

                let a = writer(&mut contents).map_err(WriteError::E)?;

Replacement in libpijul/src/working_copy/filesystem.rs at line 32 [17.208900]
B:BD[17.209178] → [17.209178:209226]
```
) -> Result<(PathBuf, String), anyhow::Error> {
```
[17.209178]
[17.209226]
```
) -> Result<(PathBuf, String), std::io::Error> {
```

Insertion in libpijul/src/working_copy/filesystem.rs at line 56 [17.208900]

[17.209915]

}
#[derive(Debug, Error)]
pub enum AddError<T: std::error::Error + 'static> {
    #[error(transparent)]
    Ignore(#[from] ignore::Error),
    #[error(transparent)]
    Io(#[from] std::io::Error),
    #[error(transparent)]
    Fs(#[from] crate::fs::FsError<T>),

Insertion in libpijul/src/working_copy/filesystem.rs at line 68 [17.208900]

[17.209918]

#[derive(Debug, Error)]
pub enum Error<C: std::error::Error + 'static, T: std::error::Error + 'static> {
    #[error(transparent)]
    Add(#[from] AddError<T>),
    #[error(transparent)]
    Record(#[from] crate::record::RecordError<C, std::io::Error, T>),
}

Replacement in libpijul/src/working_copy/filesystem.rs at line 95 [17.208900]
B:BD[17.210434] → [17.210434:210471]
```
    ) -> Result<(), anyhow::Error> {
```
[17.210434]
[17.210471]
```
    ) -> Result<(), Error<C::Error, T::Error>> {
```
Replacement in libpijul/src/working_copy/filesystem.rs at line 111 [17.208900]
B:BD[13.1792] → [13.1792:1829]
```
    ) -> Result<(), anyhow::Error> {
```
[13.1792]
[13.1829]
```
    ) -> Result<(), AddError<T::Error>> {
```
Replacement in libpijul/src/working_copy/filesystem.rs at line 168 [17.208900]
B:BD[17.211282] → [17.211282:211319]
```
    ) -> Result<(), anyhow::Error> {
```
[17.211282]
[17.211425]
```
    ) -> Result<(), Error<C::Error, T::Error>> {
```

Replacement in libpijul/src/working_copy/filesystem.rs at line 193 [17.208900]

B:BD[17.213953] → [17.213953:214029]

    fn create_dir_all(&mut self, file: &str) -> Result<(), anyhow::Error> {

[17.213953]

[11.159]

    type Error = std::io::Error;
    fn create_dir_all(&mut self, file: &str) -> Result<(), Self::Error> {

Replacement in libpijul/src/working_copy/filesystem.rs at line 197 [17.208900]

B:BD[17.214095] → [17.214095:214177]

    fn file_metadata(&self, file: &str) -> Result<InodeMetadata, anyhow::Error> {

[17.214095]

[11.215]

    fn file_metadata(&self, file: &str) -> Result<InodeMetadata, Self::Error> {

Replacement in libpijul/src/working_copy/filesystem.rs at line 203 [17.208900]

B:BD[17.214426] → [17.214426:214515]

    fn read_file(&self, file: &str, buffer: &mut Vec<u8>) -> Result<(), anyhow::Error> {

[17.214426]

[17.214515]

    fn read_file(&self, file: &str, buffer: &mut Vec<u8>) -> Result<(), Self::Error> {

Replacement in libpijul/src/working_copy/filesystem.rs at line 209 [17.208900]

B:BD[17.214660] → [17.214660:214750]

    fn modified_time(&self, file: &str) -> Result<std::time::SystemTime, anyhow::Error> {

[17.214660]

[11.334]

    fn modified_time(&self, file: &str) -> Result<std::time::SystemTime, Self::Error> {

Replacement in libpijul/src/working_copy/filesystem.rs at line 214 [17.208900]

B:BD[17.214848] → [17.214848:214921]

    fn remove_path(&mut self, path: &str) -> Result<(), anyhow::Error> {

[17.214848]

[11.392]

    fn remove_path(&mut self, path: &str) -> Result<(), Self::Error> {

Replacement in libpijul/src/working_copy/filesystem.rs at line 227 [17.208900]

B:BD[17.215297] → [17.215297:215378]

    fn rename(&mut self, former: &str, new: &str) -> Result<(), anyhow::Error> {

[17.215297]

[11.429]

    fn rename(&mut self, former: &str, new: &str) -> Result<(), Self::Error> {

Replacement in libpijul/src/working_copy/filesystem.rs at line 239 [17.208900]

B:BD[17.215737] → [17.215737:215832]

    fn set_permissions(&mut self, name: &str, permissions: u16) -> Result<(), anyhow::Error> {

[17.215737]

[17.215832]

    fn set_permissions(&mut self, name: &str, permissions: u16) -> Result<(), Self::Error> {

Replacement in libpijul/src/working_copy/filesystem.rs at line 254 [17.208900]

B:BD[17.216332] → [17.216332:216429]

    fn set_permissions(&mut self, _name: &str, _permissions: u16) -> Result<(), anyhow::Error> {

[17.216332]

[17.216429]

    fn set_permissions(&mut self, _name: &str, _permissions: u16) -> Result<(), Self::Error> {

Replacement in libpijul/src/working_copy/filesystem.rs at line 257 [17.208900]

B:BD[17.216450] → [17.216450:216536]

    fn write_file<A, F: FnOnce(&mut dyn std::io::Write) -> Result<A, anyhow::Error>>(

[17.216450]

[17.216536]

    fn write_file<A, E: std::error::Error, F: FnOnce(&mut dyn std::io::Write) -> Result<A, E>>(

Replacement in libpijul/src/working_copy/filesystem.rs at line 261 [17.208900]
B:BD[17.216594] → [17.216594:216630]
```
    ) -> Result<A, anyhow::Error> {
```
[17.216594]
[11.541]
```
    ) -> Result<A, WriteError<E>> {
```
Replacement in libpijul/src/working_copy/filesystem.rs at line 264 [17.208900]
B:BD[17.216712] → [17.216712:216752]
```
            std::fs::create_dir_all(p)?
```
[17.216712]
[17.216752]
```
            std::fs::create_dir_all(p).map_err(WriteError::Io)?
```

Replacement in libpijul/src/working_copy/filesystem.rs at line 267 [17.208900]

B:BD[17.216813] → [17.216813:216918]

        let mut file = std::io::BufWriter::new(std::fs::File::create(&path)?);
        writer(&mut file)

[17.216813]

[17.216918]

        let mut file =
            std::io::BufWriter::new(std::fs::File::create(&path).map_err(WriteError::Io)?);
        writer(&mut file).map_err(WriteError::E)

Replacement in libpijul/src/vertex_buffer.rs at line 15 [17.217202]

B:BD[17.217771] → [17.217771:217952]

    fn output_line<F: FnOnce(&mut Vec<u8>) -> Result<(), anyhow::Error>>(
        &mut self,
        key: Vertex<ChangeId>,
        contents: F,
    ) -> Result<(), anyhow::Error>;

[17.217771]

[17.217952]

    fn output_line<E, F>(&mut self, key: Vertex<ChangeId>, contents: F) -> Result<(), E>
    where
        E: From<std::io::Error>,
        F: FnOnce(&mut Vec<u8>) -> Result<(), E>;

Replacement in libpijul/src/vertex_buffer.rs at line 20 [17.217202]

B:BD[17.217953] → [17.217953:218097]

    fn output_conflict_marker(&mut self, s: &str) -> Result<(), anyhow::Error>;
    fn begin_conflict(&mut self) -> Result<(), anyhow::Error> {

[17.217953]

[17.218097]

    fn output_conflict_marker(&mut self, s: &str) -> Result<(), std::io::Error>;
    fn begin_conflict(&mut self) -> Result<(), std::io::Error> {

Replacement in libpijul/src/vertex_buffer.rs at line 24 [17.217202]

B:BD[17.218153] → [17.218153:218224]

    fn begin_zombie_conflict(&mut self) -> Result<(), anyhow::Error> {

[17.218153]

[17.218224]

    fn begin_zombie_conflict(&mut self) -> Result<(), std::io::Error> {

Replacement in libpijul/src/vertex_buffer.rs at line 27 [17.217202]

B:BD[17.218260] → [17.218260:218331]

    fn begin_cyclic_conflict(&mut self) -> Result<(), anyhow::Error> {

[17.218260]

[17.218331]

    fn begin_cyclic_conflict(&mut self) -> Result<(), std::io::Error> {

Replacement in libpijul/src/vertex_buffer.rs at line 30 [17.217202]

B:BD[17.218367] → [17.218367:218430]

    fn conflict_next(&mut self) -> Result<(), anyhow::Error> {

[17.218367]

[17.218430]

    fn conflict_next(&mut self) -> Result<(), std::io::Error> {

Replacement in libpijul/src/vertex_buffer.rs at line 33 [17.217202]

B:BD[17.218483] → [17.218483:218545]

    fn end_conflict(&mut self) -> Result<(), anyhow::Error> {

[17.218483]

[17.218545]

    fn end_conflict(&mut self) -> Result<(), std::io::Error> {

Replacement in libpijul/src/vertex_buffer.rs at line 36 [17.217202]

B:BD[17.218599] → [17.218599:218668]

    fn end_zombie_conflict(&mut self) -> Result<(), anyhow::Error> {

[17.218599]

[17.218668]

    fn end_zombie_conflict(&mut self) -> Result<(), std::io::Error> {

Replacement in libpijul/src/vertex_buffer.rs at line 39 [17.217202]

B:BD[17.218722] → [17.218722:218791]

    fn end_cyclic_conflict(&mut self) -> Result<(), anyhow::Error> {

[17.218722]

[17.218791]

    fn end_cyclic_conflict(&mut self) -> Result<(), std::io::Error> {

Replacement in libpijul/src/vertex_buffer.rs at line 80 [17.217202]

B:BD[17.219820] → [17.219820:219993]

    fn output_line<C: FnOnce(&mut Vec<u8>) -> Result<(), anyhow::Error>>(
        &mut self,
        _: Vertex<ChangeId>,
        c: C,
    ) -> Result<(), anyhow::Error> {

[17.219820]

[17.219993]

    fn output_line<E, C>(&mut self, _: Vertex<ChangeId>, c: C) -> Result<(), E>
    where
        E: From<std::io::Error>,
        C: FnOnce(&mut Vec<u8>) -> Result<(), E>,
    {

Replacement in libpijul/src/vertex_buffer.rs at line 98 [17.217202]

B:BD[17.220451] → [17.220451:220532]

    fn output_conflict_marker(&mut self, s: &str) -> Result<(), anyhow::Error> {

[17.220451]

[17.220532]

    fn output_conflict_marker(&mut self, s: &str) -> Result<(), std::io::Error> {

Replacement in libpijul/src/vertex_buffer.rs at line 112 [17.217202]

B:BD[17.220895] → [17.220895:220959]

    fn begin_conflict(&mut self) -> Result<(), anyhow::Error> {

[17.220895]

[17.220959]

    fn begin_conflict(&mut self) -> Result<(), std::io::Error> {

Replacement in libpijul/src/vertex_buffer.rs at line 119 [17.217202]

B:BD[17.221159] → [17.221159:221230]

    fn begin_zombie_conflict(&mut self) -> Result<(), anyhow::Error> {

[17.221159]

[17.221230]

    fn begin_zombie_conflict(&mut self) -> Result<(), std::io::Error> {

Replacement in libpijul/src/vertex_buffer.rs at line 126 [17.217202]

B:BD[17.221431] → [17.221431:221502]

    fn begin_cyclic_conflict(&mut self) -> Result<(), anyhow::Error> {

[17.221431]

[17.221502]

    fn begin_cyclic_conflict(&mut self) -> Result<(), std::io::Error> {

Replacement in libpijul/src/vertex_buffer.rs at line 168 [17.217202]

B:BD[17.222360] → [17.222360:222533]

    fn output_line<C: FnOnce(&mut Vec<u8>) -> Result<(), anyhow::Error>>(
        &mut self,
        _: Vertex<ChangeId>,
        c: C,
    ) -> Result<(), anyhow::Error> {

[17.222360]

[17.222533]

    fn output_line<E, C>(&mut self, _: Vertex<ChangeId>, c: C) -> Result<(), E>
    where
        E: From<std::io::Error>,
        C: FnOnce(&mut Vec<u8>) -> Result<(), E>,
    {

Replacement in libpijul/src/vertex_buffer.rs at line 185 [17.217202]

B:BD[17.222923] → [17.222923:223004]

    fn output_conflict_marker(&mut self, s: &str) -> Result<(), anyhow::Error> {

[17.222923]

[17.223004]

    fn output_conflict_marker(&mut self, s: &str) -> Result<(), std::io::Error> {

Replacement in libpijul/src/vertex_buffer.rs at line 196 [17.217202]

B:BD[17.223279] → [17.223279:223343]

    fn begin_conflict(&mut self) -> Result<(), anyhow::Error> {

[17.223279]

[17.223343]

    fn begin_conflict(&mut self) -> Result<(), std::io::Error> {

Replacement in libpijul/src/vertex_buffer.rs at line 199 [17.217202]

B:BD[17.223399] → [17.223399:223470]

    fn begin_zombie_conflict(&mut self) -> Result<(), anyhow::Error> {

[17.223399]

[17.223470]

    fn begin_zombie_conflict(&mut self) -> Result<(), std::io::Error> {

Replacement in libpijul/src/vertex_buffer.rs at line 202 [17.217202]

B:BD[17.223526] → [17.223526:223597]

    fn begin_cyclic_conflict(&mut self) -> Result<(), anyhow::Error> {

[17.223526]

[17.223597]

    fn begin_cyclic_conflict(&mut self) -> Result<(), std::io::Error> {

Replacement in libpijul/src/unrecord/working_copy.rs at line 10 [17.225940]
B:BD[17.226275] → [17.226275:226308]
```
) -> Result<(), anyhow::Error> {
```
[17.226275]
[17.226308]
```
) -> Result<(), T::Error> {
```
Replacement in libpijul/src/unrecord/working_copy.rs at line 29 [17.225940]
B:BD[17.226907] → [17.226907:226940]
```
) -> Result<(), anyhow::Error> {
```
[17.226907]
[17.226940]
```
) -> Result<(), super::UnrecordError<P::Error, T::Error>> {
```
Replacement in libpijul/src/unrecord/working_copy.rs at line 47 [17.225940]
B:BD[17.227588] → [17.227588:227621]
```
) -> Result<(), anyhow::Error> {
```
[17.227588]
[17.227621]
```
) -> Result<(), super::UnrecordError<P::Error, T::Error>> {
```

Replacement in libpijul/src/unrecord/working_copy.rs at line 67 [17.225940]

B:BD[17.228382] → [17.228382:228471]

            return_value = Some(restore_inode(txn, changes, source, dest, Inode::ROOT)?)

[17.228382]

[17.228471]

            return_value = Some(restore_inode(txn, changes, source, dest, Inode::ROOT)?);

Replacement in libpijul/src/unrecord/working_copy.rs at line 69 [17.225940]

B:BD[17.228548] → [17.228548:228631]

            return_value = Some(restore_inode(txn, changes, source, dest, inode)?)

[17.228548]

[17.228631]

            return_value = Some(restore_inode(txn, changes, source, dest, inode)?);

Replacement in libpijul/src/unrecord/working_copy.rs at line 85 [17.225940]
B:BD[17.229088] → [17.229088:229124]
```
) -> Result<Inode, anyhow::Error> {
```
[17.229088]
[17.229174]
```
) -> Result<Inode, super::UnrecordError<P::Error, T::Error>> {
```

Replacement in libpijul/src/unrecord/working_copy.rs at line 87 [17.225940]

B:BD[17.229205] → [17.229205:229297]

    let (_, basename) = changes.get_file_name(|h| txn.get_external(h), source, &mut name)?;

[17.229205]

[17.229297]

    let (_, basename) = changes
        .get_file_name(|h| txn.get_external(h), source, &mut name)
        .map_err(super::UnrecordError::Changestore)?;

Replacement in libpijul/src/unrecord/working_copy.rs at line 99 [17.225940]

B:BD[26.152] → [27.405:467]

∅:D[27.467] → [24.1571:1619]

B:BD[26.259] → [24.1571:1619]

        put_tree_with_rev(txn, file_id.as_file_id(), inode)?;
        put_inodes_with_rev(txn, inode, dest)?;

[26.152]

[26.338]

        put_tree_with_rev(txn, file_id.as_file_id(), inode).map_err(super::UnrecordError::Txn)?;
        put_inodes_with_rev(txn, inode, dest).map_err(super::UnrecordError::Txn)?;

Replacement in libpijul/src/unrecord/working_copy.rs at line 109 [17.225940]
B:BD[17.229781] → [17.229781:229827]
```
) -> Result<Vertex<ChangeId>, crate::Error> {
```
[17.229781]
[17.229827]
```
) -> Result<Vertex<ChangeId>, BlockError> {
```
Replacement in libpijul/src/unrecord/working_copy.rs at line 140 [17.225940]
∅:D[26.366] → [17.230794:230836]
B:BD[17.230794] → [17.230794:230836]
```
pub fn undo_file_reinsertion<T: MutTxnT>(
```
[17.230739]
[17.230836]
```
pub fn undo_file_reinsertion<P: ChangeStore, T: MutTxnT>(
```
Replacement in libpijul/src/unrecord/working_copy.rs at line 144 [17.225940]
B:BD[17.230916] → [17.230916:230949]
```
) -> Result<(), anyhow::Error> {
```
[17.230916]
[17.230949]
```
) -> Result<(), super::UnrecordError<P::Error, T::Error>> {
```

Replacement in libpijul/src/unrecord/working_copy.rs at line 150 [17.225940]

B:BD[17.231296] → [27.468:528]

                del_inodes_with_rev(txn, inode, position)?;

[17.231296]

[17.231440]

                del_inodes_with_rev(txn, inode, position).map_err(super::UnrecordError::Txn)?;

Deletion in libpijul/src/unrecord/mod.rs at line 1 [17.231493]
B:BD[17.231493] → [17.231494:231549]
```
// org id IuiCX9taX7EZv/Aqz/UZc5r7v/fH7MJn3/QIj46oHwc=
```
Deletion in libpijul/src/unrecord/mod.rs at line 6 [17.231493]
B:BD[17.231671] → [17.231671:231689]
```
use crate::Error;
```

Insertion in libpijul/src/unrecord/mod.rs at line 11 [17.231493]

[17.231752]

#[derive(Debug, Error)]
pub enum UnrecordError<
    ChangestoreError: std::error::Error + 'static,
    TxnError: std::error::Error + 'static,
> {
    #[error("Changestore error: {0}")]
    Changestore(ChangestoreError),
    #[error(transparent)]
    Txn(TxnError),
    #[error(transparent)]
    Block(#[from] crate::pristine::BlockError),
    #[error(transparent)]
    InconsistentChange(#[from] crate::pristine::InconsistentChange),
    #[error("Change not in channel: {}", hash.to_base32())]
    ChangeNotInChannel { hash: ChangeId },
    #[error("Change not in channel: {}", change_id.to_base32())]
    ChangeIsDependedUpon { change_id: ChangeId },
    #[error(transparent)]
    Missing(#[from] crate::missing_context::MissingError<TxnError>),
    #[error(transparent)]
    LocalApply(#[from] crate::apply::LocalApplyError<TxnError>),
    #[error(transparent)]
    Apply(#[from] crate::apply::ApplyError<ChangestoreError, TxnError>),
}

Replacement in libpijul/src/unrecord/mod.rs at line 41 [17.231493]

B:BD[17.231881] → [17.231881:231960]

) -> Result<bool, anyhow::Error> {
    let change = changes.get_change(hash)?;

[17.231881]

[17.231960]

) -> Result<bool, UnrecordError<P::Error, T::Error>> {
    let change = changes
        .get_change(hash)
        .map_err(UnrecordError::Changestore)?;

Replacement in libpijul/src/unrecord/mod.rs at line 53 [17.231493]

B:BD[17.232195] → [17.232195:232251]

    del_channel_changes(txn, &mut channel, change_id)?;

[17.232195]

[17.232251]

    del_channel_changes::<T, P>(txn, &mut channel, change_id)?;

Replacement in libpijul/src/unrecord/mod.rs at line 59 [17.231493]

B:BD[17.232391] → [17.232391:232522]

        while txn.del_dep(change_id, None)? {}
        txn.del_external(change_id, None)?;
        txn.del_internal(*hash, None)?;

[17.232391]

[17.232522]

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

Replacement in libpijul/src/unrecord/mod.rs at line 65 [17.231493]

B:BD[17.232625] → [17.232625:232676]

            txn.del_revdep(dep, Some(change_id))?;

[17.232625]

[17.232676]

            txn.del_revdep(dep, Some(change_id))
                .map_err(UnrecordError::Txn)?;

Replacement in libpijul/src/unrecord/mod.rs at line 73 [17.231493]

B:BD[17.232742] → [17.232742:232833]

// org id 4kyMdTywL4dWm7Vw3kXLcabNNGbFzSP3FTUptNMLPwg=
fn del_channel_changes<T: MutTxnT>(

[17.232742]

[17.232833]


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

Replacement in libpijul/src/unrecord/mod.rs at line 78 [17.231493]
B:BD[17.232905] → [17.232905:232938]
```
) -> Result<(), anyhow::Error> {
```
[17.232905]
[17.232938]
```
) -> Result<(), UnrecordError<P::Error, T::Error>> {
```

Replacement in libpijul/src/unrecord/mod.rs at line 82 [17.231493]

B:BD[17.233055] → [17.233055:233125]

        return Err((Error::ChangeNotOnChannel { change_id }).into());

[17.233055]

[17.233125]

        return Err(UnrecordError::ChangeNotInChannel { hash: change_id });

Replacement in libpijul/src/unrecord/mod.rs at line 92 [17.231493]

B:BD[17.233360] → [17.233360:233436]

            return Err((Error::ChangeIsDependedUpon { change_id }).into());

[17.233360]

[17.233436]

            return Err(UnrecordError::ChangeIsDependedUpon { change_id });

Replacement in libpijul/src/unrecord/mod.rs at line 96 [17.231493]

B:BD[17.233453] → [17.233453:233506]

    txn.del_changes(channel, change_id, timestamp)?;

[17.233453]

[17.233506]

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

Replacement in libpijul/src/unrecord/mod.rs at line 100 [17.231493]
B:BD[17.233519] → [17.233519:233574]
```
// org id F70s1W/0AmTkJZfg47g3+OXxINmwCgXU7G5j5QZkvh8=
```
[17.233519]
[17.233574]
Replacement in libpijul/src/unrecord/mod.rs at line 115 [17.231493]
B:BD[17.233982] → [17.233982:234037]
```
// org id UmzPcrZozUPTljK9LrlZa2FIXJwwvHpPmfRQ9uV4qTs=
```
[17.233982]
[17.234037]
Replacement in libpijul/src/unrecord/mod.rs at line 122 [17.231493]
B:BD[17.234187] → [17.234187:234220]
```
) -> Result<(), anyhow::Error> {
```
[17.234187]
[17.234220]
```
) -> Result<(), UnrecordError<C::Error, T::Error>> {
```
Replacement in libpijul/src/unrecord/mod.rs at line 136 [17.231493]
∅:D[19.7506] → [17.234838:234862]
B:BD[17.234838] → [17.234838:234862]
```
                    )?;
```
[19.7506]
[17.234862]
```
                    )
                    .map_err(UnrecordError::Txn)?;
```

Replacement in libpijul/src/unrecord/mod.rs at line 139 [17.231493]

B:BD[17.234880] → [17.234880:234960]

                unapply_newvertex(txn, channel, change_id, &mut ws, newvertex)?

[17.234880]

[17.234960]

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

Replacement in libpijul/src/unrecord/mod.rs at line 143 [17.231493]

B:BD[17.234990] → [17.234990:235104]

    repair_newvertex_contexts(txn, channel, &mut ws)?;
    // org id zX78t6A+99OopoXmY9luuPGgXMHwzPEPT8sYitaxNyc=

[17.234990]

[17.235104]

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

Replacement in libpijul/src/unrecord/mod.rs at line 146 [17.231493]

B:BD[23.2017] → [23.2017:2074]

            remove_zombies(txn, channel, change_id, n)?;

[23.2017]

[23.2074]

            remove_zombies::<T, C>(txn, channel, change_id, n)?;

Deletion in libpijul/src/unrecord/mod.rs at line 162 [17.231493]
B:BD[17.235718] → [17.235718:235773]
```
// org id ysIZl8M4RTRZyISrNO1VOKOsKxkQsZFux9RvLLl192Y=
```
Replacement in libpijul/src/unrecord/mod.rs at line 181 [17.231493]
B:BD[17.236205] → [17.236205:236239]
```
fn unapply_newvertex<T: MutTxnT>(
```
[17.236205]
[17.236239]
```
fn unapply_newvertex<T: MutTxnT, C: ChangeStore>(
```
Replacement in libpijul/src/unrecord/mod.rs at line 187 [17.231493]
B:BD[17.236377] → [17.236377:236410]
```
) -> Result<(), anyhow::Error> {
```
[17.236377]
[17.236410]
```
) -> Result<(), UnrecordError<C::Error, T::Error>> {
```
Replacement in libpijul/src/unrecord/mod.rs at line 246 [17.231493]
B:BD[19.8203] → [19.8203:8219]
```
            )?;
```
[19.8203]
[17.238504]
```
            )
            .map_err(UnrecordError::Txn)?;
```

Replacement in libpijul/src/unrecord/mod.rs at line 258 [17.231493]

B:BD[17.238829] → [23.2496:2567]

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

[17.238829]

[17.238914]

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

Replacement in libpijul/src/unrecord/mod.rs at line 263 [17.231493]
B:BD[17.238934] → [17.238934:238976]
```
fn repair_newvertex_contexts<T: MutTxnT>(
```
[17.238934]
[17.238976]
```
fn repair_newvertex_contexts<T: MutTxnT, C: ChangeStore>(
```
Replacement in libpijul/src/unrecord/mod.rs at line 267 [17.231493]
B:BD[17.239047] → [17.239047:239080]
```
) -> Result<(), anyhow::Error> {
```
[17.239047]
[17.239080]
```
) -> Result<(), UnrecordError<C::Error, T::Error>> {
```
Replacement in libpijul/src/unrecord/mod.rs at line 312 [17.231493]
B:BD[17.240305] → [17.240305:240360]
```
// org id TtkPh63N/jM5q98a/9yDp97cHPAUzouetXVib5fpVnY=
```
[17.240305]
[17.240360]
Replacement in libpijul/src/unrecord/mod.rs at line 320 [17.231493]
B:BD[17.240557] → [17.240557:240590]
```
) -> Result<(), anyhow::Error> {
```
[17.240557]
[17.240590]
```
) -> Result<(), UnrecordError<P::Error, T::Error>> {
```

Replacement in libpijul/src/unrecord/mod.rs at line 357 [17.231493]

B:BD[17.241870] → [17.241870:241945]

            working_copy::undo_file_reinsertion(txn, change_id, newedges)?

[17.241870]

[17.241945]

            working_copy::undo_file_reinsertion::<P, _>(txn, change_id, newedges)?

Replacement in libpijul/src/unrecord/mod.rs at line 371 [17.231493]
B:BD[17.242168] → [17.242168:242203]
```
) -> Result<bool, anyhow::Error> {
```
[17.242168]
[17.242203]
```
) -> Result<bool, crate::apply::ApplyError<C::Error, T::Error>> {
```
Insertion in libpijul/src/unrecord/mod.rs at line 395 [17.231493]
[17.243261]
[17.243261]
```
        .map_err(crate::apply::ApplyError::Changestore)
```
Replacement in libpijul/src/unrecord/mod.rs at line 404 [17.231493]
B:BD[17.243431] → [17.243431:243466]
```
) -> Result<bool, anyhow::Error> {
```
[17.243431]
[17.243466]
```
) -> Result<bool, C::Error> {
```
Replacement in libpijul/src/unrecord/mod.rs at line 422 [17.231493]
B:BD[17.243938] → [17.243938:243969]
```
fn remove_zombies<T: MutTxnT>(
```
[17.243938]
[17.243969]
```
fn remove_zombies<T: MutTxnT, C: ChangeStore>(
```
Replacement in libpijul/src/unrecord/mod.rs at line 427 [17.231493]
B:BD[17.244079] → [17.244079:244112]
```
) -> Result<(), anyhow::Error> {
```
[17.244079]
[17.244112]
```
) -> Result<(), UnrecordError<C::Error, T::Error>> {
```

Replacement in libpijul/src/unrecord/mod.rs at line 473 [17.231493]

B:BD[19.9353] → [19.9353:9373]

)?;

[19.9353]

[19.9373]

                )
                .map_err(UnrecordError::Txn)?;

Replacement in libpijul/src/unrecord/mod.rs at line 490 [17.231493]

B:BD[17.246511] → [19.9726:9800]

                    put_graph_with_rev(txn, channel, f, u, v, u.change)?;

[17.246511]

[17.246584]

                    put_graph_with_rev(txn, channel, f, u, v, u.change)
                        .map_err(UnrecordError::Txn)?;

Replacement in libpijul/src/unrecord/mod.rs at line 495 [17.231493]

B:BD[19.9860] → [19.9860:9942]

                del_graph_with_rev(txn, channel, e.flag, v, w, e.introduced_by)?;

[19.9860]

[17.246762]

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

Deletion in libpijul/src/unrecord/mod.rs at line 503 [17.231493]
B:BD[17.246806] → [17.246806:246861]
```
// org id 4dFFHO4v8n5FooqRmC0cyb1+9EjtjPMqW7wdJCUIRsU=
```
Replacement in libpijul/src/unrecord/mod.rs at line 510 [17.231493]
B:BD[17.247082] → [17.247082:247115]
```
) -> Result<(), anyhow::Error> {
```
[17.247082]
[17.247115]
```
) -> Result<(), UnrecordError<P::Error, T::Error>> {
```
Insertion in libpijul/src/record.rs at line 5 [17.488880]
[17.489024]
[17.489024]
```
use crate::diff;
```
Deletion in libpijul/src/record.rs at line 11 [17.488880]
B:BD[17.489199] → [17.489199:489225]
```
use crate::{diff, Error};
```

Insertion in libpijul/src/record.rs at line 12 [17.488880]

[17.489267]


#[derive(Debug, Error)]
pub enum RecordError<
    C: std::error::Error + 'static,
    W: std::error::Error,
    T: std::error::Error + 'static,
> {
    #[error("Changestore error: {0}")]
    Changestore(C),
    #[error("Working copy error: {0}")]
    WorkingCopy(W),
    #[error("System time error: {0}")]
    SystemTimeError(#[from] std::time::SystemTimeError),
    #[error(transparent)]
    Txn(T),
    #[error(transparent)]
    Diff(#[from] diff::DiffError<C>),
    #[error("Path not in repository: {0}")]
    PathNotInRepo(String),
    #[error(transparent)]
    Io(#[from] std::io::Error),
}

Replacement in libpijul/src/record.rs at line 162 [17.488880]
B:BD[17.492891] → [17.492891:492928]
```
    ) -> Result<(), anyhow::Error> {
```
[17.492891]
[17.492928]
```
    ) -> Result<(), RecordError<C::Error, W::Error, T::Error>> {
```
Replacement in libpijul/src/record.rs at line 207 [17.488880]
B:BD[17.495237] → [17.495237:495269]
```
            self.push_children(
```
[17.495237]
[17.495269]
```
            self.push_children::<_, _, C>(
```

Replacement in libpijul/src/record.rs at line 225 [17.488880]

B:BD[17.495726] → [17.495726:495795]

    ) -> Result<Option<Position<Option<ChangeId>>>, anyhow::Error> {

[17.495726]

[17.495795]

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

Replacement in libpijul/src/record.rs at line 323 [17.488880]
B:BD[17.499681] → [17.499681:499718]
```
    ) -> Result<(), anyhow::Error> {
```
[17.499681]
[17.499718]
```
    ) -> Result<(), RecordError<C::Error, W::Error, T::Error>> {
```

Replacement in libpijul/src/record.rs at line 344 [17.488880]

B:BD[17.500570] → [17.500570:500652]

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

[17.500570]

[17.500652]

            changes
                .get_contents(|p| txn.get_external(p), name_dest, &mut name)
                .map_err(RecordError::Changestore)?;

Replacement in libpijul/src/record.rs at line 383 [17.488880]

B:BD[17.502254] → [17.502254:502273]

)?

[17.502254]

[17.502273]

                )
                .map_err(RecordError::Changestore)?

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

B:BD[17.502569] → [17.502569:502635]

                working_copy.read_file(&item.full_path, &mut b)?;

[17.502569]

[17.502635]

                working_copy
                    .read_file(&item.full_path, &mut b)
                    .map_err(RecordError::WorkingCopy)?;

Replacement in libpijul/src/record.rs at line 455 [17.488880]

B:BD[17.504647] → [17.504647:504701]

    fn push_children<'a, T: MutTxnT, W: WorkingCopy>(

[17.504647]

[17.504701]

    fn push_children<'a, T: MutTxnT, W: WorkingCopy, C: ChangeStore>(

Replacement in libpijul/src/record.rs at line 464 [17.488880]
B:BD[17.504935] → [17.504935:504972]
```
    ) -> Result<(), anyhow::Error> {
```
[17.504935]
[17.504972]
```
    ) -> Result<(), RecordError<C::Error, W::Error, T::Error>> {
```

Replacement in libpijul/src/record.rs at line 507 [17.488880]

∅:D[24.1661] → [17.506695:506821]

B:BD[17.506695] → [17.506695:506821]

            return Err((Error::FileNotInRepo {
                path: prefix.to_string(),
            })
            .into());

[24.1661]

[17.506821]

            return Err(RecordError::PathNotInRepo(prefix.to_string()));

Replacement in libpijul/src/record.rs at line 517 [17.488880]
B:BD[17.507032] → [17.507032:507067]
```
) -> Result<bool, anyhow::Error> {
```
[17.507032]
[17.507067]
```
) -> Result<bool, std::time::SystemTimeError> {
```
Replacement in libpijul/src/record.rs at line 546 [17.488880]
B:BD[17.507905] → [17.507905:507942]
```
    ) -> Result<(), anyhow::Error> {
```
[17.507905]
[17.507942]
```
    ) -> Result<(), C::Error> {
```

Replacement in libpijul/src/record.rs at line 549 [17.488880]

B:BD[17.508141] → [17.508141:508195]

        item.metadata.write(&mut self.rec.contents)?;

[17.508141]

[17.508195]

        item.metadata.write(&mut self.rec.contents).unwrap();

Replacement in libpijul/src/record.rs at line 628 [17.488880]
B:BD[17.511024] → [17.511024:511065]
```
) -> Result<MovedEdges, anyhow::Error> {
```
[17.511024]
[17.511065]
```
) -> Result<MovedEdges, C::Error> {
```

Insertion in libpijul/src/pristine/sanakirja.rs at line 19 [17.531056]

[17.531485]

#[derive(Debug, Error)]
pub enum SanakirjaError {
    #[error(transparent)]
    Sanakirja(#[from] ::sanakirja::Error),
    #[error("Pristine locked")]
    PristineLocked,
    #[error("Pristine corrupt")]
    PristineCorrupt,
    #[error(transparent)]
    Borrow(#[from] std::cell::BorrowError),
}

Replacement in libpijul/src/pristine/sanakirja.rs at line 32 [17.531056]

B:BD[17.531501] → [17.531501:531574]

    pub fn new<P: AsRef<Path>>(name: P) -> Result<Self, anyhow::Error> {

[17.531501]

[17.531574]

    pub fn new<P: AsRef<Path>>(name: P) -> Result<Self, SanakirjaError> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 35 [17.531056]

B:BD[17.531623] → [17.531623:531710]

    pub unsafe fn new_nolock<P: AsRef<Path>>(name: P) -> Result<Self, anyhow::Error> {

[17.531623]

[17.531710]

    pub unsafe fn new_nolock<P: AsRef<Path>>(name: P) -> Result<Self, SanakirjaError> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 38 [17.531056]

B:BD[17.531766] → [17.531766:531860]

    pub fn new_with_size<P: AsRef<Path>>(name: P, size: u64) -> Result<Self, anyhow::Error> {

[17.531766]

[28.83]

    pub fn new_with_size<P: AsRef<Path>>(name: P, size: u64) -> Result<Self, SanakirjaError> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 44 [17.531056]

B:BD[28.331] → [28.331:392]

                    Err(crate::Error::PristineLocked.into())

[28.331]

[28.392]

                    Err(SanakirjaError::PristineLocked)

Replacement in libpijul/src/pristine/sanakirja.rs at line 46 [17.531056]

B:BD[28.417] → [28.417:451]

                    Err(e.into())

[28.417]

[28.451]

                    Err(SanakirjaError::Sanakirja(sanakirja::Error::IO(e)))

Replacement in libpijul/src/pristine/sanakirja.rs at line 49 [17.531056]
B:BD[28.483] → [19.36470:36507]
```
            Err(e) => Err(e.into()),
```
[28.483]
[28.519]
```
            Err(e) => Err(SanakirjaError::Sanakirja(e)),
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 55 [17.531056]
B:BD[17.532052] → [17.532052:532091]
```
    ) -> Result<Self, anyhow::Error> {
```
[17.532052]
[17.532091]
```
    ) -> Result<Self, SanakirjaError> {
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 60 [17.531056]
B:BD[17.532198] → [17.532198:532253]
```
    pub fn new_anon() -> Result<Self, anyhow::Error> {
```
[17.532198]
[17.532253]
```
    pub fn new_anon() -> Result<Self, SanakirjaError> {
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 63 [17.531056]

B:BD[17.532301] → [17.532301:532375]

    pub fn new_anon_with_size(size: u64) -> Result<Self, anyhow::Error> {

[17.532301]

[17.532375]

    pub fn new_anon_with_size(size: u64) -> Result<Self, SanakirjaError> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 89 [17.531056]
B:BD[17.532743] → [17.532743:532803]
```
    pub fn txn_begin(&self) -> Result<Txn, anyhow::Error> {
```
[17.532743]
[17.532803]
```
    pub fn txn_begin(&self) -> Result<Txn, SanakirjaError> {
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 120 [17.531056]
B:BD[17.534054] → [17.534054:534108]
```
            Err(crate::Error::PristineCorrupt.into())
```
[17.534054]
[17.534108]
```
            Err(SanakirjaError::PristineCorrupt)
```
Insertion in libpijul/src/pristine/sanakirja.rs at line 331 [17.531056]
[17.542281]
[17.542300]
```
    type Error = SanakirjaError;
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 352 [17.531056]

B:BD[17.542895] → [17.542895:542980]

    fn hash_from_prefix(&self, s: &str) -> Result<(Hash, ChangeId), anyhow::Error> {

[17.542895]

[17.542980]

    fn hash_from_prefix(&self, s: &str) -> Result<(Hash, ChangeId), super::HashPrefixError> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 356 [17.531056]

B:BD[17.543067] → [17.543067:543147]

            return Err((crate::Error::ParseError { s: s.to_string() }).into());

[17.543067]

[17.543147]

            return Err(super::HashPrefixError::Parse(s.to_string()));

Replacement in libpijul/src/pristine/sanakirja.rs at line 373 [17.531056]

B:BD[17.543716] → [17.543716:543884]

                    return Err((crate::Error::AmbiguousHashPrefix {
                        prefix: s.to_string(),
                    })
                    .into());

[17.543716]

[17.543884]

                    return Err(super::HashPrefixError::Ambiguous(s.to_string()));

Replacement in libpijul/src/pristine/sanakirja.rs at line 380 [17.531056]

B:BD[17.544005] → [17.544005:544126]

            Err((crate::Error::ChangeNotFound {
                hash: s.to_string(),
            })
            .into())

[17.544005]

[17.544126]

            Err(super::HashPrefixError::NotFound(s.to_string()))

Replacement in libpijul/src/pristine/sanakirja.rs at line 388 [17.531056]
B:BD[17.544252] → [17.544252:544291]
```
    ) -> Result<Hash, anyhow::Error> {
```
[17.544252]
[17.544291]
```
    ) -> Result<Hash, super::HashPrefixError> {
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 393 [17.531056]

B:BD[17.544416] → [17.544416:544496]

            return Err((crate::Error::ParseError { s: s.to_string() }).into());

[17.544416]

[17.544496]

            return Err(super::HashPrefixError::Parse(s.to_string()));

Replacement in libpijul/src/pristine/sanakirja.rs at line 410 [17.531056]

B:BD[17.545049] → [17.545049:545217]

                    return Err((crate::Error::AmbiguousHashPrefix {
                        prefix: s.to_string(),
                    })
                    .into());

[17.545049]

[17.545217]

                    return Err(super::HashPrefixError::Ambiguous(s.to_string()));

Replacement in libpijul/src/pristine/sanakirja.rs at line 417 [17.531056]

B:BD[17.545338] → [17.545338:545459]

            Err((crate::Error::ChangeNotFound {
                hash: s.to_string(),
            })
            .into())

[17.545338]

[17.545459]

            Err(super::HashPrefixError::NotFound(s.to_string()))

Replacement in libpijul/src/pristine/sanakirja.rs at line 812 [17.531056]
B:BD[17.559008] → [17.559008:559047]
```
    ) -> Result<bool, anyhow::Error> {
```
[17.559008]
[17.559047]
```
    ) -> Result<bool, Self::Error> {
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 821 [17.531056]
B:BD[17.559250] → [17.559250:559289]
```
    ) -> Result<bool, anyhow::Error> {
```
[17.559250]
[17.559289]
```
    ) -> Result<bool, Self::Error> {
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 826 [17.531056]

B:BD[17.559414] → [17.559414:559510]

    fn put_partials(&mut self, k: &str, e: Position<ChangeId>) -> Result<bool, anyhow::Error> {

[17.559395]

[17.559510]

    fn put_partials(&mut self, k: &str, e: Position<ChangeId>) -> Result<bool, Self::Error> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 840 [17.531056]
B:BD[17.559846] → [17.559846:559885]
```
    ) -> Result<bool, anyhow::Error> {
```
[17.559846]
[17.559885]
```
    ) -> Result<bool, Self::Error> {
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 856 [17.531056]
B:BD[17.560268] → [17.560268:560317]
```
    ) -> Result<Option<Merkle>, anyhow::Error> {
```
[17.560268]
[17.560317]
```
    ) -> Result<Option<Merkle>, Self::Error> {
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 884 [17.531056]
B:BD[17.561234] → [17.561234:561273]
```
    ) -> Result<bool, anyhow::Error> {
```
[17.561234]
[17.561273]
```
    ) -> Result<bool, Self::Error> {
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 918 [17.531056]
B:BD[17.562319] → [17.562319:562358]
```
    ) -> Result<bool, anyhow::Error> {
```
[17.562319]
[17.562358]
```
    ) -> Result<bool, Self::Error> {
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 925 [17.531056]

B:BD[17.562607] → [17.562607:562707]

    fn del_remote(&mut self, remote: &mut RemoteRef<Self>, k: u64) -> Result<bool, anyhow::Error> {

[17.562607]

[17.562707]

    fn del_remote(&mut self, remote: &mut RemoteRef<Self>, k: u64) -> Result<bool, Self::Error> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 936 [17.531056]

B:BD[17.563092] → [17.563092:563190]

    fn open_or_create_channel(&mut self, name: &str) -> Result<ChannelRef<Self>, anyhow::Error> {

[17.563092]

[17.563190]

    fn open_or_create_channel(&mut self, name: &str) -> Result<ChannelRef<Self>, Self::Error> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 993 [17.531056]
B:BD[17.565222] → [17.565222:565273]
```
    ) -> Result<ChannelRef<Self>, anyhow::Error> {
```
[17.565222]
[17.565273]
```
    ) -> Result<ChannelRef<Self>, ForkError<Self::Error>> {
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1007 [17.531056]

B:BD[17.565672] → [17.565672:565984]

                    graph: self.txn.fork(&mut self.rng, &channel.graph)?,
                    changes: self.txn.fork(&mut self.rng, &channel.changes)?,
                    revchanges: self.txn.fork(&mut self.rng, &channel.revchanges)?,
                    states: self.txn.fork(&mut self.rng, &channel.states)?,

[17.565672]

[17.565984]

                    graph: self
                        .txn
                        .fork(&mut self.rng, &channel.graph)
                        .map_err(|e| ForkError::Txn(e.into()))?,
                    changes: self
                        .txn
                        .fork(&mut self.rng, &channel.changes)
                        .map_err(|e| ForkError::Txn(e.into()))?,
                    revchanges: self
                        .txn
                        .fork(&mut self.rng, &channel.revchanges)
                        .map_err(|e| ForkError::Txn(e.into()))?,
                    states: self
                        .txn
                        .fork(&mut self.rng, &channel.states)
                        .map_err(|e| ForkError::Txn(e.into()))?,

Replacement in libpijul/src/pristine/sanakirja.rs at line 1031 [17.531056]

B:BD[17.566324] → [17.566324:566455]

            Err((crate::Error::ChannelNameExists {
                name: new_name.to_string(),
            })
            .into())

[17.566324]

[17.566455]

            Err(super::ForkError::ChannelNameExists(new_name.to_string()))

Replacement in libpijul/src/pristine/sanakirja.rs at line 1039 [17.531056]
B:BD[17.566578] → [17.566578:566615]
```
    ) -> Result<(), anyhow::Error> {
```
[17.566578]
[17.566615]
```
    ) -> Result<(), ForkError<Self::Error>> {
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1050 [17.531056]

B:BD[17.566888] → [10.0:217]

            self.txn.del(
                &mut self.rng,
                &mut self.channels,
                UnsafeSmallStr::from_small_str(channel.borrow().name.as_small_str()),
                None,
            )?;

[17.566888]

            self.txn
                .del(
                    &mut self.rng,
                    &mut self.channels,
                    UnsafeSmallStr::from_small_str(channel.borrow().name.as_small_str()),
                    None,
                )
                .map_err(|e| ForkError::Txn(e.into()))?;

Replacement in libpijul/src/pristine/sanakirja.rs at line 1071 [17.531056]

B:BD[17.567356] → [17.567356:567487]

            Err((crate::Error::ChannelNameExists {
                name: new_name.to_string(),
            })
            .into())

[17.567356]

[17.567487]

            Err(ForkError::ChannelNameExists(new_name.to_string()))

Replacement in libpijul/src/pristine/sanakirja.rs at line 1075 [17.531056]

B:BD[17.567504] → [17.567504:567580]

    fn drop_channel(&mut self, name: &str) -> Result<bool, anyhow::Error> {

[17.567504]

[17.567580]

    fn drop_channel(&mut self, name: &str) -> Result<bool, Self::Error> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 1089 [17.531056]

B:BD[17.567999] → [17.567999:568095]

    fn open_or_create_remote(&mut self, name: &str) -> Result<RemoteRef<Self>, anyhow::Error> {

[17.567999]

[17.568095]

    fn open_or_create_remote(&mut self, name: &str) -> Result<RemoteRef<Self>, Self::Error> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 1129 [17.531056]

B:BD[17.569566] → [17.569566:569654]

    fn drop_remote(&mut self, remote: RemoteRef<Self>) -> Result<bool, anyhow::Error> {

[17.569566]

[17.569654]

    fn drop_remote(&mut self, remote: RemoteRef<Self>) -> Result<bool, Self::Error> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 1142 [17.531056]

B:BD[17.570030] → [17.570030:570111]

    fn drop_named_remote(&mut self, name: &str) -> Result<bool, anyhow::Error> {

[17.570030]

[17.570111]

    fn drop_named_remote(&mut self, name: &str) -> Result<bool, Self::Error> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 1155 [17.531056]
B:BD[17.570478] → [17.570478:570533]
```
    fn commit(mut self) -> Result<(), anyhow::Error> {
```
[17.570478]
[17.570533]
```
    fn commit(mut self) -> Result<(), Self::Error> {
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1217 [17.531056]

B:BD[17.572784] → [17.572784:572872]

    fn put_channel(&mut self, channel: ChannelRef<Self>) -> Result<(), anyhow::Error> {

[17.572784]

[17.572872]

    fn put_channel(&mut self, channel: ChannelRef<Self>) -> Result<(), SanakirjaError> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 1258 [17.531056]

B:BD[17.574502] → [17.574502:574593]

    fn commit_channel(&mut self, channel: ChannelRef<Self>) -> Result<(), anyhow::Error> {

[17.574502]

[17.574593]

    fn commit_channel(&mut self, channel: ChannelRef<Self>) -> Result<(), SanakirjaError> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 1269 [17.531056]

B:BD[17.574894] → [17.574894:574980]

    fn put_remotes(&mut self, remote: RemoteRef<Self>) -> Result<(), anyhow::Error> {

[17.574894]

[17.574980]

    fn put_remotes(&mut self, remote: RemoteRef<Self>) -> Result<(), ::sanakirja::Error> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 1293 [17.531056]

B:BD[17.575835] → [17.575835:575923]

    fn commit_remote(&mut self, remote: RemoteRef<Self>) -> Result<(), anyhow::Error> {

[17.575835]

[17.575923]

    fn commit_remote(&mut self, remote: RemoteRef<Self>) -> Result<(), ::sanakirja::Error> {

Replacement in libpijul/src/pristine/mod.rs at line 114 [17.586748]

B:BD[17.589085] → [17.589085:589140]

// org id Zm7WF9q4bHktcCg0LXmmKlQP7XVt4IkPEDuF9pREDw4=

[17.589085]

[17.589140]

#[derive(Debug, Error)]
pub enum HashPrefixError {
    #[error("Failed to parse hash prefix: {0}")]
    Parse(String),
    #[error("Ambiguous hash prefix: {0}")]
    Ambiguous(String),
    #[error("Change not found: {0}")]
    NotFound(String),
}
#[derive(Debug, Error)]
pub enum ForkError<T: std::error::Error + 'static> {
    #[error("Channel name already exists: {0}")]
    ChannelNameExists(String),
    #[error(transparent)]
    Txn(T),
}

Insertion in libpijul/src/pristine/mod.rs at line 134 [17.586748]
[17.589205]
[17.589205]
```
    type Error: std::error::Error + Send + Sync + 'static;
```

Replacement in libpijul/src/pristine/mod.rs at line 195 [17.586748]

B:BD[17.591137] → [17.591137:591226]

    fn hash_from_prefix(&self, prefix: &str) -> Result<(Hash, ChangeId), anyhow::Error>;

[17.591137]

[17.591226]

    fn hash_from_prefix(&self, prefix: &str) -> Result<(Hash, ChangeId), HashPrefixError>;

Replacement in libpijul/src/pristine/mod.rs at line 200 [17.586748]
B:BD[17.591329] → [17.591329:591367]
```
    ) -> Result<Hash, anyhow::Error>;
```
[17.591329]
[17.591367]
```
    ) -> Result<Hash, HashPrefixError>;
```

Insertion in libpijul/src/pristine/mod.rs at line 346 [17.586748]

[29.354]

[19.38850]

#[derive(Error, Debug)]
#[error("Inconsistent change")]
pub struct InconsistentChange {}

Replacement in libpijul/src/pristine/mod.rs at line 354 [17.586748]
B:BD[19.38959] → [19.38959:39007]
```
) -> Result<Position<ChangeId>, crate::Error> {
```
[19.38959]
[16.0]
```
) -> Result<Position<ChangeId>, InconsistentChange> {
```

Replacement in libpijul/src/pristine/mod.rs at line 359 [17.586748]

B:BD[19.39254] → [16.109:167]

            return Err(crate::Error::InconsistentChange);

[19.39254]

[16.167]

            return Err(InconsistentChange {});

Replacement in libpijul/src/pristine/mod.rs at line 513 [17.586748]
B:BD[19.43431] → [19.43431:43464]
```
) -> Result<(), anyhow::Error> {
```
[19.43431]
[19.43464]
```
) -> Result<(), std::io::Error> {
```
Deletion in libpijul/src/pristine/mod.rs at line 536 [17.586748]
B:BD[17.609461] → [19.43975:44030]
```
// org id oGZWRYu9yo9VKkz4S9hipd5OpFx6kQiF5q/T9jSqp5A=
```
Replacement in libpijul/src/pristine/mod.rs at line 543 [17.586748]
B:BD[19.44289] → [19.44289:44324]
```
) -> Result<bool, anyhow::Error> {
```
[19.44289]
[19.44324]
```
) -> Result<bool, std::io::Error> {
```
Replacement in libpijul/src/pristine/mod.rs at line 557 [17.586748]
B:BD[19.44669] → [19.44669:44702]
```
) -> Result<(), anyhow::Error> {
```
[19.44669]
[19.44702]
```
) -> Result<(), std::io::Error> {
```
Replacement in libpijul/src/pristine/mod.rs at line 597 [17.586748]
B:BD[19.45440] → [19.45440:45475]
```
) -> Result<bool, anyhow::Error> {
```
[19.45440]
[8.294]
```
) -> Result<bool, std::io::Error> {
```
Replacement in libpijul/src/pristine/mod.rs at line 719 [17.586748]
B:BD[19.49172] → [19.49172:49205]
```
) -> Result<(), anyhow::Error> {
```
[19.49172]
[19.49205]
```
) -> Result<(), std::io::Error> {
```
Replacement in libpijul/src/pristine/mod.rs at line 1079 [17.586748]
B:BD[17.629258] → [17.629258:629296]
```
    ) -> Result<bool, anyhow::Error>;
```
[17.629258]
[17.629296]
```
    ) -> Result<bool, Self::Error>;
```
Replacement in libpijul/src/pristine/mod.rs at line 1087 [17.586748]
B:BD[17.629546] → [17.629546:629584]
```
    ) -> Result<bool, anyhow::Error>;
```
[17.629546]
[17.629584]
```
    ) -> Result<bool, Self::Error>;
```
Replacement in libpijul/src/pristine/mod.rs at line 1096 [17.586748]
B:BD[17.629939] → [17.629939:629987]
```
    ) -> Result<Option<Merkle>, anyhow::Error>;
```
[17.629939]
[17.629987]
```
    ) -> Result<Option<Merkle>, Self::Error>;
```
Replacement in libpijul/src/pristine/mod.rs at line 1104 [17.586748]
B:BD[17.630240] → [17.630240:630278]
```
    ) -> Result<bool, anyhow::Error>;
```
[17.630240]
[17.630278]
```
    ) -> Result<bool, Self::Error>;
```

Replacement in libpijul/src/pristine/mod.rs at line 1116 [17.586748]

B:BD[17.631045] → [17.631045:631142]

    fn open_or_create_channel(&mut self, name: &str) -> Result<ChannelRef<Self>, anyhow::Error>;

[17.631045]

[17.631142]

    fn open_or_create_channel(&mut self, name: &str) -> Result<ChannelRef<Self>, Self::Error>;

Replacement in libpijul/src/pristine/mod.rs at line 1122 [17.586748]
B:BD[17.631231] → [17.631231:631281]
```
    ) -> Result<ChannelRef<Self>, anyhow::Error>;
```
[17.631231]
[17.631281]
```
    ) -> Result<ChannelRef<Self>, ForkError<Self::Error>>;
```
Replacement in libpijul/src/pristine/mod.rs at line 1128 [17.586748]
B:BD[17.631384] → [17.631384:631420]
```
    ) -> Result<(), anyhow::Error>;
```
[17.631384]
[17.631420]
```
    ) -> Result<(), ForkError<Self::Error>>;
```

Replacement in libpijul/src/pristine/mod.rs at line 1130 [17.586748]

B:BD[17.631421] → [17.631421:631496]

    fn drop_channel(&mut self, name: &str) -> Result<bool, anyhow::Error>;

[17.631421]

[17.631496]

    fn drop_channel(&mut self, name: &str) -> Result<bool, Self::Error>;

Replacement in libpijul/src/pristine/mod.rs at line 1133 [17.586748]
B:BD[17.631530] → [17.631530:631580]
```
    fn commit(self) -> Result<(), anyhow::Error>;
```
[17.631530]
[17.636462]
```
    fn commit(self) -> Result<(), Self::Error>;
```

Replacement in libpijul/src/pristine/mod.rs at line 1135 [17.586748]

B:BD[17.637894] → [17.637894:637989]

    fn put_partials(&mut self, k: &str, e: Position<ChangeId>) -> Result<bool, anyhow::Error>;

[17.636463]

[17.637989]

    fn put_partials(&mut self, k: &str, e: Position<ChangeId>) -> Result<bool, Self::Error>;

Replacement in libpijul/src/pristine/mod.rs at line 1137 [17.586748]

B:BD[17.638009] → [17.638009:638105]

B:BD[17.638105] → [17.638105:638143]

    fn del_partials(
        &mut self,
        k: &str,
        e: Option<Position<ChangeId>>,
    ) -> Result<bool, anyhow::Error>;

[17.637990]

[17.638143]

    fn del_partials(&mut self, k: &str, e: Option<Position<ChangeId>>)
        -> Result<bool, Self::Error>;

Replacement in libpijul/src/pristine/mod.rs at line 1140 [17.586748]

B:BD[17.638144] → [17.638144:638239]

    fn open_or_create_remote(&mut self, name: &str) -> Result<RemoteRef<Self>, anyhow::Error>;

[17.638144]

[17.638239]

    fn open_or_create_remote(&mut self, name: &str) -> Result<RemoteRef<Self>, Self::Error>;

Replacement in libpijul/src/pristine/mod.rs at line 1147 [17.586748]
B:BD[17.638359] → [17.638359:638397]
```
    ) -> Result<bool, anyhow::Error>;
```
[17.638359]
[17.638397]
```
    ) -> Result<bool, Self::Error>;
```

Replacement in libpijul/src/pristine/mod.rs at line 1149 [17.586748]

B:BD[17.638398] → [17.638398:638497]

    fn del_remote(&mut self, remote: &mut RemoteRef<Self>, k: u64) -> Result<bool, anyhow::Error>;

[17.638398]

[17.638497]

    fn del_remote(&mut self, remote: &mut RemoteRef<Self>, k: u64) -> Result<bool, Self::Error>;

Replacement in libpijul/src/pristine/mod.rs at line 1151 [17.586748]

B:BD[17.638498] → [17.638498:638585]

    fn drop_remote(&mut self, remote: RemoteRef<Self>) -> Result<bool, anyhow::Error>;

[17.638498]

[17.638585]

    fn drop_remote(&mut self, remote: RemoteRef<Self>) -> Result<bool, Self::Error>;

Replacement in libpijul/src/pristine/mod.rs at line 1153 [17.586748]

B:BD[17.638586] → [17.638586:638668]

    fn drop_named_remote(&mut self, remote: &str) -> Result<bool, anyhow::Error>;

[17.638586]

[19.50088]

    fn drop_named_remote(&mut self, remote: &str) -> Result<bool, Self::Error>;

Replacement in libpijul/src/pristine/mod.rs at line 1160 [17.586748]
B:BD[19.50207] → [19.50207:50240]
```
) -> Result<(), anyhow::Error> {
```
[19.50207]
[19.50240]
```
) -> Result<(), T::Error> {
```
Replacement in libpijul/src/pristine/mod.rs at line 1170 [17.586748]
B:BD[27.1646] → [27.1646:1681]
```
) -> Result<bool, anyhow::Error> {
```
[27.1646]
[27.1681]
```
) -> Result<bool, T::Error> {
```
Replacement in libpijul/src/pristine/mod.rs at line 1183 [17.586748]
B:BD[27.1947] → [27.1947:1980]
```
) -> Result<(), anyhow::Error> {
```
[27.1947]
[27.1980]
```
) -> Result<(), T::Error> {
```
Replacement in libpijul/src/pristine/mod.rs at line 1193 [17.586748]
B:BD[27.2155] → [27.2155:2190]
```
) -> Result<bool, anyhow::Error> {
```
[27.2155]
[27.2190]
```
) -> Result<bool, T::Error> {
```
Replacement in libpijul/src/pristine/mod.rs at line 1211 [17.586748]
B:BD[19.50582] → [19.50582:50615]
```
) -> Result<(), anyhow::Error> {
```
[19.50582]
[19.50615]
```
) -> Result<(), T::Error> {
```
Replacement in libpijul/src/pristine/mod.rs at line 1270 [17.586748]
B:BD[19.52349] → [19.52349:52384]
```
) -> Result<bool, anyhow::Error> {
```
[19.52349]
[19.52384]
```
) -> Result<bool, T::Error> {
```
Replacement in libpijul/src/pristine/mod.rs at line 1311 [17.586748]
B:BD[19.53375] → [19.53375:53410]
```
) -> Result<bool, anyhow::Error> {
```
[19.53375]
[19.53410]
```
) -> Result<bool, T::Error> {
```
Replacement in libpijul/src/pristine/mod.rs at line 1353 [17.586748]
B:BD[19.54432] → [19.54432:54465]
```
) -> Result<(), anyhow::Error> {
```
[19.54432]
[19.54465]
```
) -> Result<(), T::Error> {
```
Replacement in libpijul/src/pristine/mod.rs at line 1432 [17.586748]
B:BD[30.2138] → [30.2138:2171]
```
) -> Result<(), anyhow::Error> {
```
[30.2138]
[30.2171]
```
) -> Result<(), std::io::Error> {
```

Insertion in libpijul/src/pristine/channel_dump.rs at line 3 [17.650052]

[17.650093]


#[derive(Debug, Error)]
pub enum ChannelDumpError<T: std::error::Error + 'static> {
    #[error(transparent)]
    Txn(T),
    #[error("Channel name already exists: {0}")]
    ChannelNameExists(String),
}

Replacement in libpijul/src/pristine/channel_dump.rs at line 309 [17.650052]

B:BD[17.661301] → [17.661301:661375]

    pub fn read(&mut self, bytes: &[u8]) -> Result<bool, anyhow::Error> {

[17.661301]

[17.661375]

    pub fn read(&mut self, bytes: &[u8]) -> Result<bool, T::Error> {

Replacement in libpijul/src/pristine/channel_dump.rs at line 395 [17.650052]
B:BD[17.665110] → [17.665110:665143]
```
) -> Result<(), anyhow::Error> {
```
[17.665110]
[17.665143]
```
) -> Result<(), T::Error> {
```

Insertion in libpijul/src/pristine/block.rs at line 2 [31.11]

[31.26]


#[derive(Debug, Error)]
#[error("Block error: {:?}", block)]
pub struct BlockError {
    block: Position<ChangeId>,
}

Replacement in libpijul/src/pristine/block.rs at line 14 [31.11]
B:BD[31.191] → [31.191:237]
```
) -> Result<Vertex<ChangeId>, crate::Error> {
```
[31.191]
[31.237]
```
) -> Result<Vertex<ChangeId>, BlockError> {
```

Replacement in libpijul/src/pristine/block.rs at line 28 [31.11]

B:BD[31.621] → [31.621:680]

        return Err(crate::Error::WrongBlock { block: p });

[31.621]

[31.680]

        return Err(BlockError { block: p });

Replacement in libpijul/src/pristine/block.rs at line 50 [31.11]

B:BD[31.1526] → [31.1526:1589]

            return Err(crate::Error::WrongBlock { block: p });

[31.1526]

[31.1589]

            return Err(BlockError { block: p });

Replacement in libpijul/src/pristine/block.rs at line 59 [31.11]
B:BD[31.1789] → [31.1789:1836]
```
    Err(crate::Error::WrongBlock { block: p })
```
[31.1789]
[31.1836]
```
    Err(BlockError { block: p })
```
Replacement in libpijul/src/pristine/block.rs at line 67 [31.11]
B:BD[31.2008] → [31.2008:2054]
```
) -> Result<Vertex<ChangeId>, crate::Error> {
```
[31.2008]
[31.2054]
```
) -> Result<Vertex<ChangeId>, BlockError> {
```

Replacement in libpijul/src/pristine/block.rs at line 81 [31.11]

B:BD[31.2477] → [31.2477:2536]

        return Err(crate::Error::WrongBlock { block: p });

[31.2477]

[31.2536]

        return Err(BlockError { block: p });

Replacement in libpijul/src/pristine/block.rs at line 118 [31.11]
B:BD[31.3968] → [31.3968:4019]
```
        Err(crate::Error::WrongBlock { block: p })
```
[31.3968]
[31.4019]
```
        Err(BlockError { block: p })
```
Deletion in libpijul/src/output/output.rs at line 1 [17.671807]
B:BD[17.671807] → [17.671808:671863]
```
// org id YWj26SRzNLfGg2Qeglz9QVnhMTU+0+RMuMvr6DwSA38=
```
Replacement in libpijul/src/output/output.rs at line 3 [17.671807]
B:BD[17.671995] → [17.671995:672038]
```
use super::{collect_children, OutputItem};
```
[17.671995]
[17.672038]
```
use super::{collect_children, OutputError, OutputItem, PristineOutputError};
```
Deletion in libpijul/src/output/output.rs at line 14 [17.671807]
B:BD[17.672377] → [17.672377:672432]
```
// org id LRtRE+PMuzBEsI/KgD1sy2W/K0f0HAN70rZlknlfCWs=
```
Replacement in libpijul/src/output/output.rs at line 24 [17.671807]
B:BD[17.672755] → [17.672755:672810]
```
// org id 0ve7DFbo4xqHFBVPHbChT6lFMPwRxbNcxRs4Yzsb6rs=
```
[17.672755]
[17.672810]
Replacement in libpijul/src/output/output.rs at line 37 [17.671807]
B:BD[17.673225] → [17.673225:673269]
```
) -> Result<Vec<Conflict>, anyhow::Error> {
```
[17.673225]
[17.673269]
```
) -> Result<Vec<Conflict>, OutputError<P::Error, T::Error, R::Error>> {
```
Deletion in libpijul/src/output/output.rs at line 49 [17.671807]
B:BD[17.673483] → [17.673483:673538]
```
// org id MpMlEfciwimf8weu0yPEV+/uIP9ErgimOTSV8nipLRA=
```

Replacement in libpijul/src/output/output.rs at line 63 [17.671807]

B:BD[17.673828] → [17.673828:673931]

) -> Result<Vec<Conflict>, anyhow::Error> {
    // org id lpPIIMEW5CckD8tHjyvaRg/qw+G7csmIRQ9jxvSlOrk=

[17.673828]

[17.673931]

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

Replacement in libpijul/src/output/output.rs at line 82 [17.671807]
B:BD[17.674493] → [17.674493:674537]
```
        kill_dead_files(txn, repo, &dead)?;
```
[17.674493]
[17.674537]
```
        kill_dead_files::<T, R, P>(txn, repo, &dead)?;
```
Deletion in libpijul/src/output/output.rs at line 91 [17.671807]
B:BD[17.674858] → [17.674858:674917]
```
    // org id gsYVU8LjyrWgVuIqAeIYTdCP2GY2jK+dVUaY5EM8DZU=
```

Replacement in libpijul/src/output/output.rs at line 147 [17.671807]

B:BD[17.677310] → [17.677310:677425]

                // org id 17m71heSzJMzN/R3aNLLqJlxXhZYglRTUOrHQjDCwVs=
                let inode = move_or_create(

[17.677310]

[17.677425]

                let inode = move_or_create::<T, R, P>(

Replacement in libpijul/src/output/output.rs at line 158 [17.671807]

B:BD[17.677856] → [17.677856:677912]

                    kill_dead_files(txn, repo, &dead)?;

[17.677856]

[17.677912]

                    kill_dead_files::<T, R, P>(txn, repo, &dead)?;

Deletion in libpijul/src/output/output.rs at line 161 [17.671807]
B:BD[17.677973] → [17.677973:678044]
```
                // org id 3dDmtOVITWsw6WH+WZ2gvHHNSFGeGJOf7xMvsclLv0M=
```

Replacement in libpijul/src/output/output.rs at line 162 [17.671807]

B:BD[17.678091] → [17.678091:678140]

                    repo.create_dir_all(&path)?;

[17.678091]

[17.678140]

                    repo.create_dir_all(&path)
                        .map_err(OutputError::WorkingCopy)?;

Replacement in libpijul/src/output/output.rs at line 176 [17.671807]

B:BD[17.678585] → [17.678585:678702]

                        output_file(txn, channel, changes, &output_item, &mut conflicts, w)
                    })?;

[17.678585]

[17.678702]

                        output_file::<_, _, R>(
                            txn,
                            channel,
                            changes,
                            &output_item,
                            &mut conflicts,
                            w,
                        )
                    })
                    .map_err(OutputError::from)?

Replacement in libpijul/src/output/output.rs at line 192 [17.671807]

B:BD[17.678910] → [17.678910:679059]

                // org id 2XIp9np3LpR5M9OuJWMtiEOx57jFCeckeuAd61x3hKU=
                repo.set_permissions(&path, output_item.meta.permissions())?;

[17.678910]

[17.679059]

                repo.set_permissions(&path, output_item.meta.permissions())
                    .map_err(OutputError::WorkingCopy)?;

Replacement in libpijul/src/output/output.rs at line 199 [17.671807]
B:BD[17.679182] → [17.679182:679209]
```
        repo.rename(a, b)?
```
[17.679182]
[17.679209]
```
        repo.rename(a, b).map_err(OutputError::WorkingCopy)?
```
Deletion in libpijul/src/output/output.rs at line 204 [17.671807]
B:BD[17.679236] → [17.679236:679291]
```
// org id zB9X/hdfYcIVLvilzZg7Z+hMNTdYgDxn8Yv0ibiwW9s=
```

Replacement in libpijul/src/output/output.rs at line 214 [17.671807]

B:BD[17.679630] → [17.679630:679732]

// org id xBUt7AHfxqCxXNwSBliMDFiMWRNF3c0qpG6MYcEiSH4=
fn move_or_create<T: MutTxnT, R: WorkingCopy>(

[17.679630]

[17.679732]


fn move_or_create<T: MutTxnT, R: WorkingCopy, C: ChangeStore>(

Replacement in libpijul/src/output/output.rs at line 222 [17.671807]
B:BD[17.679880] → [17.679880:679916]
```
) -> Result<Inode, anyhow::Error> {
```
[17.679880]
[17.679916]
```
) -> Result<Inode, OutputError<C::Error, T::Error, R::Error>> {
```
Replacement in libpijul/src/output/output.rs at line 229 [17.671807]
B:BD[17.680136] → [17.680136:680195]
```
    // org id xS/j7ZPMIOAF9NgL2r1xaKrwJI6haZ2eBL0EQyNBgyo=
```
[17.680136]
[17.680195]

Replacement in libpijul/src/output/output.rs at line 239 [17.671807]

B:BD[17.680701] → [27.2406:2475]

                del_tree_with_rev(txn, parent.as_file_id(), inode)?;

[17.680701]

[17.680852]

                del_tree_with_rev(txn, parent.as_file_id(), inode)
                    .map_err(PristineOutputError::Txn)?;

Replacement in libpijul/src/output/output.rs at line 251 [17.671807]

B:BD[17.681223] → [17.681223:681279]

                repo.rename(&current_name, &tmp_path)?;

[17.681223]

[17.681279]

                repo.rename(&current_name, &tmp_path)
                    .map_err(OutputError::WorkingCopy)?;

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

B:BD[17.681523] → [17.681523:681602]

                    crate::fs::rec_delete(txn, file_id.clone(), inode, true)?;

[17.681523]

[17.681602]

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

Replacement in libpijul/src/output/output.rs at line 261 [17.671807]

B:BD[17.681620] → [24.1662:1729]

B:BD[24.1729] → [27.2476:2534]

                put_inodes_with_rev(txn, inode, output_item.pos)?;
                put_tree_with_rev(txn, file_id_, inode)?;

[17.681620]

[17.681836]

                put_inodes_with_rev(txn, inode, output_item.pos)
                    .map_err(PristineOutputError::Txn)?;
                put_tree_with_rev(txn, file_id_, inode).map_err(PristineOutputError::Txn)?;

Replacement in libpijul/src/output/output.rs at line 268 [17.671807]

B:BD[17.682008] → [17.682008:682083]

                crate::fs::rec_delete(txn, file_id.clone(), inode, true)?;

[17.682008]

[17.682083]

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

Replacement in libpijul/src/output/output.rs at line 271 [17.671807]

B:BD[17.682097] → [24.1730:1793]

B:BD[24.1793] → [27.2535:2589]

            put_inodes_with_rev(txn, inode, output_item.pos)?;
            put_tree_with_rev(txn, file_id_, inode)?;

[17.682097]

[17.682297]

            put_inodes_with_rev(txn, inode, output_item.pos).map_err(PristineOutputError::Txn)?;
            put_tree_with_rev(txn, file_id_, inode).map_err(PristineOutputError::Txn)?;

Deletion in libpijul/src/output/output.rs at line 275 [17.671807]
B:BD[17.682325] → [17.682325:682384]
```
    // org id uwWMiVIILtuAREerIsrWeLRjSBFCxhZtjJRLJ1BhHqQ=
```

Replacement in libpijul/src/output/output.rs at line 277 [17.671807]

B:BD[17.682457] → [17.682457:682528]

            crate::fs::rec_delete(txn, file_id.clone(), inode, true)?;

[17.682457]

[17.682528]

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

Replacement in libpijul/src/output/output.rs at line 285 [17.671807]

B:BD[17.682701] → [24.1794:1853]

B:BD[24.1853] → [27.2590:2640]

        put_inodes_with_rev(txn, inode, output_item.pos)?;
        put_tree_with_rev(txn, file_id_, inode)?;

[17.682701]

[17.682885]

        put_inodes_with_rev(txn, inode, output_item.pos).map_err(PristineOutputError::Txn)?;
        put_tree_with_rev(txn, file_id_, inode).map_err(PristineOutputError::Txn)?;

Replacement in libpijul/src/output/output.rs at line 290 [17.671807]

B:BD[17.682911] → [17.682911:683010]

// org id GN2HnMRazrBbQEPBgPOj2kiaHsrz9CfnCmvfQnMs+gU=
fn output_file<T: MutTxnT, P: ChangeStore>(

[17.682911]

[17.683010]


fn output_file<T: MutTxnT, P: ChangeStore, W: WorkingCopy>(

Replacement in libpijul/src/output/output.rs at line 298 [17.671807]
B:BD[17.683171] → [17.683171:683204]
```
) -> Result<(), anyhow::Error> {
```
[17.683171]
[17.683204]
```
) -> Result<(), OutputError<P::Error, T::Error, W::Error>> {
```

Replacement in libpijul/src/output/output.rs at line 302 [17.671807]

B:BD[17.683381] → [17.683381:683460]

    alive::output_graph(changes, txn, channel, &mut f, &mut l, &mut forward)?;

[17.683381]

[17.683460]

    alive::output_graph(changes, txn, channel, &mut f, &mut l, &mut forward)
        .map_err(PristineOutputError::from)?;

Replacement in libpijul/src/output/output.rs at line 308 [17.671807]

B:BD[17.683698] → [19.55840:55928]

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

[17.683698]

[17.683785]

        del_graph_with_rev(txn, channel, edge.flag, vertex, dest, edge.introduced_by)
            .map_err(PristineOutputError::Txn)?;

Replacement in libpijul/src/output/output.rs at line 313 [17.671807]
B:BD[17.683804] → [17.683804:683859]
```
// org id 4uIws8SX4Pc6k8n8Gg5W8ukCH1XvjAWIViBruFTA6rg=
```
[17.683804]
[17.683859]

Replacement in libpijul/src/output/output.rs at line 357 [17.671807]

B:BD[17.685348] → [17.685348:685451]

// org id qtncQESQX2X6uNqryalEkYZlRV7d5PeDxHnU2aIx/XA=
fn kill_dead_files<T: MutTxnT, W: WorkingCopy>(

[17.685348]

[17.685451]


fn kill_dead_files<T: MutTxnT, W: WorkingCopy, C: ChangeStore>(

Replacement in libpijul/src/output/output.rs at line 362 [17.671807]
B:BD[17.685544] → [17.685544:685577]
```
) -> Result<(), anyhow::Error> {
```
[17.685544]
[17.685577]
```
) -> Result<(), OutputError<C::Error, T::Error, W::Error>> {
```

Replacement in libpijul/src/output/output.rs at line 365 [17.671807]

B:BD[17.685693] → [27.2641:2703]

        del_tree_with_rev(txn, fileid.as_file_id(), *inode)?;

[17.685693]

[17.685885]

        del_tree_with_rev(txn, fileid.as_file_id(), *inode).map_err(PristineOutputError::Txn)?;

Replacement in libpijul/src/output/output.rs at line 368 [17.671807]

B:BD[27.2768] → [27.2768:2823]

            del_inodes_with_rev(txn, *inode, vertex)?;

[27.2768]

[17.686069]

            del_inodes_with_rev(txn, *inode, vertex).map_err(PristineOutputError::Txn)?;

Replacement in libpijul/src/output/output.rs at line 371 [17.671807]

B:BD[17.686114] → [17.686114:686151]

            repo.remove_path(&name)?

[17.686114]

[17.686151]

            repo.remove_path(&name).map_err(OutputError::WorkingCopy)?

Insertion in libpijul/src/output/mod.rs at line 11 [17.686190]

[17.686366]

#[derive(Debug, Error)]
pub enum OutputError<
    ChangestoreError: std::error::Error + 'static,
    Txn: std::error::Error + 'static,
    W: std::error::Error + 'static,
> {
    #[error("Working copy error: {0}")]
    WorkingCopy(W),
    #[error(transparent)]
    Pristine(#[from] PristineOutputError<ChangestoreError, Txn>),
}
#[derive(Debug, Error)]
pub enum PristineOutputError<ChangestoreError: std::error::Error, Txn: std::error::Error + 'static>
{
    #[error(transparent)]
    Txn(Txn),
    #[error("Changestore error: {0}")]
    Changestore(ChangestoreError),
    #[error(transparent)]
    Io(#[from] std::io::Error),
    #[error(transparent)]
    Fs(#[from] crate::fs::FsError<Txn>),
}
use crate::working_copy::WriteError;
impl<C: std::error::Error, T: std::error::Error + 'static, W: std::error::Error>
    OutputError<C, T, W>
{
    fn from(e: WriteError<Self>) -> Self {
        match e {
            WriteError::Io(e) => OutputError::Pristine(PristineOutputError::Io(e)),
            WriteError::E(e) => e,
        }
    }
}
#[derive(Debug, Error)]
pub enum FileError<ChangestoreError: std::error::Error + 'static> {
    #[error(transparent)]
    Changestore(ChangestoreError),
    #[error(transparent)]
    Io(#[from] std::io::Error),
}
impl<C: std::error::Error, T: std::error::Error + 'static> From<FileError<C>>
    for PristineOutputError<C, T>
{
    fn from(e: FileError<C>) -> Self {
        match e {
            FileError::Changestore(e) => PristineOutputError::Changestore(e),
            FileError::Io(e) => PristineOutputError::Io(e),
        }
    }
}

Replacement in libpijul/src/output/mod.rs at line 87 [17.686190]
B:BD[17.686842] → [17.686842:686875]
```
) -> Result<(), anyhow::Error> {
```
[17.686842]
[17.686875]
```
) -> Result<(), PristineOutputError<P::Error, T::Error>> {
```
Deletion in libpijul/src/output/mod.rs at line 105 [17.686190]
B:BD[17.687287] → [17.687287:687350]
```
        // org id Gb4FgVTFFkCPgh6xtUjeL/ntA6wAsIKhRiiX/8b4Jy8=
```

Replacement in libpijul/src/output/mod.rs at line 108 [17.686190]

B:BD[17.687519] → [17.687519:687603]

        changes.get_contents(|h| txn.get_external(h), name_vertex, &mut name_buf)?;

[17.687519]

[17.687603]

        changes
            .get_contents(|h| txn.get_external(h), name_vertex, &mut name_buf)
            .map_err(|e| PristineOutputError::Changestore(e))?;

Deletion in libpijul/src/output/mod.rs at line 124 [17.686190]
B:BD[17.688082] → [17.688082:688145]
```
        // org id RFCdVpFfGZuILPerwkNtNS2jmRrxrMOGl0kh7aVMVmM=
```
Insertion in libpijul/src/output/archive.rs at line 9 [17.690044]
[17.690250]
[17.690250]
```
    type Error: std::error::Error;
```

Replacement in libpijul/src/output/archive.rs at line 11 [17.690044]

B:BD[17.690318] → [17.690318:690392]

    fn close_file(&mut self, f: Self::File) -> Result<(), anyhow::Error>;

[17.690318]

[17.690392]

    fn close_file(&mut self, f: Self::File) -> Result<(), Self::Error>;

Insertion in libpijul/src/output/archive.rs at line 53 [17.690044]
[17.691376]
[17.691376]
```
    type Error = std::io::Error;
```

Replacement in libpijul/src/output/archive.rs at line 66 [17.690044]

B:BD[17.691768] → [17.691768:691846]

    fn close_file(&mut self, file: Self::File) -> Result<(), anyhow::Error> {

[17.691768]

[17.691846]

    fn close_file(&mut self, file: Self::File) -> Result<(), Self::Error> {

Insertion in libpijul/src/output/archive.rs at line 76 [17.690044]

[17.692166]

}
#[derive(Debug, Error)]
pub enum ArchiveError<
    P: std::error::Error + 'static,
    T: std::error::Error + 'static,
    A: std::error::Error + 'static,
> {
    #[error(transparent)]
    A(A),
    #[error(transparent)]
    Txn(T),
    #[error(transparent)]
    Unrecord(#[from] crate::unrecord::UnrecordError<P, T>),
    #[error(transparent)]
    Apply(#[from] crate::apply::ApplyError<P, T>),
    #[error("State not found: {:?}", state)]
    StateNotFound { state: crate::pristine::Merkle },
    #[error(transparent)]
    File(#[from] crate::output::FileError<P>),
    #[error(transparent)]
    Output(#[from] crate::output::PristineOutputError<P, T>),

Replacement in libpijul/src/output/archive.rs at line 106 [17.690044]
B:BD[17.692359] → [17.692359:692403]
```
) -> Result<Vec<Conflict>, anyhow::Error> {
```
[17.692359]
[17.692403]
```
) -> Result<Vec<Conflict>, ArchiveError<P::Error, T::Error, A::Error>> {
```

Replacement in libpijul/src/output/archive.rs at line 203 [17.690044]

B:BD[17.696086] → [17.696086:696127]

                    arch.close_file(f)?;

[17.696086]

[17.696127]

                    arch.close_file(f).map_err(ArchiveError::A)?;

Deletion in libpijul/src/missing_context.rs at line 1 [17.696460]
B:BD[17.696460] → [17.696461:696516]
```
// org id 58v3AKimretz5he0vs+xqV3r0G0SNrO0HFWAzfAI/50=
```

Insertion in libpijul/src/missing_context.rs at line 7 [17.696460]

[17.696706]


#[derive(Debug, Error)]
pub enum MissingError<TxnError: std::error::Error + 'static> {
    #[error(transparent)]
    Txn(TxnError),
    #[error(transparent)]
    Block(#[from] BlockError),
    #[error(transparent)]
    Inconsistent(#[from] InconsistentChange),
}

Replacement in libpijul/src/missing_context.rs at line 24 [17.696460]

B:BD[17.696868] → [17.696868:696955]

    ) -> Result<Option<&(Graph, HashMap<Vertex<ChangeId>, VertexId>)>, crate::Error> {

[17.696868]

[17.696955]

    ) -> Result<Option<&(Graph, HashMap<Vertex<ChangeId>, VertexId>)>, InconsistentChange> {

Replacement in libpijul/src/missing_context.rs at line 33 [17.696460]

B:BD[17.697325] → [32.566:640]

                            return Err(crate::Error::InconsistentChange);

[17.697325]

[17.697406]

                            return Err(InconsistentChange {});

Replacement in libpijul/src/missing_context.rs at line 51 [17.696460]
B:BD[17.697950] → [17.697950:698005]
```
// org id CwY6M+Aa91RfVAJkIYG3StPNDxg5S2/Q0RJB2eWlhFg=
```
[17.697950]
[17.698005]
Replacement in libpijul/src/missing_context.rs at line 64 [17.696460]
B:BD[17.698287] → [17.698287:698320]
```
) -> Result<(), anyhow::Error> {
```
[17.698287]
[17.698320]
```
) -> Result<(), MissingError<T::Error>> {
```
Replacement in libpijul/src/missing_context.rs at line 103 [17.696460]
B:BD[17.699639] → [17.699639:699655]
```
            )?;
```
[17.699639]
[17.699655]
```
            )
            .map_err(MissingError::Txn)?;
```
Replacement in libpijul/src/missing_context.rs at line 114 [17.696460]
B:BD[17.699886] → [17.699886:699902]
```
            )?;
```
[17.699886]
[17.699902]
```
            )
            .map_err(MissingError::Txn)?;
```
Replacement in libpijul/src/missing_context.rs at line 126 [17.696460]
B:BD[17.700095] → [17.700095:700128]
```
) -> Result<(), anyhow::Error> {
```
[17.700095]
[17.700128]
```
) -> Result<(), MissingError<T::Error>> {
```
Replacement in libpijul/src/missing_context.rs at line 142 [17.696460]
B:BD[17.700557] → [17.700557:700569]
```
        )?;
```
[17.700557]
[17.700569]
```
        )
        .map_err(MissingError::Txn)?;
```
Replacement in libpijul/src/missing_context.rs at line 147 [17.696460]
B:BD[17.700588] → [17.700588:700643]
```
// org id 33iwKoFwpXhCt1MdikUmkOn7apYc7yMUk23JBOUn5mg=
```
[17.700588]
[17.700643]
Replacement in libpijul/src/missing_context.rs at line 159 [17.696460]
B:BD[17.700904] → [17.700904:700937]
```
) -> Result<(), anyhow::Error> {
```
[17.700904]
[17.700937]
```
) -> Result<(), MissingError<T::Error>> {
```
Replacement in libpijul/src/missing_context.rs at line 189 [17.696460]
B:BD[19.57371] → [19.57371:57387]
```
            )?;
```
[19.57371]
[17.701825]
```
            )
            .map_err(MissingError::Txn)?;
```
Replacement in libpijul/src/missing_context.rs at line 195 [17.696460]
B:BD[17.701854] → [17.701854:701909]
```
// org id GMesFpbMkVsOgAOjes5yxc060bclzWVMLh5KLd/KQc8=
```
[17.701854]
[17.701909]
Replacement in libpijul/src/missing_context.rs at line 204 [17.696460]
B:BD[17.702145] → [17.702145:702176]
```
) -> Result<(), anyhow::Error>
```
[17.702145]
[17.702176]
```
) -> Result<(), MissingError<T::Error>>
```
Deletion in libpijul/src/missing_context.rs at line 296 [17.696460]
B:BD[17.705750] → [17.705750:705805]
```
// org id OfylSf5taky9lfC0119yeNkCZSw55LxD7HNIT7E0TO8=
```
Replacement in libpijul/src/missing_context.rs at line 304 [17.696460]
B:BD[17.706038] → [17.706038:706069]
```
) -> Result<(), anyhow::Error>
```
[17.706038]
[17.706069]
```
) -> Result<(), MissingError<T::Error>>
```
Replacement in libpijul/src/missing_context.rs at line 322 [17.696460]
B:BD[17.706666] → [17.706666:706721]
```
// org id ueoLxafjHlJdBaAESsgdkbWhSKPGMpMkuFiROTxbrSM=
```
[17.706666]
[17.706721]
Replacement in libpijul/src/missing_context.rs at line 424 [17.696460]
B:BD[17.709559] → [17.709559:709590]
```
) -> Result<(), anyhow::Error>
```
[17.709559]
[17.709590]
```
) -> Result<(), MissingError<T::Error>>
```
Deletion in libpijul/src/missing_context.rs at line 428 [17.696460]
B:BD[17.709626] → [17.709626:709685]
```
    // org id HPoxuN+RIwX+UvJZERkZAFK6+F5MEAFM39nnpnXs9YY=
```
Deletion in libpijul/src/missing_context.rs at line 439 [17.696460]
B:BD[17.710193] → [17.710193:710260]
```
            // org id izc8DKE2hSSCYLTpux0cTTOqoMvRdn35r2Hfrdyq82w=
```
Replacement in libpijul/src/missing_context.rs at line 447 [17.696460]
B:BD[17.710515] → [17.710515:710531]
```
            )?;
```
[17.710515]
[17.710531]
```
            )
            .map_err(MissingError::Txn)?;
```

Replacement in libpijul/src/missing_context.rs at line 460 [17.696460]

B:BD[17.710962] → [17.710962:710986]

)?;

[17.710962]

[17.710986]

                    )
                    .map_err(MissingError::Txn)?;

Deletion in libpijul/src/missing_context.rs at line 468 [17.696460]
B:BD[17.711106] → [17.711106:711169]
```
        // org id Hux8KrdJakJleVXFgumk9t/dqB3Cl95Q0HD49nlsmD4=
```
Replacement in libpijul/src/missing_context.rs at line 484 [17.696460]
B:BD[17.711811] → [17.711811:711844]
```
) -> Result<(), anyhow::Error> {
```
[17.711811]
[17.711844]
```
) -> Result<(), MissingError<T::Error>> {
```

Replacement in libpijul/src/missing_context.rs at line 502 [17.696460]

B:BD[17.712486] → [17.712486:712510]

)?;

[17.712486]

[17.712510]

                    )
                    .map_err(MissingError::Txn)?;

Replacement in libpijul/src/missing_context.rs at line 509 [17.696460]

B:BD[19.59363] → [19.59363:59459]

                    del_graph_with_rev(txn, channel, e.flag, dest_vertex, p, e.introduced_by)?;

[19.59363]

[17.712749]

                    del_graph_with_rev(txn, channel, e.flag, dest_vertex, p, e.introduced_by)
                        .map_err(MissingError::Txn)?;

Replacement in libpijul/src/missing_context.rs at line 526 [17.696460]
B:BD[17.713044] → [17.713044:713075]
```
) -> Result<(), anyhow::Error>
```
[17.713044]
[17.713075]
```
) -> Result<(), MissingError<T::Error>>
```
Replacement in libpijul/src/missing_context.rs at line 579 [17.696460]
B:BD[17.714609] → [17.714609:714642]
```
) -> Result<(), anyhow::Error> {
```
[17.714609]
[17.714642]
```
) -> Result<(), MissingError<T::Error>> {
```

Replacement in libpijul/src/missing_context.rs at line 596 [17.696460]

B:BD[17.715820] → [17.715820:715840]

)?;

[17.715820]

[17.715840]

                )
                .map_err(MissingError::Txn)?;

Replacement in libpijul/src/missing_context.rs at line 622 [17.696460]

B:BD[17.716619] → [19.60144:60224]

            put_graph_with_rev(txn, channel, flag, parent_dest, v, change_id)?;

[17.716619]

[17.716698]

            put_graph_with_rev(txn, channel, flag, parent_dest, v, change_id)
                .map_err(MissingError::Txn)?;

Replacement in libpijul/src/missing_context.rs at line 633 [17.696460]
B:BD[17.716852] → [17.716852:716885]
```
) -> Result<(), anyhow::Error> {
```
[17.716852]
[17.716885]
```
) -> Result<(), MissingError<T::Error>> {
```

Replacement in libpijul/src/lib.rs at line 94 [17.717381]

B:BD[17.720137] → [17.720137:720177]

pub use crate::fs::WorkingCopyIterator;

[17.720137]

[17.720177]

pub use crate::apply::{ApplyError, LocalApplyError};
pub use crate::fs::{FsError, WorkingCopyIterator};

Replacement in libpijul/src/lib.rs at line 116 [17.717381]

B:BD[17.720799] → [17.720799:720857]

    ) -> Result<(u64, pristine::Merkle), anyhow::Error> {

[17.720799]

[17.720857]

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

Replacement in libpijul/src/lib.rs at line 126 [17.717381]
B:BD[17.721167] → [17.721167:721204]
```
    ) -> Result<(), anyhow::Error> {
```
[17.721167]
[17.721204]
```
    ) -> Result<(), crate::apply::ApplyError<C::Error, Self::Error>> {
```

Replacement in libpijul/src/lib.rs at line 135 [17.717381]

B:BD[17.721471] → [17.721471:721529]

    ) -> Result<(u64, pristine::Merkle), anyhow::Error> {

[17.721471]

[17.721529]

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

Replacement in libpijul/src/lib.rs at line 144 [17.717381]
B:BD[17.721775] → [17.721775:721812]
```
    ) -> Result<(), anyhow::Error> {
```
[17.721775]
[17.721812]
```
    ) -> Result<(), crate::apply::ApplyError<C::Error, Self::Error>> {
```
Replacement in libpijul/src/lib.rs at line 153 [17.717381]
B:BD[17.722067] → [17.722067:722104]
```
    ) -> Result<(), anyhow::Error> {
```
[17.722067]
[17.722104]
```
    ) -> Result<(), crate::apply::ApplyError<C::Error, Self::Error>> {
```

Replacement in libpijul/src/lib.rs at line 164 [17.717381]

B:BD[17.722441] → [17.722441:722499]

    ) -> Result<(u64, pristine::Merkle), anyhow::Error> {

[17.722441]

[17.722499]

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

Replacement in libpijul/src/lib.rs at line 174 [17.717381]

B:BD[17.722831] → [17.722831:722889]

    ) -> Result<(u64, pristine::Merkle), anyhow::Error> {

[17.722831]

[17.722889]

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

Replacement in libpijul/src/lib.rs at line 186 [17.717381]

B:BD[17.723283] → [17.723283:723320]

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

[17.723283]

[17.723320]

    ) -> Result<(), crate::record::RecordError<C::Error, W::Error, Self::Error>> {

Replacement in libpijul/src/lib.rs at line 197 [17.717381]

B:BD[17.723681] → [17.723681:723732]

    ) -> Result<record::Recorded, anyhow::Error> {

[17.723681]

[17.723732]

    ) -> Result<record::Recorded, crate::record::RecordError<C::Error, W::Error, Self::Error>> {

Replacement in libpijul/src/lib.rs at line 208 [17.717381]

B:BD[17.724094] → [17.724094:724143]

    ) -> Result<pristine::Hash, anyhow::Error> {

[17.724094]

[17.724183]

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

Replacement in libpijul/src/lib.rs at line 232 [17.717381]

B:BD[17.725022] → [17.725022:725076]

        let hash = changestore.save_change(&change)?;

[17.725022]

[7.380]

        let hash = changestore
            .save_change(&change)
            .map_err(apply::ApplyError::Changestore)?;

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

B:BD[17.725363] → [17.725363:725402]

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

[17.725363]

[17.725402]

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

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

B:BD[17.725733] → [17.725733:725789]

    ) -> Result<Vec<output::Conflict>, anyhow::Error> {

[17.725733]

[17.725789]

    ) -> Result<Vec<output::Conflict>, output::OutputError<C::Error, Self::Error, R::Error>> {

Replacement in libpijul/src/lib.rs at line 269 [17.717381]

B:BD[17.726194] → [17.726194:726264]

    fn add_file(&mut self, path: &str) -> Result<(), anyhow::Error> {

[17.726194]

[17.726264]

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

Replacement in libpijul/src/lib.rs at line 277 [17.717381]

B:BD[17.726545] → [17.726545:726614]

    fn add_dir(&mut self, path: &str) -> Result<(), anyhow::Error> {

[17.726545]

[17.726614]

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

Replacement in libpijul/src/lib.rs at line 284 [17.717381]

B:BD[17.726871] → [17.726871:726950]

    fn add(&mut self, path: &str, is_dir: bool) -> Result<(), anyhow::Error> {

[17.726871]

[17.726950]

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

Replacement in libpijul/src/lib.rs at line 288 [17.717381]

B:BD[17.727005] → [17.727005:727082]

    fn move_file(&mut self, a: &str, b: &str) -> Result<(), anyhow::Error> {

[17.727005]

[17.727082]

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

Replacement in libpijul/src/lib.rs at line 292 [17.717381]

B:BD[17.727123] → [17.727123:727193]

    fn remove_file(&mut self, a: &str) -> Result<(), anyhow::Error> {

[17.727123]

[17.727193]

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

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

B:BD[17.727334] → [17.727334:727418]

    ) -> Result<pristine::channel_dump::ChannelFromDump<'a, Self>, anyhow::Error> {

[17.727334]

[17.727418]

    ) -> Result<
        pristine::channel_dump::ChannelFromDump<'a, Self>,
        pristine::channel_dump::ChannelDumpError<Self::Error>,
    > {
        use pristine::channel_dump::*;

Replacement in libpijul/src/lib.rs at line 306 [17.717381]

B:BD[17.727465] → [19.60362:60444]

∅:D[19.60444] → [17.727527:727603]

B:BD[17.727527] → [17.727527:727603]

            let channel = pristine::MutTxnT::open_or_create_channel(self, name)?;
            Ok(pristine::channel_dump::ChannelFromDump::new(self, channel))

[17.727465]

[17.727603]

            let channel = pristine::MutTxnT::open_or_create_channel(self, name)
                .map_err(ChannelDumpError::Txn)?;
            Ok(ChannelFromDump::new(self, channel))

Replacement in libpijul/src/lib.rs at line 310 [17.717381]

B:BD[17.727620] → [17.727620:727664]

B:BD[17.727664] → [17.727664:727719]

B:BD[17.727719] → [17.727719:727740]

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

[17.727620]

[17.727740]

            Err(ChannelDumpError::ChannelNameExists(name.to_string()))

Replacement in libpijul/src/lib.rs at line 321 [17.717381]

B:BD[17.728008] → [17.728008:728064]

    ) -> Result<Vec<output::Conflict>, anyhow::Error> {

[17.728008]

[17.728064]

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

Replacement in libpijul/src/lib.rs at line 348 [17.717381]

B:BD[17.728757] → [17.728757:728813]

    ) -> Result<Vec<output::Conflict>, anyhow::Error> {

[17.728757]

[17.728813]

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

Replacement in libpijul/src/lib.rs at line 370 [17.717381]

B:BD[17.729545] → [17.729545:729602]

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

[17.729545]

[17.729602]

            Err(output::ArchiveError::StateNotFound { state })

Replacement in libpijul/src/lib.rs at line 501 [17.717381]
B:BD[17.731981] → [17.731981:732030]
```
    ) -> Result<(String, bool), anyhow::Error> {
```
[17.731981]
[17.732030]
```
    ) -> Result<(String, bool), C::Error> {
```
Replacement in libpijul/src/lib.rs at line 514 [17.717381]
B:BD[17.732453] → [17.732453:732502]
```
    ) -> Result<(String, bool), anyhow::Error> {
```
[17.732453]
[17.732502]
```
    ) -> Result<(String, bool), C::Error> {
```

Replacement in libpijul/src/lib.rs at line 527 [17.717381]

B:BD[17.732890] → [17.732890:732971]

    ) -> Result<(pristine::Position<pristine::ChangeId>, bool), anyhow::Error> {

[17.732890]

[17.732971]

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

Replacement in libpijul/src/lib.rs at line 537 [17.717381]
B:BD[17.733275] → [17.733275:733312]
```
    ) -> Result<(), anyhow::Error> {
```
[17.733275]
[17.733312]
```
    ) -> Result<(), output::FileError<C::Error>> {
```

Replacement in libpijul/src/lib.rs at line 550 [17.717381]

B:BD[17.733724] → [17.733724:733780]

    ) -> Result<Vec<output::Conflict>, anyhow::Error> {

[17.733724]

[17.733780]

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

Replacement in libpijul/src/lib.rs at line 560 [17.717381]

B:BD[17.734091] → [17.734091:734147]

    ) -> Result<Vec<output::Conflict>, anyhow::Error> {

[17.734091]

[17.734147]

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

Deletion in libpijul/src/fs.rs at line 1 [17.737429]
B:BD[17.737429] → [17.737430:737485]
```
// org id GEhwQUzK6088geMhP32RRVZ2gKcVn8vpgw30CsBQVAw=
```
Deletion in libpijul/src/fs.rs at line 20 [17.737429]
B:BD[17.738443] → [17.738443:738461]
```
use crate::Error;
```

Insertion in libpijul/src/fs.rs at line 22 [17.737429]

[5.1]

[17.738541]

#[derive(Debug, Error)]
pub enum FsError<T: std::error::Error + 'static> {
    #[error("Path not found: {0}")]
    NotFound(String),
    #[error("File already in repository: {0}")]
    AlreadyInRepo(String),
    #[error(transparent)]
    Txn(T),
}

Replacement in libpijul/src/fs.rs at line 103 [17.737429]

∅:D[5.7] → [17.740636:740814]

B:BD[17.740636] → [17.740636:740814]

/// Find the inode corresponding to that path, or return an error if
/// there's no such inode.
pub fn find_inode<T: TxnT>(txn: &T, path: &str) -> Result<Inode, anyhow::Error> {

[5.7]

[17.740814]

/// Find the inode corresponding to that path, if it exists.
pub fn find_inode<T: TxnT>(txn: &T, path: &str) -> Result<Inode, FsError<T::Error>> {

Replacement in libpijul/src/fs.rs at line 110 [17.737429]

B:BD[17.741040] → [17.741040:741140]

        Err((Error::FileNotInRepo {
            path: path.to_string(),
        })
        .into())

[17.741040]

[17.741140]

        Err(FsError::NotFound(path.to_string()))

Replacement in libpijul/src/fs.rs at line 162 [17.737429]
B:BD[17.742759] → [17.742759:742795]
```
) -> Result<Inode, anyhow::Error> {
```
[17.742759]
[17.742795]
```
) -> Result<Inode, FsError<T::Error>> {
```

Replacement in libpijul/src/fs.rs at line 175 [17.737429]

B:BD[17.743256] → [27.2824:2896]

                del_tree_with_rev(txn, parent_id.as_file_id(), inode)?;

[17.743256]

[17.743414]

                del_tree_with_rev(txn, parent_id.as_file_id(), inode).map_err(FsError::Txn)?;

Replacement in libpijul/src/fs.rs at line 177 [17.737429]

B:BD[17.743482] → [27.2897:2959]

                    del_inodes_with_rev(txn, inode, vertex)?;

[17.743482]

[17.743619]

                    del_inodes_with_rev(txn, inode, vertex).map_err(FsError::Txn)?;

Replacement in libpijul/src/fs.rs at line 179 [17.737429]

B:BD[17.743637] → [27.2960:3032]

                put_tree_with_rev(txn, parent_id.as_file_id(), child)?;

[17.743637]

[17.743764]

                put_tree_with_rev(txn, parent_id.as_file_id(), child).map_err(FsError::Txn)?;

Replacement in libpijul/src/fs.rs at line 183 [17.737429]

B:BD[17.743821] → [17.743821:743945]

            Err((Error::FileAlreadyInRepo {
                path: filename.to_string(),
            })
            .into())

[17.743821]

[17.743945]

            Err(FsError::AlreadyInRepo(filename.to_string()))

Replacement in libpijul/src/fs.rs at line 191 [17.737429]

B:BD[17.744222] → [27.3033:3103]

        put_tree_with_rev(txn, parent_id.as_file_id(), child_inode)?;

[17.744222]

[17.744345]

        put_tree_with_rev(txn, parent_id.as_file_id(), child_inode).map_err(FsError::Txn)?;

Replacement in libpijul/src/fs.rs at line 198 [17.737429]

B:BD[17.744509] → [17.744509:744570]

            txn.put_tree(dir_id.as_file_id(), child_inode)?;

[17.744509]

[17.744570]

            txn.put_tree(dir_id.as_file_id(), child_inode)
                .map_err(FsError::Txn)?;

Replacement in libpijul/src/fs.rs at line 210 [17.737429]
B:BD[17.744782] → [17.744782:744815]
```
) -> Result<(), anyhow::Error> {
```
[17.744782]
[17.744815]
```
) -> Result<(), FsError<T::Error>> {
```
Replacement in libpijul/src/fs.rs at line 236 [17.737429]
B:BD[17.745846] → [17.745846:745879]
```
) -> Result<(), anyhow::Error> {
```
[17.745846]
[17.745879]
```
) -> Result<(), FsError<T::Error>> {
```
Replacement in libpijul/src/fs.rs at line 246 [17.737429]
B:BD[17.746112] → [17.746112:746145]
```
) -> Result<(), anyhow::Error> {
```
[17.746112]
[17.746145]
```
) -> Result<(), FsError<T::Error>> {
```

Replacement in libpijul/src/fs.rs at line 249 [17.737429]

B:BD[17.746252] → [27.3104:3162]

    del_tree_with_rev(txn, fileref.as_file_id(), inode)?;

[17.746252]

[17.746499]

    del_tree_with_rev(txn, fileref.as_file_id(), inode).map_err(FsError::Txn)?;

Replacement in libpijul/src/fs.rs at line 270 [17.737429]
B:BD[17.747046] → [17.747046:747079]
```
) -> Result<(), anyhow::Error> {
```
[17.747046]
[17.747079]
```
) -> Result<(), FsError<T::Error>> {
```

Replacement in libpijul/src/fs.rs at line 298 [17.737429]

∅:D[12.67] → [27.3163:3230]

B:BD[17.747947] → [27.3163:3230]

        assert!(txn.del_tree(file_id.as_file_id(), Some(inode))?);

[12.67]

[17.748177]

        assert!(txn
            .del_tree(file_id.as_file_id(), Some(inode))
            .map_err(FsError::Txn)?);

Replacement in libpijul/src/fs.rs at line 302 [17.737429]

B:BD[17.748183] → [27.3231:3292]

    if del_tree_with_rev(txn, parent.as_file_id(), inode)? {

[17.748183]

[27.3292]

    if del_tree_with_rev(txn, parent.as_file_id(), inode).map_err(FsError::Txn)? {

Replacement in libpijul/src/fs.rs at line 304 [17.737429]

B:BD[27.3352] → [27.3352:3406]

            del_inodes_with_rev(txn, inode, vertex)?;

[27.3352]

[17.748543]

            del_inodes_with_rev(txn, inode, vertex).map_err(FsError::Txn)?;

Replacement in libpijul/src/fs.rs at line 317 [17.737429]

B:BD[17.748753] → [17.748753:748840]

pub fn remove_file<T: MutTxnT>(txn: &mut T, path: &str) -> Result<(), anyhow::Error> {

[17.748753]

[17.748840]

pub fn remove_file<T: MutTxnT>(txn: &mut T, path: &str) -> Result<(), FsError<T::Error>> {

Replacement in libpijul/src/fs.rs at line 614 [17.737429]

B:BD[17.759162] → [17.759162:759219]

) -> Result<(Position<ChangeId>, bool), anyhow::Error> {

[17.759162]

[17.759219]

) -> Result<(Position<ChangeId>, bool), FsError<C::Error>> {

Replacement in libpijul/src/fs.rs at line 629 [17.737429]

B:BD[17.759848] → [17.759848:759934]

            changes.get_contents(|h| txn.get_external(h), name_dest, &mut name_buf)?;

[17.759848]

[17.759934]

            changes
                .get_contents(|h| txn.get_external(h), name_dest, &mut name_buf)
                .map_err(FsError::Txn)?;

Replacement in libpijul/src/fs.rs at line 654 [17.737429]

B:BD[17.760725] → [17.760725:760849]

            return Err((Error::FileNotInRepo {
                path: path.to_string(),
            })
            .into());

[17.760725]

[17.760849]

            return Err(FsError::NotFound(path.to_string()));

Replacement in libpijul/src/fs.rs at line 666 [17.737429]
B:BD[17.761102] → [17.761102:761147]
```
) -> Result<(String, bool), anyhow::Error> {
```
[17.761102]
[17.761147]
```
) -> Result<(String, bool), C::Error> {
```
Deletion in libpijul/src/find_alive.rs at line 1 [17.763306]
B:BD[17.763306] → [17.763307:763362]
```
// org id MEBHKxb8oK7gGUqwl4XgvF1rhw0vYcS2SvEcXbaqMok=
```
Replacement in libpijul/src/find_alive.rs at line 3 [17.763306]
B:BD[17.763466] → [17.763466:763521]
```
// org id 7GC7Q2pCnb0s8d1hQ5JvScuZvi24ZElhM713+gpHgeY=
```
[17.763466]
[17.763521]
Replacement in libpijul/src/find_alive.rs at line 8 [17.763306]
B:BD[17.763631] → [17.763631:763686]
```
) -> Result<HashSet<Vertex<ChangeId>>, crate::Error> {
```
[17.763631]
[17.763686]
```
) -> Result<HashSet<Vertex<ChangeId>>, BlockError> {
```
Deletion in libpijul/src/find_alive.rs at line 16 [17.763306]
B:BD[17.763908] → [17.763908:763967]
```
    // org id naTw4q63bu2EvVqiMcyTpsR2XgGPIlo+Xg0pAHxty50=
```
Deletion in libpijul/src/find_alive.rs at line 23 [17.763306]
B:BD[17.764231] → [17.764231:764294]
```
        // org id rATmHVXe7ujnLJm9BtP1kGj7iFT2vIEqTj1NygT3jKg=
```
Deletion in libpijul/src/find_alive.rs at line 27 [17.763306]
B:BD[17.764479] → [17.764479:764546]
```
            // org id zyrR2nOtEiDH3D+9lWuTt+nzSRQoz8jgKSCV9Pn6rBE=
```
Deletion in libpijul/src/find_alive.rs at line 41 [17.763306]
B:BD[17.765010] → [17.765010:765077]
```
            // org id uQvQHlOvPqlL+IP8xnqczr279XI5bz+CUrzAi0CkA+c=
```
Replacement in libpijul/src/find_alive.rs at line 46 [17.763306]
B:BD[17.765135] → [17.765135:765190]
```
// org id Pw320u7FKY4pwoQyoNx3dm1mLfOcikfMt+ObiMN9njo=
```
[17.765135]
[17.765190]

Replacement in libpijul/src/find_alive.rs at line 51 [17.763306]

B:BD[17.765298] → [17.765298:765386]

) -> Result<(HashSet<Vertex<ChangeId>>, Vec<(Vertex<ChangeId>, Edge)>), crate::Error> {

[17.765298]

[17.765386]

) -> Result<(HashSet<Vertex<ChangeId>>, Vec<(Vertex<ChangeId>, Edge)>), BlockError> {

Deletion in libpijul/src/find_alive.rs at line 60 [17.763306]
B:BD[17.765638] → [17.765638:765697]
```
    // org id 4NHenXps5de4P2CKb7tHKFazsveVGn9JlzWwLKcaDfY=
```
Deletion in libpijul/src/find_alive.rs at line 70 [17.763306]
B:BD[17.766044] → [17.766044:766107]
```
        // org id yUDemNuncRZ3JF72y4FgQuPPYbQhsyj+3Dw9xom4PyQ=
```
Deletion in libpijul/src/find_alive.rs at line 76 [17.763306]
B:BD[17.766414] → [17.766414:766481]
```
            // org id wquayIcqrmfRuMmqB4vd/wlbkHCGqWHFKFrwWY7st9g=
```
Deletion in libpijul/src/find_alive.rs at line 105 [17.763306]
B:BD[17.767543] → [17.767543:767610]
```
            // org id S8/CnGSbU1qxCbYJGuK142RZkxIMPWg2k8LfVRnevOY=
```
Deletion in libpijul/src/diff/vertex_buffer.rs at line 1 [17.768903]
B:BD[17.768903] → [17.768904:768959]
```
// org id CuLytHOw5MhIUxraqhZp3RiCvAXraOTYajmAlakyEYY=
```
Deletion in libpijul/src/diff/vertex_buffer.rs at line 4 [17.768903]
B:BD[17.769051] → [17.769051:769106]
```
// org id JJDR/iA4tUvr8bHYeAudspj8wfK5zy20N2fayiMztIQ=
```
Deletion in libpijul/src/diff/vertex_buffer.rs at line 6 [17.768903]
B:BD[17.769153] → [17.769153:769212]
```
    // org id O4woWVifU6a3TB5v+SW/IS06RN6LDal4OOyCtAcxrLg=
```
Deletion in libpijul/src/diff/vertex_buffer.rs at line 8 [17.768903]
B:BD[17.769277] → [17.769277:769336]
```
    // org id znv/E/xSBDaD0tw5tDrdhOrfa00e2i6hoX4Y0P0M1yU=
```
Deletion in libpijul/src/diff/vertex_buffer.rs at line 10 [17.768903]
B:BD[17.769393] → [17.769393:769452]
```
    // org id VrcGilQ4pnxnCqaZ30f0AYxuMW5/PAjPKYEV0W8OS3o=
```
Deletion in libpijul/src/diff/vertex_buffer.rs at line 11 [17.768903]
B:BD[17.769489] → [17.769489:769548]
```
    // org id tHKWG2wUrgq0sWiE8x5vHspQufWcVCF0VBQMdJ/E6PI=
```
Deletion in libpijul/src/diff/vertex_buffer.rs at line 12 [17.768903]
B:BD[17.769596] → [17.769596:769655]
```
    // org id RtX+AmeBXlMmux4krn3hr2TC5YAQ4dUD0aQ9cG0WmPE=
```
Replacement in libpijul/src/diff/vertex_buffer.rs at line 17 [17.768903]
B:BD[17.769828] → [17.769828:769883]
```
// org id BJp9ZUxNcNZGXbeuELu/m0hxjcCh0Lrworivp2DNz/I=
```
[17.769828]
[17.769883]
Replacement in libpijul/src/diff/vertex_buffer.rs at line 32 [17.768903]
B:BD[17.770115] → [17.770115:770170]
```
// org id x2fKAxT97bw7IkKwnYnx5G3Ys3zfwC7SQzd3J/n1vPU=
```
[17.770115]
[17.770170]
Replacement in libpijul/src/diff/vertex_buffer.rs at line 40 [17.768903]
B:BD[17.770318] → [17.770318:770373]
```
// org id CBYn0QVUhTLd+1DPhJGxeuxcQPrCqfoCj5QdyKDc7Hg=
```
[17.770318]
[17.770373]
Replacement in libpijul/src/diff/vertex_buffer.rs at line 47 [17.768903]
B:BD[17.770463] → [17.770463:770518]
```
// org id a0AuyLQJdOXmDjcbzuLKji89Suyb79UP94XH0DGe0rs=
```
[17.770463]
[17.770518]
Replacement in libpijul/src/diff/vertex_buffer.rs at line 55 [17.768903]
B:BD[17.770684] → [17.770684:770739]
```
// org id pMXpkacg64vkNGPaLA/BBNw5jtn7ZI+FySQGEkPivNo=
```
[17.770684]
[17.770739]
Replacement in libpijul/src/diff/vertex_buffer.rs at line 86 [17.768903]
B:BD[17.771665] → [17.771665:771720]
```
// org id NnHmVJ1BuujNsYVWbu4O4GAsabVxPG61uPjBjwLDGXY=
```
[17.771665]
[17.771720]
Replacement in libpijul/src/diff/vertex_buffer.rs at line 114 [17.768903]
B:BD[17.772640] → [17.772640:772695]
```
// org id Pk25wSBAZ0t4Oeyx6ZTm1xqxX4h54qK8APBYvN+cjoo=
```
[17.772640]
[17.772695]

Replacement in libpijul/src/diff/vertex_buffer.rs at line 140 [17.768903]

B:BD[17.773473] → [17.773473:773663]

    fn output_line<C: FnOnce(&mut Vec<u8>) -> Result<(), anyhow::Error>>(
        &mut self,
        v: crate::pristine::Vertex<ChangeId>,
        c: C,
    ) -> Result<(), anyhow::Error> {

[17.773473]

[17.773663]

    fn output_line<E, C>(&mut self, v: crate::pristine::Vertex<ChangeId>, c: C) -> Result<(), E>
    where
        E: From<std::io::Error>,
        C: FnOnce(&mut Vec<u8>) -> Result<(), E>,
    {

Replacement in libpijul/src/diff/vertex_buffer.rs at line 159 [17.768903]

B:BD[17.774078] → [17.774078:774201]

    // org id 0I3Htm1AUtdNytI0fsyZC9DaKebRuVAOWnCAp1eM4As=
    fn begin_conflict(&mut self) -> Result<(), anyhow::Error> {

[17.774078]

[17.774201]


    fn begin_conflict(&mut self) -> Result<(), std::io::Error> {

Replacement in libpijul/src/diff/vertex_buffer.rs at line 165 [17.768903]

B:BD[17.774324] → [17.774324:774395]

    fn begin_cyclic_conflict(&mut self) -> Result<(), anyhow::Error> {

[17.774324]

[17.774395]

    fn begin_cyclic_conflict(&mut self) -> Result<(), std::io::Error> {

Replacement in libpijul/src/diff/vertex_buffer.rs at line 172 [17.768903]

B:BD[17.774613] → [17.774613:774684]

    fn begin_zombie_conflict(&mut self) -> Result<(), anyhow::Error> {

[17.774613]

[17.774684]

    fn begin_zombie_conflict(&mut self) -> Result<(), std::io::Error> {

Replacement in libpijul/src/diff/vertex_buffer.rs at line 176 [17.768903]

B:BD[17.774807] → [17.774807:774928]

    // org id zJgaktpjBecKJlgqzyViT+wt457sbkOEgjcJ7OGLOcU=
    fn end_conflict(&mut self) -> Result<(), anyhow::Error> {

[17.774807]

[17.774928]


    fn end_conflict(&mut self) -> Result<(), std::io::Error> {

Replacement in libpijul/src/diff/vertex_buffer.rs at line 193 [17.768903]

B:BD[17.775540] → [17.775540:775609]

    fn end_cyclic_conflict(&mut self) -> Result<(), anyhow::Error> {

[17.775540]

[17.775609]

    fn end_cyclic_conflict(&mut self) -> Result<(), std::io::Error> {

Replacement in libpijul/src/diff/vertex_buffer.rs at line 199 [17.768903]

B:BD[17.775781] → [17.775781:775903]

    // org id W0ejcsiNdGBeNc6omb0+BUSF8MKjBtY+mLMyyqcvPBU=
    fn conflict_next(&mut self) -> Result<(), anyhow::Error> {

[17.775781]

[17.775903]


    fn conflict_next(&mut self) -> Result<(), std::io::Error> {

Replacement in libpijul/src/diff/vertex_buffer.rs at line 212 [17.768903]

B:BD[17.776342] → [17.776342:776487]

    // org id kwhiQGVdomF6A7ajQbYvVGPQrMY24ay2R9148GsaXPw=
    fn output_conflict_marker(&mut self, marker: &str) -> Result<(), anyhow::Error> {

[17.776342]

[17.776487]


    fn output_conflict_marker(&mut self, marker: &str) -> Result<(), std::io::Error> {

Replacement in libpijul/src/diff/vertex_buffer.rs at line 243 [17.768903]
B:BD[17.777384] → [17.777384:777439]
```
// org id JBb+2glaECLGIRa7HRodwcjfm5JxXetKLaq3zZ/Nmlk=
```
[17.777384]
[17.777439]

Insertion in libpijul/src/diff/mod.rs at line 32 [17.793247]

[17.794100]


#[derive(Debug, Error)]
pub enum DiffError<P: std::error::Error + 'static> {
    #[error(transparent)]
    Output(#[from] crate::output::FileError<P>),
}

Replacement in libpijul/src/diff/mod.rs at line 50 [17.793247]
B:BD[17.794388] → [17.794388:794425]
```
    ) -> Result<(), anyhow::Error> {
```
[17.794388]
[17.794425]
```
    ) -> Result<(), DiffError<P::Error>> {
```

Insertion in libpijul/src/changestore/mod.rs at line 20 [17.817216]

[17.818010]

    type Error: std::error::Error
        + std::fmt::Debug
        + Send
        + Sync
        + From<std::str::Utf8Error>
        + From<crate::change::ChangeError>
        + 'static;

Replacement in libpijul/src/changestore/mod.rs at line 33 [17.817216]

B:BD[17.818231] → [17.818231:818346]

    ) -> Result<usize, anyhow::Error>;
    fn get_header(&self, h: &Hash) -> Result<ChangeHeader, anyhow::Error> {

[17.818231]

[17.818346]

    ) -> Result<usize, Self::Error>;
    fn get_header(&self, h: &Hash) -> Result<ChangeHeader, Self::Error> {

Replacement in libpijul/src/changestore/mod.rs at line 41 [17.817216]

B:BD[17.818500] → [17.818500:818539]

B:BD[17.818539] → [33.84:166]

    ) -> Result<usize, anyhow::Error>;
    fn get_dependencies(&self, hash: &Hash) -> Result<Vec<Hash>, anyhow::Error> {

[17.818500]

[17.818626]

    ) -> Result<usize, Self::Error>;
    fn get_dependencies(&self, hash: &Hash) -> Result<Vec<Hash>, Self::Error> {

Replacement in libpijul/src/changestore/mod.rs at line 45 [17.817216]

B:BD[17.818687] → [33.167:248]

    fn get_extra_known(&self, hash: &Hash) -> Result<Vec<Hash>, anyhow::Error> {

[17.818687]

[17.818773]

    fn get_extra_known(&self, hash: &Hash) -> Result<Vec<Hash>, Self::Error> {

Replacement in libpijul/src/changestore/mod.rs at line 48 [17.817216]

B:BD[17.818833] → [17.818833:818914]

    fn knows(&self, hash0: &Hash, hash1: &Hash) -> Result<bool, anyhow::Error> {

[17.818833]

[17.818914]

    fn knows(&self, hash0: &Hash, hash1: &Hash) -> Result<bool, Self::Error> {

Replacement in libpijul/src/changestore/mod.rs at line 57 [17.817216]
B:BD[17.819140] → [17.819140:819179]
```
    ) -> Result<bool, anyhow::Error> {
```
[17.819140]
[17.819179]
```
    ) -> Result<bool, Self::Error> {
```

Replacement in libpijul/src/changestore/mod.rs at line 66 [17.817216]

B:BD[17.819448] → [17.819448:819697]

    ) -> Result<Vec<Hash>, anyhow::Error>;
    fn save_change(&self, p: &Change) -> Result<Hash, anyhow::Error>;
    fn del_change(&self, h: &Hash) -> Result<bool, anyhow::Error>;
    fn get_change(&self, h: &Hash) -> Result<Change, anyhow::Error>;

[17.819448]

[17.819697]

    ) -> Result<Vec<Hash>, Self::Error>;
    fn save_change(&self, p: &Change) -> Result<Hash, Self::Error>;
    fn del_change(&self, h: &Hash) -> Result<bool, Self::Error>;
    fn get_change(&self, h: &Hash) -> Result<Change, Self::Error>;

Replacement in libpijul/src/changestore/mod.rs at line 75 [17.817216]
B:BD[17.819852] → [17.819852:819911]
```
    ) -> Result<(InodeMetadata, &'a str), anyhow::Error> {
```
[17.819852]
[17.819911]
```
    ) -> Result<(InodeMetadata, &'a str), Self::Error> {
```
Deletion in libpijul/src/changestore/memory.rs at line 5 [17.820702]
B:BD[17.820846] → [17.820846:820864]
```
use crate::Error;
```

Insertion in libpijul/src/changestore/memory.rs at line 22 [17.820702]

[17.821211]

#[derive(Debug, Error)]
pub enum Error {
    #[error(transparent)]
    Io(#[from] std::io::Error),
    #[error(transparent)]
    Utf8(#[from] std::str::Utf8Error),
    #[error(transparent)]
    Change(#[from] crate::change::ChangeError),
    #[error("Change not found: {:?}", hash)]
    ChangeNotFound { hash: crate::Hash },
    #[error(transparent)]
    Bincode(#[from] bincode::Error),
}

Insertion in libpijul/src/changestore/memory.rs at line 37 [17.820702]
[17.821241]
[17.821241]
```
    type Error = Error;
```
Replacement in libpijul/src/changestore/memory.rs at line 48 [17.820702]
B:BD[17.821589] → [17.821589:821629]
```
    ) -> Result<usize, anyhow::Error> {
```
[17.821589]
[17.821629]
```
    ) -> Result<usize, Self::Error> {
```
Replacement in libpijul/src/changestore/memory.rs at line 65 [17.820702]
B:BD[17.822154] → [17.822154:822194]
```
    ) -> Result<usize, anyhow::Error> {
```
[17.822154]
[17.822194]
```
    ) -> Result<usize, Self::Error> {
```
Replacement in libpijul/src/changestore/memory.rs at line 87 [17.820702]
B:BD[17.822890] → [17.822890:822934]
```
    ) -> Result<Vec<Hash>, anyhow::Error> {
```
[17.822890]
[17.822934]
```
    ) -> Result<Vec<Hash>, Self::Error> {
```

Replacement in libpijul/src/changestore/memory.rs at line 98 [17.820702]

B:BD[17.823259] → [17.823259:823330]

    fn save_change(&self, p: &Change) -> Result<Hash, anyhow::Error> {

[17.823259]

[17.823330]

    fn save_change(&self, p: &Change) -> Result<Hash, Self::Error> {

Replacement in libpijul/src/changestore/memory.rs at line 104 [17.820702]

B:BD[17.823469] → [17.823469:823537]

    fn del_change(&self, h: &Hash) -> Result<bool, anyhow::Error> {

[17.823469]

[17.823537]

    fn del_change(&self, h: &Hash) -> Result<bool, Self::Error> {

Replacement in libpijul/src/changestore/memory.rs at line 108 [17.820702]

B:BD[17.823628] → [17.823628:823698]

    fn get_change(&self, h: &Hash) -> Result<Change, anyhow::Error> {

[17.823628]

[17.823698]

    fn get_change(&self, h: &Hash) -> Result<Change, Self::Error> {

Replacement in libpijul/src/changestore/memory.rs at line 113 [17.820702]

B:BD[17.823823] → [17.823823:823978]

            use crate::pristine::Base32;
            Err((Error::ChangeNotFound {
                hash: h.to_base32(),
            })
            .into())

[17.823823]

[17.823978]

            Err(Error::ChangeNotFound { hash: *h })

Insertion in libpijul/src/changestore/filesystem.rs at line 17 [17.824013]

[17.824519]

}
#[derive(Debug, Error)]
pub enum Error {
    #[error(transparent)]
    Io(#[from] std::io::Error),
    #[error(transparent)]
    Utf8(#[from] std::str::Utf8Error),
    #[error(transparent)]
    ChangeFile(#[from] crate::change::ChangeError),
    #[error(transparent)]
    Persist(#[from] tempfile::PersistError),

Replacement in libpijul/src/changestore/filesystem.rs at line 79 [17.824013]
B:BD[17.826098] → [17.826098:826121]
```
        anyhow::Error,
```
[17.826098]
[17.826121]
```
        crate::change::ChangeError,
```
Replacement in libpijul/src/changestore/filesystem.rs at line 96 [17.824013]
B:BD[17.826612] → [17.826612:826649]
```
    ) -> Result<(), anyhow::Error> {
```
[17.826612]
[17.826649]
```
    ) -> Result<(), crate::change::ChangeError> {
```

Replacement in libpijul/src/changestore/filesystem.rs at line 98 [17.824013]

B:BD[17.826696] → [17.826696:826755]

        self.save_from_buf_unchecked(buf, hash, change_id)

[17.826696]

[17.826755]

        self.save_from_buf_unchecked(buf, hash, change_id)?;
        Ok(())

Replacement in libpijul/src/changestore/filesystem.rs at line 107 [17.824013]
B:BD[17.826891] → [17.826891:826928]
```
    ) -> Result<(), anyhow::Error> {
```
[17.826891]
[17.826928]
```
    ) -> Result<(), std::io::Error> {
```
Insertion in libpijul/src/changestore/filesystem.rs at line 124 [17.824013]
[17.827463]
[17.827463]
```
    type Error = Error;
```

Replacement in libpijul/src/changestore/filesystem.rs at line 148 [17.824013]

B:BD[17.828230] → [17.828230:828306]

    fn get_header(&self, h: &Hash) -> Result<ChangeHeader, anyhow::Error> {

[17.828230]

[17.828306]

    fn get_header(&self, h: &Hash) -> Result<ChangeHeader, Self::Error> {

Replacement in libpijul/src/changestore/filesystem.rs at line 159 [17.824013]
B:BD[17.828611] → [17.828611:828651]
```
    ) -> Result<usize, anyhow::Error> {
```
[17.828611]
[17.828651]
```
    ) -> Result<usize, Self::Error> {
```
Replacement in libpijul/src/changestore/filesystem.rs at line 174 [17.824013]
B:BD[17.829117] → [17.829117:829157]
```
    ) -> Result<usize, anyhow::Error> {
```
[17.829117]
[17.829157]
```
    ) -> Result<usize, Self::Error> {
```
Replacement in libpijul/src/changestore/filesystem.rs at line 193 [17.824013]
B:BD[17.829768] → [17.829768:829812]
```
    ) -> Result<Vec<Hash>, anyhow::Error> {
```
[17.829768]
[17.829812]
```
    ) -> Result<Vec<Hash>, Self::Error> {
```

Replacement in libpijul/src/changestore/filesystem.rs at line 205 [17.824013]

B:BD[17.830156] → [17.830156:830227]

    fn save_change(&self, p: &Change) -> Result<Hash, anyhow::Error> {

[17.830156]

[17.830227]

    fn save_change(&self, p: &Change) -> Result<Hash, Self::Error> {

Replacement in libpijul/src/changestore/filesystem.rs at line 217 [17.824013]

B:BD[17.830625] → [17.830625:830696]

    fn del_change(&self, hash: &Hash) -> Result<bool, anyhow::Error> {

[17.830625]

[17.830696]

    fn del_change(&self, hash: &Hash) -> Result<bool, Self::Error> {

Replacement in libpijul/src/changestore/filesystem.rs at line 224 [17.824013]

B:BD[17.831024] → [17.831024:831094]

    fn get_change(&self, h: &Hash) -> Result<Change, anyhow::Error> {

[17.831024]

[17.831094]

    fn get_change(&self, h: &Hash) -> Result<Change, Self::Error> {

Deletion in libpijul/src/change.rs at line 1 [17.831311]
B:BD[17.831311] → [17.831312:831385]
```
// org id 4+w2sTG9zBScwyjzB8qqUXj0dCYZg3xGYPeKsGKua2k=
use super::Error;
```
Deletion in libpijul/src/change.rs at line 4 [17.831311]
B:BD[17.831481] → [17.831481:831519]
```
#[cfg(feature = "zstd")]
pub mod v3;
```

Insertion in libpijul/src/change.rs at line 7 [17.831311]

[17.831565]


#[cfg(feature = "text-changes")]
mod text_changes;
mod change_file;
pub use change_file::*;
#[derive(Debug, Error)]
pub enum ChangeError {
    #[error("Version mismatch")]
    VersionMismatch,
    #[error(transparent)]
    Io(#[from] std::io::Error),
    #[error(transparent)]
    Bincode(#[from] bincode::Error),
    #[error(transparent)]
    Zstd(#[from] zstd_seekable::Error),
    #[error(transparent)]
    TomlDe(#[from] toml::de::Error),
    #[error(transparent)]
    TomlSer(#[from] toml::ser::Error),
    #[error("Missing contents for change {:?}", hash)]
    MissingContents { hash: crate::pristine::Hash },
    #[error("Change hash mismatch, claimed {:?}, computed {:?}", claimed, computed)]
    ChangeHashMismatch {
        claimed: crate::pristine::Hash,
        computed: crate::pristine::Hash,
    },
    #[error(
        "Change contents hash mismatch, claimed {:?}, computed {:?}",
        claimed,
        computed
    )]
    ContentsHashMismatch {
        claimed: crate::pristine::Hash,
        computed: crate::pristine::Hash,
    },
}

Replacement in libpijul/src/change.rs at line 1169 [17.831311]

B:BD[17.868798] → [17.868798:868875]

fn compress<W: Write>(input: &[u8], mut w: W) -> Result<(), anyhow::Error> {

[17.868798]

[17.868875]

fn compress<W: Write>(input: &[u8], mut w: W) -> Result<(), ChangeError> {

Replacement in libpijul/src/change.rs at line 1190 [17.831311]
B:BD[17.869478] → [17.869478:869516]
```
    ) -> Result<u64, anyhow::Error> {
```
[17.869478]
[17.869516]
```
    ) -> Result<u64, ChangeError> {
```

Replacement in libpijul/src/change.rs at line 1196 [17.831311]

B:BD[17.869757] → [17.869757:869812]

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

[17.869757]

[17.869812]

            return Err(ChangeError::VersionMismatch);

Replacement in libpijul/src/change.rs at line 1206 [17.831311]

B:BD[17.870081] → [17.870081:870162]

    pub fn serialize<W: Write>(&self, mut w: W) -> Result<Hash, anyhow::Error> {

[17.870081]

[17.870244]

    pub fn serialize<W: Write>(&self, mut w: W) -> Result<Hash, ChangeError> {

Replacement in libpijul/src/change.rs at line 1254 [17.831311]

B:BD[17.871761] → [17.871761:871846]

    pub fn check_from_buffer(buf: &[u8], hash: &Hash) -> Result<(), anyhow::Error> {

[17.871761]

[17.871846]

    pub fn check_from_buffer(buf: &[u8], hash: &Hash) -> Result<(), ChangeError> {

Replacement in libpijul/src/change.rs at line 1257 [17.831311]

B:BD[17.871982] → [17.871982:872037]

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

[17.871982]

[17.872037]

            return Err(ChangeError::VersionMismatch);

Replacement in libpijul/src/change.rs at line 1273 [17.831311]

B:BD[17.872645] → [17.872645:872697]

            return Err((Error::ChangeHashMismatch {

[17.872645]

[17.872697]

            return Err((ChangeError::ChangeHashMismatch {

Replacement in libpijul/src/change.rs at line 1295 [17.831311]

B:BD[17.873489] → [17.873489:873543]

            return Err((Error::ContentsHashMismatch {

[17.873489]

[17.873543]

            return Err(ChangeError::ContentsHashMismatch {

Replacement in libpijul/src/change.rs at line 1298 [17.831311]
B:BD[17.873631] → [17.873631:873668]
```
            })
            .into());
```
[17.873631]
[17.873668]
```
            });
```

Replacement in libpijul/src/change.rs at line 1305 [17.831311]

B:BD[17.873795] → [17.873795:873884]

    pub fn deserialize(file: &str, hash: Option<&Hash>) -> Result<Self, anyhow::Error> {

[17.873795]

[17.873884]

    pub fn deserialize(file: &str, hash: Option<&Hash>) -> Result<Self, ChangeError> {

Replacement in libpijul/src/change.rs at line 1312 [17.831311]

B:BD[17.874154] → [17.874154:874209]

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

[17.874154]

[17.874209]

            return Err(ChangeError::VersionMismatch);

Replacement in libpijul/src/change.rs at line 1329 [17.831311]

B:BD[17.874826] → [17.874826:874886]

                    return Err((Error::ChangeHashMismatch {

[17.874826]

[17.874886]

                    return Err(ChangeError::ChangeHashMismatch {

Replacement in libpijul/src/change.rs at line 1332 [17.831311]

B:BD[17.874975] → [17.874975:875028]

                    })
                    .into());

[17.874975]

[17.875028]

});

Replacement in libpijul/src/change.rs at line 1374 [17.831311]
B:BD[17.876440] → [17.876440:876496]
```
    pub fn hash(&self) -> Result<Hash, anyhow::Error> {
```
[17.876440]
[17.876496]
```
    pub fn hash(&self) -> Result<Hash, bincode::Error> {
```

Deletion in libpijul/src/change.rs at line 1381 [17.831311]

B:BD[17.876662] → [17.876662:878745]

B:BD[17.878745] → [17.878745:878841]

B:BD[17.878841] → [17.878841:878977]

B:BD[17.878977] → [17.878977:880955]

B:BD[17.880955] → [17.880955:881040]

B:BD[17.881040] → [17.881040:882461]

B:BD[17.882461] → [33.1240:1323]

∅:D[33.1323] → [17.882554:885299]

B:BD[17.882554] → [17.882554:885299]

B:BD[17.885299] → [33.1324:1399]

∅:D[33.1399] → [17.885376:885517]

B:BD[17.885376] → [17.885376:885517]

B:BD[17.885517] → [33.1400:1470]

∅:D[33.1470] → [17.885589:886662]

B:BD[17.885589] → [17.885589:886662]

B:BD[17.886662] → [17.886662:886733]

B:BD[17.886733] → [17.886733:886865]

B:BD[17.886865] → [17.886865:887016]

B:BD[17.887016] → [17.887016:887744]

B:BD[17.887744] → [9.418:452]

∅:D[9.452] → [17.887782:888474]

B:BD[17.887782] → [17.887782:888474]

B:BD[17.888474] → [9.453:487]

∅:D[9.487] → [17.888512:888888]

B:BD[17.888512] → [17.888512:888888]

B:BD[17.888888] → [9.488:518]

∅:D[9.518] → [17.888922:889088]

B:BD[17.888922] → [17.888922:889088]

B:BD[17.889088] → [9.519:553]

∅:D[9.553] → [17.889126:889214]

B:BD[17.889126] → [17.889126:889214]

B:BD[17.889214] → [17.889214:889239]

B:BD[17.889239] → [9.554:588]

∅:D[9.588] → [17.889277:889551]

B:BD[17.889277] → [17.889277:889551]

B:BD[17.889551] → [9.589:619]

∅:D[9.619] → [17.889585:889753]

B:BD[17.889585] → [17.889585:889753]

B:BD[17.889753] → [17.889753:889841]

B:BD[17.889841] → [17.889841:889866]

B:BD[17.889866] → [9.620:654]

∅:D[9.654] → [17.889904:891488]

B:BD[17.889904] → [17.889904:891488]

B:BD[17.891488] → [17.891488:891541]

B:BD[17.891541] → [17.891541:891869]

B:BD[17.891869] → [25.618:648]

∅:D[25.648] → [17.891903:891957]

B:BD[17.891903] → [17.891903:891957]

B:BD[17.891957] → [17.891957:892039]

B:BD[17.892039] → [17.892039:892327]

B:BD[17.892327] → [25.649:679]

∅:D[25.679] → [17.892361:892474]

B:BD[17.892361] → [17.892361:892474]

B:BD[17.892474] → [17.892474:892643]

B:BD[17.892643] → [17.892643:892938]

B:BD[17.892938] → [9.655:685]

∅:D[9.685] → [17.892972:893324]

B:BD[17.892972] → [17.892972:893324]

B:BD[17.893324] → [9.686:716]

∅:D[9.716] → [17.893358:893723]

B:BD[17.893358] → [17.893358:893723]

B:BD[17.893723] → [25.680:710]

∅:D[25.710] → [17.893757:893811]

B:BD[17.893757] → [17.893757:893811]

B:BD[17.893811] → [34.1210:1292]

∅:D[34.1292] → [17.893811:894129]

B:BD[17.893811] → [17.893811:894129]

B:BD[17.894129] → [25.711:741]

∅:D[25.741] → [17.894163:894217]

B:BD[17.894163] → [17.894163:894217]

B:BD[17.894217] → [34.1293:1375]

∅:D[34.1375] → [17.894217:894291]

B:BD[17.894217] → [17.894217:894291]

B:BD[17.894291] → [19.66822:66993]

∅:D[35.93] → [17.894369:894429]

∅:D[19.66993] → [17.894369:894429]

B:BD[17.894369] → [17.894369:894429]

B:BD[17.894429] → [25.742:772]

∅:D[35.128] → [17.894486:894540]

∅:D[25.772] → [17.894486:894540]

B:BD[17.894486] → [17.894486:894540]

B:BD[17.894540] → [34.1376:1458]

∅:D[34.1458] → [17.894540:896408]

B:BD[17.894540] → [17.894540:896408]

B:BD[17.896408] → [35.129:251]

∅:D[35.251] → [17.896503:904855]

B:BD[17.896503] → [17.896503:904855]

B:BD[17.904855] → [35.252:912]

B:BD[35.912] → [19.66994:67014]

∅:D[35.931] → [17.904855:905077]

∅:D[19.67014] → [17.904855:905077]

B:BD[17.904855] → [17.904855:905077]

B:BD[17.905077] → [23.6772:6816]

∅:D[23.6816] → [17.905121:905792]

B:BD[17.905121] → [17.905121:905792]

B:BD[17.905792] → [23.6817:6869]

∅:D[23.6869] → [17.905844:905985]

B:BD[17.905844] → [17.905844:905985]

B:BD[17.905985] → [23.6870:6922]

∅:D[23.6922] → [17.906037:910672]

B:BD[17.906037] → [17.906037:910672]

B:BD[17.910672] → [2.4331:4375]

∅:D[2.4375] → [17.910672:911073]

B:BD[17.910672] → [17.910672:911073]

B:BD[17.911073] → [23.6923:6975]

∅:D[23.6975] → [17.911125:912754]

B:BD[17.911125] → [17.911125:912754]

B:BD[17.912917] → [17.912917:912947]

B:BD[17.912947] → [34.1459:1536]

∅:D[34.1536] → [17.912947:912973]

B:BD[17.912947] → [17.912947:912973]

B:BD[17.912973] → [23.6976:7028]

∅:D[23.7028] → [17.913025:914758]

B:BD[17.913025] → [17.913025:914758]

B:BD[17.914758] → [34.1537:2006]

∅:D[34.2006] → [17.914819:915263]

B:BD[17.914819] → [17.914819:915263]

B:BD[17.915263] → [34.2007:2613]

∅:D[34.2613] → [17.915427:917686]

B:BD[17.915427] → [17.915427:917686]

B:BD[17.917686] → [23.7029:7107]

∅:D[23.7107] → [17.917890:918425]

B:BD[17.917890] → [17.917890:918425]

B:BD[17.918425] → [2.4376:4450]

∅:D[2.4450] → [17.918425:919617]

B:BD[17.918425] → [17.918425:919617]

B:BD[17.919617] → [23.7108:7143]

∅:D[23.7143] → [17.919652:921737]

B:BD[17.919652] → [17.919652:921737]

B:BD[17.921737] → [17.921737:921783]

B:BD[17.921783] → [17.921783:921847]

B:BD[17.921847] → [17.921847:921884]

B:BD[17.921884] → [36.0:67]

B:BD[36.67] → [15.0:87]

∅:D[15.87] → [36.142:380]

B:BD[36.142] → [36.142:380]

∅:D[36.380] → [17.922035:922066]

B:BD[17.922035] → [17.922035:922066]

B:BD[17.922066] → [17.922066:922146]

B:BD[17.922146] → [17.922146:922156]

B:BD[17.922156] → [17.922156:922178]

B:BD[17.922178] → [17.922178:922247]

B:BD[17.922247] → [17.922247:922356]

B:BD[17.922356] → [17.922356:922536]

B:BD[17.922536] → [17.922536:922580]

B:BD[17.922580] → [17.922580:923124]

B:BD[17.923124] → [17.923124:923179]

B:BD[17.923179] → [17.923179:927244]

B:BD[17.927244] → [9.717:739]

∅:D[9.739] → [17.927270:930990]

B:BD[17.927270] → [17.927270:930990]

// org id SY0PPKJcw1SQ8DEsOkicihzeXjmhMRxFEiBeypeSfTY=
use crate::changestore::*;
use std::collections::hash_map::Entry;
use std::collections::HashMap;
use std::io::BufRead;
#[cfg(feature = "text-changes")]
impl LocalChange<Local> {
    const DEPS_LINE: &'static str = "# Dependencies\n";
    const CHANGES_LINE: &'static str = "# Changes\n";
    pub fn write_all_deps<F: FnMut(Hash) -> Result<(), anyhow::Error>>(
        &self,
        mut f: F,
    ) -> Result<(), anyhow::Error> {
        for c in self.changes.iter() {
            for c in c.iter() {
                match *c {
                    Atom::NewVertex(ref n) => {
                        for change in n
                            .up_context
                            .iter()
                            .chain(n.down_context.iter())
                            .map(|c| c.change)
                            .chain(std::iter::once(n.inode.change))
                        {
                            if let Some(change) = change {
                                if let Hash::None = change {
                                    continue;
                                }
                                f(change)?
                            }
                        }
                    }
                    Atom::EdgeMap(ref e) => {
                        for edge in e.edges.iter() {
                            for change in &[
                                edge.from.change,
                                edge.to.change,
                                edge.introduced_by,
                                e.inode.change,
                            ] {
                                if let Some(change) = *change {
                                    if let Hash::None = change {
                                        continue;
                                    }
                                    f(change)?
                                }
                            }
                        }
                    }
                }
            }
        }
        Ok(())
    }
    pub fn write<W: Write, C: ChangeStore, F: FnMut(&Local, Position<Option<Hash>>) -> String>(
        &self,
        changes: &C,
        hash: Option<Hash>,
        mut file_name: F,
        write_header: bool,
        mut w: W,
    ) -> Result<(), anyhow::Error> {
        if let Some(h) = hash {
            // Check if we have the full contents
            let mut hasher = Hasher::default();
            hasher.update(&self.contents);
            let hash = hasher.finish();
            if hash != self.contents_hash {
                return Err((Error::MissingContents {
                    hash: h.to_base32(),
                })
                .into());
            }
        }
        if write_header {
            w.write_all(toml::ser::to_string_pretty(&self.header)?.as_bytes())?;
            w.write_all(b"\n")?;
        }
        let mut hashes = HashMap::new();
        let mut i = 2;
        let mut needs_newline = false;
        if !self.dependencies.is_empty() {
            w.write_all(Self::DEPS_LINE.as_bytes())?;
            needs_newline = true;
            for dep in self.dependencies.iter() {
                hashes.insert(*dep, i);
                writeln!(w, "[{}] {}", i, dep.to_base32())?;
                i += 1;
            }
        }
        self.write_all_deps(|change| {
            if let Entry::Vacant(e) = hashes.entry(change) {
                e.insert(i);
                if !needs_newline {
                    w.write_all(Self::DEPS_LINE.as_bytes())?;
                    needs_newline = true;
                }
                writeln!(w, "[{}]+{}", i, change.to_base32())?;
                i += 1;
            }
            Ok(())
        })?;
        if !self.extra_known.is_empty() {
            needs_newline = true;
            for dep in self.extra_known.iter() {
                writeln!(w, "[*] {}", dep.to_base32())?;
                i += 1;
            }
        }
        if !self.changes.is_empty() {
            if needs_newline {
                w.write_all(b"\n")?
            }
            w.write_all(Self::CHANGES_LINE.as_bytes())?;
            for (n, rec) in self.changes.iter().enumerate() {
                write!(w, "\n{}. ", n + 1)?;
                rec.write(changes, &mut file_name, &hashes, &self.contents, &mut w)?
            }
        }
        Ok(())
    }
}
impl Change {
    pub fn read_and_deps<R: BufRead, T: TxnT>(
        r: R,
        updatables: &mut HashMap<usize, crate::InodeUpdate>,
        txn: &T,
        channel: &ChannelRef<T>,
    ) -> Result<Self, anyhow::Error> {
        let (mut change, extra_dependencies) = Self::read_(r, updatables)?;
        let (mut deps, extra) = dependencies(txn, channel, change.hashed.changes.iter());
        deps.extend(extra_dependencies.into_iter());
        change.hashed.dependencies = deps;
        change.hashed.extra_known = extra;
        Ok(change)
    }
    pub fn read<R: BufRead>(
        r: R,
        updatables: &mut HashMap<usize, crate::InodeUpdate>,
    ) -> Result<Self, anyhow::Error> {
        Ok(Self::read_(r, updatables)?.0)
    }
    fn read_<R: BufRead>(
        mut r: R,
        updatables: &mut HashMap<usize, crate::InodeUpdate>,
    ) -> Result<(Self, HashSet<Hash>), anyhow::Error> {
        use self::text_changes::*;
        let mut section = Section::Header(String::new());
        let mut change = Change {
            offsets: Offsets::default(),
            hashed: Hashed {
                version: VERSION,
                header: ChangeHeader {
                    authors: Vec::new(),
                    message: String::new(),
                    description: None,
                    timestamp: chrono::Utc::now(),
                },
                dependencies: Vec::new(),
                extra_known: Vec::new(),
                metadata: Vec::new(),
                changes: Vec::new(),
                contents_hash: Hasher::default().finish(),
            },
            unhashed: None,
            contents: Vec::new(),
        };
        let conclude_section = |change: &mut Change,
                                section: Section,
                                contents: &mut Vec<u8>|
         -> Result<(), anyhow::Error> {
            match section {
                Section::Header(ref s) => {
                    debug!("header = {:?}", s);
                    change.header = toml::de::from_str(&s)?;
                    Ok(())
                }
                Section::Deps => Ok(()),
                Section::Changes {
                    mut changes,
                    current,
                    ..
                } => {
                    if has_newvertices(&current) {
                        contents.push(0)
                    }
                    if let Some(c) = current {
                        debug!("next action = {:?}", c);
                        changes.push(c)
                    }
                    change.changes = changes;
                    Ok(())
                }
            }
        };
        let mut h = String::new();
        let mut contents = Vec::new();
        let mut deps = HashMap::new();
        let mut extra_dependencies = HashSet::new();
        while r.read_line(&mut h)? > 0 {
            debug!("h = {:?}", h);
            if h == Self::DEPS_LINE {
                let section = std::mem::replace(&mut section, Section::Deps);
                conclude_section(&mut change, section, &mut contents)?;
            } else if h == Self::CHANGES_LINE {
                let section = std::mem::replace(
                    &mut section,
                    Section::Changes {
                        changes: Vec::new(),
                        current: None,
                        offsets: HashMap::new(),
                    },
                );
                conclude_section(&mut change, section, &mut contents)?;
            } else {
                use regex::Regex;
                lazy_static! {
                    static ref DEPS: Regex = Regex::new(r#"\[(\d*|\*)\](\+| ) *(\S*)"#).unwrap();
                    static ref KNOWN: Regex = Regex::new(r#"(\S*)"#).unwrap();
                }
                match section {
                    Section::Header(ref mut s) => s.push_str(&h),
                    Section::Deps => {
                        if let Some(d) = DEPS.captures(&h) {
                            let hash = Hash::from_base32(d[3].as_bytes()).unwrap();
                            if let Ok(n) = d[1].parse() {
                                if &d[2] == " " {
                                    change.hashed.dependencies.push(hash);
                                }
                                deps.insert(n, hash);
                            } else if &d[1] == "*" {
                                change.hashed.extra_known.push(hash);
                            } else {
                                extra_dependencies.insert(hash);
                            }
                        }
                    }
                    Section::Changes {
                        ref mut current,
                        ref mut changes,
                        ref mut offsets,
                    } => {
                        if let Some(next) =
                            Record::read(updatables, current, &mut contents, &deps, offsets, &h)?
                        {
                            debug!("next action = {:?}", next);
                            changes.push(next)
                        }
                    }
                }
            }
            h.clear();
        }
        conclude_section(&mut change, section, &mut contents)?;
        change.contents = contents;
        change.contents_hash = {
            let mut hasher = Hasher::default();
            hasher.update(&change.contents);
            hasher.finish()
        };
        Ok((change, extra_dependencies))
    }
}
#[cfg(feature = "text-changes")]
impl Record<Option<Hash>, Local> {
    fn write<
        W: std::io::Write,
        C: ChangeStore,
        F: FnMut(&Local, Position<Option<Hash>>) -> String,
    >(
        &self,
        changes: &C,
        mut file_name: F,
        hashes: &HashMap<Hash, usize>,
        change_contents: &[u8],
        mut w: W,
    ) -> Result<(), anyhow::Error> {
        use self::text_changes::*;
        match self {
            Record::FileMove { del, add, path } => match add {
                Atom::NewVertex(ref add) => {
                    let name = std::str::from_utf8(
                        &change_contents[add.start.0 as usize + 2..add.end.0 as usize],
                    )
                    .unwrap();
                    let perms = crate::pristine::InodeMetadata::from_basename(
                        &change_contents[add.start.0 as usize..add.start.0 as usize + 2],
                    );
                    write!(w, "Moved: {:?} {:?} {:o} ", path, name, perms.0)?;
                    write_pos(&mut w, hashes, del.inode())?;
                    writeln!(w)?;
                    write_atom(&mut w, hashes, &del)?;
                    write!(w, "up")?;
                    for c in add.up_context.iter() {
                        write!(w, " ")?;
                        write_pos(&mut w, hashes, *c)?
                    }
                    write!(w, ", down")?;
                    for c in add.down_context.iter() {
                        write!(w, " ")?;
                        write_pos(&mut w, hashes, *c)?
                    }
                    w.write_all(b"\n")?;
                }
                Atom::EdgeMap(_) => {
                    write!(w, "Moved: {:?} ", path)?;
                    write_pos(&mut w, hashes, del.inode())?;
                    writeln!(w)?;
                    write_atom(&mut w, hashes, &add)?;
                    write_atom(&mut w, hashes, &del)?;
                }
            },
            Record::FileDel {
                del,
                contents,
                path,
            } => {
                write!(w, "File deletion: {:?} ", path)?;
                write_pos(&mut w, hashes, del.inode())?;
                writeln!(w)?;
                write_atom(&mut w, hashes, &del)?;
                if let Some(ref contents) = contents {
                    write_atom(&mut w, hashes, &contents)?;
                    writeln!(w)?;
                    print_change_contents(&mut w, changes, contents, change_contents)?;
                } else {
                    writeln!(w)?;
                }
            }
            Record::FileUndel {
                undel,
                contents,
                path,
            } => {
                write!(w, "File un-deletion: {:?} ", path)?;
                write_pos(&mut w, hashes, undel.inode())?;
                writeln!(w)?;
                write_atom(&mut w, hashes, &undel)?;
                if let Some(ref contents) = contents {
                    write_atom(&mut w, hashes, &contents)?;
                    print_change_contents(&mut w, changes, contents, change_contents)?;
                } else {
                    writeln!(w)?;
                }
            }
            Record::FileAdd {
                add_name,
                contents,
                path,
                ..
            } => {
                if let Atom::NewVertex(ref n) = add_name {
                    let name = std::str::from_utf8(
                        &change_contents[n.start.0 as usize + 2..n.end.0 as usize],
                    )
                    .unwrap();
                    let perms = crate::pristine::InodeMetadata::from_basename(
                        &change_contents[n.start.0 as usize..n.start.0 as usize + 2],
                    );
                    let parent = if let Some(p) = crate::path::parent(&path) {
                        if p.is_empty() {
                            "/"
                        } else {
                            p
                        }
                    } else {
                        "/"
                    };
                    write!(
                        w,
                        "File addition: {:?} in {:?} {:o}\n  up",
                        name, parent, perms.0
                    )?;
                    assert!(n.down_context.is_empty());
                    for c in n.up_context.iter() {
                        write!(w, " ")?;
                        write_pos(&mut w, hashes, *c)?
                    }
                    writeln!(w, ", new {}:{}", n.start.0, n.end.0)?;
                }
                if let Some(Atom::NewVertex(ref n)) = contents {
                    let c = &change_contents[n.start.0 as usize..n.end.0 as usize];
                    print_contents(&mut w, "+", c)?;
                    if !c.ends_with(b"\n") {
                        writeln!(w, "\\")?
                    }
                }
            }
            Record::Edit { change, local } => {
                write!(w, "Edit in {} ", file_name(&local, change.inode()))?;
                write_pos(&mut w, hashes, change.inode())?;
                writeln!(w)?;
                write_atom(&mut w, hashes, &change)?;
                print_change_contents(&mut w, changes, change, change_contents)?;
            }
            Record::Replacement {
                change,
                replacement,
                local,
            } => {
                write!(w, "Replacement in {} ", file_name(&local, change.inode()))?;
                write_pos(&mut w, hashes, change.inode())?;
                writeln!(w)?;
                write_atom(&mut w, hashes, &change)?;
                write_atom(&mut w, hashes, &replacement)?;
                print_change_contents(&mut w, changes, change, change_contents)?;
                print_change_contents(&mut w, changes, replacement, change_contents)?;
            }
            Record::SolveNameConflict { name, path } => {
                write!(w, "Solving a name conflict in {:?} ", path)?;
                write_pos(&mut w, hashes, name.inode())?;
                write!(w, ": ")?;
                write_deleted_names(&mut w, changes, name)?;
                writeln!(w)?;
                write_atom(&mut w, hashes, &name)?;
            }
            Record::UnsolveNameConflict { name, path } => {
                write!(w, "Un-solving a name conflict in {:?} ", path)?;
                write_pos(&mut w, hashes, name.inode())?;
                write!(w, ": ")?;
                write_deleted_names(&mut w, changes, name)?;
                writeln!(w)?;
                write_atom(&mut w, hashes, &name)?;
            }
            Record::SolveOrderConflict { change, local } => {
                write!(
                    w,
                    "Solving an order conflict in {} ",
                    file_name(&local, change.inode())
                )?;
                write_pos(&mut w, hashes, change.inode())?;
                writeln!(w)?;
                write_atom(&mut w, hashes, &change)?;
                print_change_contents(&mut w, changes, change, change_contents)?;
            }
            Record::UnsolveOrderConflict { change, local } => {
                write!(
                    w,
                    "Un-solving an order conflict in {} ",
                    file_name(&local, change.inode())
                )?;
                write_pos(&mut w, hashes, change.inode())?;
                writeln!(w)?;
                write_atom(&mut w, hashes, &change)?;
                print_change_contents(&mut w, changes, change, change_contents)?;
            }
            Record::ResurrectZombies { change, local } => {
                write!(
                    w,
                    "Resurrecting zombie lines in {:?}:{} ",
                    local.path, local.line
                )?;
                write_pos(&mut w, hashes, change.inode())?;
                writeln!(w)?;
                write_atom(&mut w, hashes, &change)?;
                print_change_contents(&mut w, changes, change, change_contents)?;
            }
        }
        Ok(())
    }
}
#[cfg(feature = "text-changes")]
impl Record<Option<Hash>, Local> {
    fn read(
        updatables: &mut HashMap<usize, crate::InodeUpdate>,
        current: &mut Option<Self>,
        mut contents_: &mut Vec<u8>,
        changes: &HashMap<usize, Hash>,
        offsets: &mut HashMap<u64, ChangePosition>,
        h: &str,
    ) -> Result<Option<Self>, Error> {
        use self::text_changes::*;
        use regex::Regex;
        lazy_static! {
            static ref FILE_ADDITION: Regex =
                Regex::new(r#"(?P<n>\d+)\. File addition: "(?P<name>[^"]*)" in "(?P<parent>[^"]*)" (?P<perm>\d+)"#).unwrap();
            static ref EDIT: Regex =
                Regex::new(r#"(\d+)\. Edit in ([^:]+):(\d+) (\d+\.\d+)"#).unwrap();
            static ref REPLACEMENT: Regex =
                Regex::new(r#"(\d+)\. Replacement in ([^:]+):(\d+) (\d+\.\d+)"#).unwrap();
            static ref FILE_DELETION: Regex =
                Regex::new(r#"(\d+)\. File deletion: "([^"]*)" (\d+\.\d+)"#).unwrap();
            static ref FILE_UNDELETION: Regex =
                Regex::new(r#"(\d+)\. File un-deletion: "([^"]*)" (\d+\.\d+)"#).unwrap();
            static ref MOVE: Regex =
                Regex::new(r#"(\d+)\. Moved: "(?P<former>[^"]*)" "(?P<new>[^"]*)" (?P<perm>\d+) (?P<inode>.*)"#).unwrap();
            static ref MOVE_: Regex = Regex::new(r#"(\d+)\. Moved: "([^"]*)" (.*)"#).unwrap();
            static ref NAME_CONFLICT: Regex = Regex::new(
                r#"(\d+)\. ((Solving)|(Un-solving)) a name conflict in "([^"]*)" (.*): .*"#
            )
            .unwrap();
            static ref ORDER_CONFLICT: Regex = Regex::new(
                r#"(\d+)\. ((Solving)|(Un-solving)) an order conflict in (.*):(\d+) (\d+\.\d+)"#
            )
            .unwrap();
            static ref ZOMBIE: Regex =
                Regex::new(r#"(\d+)\. Resurrecting zombie lines in (?P<path>"[^"]+"):(?P<line>\d+) (?P<inode>\d+\.\d+)"#)
                    .unwrap();
            static ref CONTEXT: Regex = Regex::new(
                r#"up ((\d+\.\d+ )*\d+\.\d+)(, new (\d+):(\d+))?(, down ((\d+\.\d+ )*\d+\.\d+))?"#
            )
            .unwrap();
        }
        if let Some(cap) = FILE_ADDITION.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)
            }
            let mut add_name = default_newvertex();
            add_name.start = ChangePosition(contents_.len() as u64);
            add_name.flag = EdgeFlags::FOLDER | EdgeFlags::BLOCK;
            let name = &cap.name("name").unwrap().as_str();
            let path = {
                let parent = cap.name("parent").unwrap().as_str();
                (if parent == "/" {
                    String::new()
                } else {
                    parent.to_string()
                }) + name
            };
            let meta = cap
                .name("perm")
                .unwrap()
                .as_str()
                .chars()
                .fold(0, |x, c| x * 8 + (c as u16 - b'0' as u16));
            let meta = InodeMetadata(meta);
            meta.write(&mut contents_).unwrap();
            contents_.extend(name.as_bytes());
            add_name.end = ChangePosition(contents_.len() as u64);
            let mut add_inode = default_newvertex();
            add_inode.flag = EdgeFlags::FOLDER | EdgeFlags::BLOCK;
            add_inode.up_context.push(Position {
                change: None,
                pos: ChangePosition(contents_.len() as u64),
            });
            contents_.push(0);
            add_inode.start = ChangePosition(contents_.len() as u64);
            add_inode.end = ChangePosition(contents_.len() as u64);
            contents_.push(0);
            let n = cap.name("n").unwrap().as_str().parse().unwrap();
            if let Entry::Occupied(mut e) = updatables.entry(n) {
                if let crate::InodeUpdate::Add { ref mut pos, .. } = e.get_mut() {
                    *pos = add_inode.start
                }
            }
            Ok(std::mem::replace(
                current,
                Some(Record::FileAdd {
                    add_name: Atom::NewVertex(add_name),
                    add_inode: Atom::NewVertex(add_inode),
                    contents: None,
                    path,
                }),
            ))
        } else if let Some(cap) = EDIT.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)
            }
            let mut v = default_newvertex();
            v.inode = parse_pos(changes, &cap[4]);
            Ok(std::mem::replace(
                current,
                Some(Record::Edit {
                    change: Atom::NewVertex(v),
                    local: Local {
                        path: cap[2].to_string(),
                        line: cap[3].parse().unwrap(),
                    },
                }),
            ))
        } else if let Some(cap) = REPLACEMENT.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)
            }
            let mut v = default_newvertex();
            v.inode = parse_pos(changes, &cap[4]);
            Ok(std::mem::replace(
                current,
                Some(Record::Replacement {
                    change: Atom::NewVertex(v.clone()),
                    replacement: Atom::NewVertex(v),
                    local: Local {
                        path: cap[2].to_string(),
                        line: cap[3].parse().unwrap(),
                    },
                }),
            ))
        } else if let Some(cap) = FILE_DELETION.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)
            }
            let mut del = default_edgemap();
            del.inode = parse_pos(changes, &cap[3]);
            Ok(std::mem::replace(
                current,
                Some(Record::FileDel {
                    del: Atom::EdgeMap(del),
                    contents: None,
                    path: cap[2].to_string(),
                }),
            ))
        } else if let Some(cap) = FILE_UNDELETION.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)
            }
            let mut undel = default_edgemap();
            undel.inode = parse_pos(changes, &cap[3]);
            Ok(std::mem::replace(
                current,
                Some(Record::FileUndel {
                    undel: Atom::EdgeMap(undel),
                    contents: None,
                    path: cap[2].to_string(),
                }),
            ))
        } else if let Some(cap) = NAME_CONFLICT.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)
            }
            let mut name = default_edgemap();
            debug!("cap = {:?}", cap);
            name.inode = parse_pos(changes, &cap[6]);
            Ok(std::mem::replace(
                current,
                if &cap[2] == "Solving" {
                    Some(Record::SolveNameConflict {
                        name: Atom::EdgeMap(name),
                        path: cap[5].to_string(),
                    })
                } else {
                    Some(Record::UnsolveNameConflict {
                        name: Atom::EdgeMap(name),
                        path: cap[5].to_string(),
                    })
                },
            ))
        } else if let Some(cap) = MOVE.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)
            }
            let mut add = default_newvertex();
            add.start = ChangePosition(contents_.len() as u64);
            add.flag = EdgeFlags::FOLDER | EdgeFlags::BLOCK;
            let name = cap.name("new").unwrap().as_str();
            let meta = cap
                .name("perm")
                .unwrap()
                .as_str()
                .chars()
                .fold(0, |x, c| x * 8 + (c as u16 - b'0' as u16));
            let meta = InodeMetadata(meta);
            meta.write(&mut contents_).unwrap();
            contents_.extend(name.as_bytes());
            add.end = ChangePosition(contents_.len() as u64);
            let mut del = default_edgemap();
            del.inode = parse_pos(changes, cap.name("inode").unwrap().as_str());
            Ok(std::mem::replace(
                current,
                Some(Record::FileMove {
                    del: Atom::EdgeMap(del),
                    add: Atom::NewVertex(add),
                    path: cap[2].to_string(),
                }),
            ))
        } else if let Some(cap) = MOVE_.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)
            }
            let mut add = default_edgemap();
            let mut del = default_edgemap();
            add.inode = parse_pos(changes, &cap[3]);
            del.inode = add.inode;
            Ok(std::mem::replace(
                current,
                Some(Record::FileMove {
                    del: Atom::EdgeMap(del),
                    add: Atom::EdgeMap(add),
                    path: cap[2].to_string(),
                }),
            ))
        } else if let Some(cap) = ORDER_CONFLICT.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)
            }
            Ok(std::mem::replace(
                current,
                Some(if &cap[2] == "Solving" {
                    let mut v = default_newvertex();
                    v.inode = parse_pos(changes, &cap[7]);
                    Record::SolveOrderConflict {
                        change: Atom::NewVertex(v),
                        local: Local {
                            path: cap[5].to_string(),
                            line: cap[6].parse().unwrap(),
                        },
                    }
                } else {
                    let mut v = default_edgemap();
                    v.inode = parse_pos(changes, &cap[7]);
                    Record::UnsolveOrderConflict {
                        change: Atom::EdgeMap(v),
                        local: Local {
                            path: cap[5].to_string(),
                            line: cap[6].parse().unwrap(),
                        },
                    }
                }),
            ))
        } else if let Some(cap) = ZOMBIE.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)
            }
            let mut v = default_edgemap();
            v.inode = parse_pos(changes, &cap.name("inode").unwrap().as_str());
            Ok(std::mem::replace(
                current,
                Some(Record::ResurrectZombies {
                    change: Atom::EdgeMap(v),
                    local: Local {
                        path: cap.name("path").unwrap().as_str().parse().unwrap(),
                        line: cap.name("line").unwrap().as_str().parse().unwrap(),
                    },
                }),
            ))
        } else {
            match current {
                Some(Record::FileAdd {
                    ref mut contents,
                    ref mut add_name,
                    ..
                }) => {
                    if h.starts_with('+') {
                        if contents.is_none() {
                            let mut v = default_newvertex();
                            let inode = Position {
                                change: None,
                                pos: ChangePosition(contents_.len() as u64 - 1),
                            };
                            v.up_context.push(inode);
                            v.inode = inode;
                            v.start = ChangePosition(contents_.len() as u64);
                            *contents = Some(Atom::NewVertex(v));
                        }
                        if let Some(Atom::NewVertex(ref mut contents)) = contents {
                            if h.starts_with('+') {
                                text_changes::parse_line_add(h, contents, contents_)
                            }
                        }
                    } else if h.starts_with('\\') {
                        if let Some(Atom::NewVertex(ref mut contents)) = contents {
                            if contents_[contents.end.0 as usize - 1] == b'\n' {
                                assert_eq!(contents.end.0 as usize, contents_.len());
                                contents_.pop();
                                contents.end.0 -= 1;
                            }
                        }
                    } else if let Some(cap) = CONTEXT.captures(h) {
                        if let Atom::NewVertex(ref mut name) = add_name {
                            name.up_context = parse_pos_vec(changes, offsets, &cap[1])?;
                            if let (Some(new_start), Some(new_end)) = (cap.get(4), cap.get(5)) {
                                offsets.insert(new_start.as_str().parse().unwrap(), name.start);
                                offsets.insert(new_end.as_str().parse().unwrap(), name.end);
                                offsets.insert(
                                    new_end.as_str().parse::<u64>().unwrap() + 1,
                                    name.end + 1,
                                );
                            }
                        }
                    }
                    Ok(None)
                }
                Some(Record::FileDel {
                    ref mut del,
                    ref mut contents,
                    ..
                }) => {
                    if let Some(edges) = parse_edges(changes, h) {
                        if let Atom::EdgeMap(ref mut e) = del {
                            if edges[0].flag.contains(EdgeFlags::FOLDER) {
                                *e = EdgeMap {
                                    inode: e.inode,
                                    edges,
                                }
                            } else {
                                *contents = Some(Atom::EdgeMap(EdgeMap {
                                    inode: e.inode,
                                    edges,
                                }))
                            }
                        }
                    }
                    Ok(None)
                }
                Some(Record::FileUndel {
                    ref mut undel,
                    ref mut contents,
                    ..
                }) => {
                    if let Some(edges) = parse_edges(changes, h) {
                        if let Atom::EdgeMap(ref mut e) = undel {
                            if edges[0].flag.contains(EdgeFlags::FOLDER) {
                                *e = EdgeMap {
                                    inode: e.inode,
                                    edges,
                                }
                            } else {
                                *contents = Some(Atom::EdgeMap(EdgeMap {
                                    inode: e.inode,
                                    edges,
                                }))
                            }
                        }
                    }
                    Ok(None)
                }
                Some(Record::FileMove {
                    ref mut del,
                    ref mut add,
                    ..
                }) => {
                    if let Some(edges) = parse_edges(changes, h) {
                        if edges[0].flag.contains(EdgeFlags::DELETED) {
                            *del = Atom::EdgeMap(EdgeMap {
                                inode: del.inode(),
                                edges,
                            });
                            return Ok(None);
                        } else if let Atom::EdgeMap(ref mut add) = add {
                            if add.edges.is_empty() {
                                *add = EdgeMap {
                                    inode: add.inode,
                                    edges,
                                };
                                return Ok(None);
                            }
                        }
                    } else if let Some(cap) = CONTEXT.captures(h) {
                        if let Atom::NewVertex(ref mut c) = add {
                            debug!("cap = {:?}", cap);
                            c.up_context = parse_pos_vec(changes, offsets, &cap[1])?;
                            if let Some(cap) = cap.get(7) {
                                c.down_context = parse_pos_vec(changes, offsets, cap.as_str())?;
                            }
                        }
                    }
                    Ok(None)
                }
                Some(Record::Edit { ref mut change, .. }) => {
                    debug!("edit {:?}", h);
                    if h.starts_with("+ ") {
                        if let Atom::NewVertex(ref mut change) = change {
                            if change.start == change.end {
                                change.start = ChangePosition(contents_.len() as u64);
                            }
                            text_changes::parse_line_add(h, change, contents_)
                        }
                    } else if h.starts_with('\\') {
                        if let Atom::NewVertex(ref mut change) = change {
                            if contents_[change.end.0 as usize - 1] == b'\n' {
                                assert_eq!(change.end.0 as usize, contents_.len());
                                contents_.pop();
                                change.end.0 -= 1;
                            }
                        }
                    } else if let Some(cap) = CONTEXT.captures(h) {
                        if let Atom::NewVertex(ref mut c) = change {
                            debug!("cap = {:?}", cap);
                            c.up_context = parse_pos_vec(changes, offsets, &cap[1])?;
                            if let Some(cap) = cap.get(7) {
                                c.down_context = parse_pos_vec(changes, offsets, cap.as_str())?;
                            }
                        }
                    } else if let Some(edges) = parse_edges(changes, h) {
                        *change = Atom::EdgeMap(EdgeMap {
                            inode: change.inode(),
                            edges,
                        });
                    }
                    Ok(None)
                }
                Some(Record::Replacement {
                    ref mut change,
                    ref mut replacement,
                    ..
                }) => {
                    if h.starts_with("+ ") {
                        if let Atom::NewVertex(ref mut repl) = replacement {
                            if repl.start == repl.end {
                                repl.start = ChangePosition(contents_.len() as u64);
                            }
                            text_changes::parse_line_add(h, repl, contents_)
                        }
                    } else if h.starts_with('\\') {
                        if let Atom::NewVertex(ref mut repl) = replacement {
                            if contents_[repl.end.0 as usize - 1] == b'\n' {
                                assert_eq!(repl.end.0 as usize, contents_.len());
                                contents_.pop();
                                repl.end.0 -= 1;
                            }
                        }
                    } else if let Some(cap) = CONTEXT.captures(h) {
                        debug!("cap = {:?}", cap);
                        if let Atom::NewVertex(ref mut repl) = replacement {
                            repl.up_context = parse_pos_vec(changes, offsets, &cap[1])?;
                            if let Some(cap) = cap.get(7) {
                                repl.down_context = parse_pos_vec(changes, offsets, cap.as_str())?;
                            }
                        }
                    } else if let Some(edges) = parse_edges(changes, h) {
                        *change = Atom::EdgeMap(EdgeMap {
                            inode: change.inode(),
                            edges,
                        });
                    }
                    Ok(None)
                }
                Some(Record::SolveNameConflict { ref mut name, .. })
                | Some(Record::UnsolveNameConflict { ref mut name, .. }) => {
                    if let Some(edges) = parse_edges(changes, h) {
                        *name = Atom::EdgeMap(EdgeMap {
                            edges,
                            inode: name.inode(),
                        })
                    }
                    Ok(None)
                }
                Some(Record::SolveOrderConflict { ref mut change, .. }) => {
                    if h.starts_with("+ ") {
                        if let Atom::NewVertex(ref mut change) = change {
                            if change.start == change.end {
                                change.start = ChangePosition(contents_.len() as u64);
                            }
                            text_changes::parse_line_add(h, change, contents_)
                        }
                    } else if let Some(cap) = CONTEXT.captures(h) {
                        debug!("cap = {:?}", cap);
                        if let Atom::NewVertex(ref mut change) = change {
                            change.up_context = parse_pos_vec(changes, offsets, &cap[1])?;
                            if let Some(cap) = cap.get(7) {
                                change.down_context =
                                    parse_pos_vec(changes, offsets, cap.as_str())?;
                            }
                            if let (Some(new_start), Some(new_end)) = (cap.get(4), cap.get(5)) {
                                let new_start = new_start.as_str().parse::<u64>().unwrap();
                                let new_end = new_end.as_str().parse::<u64>().unwrap();
                                change.start = ChangePosition(contents_.len() as u64);
                                change.end =
                                    ChangePosition(contents_.len() as u64 + new_end - new_start);
                                offsets.insert(new_end, change.end);
                            }
                        }
                    }
                    Ok(None)
                }
                Some(Record::UnsolveOrderConflict { ref mut change, .. }) => {
                    if let Some(edges) = parse_edges(changes, h) {
                        if let Atom::EdgeMap(ref mut change) = change {
                            change.edges = edges
                        }
                    }
                    Ok(None)
                }
                Some(Record::ResurrectZombies { ref mut change, .. }) => {
                    if let Some(edges) = parse_edges(changes, h) {
                        if let Atom::EdgeMap(ref mut change) = change {
                            change.edges = edges
                        }
                    }
                    Ok(None)
                }
                None => {
                    debug!("current = {:#?}", current);
                    debug!("h = {:?}", h);
                    Ok(None)
                }
            }
        }
    }
}
#[cfg(feature = "text-changes")]
mod text_changes {
    use super::*;
    lazy_static! {
        static ref POS: regex::Regex = regex::Regex::new(r#"(\d+)\.(\d+)"#).unwrap();
        static ref EDGE: regex::Regex =
            regex::Regex::new(r#"\s*(?P<prev>[BFD]*):(?P<flag>[BFD]*)\s+(?P<up_c>\d+)\.(?P<up_l>\d+)\s*->\s*(?P<c>\d+)\.(?P<l0>\d+):(?P<l1>\d+)/(?P<intro>\d+)\s*"#).unwrap();
    }
    pub fn default_newvertex() -> NewVertex<Option<Hash>> {
        NewVertex {
            start: ChangePosition(0),
            end: ChangePosition(0),
            flag: EdgeFlags::empty(),
            up_context: Vec::new(),
            down_context: Vec::new(),
            inode: Position {
                change: Some(Hash::None),
                pos: ChangePosition(0),
            },
        }
    }
    pub fn default_edgemap() -> EdgeMap<Option<Hash>> {
        EdgeMap {
            edges: Vec::new(),
            inode: Position {
                change: Some(Hash::None),
                pos: ChangePosition(0),
            },
        }
    }
    pub fn has_newvertices<L>(current: &Option<Record<Option<Hash>, L>>) -> bool {
        match current {
            Some(Record::FileAdd { contents: None, .. }) | None => false,
            Some(rec) => rec.iter().any(|e| matches!(e, Atom::NewVertex(_))),
        }
    }
    pub fn parse_pos_vec(
        changes: &HashMap<usize, Hash>,
        offsets: &HashMap<u64, ChangePosition>,
        s: &str,
    ) -> Result<Vec<Position<Option<Hash>>>, Error> {
        let mut v = Vec::new();
        for pos in POS.captures_iter(s) {
            let change: usize = (&pos[1]).parse().unwrap();
            let pos: u64 = (&pos[2]).parse().unwrap();
            let pos = if change == 0 {
                if let Some(&pos) = offsets.get(&pos) {
                    pos
                } else {
                    debug!("inconsistent change: {:?} {:?}", s, offsets);
                    return Err(Error::InconsistentChange);
                }
            } else {
                ChangePosition(pos)
            };
            v.push(Position {
                change: change_ref(changes, change),
                pos,
            })
        }
        Ok(v)
    }
    fn change_ref(changes: &HashMap<usize, Hash>, change: usize) -> Option<Hash> {
        debug!("change_ref {:?} {:?}", changes, change);
        if change == 0 {
            None
        } else if change == 1 {
            Some(Hash::None)
        } else {
            Some(*changes.get(&change).unwrap())
        }
    }
    pub fn parse_pos(changes: &HashMap<usize, Hash>, s: &str) -> Position<Option<Hash>> {
        let pos = POS.captures(s).unwrap();
        let change: usize = (&pos[1]).parse().unwrap();
        let pos: u64 = (&pos[2]).parse().unwrap();
        Position {
            change: change_ref(changes, change),
            pos: ChangePosition(pos),
        }
    }
    pub fn parse_edges(
        changes: &HashMap<usize, Hash>,
        s: &str,
    ) -> Option<Vec<NewEdge<Option<Hash>>>> {
        debug!("parse_edges {:?}", s);
        let mut result = Vec::new();
        for edge in s.split(',') {
            debug!("parse edge {:?}", edge);
            if let Some(cap) = EDGE.captures(edge) {
                let previous = read_flag(cap.name("prev").unwrap().as_str());
                let flag = read_flag(cap.name("flag").unwrap().as_str());
                let change0: usize = cap.name("up_c").unwrap().as_str().parse().unwrap();
                let pos0: u64 = cap.name("up_l").unwrap().as_str().parse().unwrap();
                let change1: usize = cap.name("c").unwrap().as_str().parse().unwrap();
                let start1: u64 = cap.name("l0").unwrap().as_str().parse().unwrap();
                let end1: u64 = cap.name("l1").unwrap().as_str().parse().unwrap();
                let introduced_by: usize = cap.name("intro").unwrap().as_str().parse().unwrap();
                result.push(NewEdge {
                    previous,
                    flag,
                    from: Position {
                        change: change_ref(changes, change0),
                        pos: ChangePosition(pos0),
                    },
                    to: Vertex {
                        change: change_ref(changes, change1),
                        start: ChangePosition(start1),
                        end: ChangePosition(end1),
                    },
                    introduced_by: change_ref(changes, introduced_by),
                })
            } else {
                debug!("not parsed");
                return None;
            }
        }
        Some(result)
    }
    pub fn parse_line_add(h: &str, change: &mut NewVertex<Option<Hash>>, contents_: &mut Vec<u8>) {
        let h = h.as_bytes();
        debug!("parse_line_add {:?} {:?}", change.end, change.start);
        debug!("parse_line_add {:?}", h);
        if h.len() > 2 {
            let h = &h[2..h.len()];
            contents_.extend(h);
        } else if h.len() > 1 {
            contents_.push(b'\n');
        }
        debug!("contents_.len() = {:?}", contents_.len());
        trace!("contents_ = {:?}", contents_);
        change.end = ChangePosition(contents_.len() as u64);
    }
    pub fn print_contents<W: std::io::Write>(
        w: &mut W,
        pref: &str,
        contents: &[u8],
    ) -> Result<(), anyhow::Error> {
        if let Ok(mut contents) = std::str::from_utf8(&contents) {
            while let Some(n) = contents.as_bytes().iter().position(|&c| c == b'\n') {
                let (a, b) = contents.split_at(n + 1);
                contents = b;
                write!(w, "{} {}", pref, a)?;
            }
            if !contents.is_empty() {
                writeln!(w, "{} {}", pref, contents)?;
            }
        } else {
            writeln!(w, "{}b{}", pref, data_encoding::BASE64.encode(contents))?
        }
        Ok(())
    }
    pub fn print_change_contents<W: std::io::Write, C: ChangeStore>(
        w: &mut W,
        changes: &C,
        change: &Atom<Option<Hash>>,
        change_contents: &[u8],
    ) -> Result<(), anyhow::Error> {
        match change {
            Atom::NewVertex(ref n) => {
                let c = &change_contents[n.start.0 as usize..n.end.0 as usize];
                print_contents(w, "+", c)?;
                if !c.ends_with(b"\n") {
                    writeln!(w, "\\")?
                }
                Ok(())
            }
            Atom::EdgeMap(ref n) if n.edges[0].flag.contains(EdgeFlags::DELETED) => {
                let mut buf = Vec::new();
                let mut current = None;
                for e in n.edges.iter() {
                    if Some(e.to) == current {
                        continue;
                    }
                    buf.clear();
                    changes.get_contents_ext(e.to, &mut buf)?;
                    print_contents(w, "-", &buf[..])?;
                    current = Some(e.to)
                }
                Ok(())
            }
            _ => Ok(()),
        }
    }
    pub fn write_deleted_names<W: std::io::Write, C: ChangeStore>(
        w: &mut W,
        changes: &C,
        del: &Atom<Option<Hash>>,
    ) -> Result<(), anyhow::Error> {
        if let Atom::EdgeMap(ref e) = del {
            let mut buf = Vec::new();
            let mut is_first = true;
            for d in e.edges.iter() {
                buf.clear();
                changes.get_contents_ext(d.to, &mut buf)?;
                if !buf.is_empty() {
                    let name = std::str::from_utf8(buf.split_at(2).1).unwrap();
                    write!(w, "{}{:?}", if is_first { "" } else { ", " }, name)?;
                    is_first = false;
                }
            }
        }
        Ok(())
    }
    pub fn write_flag<W: std::io::Write>(mut w: W, flag: EdgeFlags) -> Result<(), anyhow::Error> {
        if flag.contains(EdgeFlags::BLOCK) {
            w.write_all(b"B")?;
        }
        if flag.contains(EdgeFlags::FOLDER) {
            w.write_all(b"F")?;
        }
        if flag.contains(EdgeFlags::DELETED) {
            w.write_all(b"D")?;
        }
        assert!(!flag.contains(EdgeFlags::PARENT));
        assert!(!flag.contains(EdgeFlags::PSEUDO));
        Ok(())
    }
    pub fn read_flag(s: &str) -> EdgeFlags {
        let mut f = EdgeFlags::empty();
        for i in s.chars() {
            match i {
                'B' => f |= EdgeFlags::BLOCK,
                'F' => f |= EdgeFlags::FOLDER,
                'D' => f |= EdgeFlags::DELETED,
                c => panic!("read_flag: {:?}", c),
            }
        }
        f
    }
    pub fn write_pos<W: std::io::Write>(
        mut w: W,
        hashes: &HashMap<Hash, usize>,
        pos: Position<Option<Hash>>,
    ) -> Result<(), anyhow::Error> {
        let change = if let Some(Hash::None) = pos.change {
            1
        } else if let Some(ref c) = pos.change {
            *hashes.get(c).unwrap()
        } else {
            0
        };
        write!(w, "{}.{}", change, pos.pos.0)?;
        Ok(())
    }
    pub fn write_atom<W: std::io::Write>(
        w: &mut W,
        hashes: &HashMap<Hash, usize>,
        atom: &Atom<Option<Hash>>,
    ) -> Result<(), anyhow::Error> {
        match atom {
            Atom::NewVertex(ref n) => write_newvertex(w, hashes, n),
            Atom::EdgeMap(ref n) => write_edgemap(w, hashes, n),
        }
    }
    pub fn write_newvertex<W: std::io::Write>(
        mut w: W,
        hashes: &HashMap<Hash, usize>,
        n: &NewVertex<Option<Hash>>,
    ) -> Result<(), anyhow::Error> {
        write!(w, "  up")?;
        for c in n.up_context.iter() {
            write!(w, " ")?;
            write_pos(&mut w, hashes, *c)?
        }
        write!(w, ", new {}:{}", n.start.0, n.end.0)?;
        if !n.down_context.is_empty() {
            write!(w, ", down")?;
            for c in n.down_context.iter() {
                write!(w, " ")?;
                write_pos(&mut w, hashes, *c)?
            }
        }
        w.write_all(b"\n")?;
        Ok(())
    }
    pub fn write_edgemap<W: std::io::Write>(
        mut w: W,
        hashes: &HashMap<Hash, usize>,
        n: &EdgeMap<Option<Hash>>,
    ) -> Result<(), anyhow::Error> {
        let mut is_first = true;
        for c in n.edges.iter() {
            if !is_first {
                write!(w, ", ")?;
            }
            is_first = false;
            write_flag(&mut w, c.previous)?;
            write!(w, ":")?;
            write_flag(&mut w, c.flag)?;
            write!(w, " ")?;
            write_pos(&mut w, hashes, c.from)?;
            write!(w, " -> ")?;
            write_pos(&mut w, hashes, c.to.start_pos())?;
            let h = if let Some(h) = hashes.get(c.introduced_by.as_ref().unwrap()) {
                h
            } else {
                panic!("introduced_by = {:?}, not found", c.introduced_by);
            };
            write!(w, ":{}/{}", c.to.end.0, h)?;
        }
        writeln!(w)?;
        Ok(())
    }
    #[cfg(feature = "text-changes")]
    #[derive(Debug, Clone, PartialEq, Eq)]
    pub enum Section {
        Header(String),
        Deps,
        Changes {
            changes: Vec<Record<Option<Hash>, Local>>,
            current: Option<Record<Option<Hash>, Local>>,
            offsets: HashMap<u64, ChangePosition>,
        },
    }
}
// org id XDu/0rcMPSdaCWLiWWDiw32Rl45EX9uwvy9vprRXJbg=
/// An open, seekable change file.
#[cfg(feature = "zstd")]
pub struct ChangeFile<'a> {
    s: Option<zstd_seekable::Seekable<'a, OffFile>>,
    hashed: Hashed<Local>,
    hash: Hash,
    unhashed: Option<toml::Value>,
}
struct OffFile {
    f: std::fs::File,
    start: u64,
}
unsafe impl Send for OffFile {}
impl std::io::Read for OffFile {
    fn read(&mut self, buf: &mut [u8]) -> Result<usize, std::io::Error> {
        self.f.read(buf)
    }
}
impl std::io::Seek for OffFile {
    fn seek(&mut self, from: std::io::SeekFrom) -> Result<u64, std::io::Error> {
        use std::io::SeekFrom;
        let from = match from {
            SeekFrom::Start(s) => SeekFrom::Start(s + self.start),
            c => c,
        };
        self.f.seek(from)
    }
}
#[cfg(feature = "zstd")]
impl<'a> ChangeFile<'a> {
    /// Open a change file from a path.
    pub fn open(hash: Hash, path: &str) -> Result<Self, anyhow::Error> {
        use std::io::Read;
        let mut r = std::fs::File::open(path)?;
        let mut buf = Vec::new();
        buf.resize(Change::OFFSETS_SIZE as usize, 0);
        r.read_exact(&mut buf)?;
        let offsets: Offsets = bincode::deserialize(&buf)?;
        if offsets.version != VERSION {
            return Err(Error::VersionMismatch.into());
        }
        buf.clear();
        buf.resize((offsets.unhashed_off - Change::OFFSETS_SIZE) as usize, 0);
        r.read_exact(&mut buf)?;
        let mut buf2 = vec![0u8; offsets.hashed_len as usize];
        let hashed: Hashed<Local> = {
            let mut s = zstd_seekable::Seekable::init_buf(&buf)?;
            s.decompress(&mut buf2, 0)?;
            bincode::deserialize(&buf2)?
        };
        buf.resize((offsets.contents_off - offsets.unhashed_off) as usize, 0);
        let unhashed = if buf.is_empty() {
            None
        } else {
            r.read_exact(&mut buf)?;
            let mut s = zstd_seekable::Seekable::init_buf(&buf)?;
            buf2.resize(offsets.unhashed_len as usize, 0);
            s.decompress(&mut buf2, 0)?;
            Some(toml::de::from_slice(&buf2)?)
        };
        let m = r.metadata()?;
        let s = if offsets.contents_off >= m.len() {
            None
        } else {
            Some(zstd_seekable::Seekable::init(Box::new(OffFile {
                f: r,
                start: offsets.contents_off,
            }))?)
        };
        Ok(ChangeFile {
            s,
            hashed,
            hash,
            unhashed,
        })
    }
    pub fn has_contents(&self) -> bool {
        self.s.is_some()
    }
    /// Reads the contents at an offset into `buf`, and returns the
    /// number of bytes read. The bounds of the change's "contents"
    /// section are not checked.
    pub fn read_contents(&mut self, offset: u64, buf: &mut [u8]) -> Result<usize, anyhow::Error> {
        debug!("read_contents {:?} {:?}", offset, buf.len());
        if let Some(ref mut s) = self.s {
            Ok(s.decompress(buf, offset)?)
        } else {
            Err((Error::MissingContents {
                hash: self.hash.to_base32(),
            })
            .into())
        }
    }
    pub fn hashed(&self) -> &Hashed<Local> {
        &self.hashed
    }
    pub fn unhashed(&self) -> &Option<toml::Value> {
        &self.unhashed
    }
}

File deletion: v3.rs

BF:BFD[17.931000] → [17.931001:931008]

BF:BFD[17.931008] → [17.931009:931009]

B:BD[17.931009] → [17.931010:944077]

use super::*;
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
enum Atom3<Change> {
    NewVertex(NewVertex<Change>),
    EdgeMap(EdgeMap3<Change>),
}
impl Atom3<Option<Hash>> {
    fn to_v4(self, translation: &HashMap<Option<Hash>, Option<Hash>>) -> Atom<Option<Hash>> {
        match self {
            Atom3::NewVertex(n) => Atom::NewVertex(NewVertex {
                up_context: n
                    .up_context
                    .into_iter()
                    .map(|x| Position {
                        change: *translation.get(&x.change).unwrap(),
                        ..x
                    })
                    .collect(),
                down_context: n
                    .down_context
                    .into_iter()
                    .map(|x| Position {
                        change: *translation.get(&x.change).unwrap(),
                        ..x
                    })
                    .collect(),
                flag: n.flag,
                start: n.start,
                end: n.end,
                inode: Position {
                    change: *translation.get(&n.inode.change).unwrap(),
                    ..n.inode
                },
            }),
            Atom3::EdgeMap(e) => Atom::EdgeMap(e.to_v4(translation)),
        }
    }
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
struct EdgeMap3<Change> {
    pub previous: EdgeFlags,
    pub flag: EdgeFlags,
    pub edges: Vec<NewEdge3<Change>>,
    pub inode: Position<Change>,
}
impl EdgeMap3<Option<Hash>> {
    fn to_v4(self, translations: &HashMap<Option<Hash>, Option<Hash>>) -> EdgeMap<Option<Hash>> {
        let flag = self.flag;
        let previous = self.previous;
        EdgeMap {
            inode: Position {
                change: *translations.get(&self.inode.change).unwrap(),
                ..self.inode
            },
            edges: self
                .edges
                .into_iter()
                .map(|e| NewEdge {
                    previous,
                    flag,
                    from: Position {
                        change: *translations.get(&e.from.change).unwrap(),
                        ..e.from
                    },
                    to: Vertex {
                        change: *translations.get(&e.to.change).unwrap(),
                        ..e.to
                    },
                    introduced_by: *translations.get(&e.introduced_by).unwrap(),
                })
                .collect(),
        }
    }
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
struct NewEdge3<Change> {
    pub from: Position<Change>,
    pub to: Vertex<Change>,
    pub introduced_by: Change,
}
#[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
enum Record3<Hash, Local> {
    FileMove {
        del: Atom3<Hash>,
        add: Atom3<Hash>,
        confirm: Option<Atom3<Hash>>,
        path: String,
    },
    FileDel {
        del: Atom3<Hash>,
        confirm: Option<Atom3<Hash>>,
        contents: Option<Atom3<Hash>>,
        path: String,
    },
    FileUndel {
        undel: Atom3<Hash>,
        confirm: Option<Atom3<Hash>>,
        contents: Option<Atom3<Hash>>,
        path: String,
    },
    FileAdd {
        add_name: Atom3<Hash>,
        add_inode: Atom3<Hash>,
        contents: Option<Atom3<Hash>>,
        path: String,
    },
    SolveNameConflict {
        name: Atom3<Hash>,
        confirm: Option<Atom3<Hash>>,
        path: String,
    },
    UnsolveNameConflict {
        name: Atom3<Hash>,
        confirm: Option<Atom3<Hash>>,
        path: String,
    },
    Edit {
        change: Atom3<Hash>,
        local: Local,
    },
    Replacement {
        change: Atom3<Hash>,
        replacement: Atom3<Hash>,
        local: Local,
    },
    SolveOrderConflict {
        change: Atom3<Hash>,
        local: Local,
    },
    UnsolveOrderConflict {
        change: Atom3<Hash>,
        local: Local,
    },
    ResurrectZombies {
        alive: Atom3<Hash>,
        dead: Atom3<Hash>,
        local: Local,
    },
}
impl Record3<Option<Hash>, Local> {
    fn to_v4(
        self,
        translation: &HashMap<Option<Hash>, Option<Hash>>,
    ) -> Record<Option<Hash>, Local> {
        match self {
            Record3::FileMove {
                del,
                add,
                confirm,
                path,
            } => {
                let mut del = del.to_v4(translation);
                if let Atom::EdgeMap(ref mut e) = del {
                    if let Some(Atom3::EdgeMap(c)) = confirm {
                        let c = c.to_v4(translation);
                        e.edges.extend(c.edges.into_iter())
                    }
                }
                let add = add.to_v4(translation);
                Record::FileMove { del, add, path }
            }
            Record3::FileDel {
                del,
                confirm,
                contents,
                path,
            } => {
                let mut del = del.to_v4(translation);
                if let Atom::EdgeMap(ref mut e) = del {
                    if let Some(Atom3::EdgeMap(c)) = confirm {
                        let c = c.to_v4(translation);
                        e.edges.extend(c.edges.into_iter())
                    }
                }
                let contents = contents.map(|c| c.to_v4(translation));
                Record::FileDel {
                    del,
                    contents,
                    path,
                }
            }
            Record3::FileUndel {
                undel,
                confirm,
                contents,
                path,
            } => {
                let mut undel = undel.to_v4(translation);
                if let Atom::EdgeMap(ref mut e) = undel {
                    if let Some(Atom3::EdgeMap(c)) = confirm {
                        let c = c.to_v4(translation);
                        e.edges.extend(c.edges.into_iter())
                    }
                }
                let contents = contents.map(|c| c.to_v4(translation));
                Record::FileUndel {
                    undel,
                    contents,
                    path,
                }
            }
            Record3::FileAdd {
                add_name,
                add_inode,
                contents,
                path,
            } => Record::FileAdd {
                add_name: add_name.to_v4(translation),
                add_inode: add_inode.to_v4(translation),
                contents: contents.map(|c| c.to_v4(translation)),
                path,
            },
            Record3::SolveNameConflict {
                name,
                confirm,
                path,
            } => {
                let mut name = name.to_v4(translation);
                if let Atom::EdgeMap(ref mut e) = name {
                    if let Some(Atom3::EdgeMap(c)) = confirm {
                        let c = c.to_v4(translation);
                        e.edges.extend(c.edges.into_iter())
                    }
                }
                Record::SolveNameConflict { name, path }
            }
            Record3::UnsolveNameConflict {
                name,
                confirm,
                path,
            } => {
                let mut name = name.to_v4(translation);
                if let Atom::EdgeMap(ref mut e) = name {
                    if let Some(Atom3::EdgeMap(c)) = confirm {
                        let c = c.to_v4(translation);
                        e.edges.extend(c.edges.into_iter())
                    }
                }
                Record::UnsolveNameConflict { name, path }
            }
            Record3::Edit { change, local } => Record::Edit {
                change: change.to_v4(translation),
                local,
            },
            Record3::Replacement {
                change,
                replacement,
                local,
            } => Record::Replacement {
                change: change.to_v4(translation),
                replacement: replacement.to_v4(translation),
                local,
            },
            Record3::SolveOrderConflict { change, local } => Record::SolveOrderConflict {
                change: change.to_v4(translation),
                local,
            },
            Record3::UnsolveOrderConflict { change, local } => Record::UnsolveOrderConflict {
                change: change.to_v4(translation),
                local,
            },
            Record3::ResurrectZombies { alive, dead, local } => {
                let mut change = alive.to_v4(translation);
                if let Atom::EdgeMap(ref mut e) = change {
                    if let Atom3::EdgeMap(c) = dead {
                        let c = c.to_v4(translation);
                        e.edges.extend(c.edges.into_iter())
                    }
                }
                Record::ResurrectZombies { change, local }
            }
        }
    }
}
#[derive(Clone, Debug, PartialEq)]
pub struct LocalChange3<Local> {
    offsets: Offsets,
    hashed: Hashed3<Local>,
    unhashed: Option<toml::Value>,
    contents: Vec<u8>,
}
const VERSION: u64 = 3;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
struct Hashed3<Local> {
    version: u64,
    header: ChangeHeader,
    dependencies: BTreeSet<Hash>,
    extra_known: BTreeSet<Hash>,
    metadata: Vec<u8>,
    changes: Vec<Record3<Option<Hash>, Local>>,
    contents_hash: Hash,
}
impl Hashed3<Local> {
    fn to_v4(self, translation: &HashMap<Option<Hash>, Option<Hash>>) -> Hashed<Local> {
        Hashed {
            version: 4,
            header: self.header,
            dependencies: self
                .dependencies
                .into_iter()
                .map(|x| translation.get(&Some(x)).unwrap().unwrap())
                .collect(),
            extra_known: self
                .extra_known
                .into_iter()
                .filter_map(|x| translation.get(&Some(x)).map(|x| x.unwrap()))
                .collect(),
            metadata: self.metadata,
            contents_hash: self.contents_hash,
            changes: self
                .changes
                .into_iter()
                .map(|x| x.to_v4(translation))
                .collect(),
        }
    }
}
impl LocalChange3<Local> {
    const OFFSETS_SIZE: u64 = 56;
    pub fn deserialize(file: &str, hash: Option<&Hash>) -> Result<Self, anyhow::Error> {
        use std::io::Read;
        let mut r = std::fs::File::open(file)?;
        let mut buf = vec![0u8; Self::OFFSETS_SIZE as usize];
        r.read_exact(&mut buf)?;
        let offsets: Offsets = bincode::deserialize(&buf)?;
        if offsets.version != VERSION {
            return Err(Error::VersionMismatch.into());
        }
        debug!("offsets = {:?}", offsets);
        buf.clear();
        buf.resize((offsets.unhashed_off - Self::OFFSETS_SIZE) as usize, 0);
        r.read_exact(&mut buf)?;
        let hashed: Hashed3<Local> = {
            let mut s = zstd_seekable::Seekable::init_buf(&buf[..])?;
            let mut out = vec![0u8; offsets.hashed_len as usize];
            s.decompress(&mut out[..], 0)?;
            let mut hasher = Hasher::default();
            hasher.update(&out);
            let computed_hash = hasher.finish();
            if let Some(hash) = hash {
                if &computed_hash != hash {
                    return Err((Error::ChangeHashMismatch {
                        claimed: *hash,
                        computed: computed_hash,
                    })
                    .into());
                }
            }
            bincode::deserialize_from(&out[..])?
        };
        buf.clear();
        buf.resize((offsets.contents_off - offsets.unhashed_off) as usize, 0);
        let unhashed = if buf.is_empty() {
            None
        } else {
            r.read_exact(&mut buf)?;
            let mut s = zstd_seekable::Seekable::init_buf(&buf[..])?;
            let mut out = vec![0u8; offsets.unhashed_len as usize];
            s.decompress(&mut out[..], 0)?;
            Some(toml::de::from_slice(&out)?)
        };
        debug!("unhashed = {:?}", unhashed);
        buf.clear();
        buf.resize((offsets.total - offsets.contents_off) as usize, 0);
        let contents = if r.read_exact(&mut buf).is_ok() {
            let mut s = zstd_seekable::Seekable::init_buf(&buf[..])?;
            let mut contents = vec![0u8; offsets.contents_len as usize];
            s.decompress(&mut contents[..], 0)?;
            contents
        } else {
            Vec::new()
        };
        debug!("contents = {:?}", contents);
        Ok(LocalChange3 {
            offsets,
            hashed,
            unhashed,
            contents,
        })
    }
    pub fn to_v4(self, translation: &HashMap<Option<Hash>, Option<Hash>>) -> LocalChange<Local> {
        LocalChange {
            offsets: self.offsets,
            hashed: self.hashed.to_v4(translation),
            unhashed: self.unhashed,
            contents: self.contents,
        }
    }
}

File addition: text_changes.rs (-rw-r--r--)

[17.931000]

use super::*;
use crate::changestore::*;
use std::collections::hash_map::Entry;
use std::collections::HashMap;
use std::io::BufRead;
#[derive(Debug, Error)]
pub enum TextDeError {
    #[error(transparent)]
    Io(#[from] std::io::Error),
    #[error(transparent)]
    TomlDe(#[from] toml::de::Error),
    #[error("Missing change [{0}]")]
    MissingChange(usize),
}
#[derive(Debug, Error)]
pub enum TextSerError<C: std::error::Error + 'static> {
    #[error(transparent)]
    C(C),
    #[error(transparent)]
    Io(#[from] std::io::Error),
    #[error(transparent)]
    TomlSer(#[from] toml::ser::Error),
    #[error("Missing contents in change {:?}", h)]
    MissingContents { h: Hash },
    #[error(transparent)]
    Change(#[from] ChangeError),
}
impl LocalChange<Local> {
    const DEPS_LINE: &'static str = "# Dependencies\n";
    const CHANGES_LINE: &'static str = "# Changes\n";
    pub fn write_all_deps<F: FnMut(Hash) -> Result<(), ChangeError>>(
        &self,
        mut f: F,
    ) -> Result<(), ChangeError> {
        for c in self.changes.iter() {
            for c in c.iter() {
                match *c {
                    Atom::NewVertex(ref n) => {
                        for change in n
                            .up_context
                            .iter()
                            .chain(n.down_context.iter())
                            .map(|c| c.change)
                            .chain(std::iter::once(n.inode.change))
                        {
                            if let Some(change) = change {
                                if let Hash::None = change {
                                    continue;
                                }
                                f(change)?
                            }
                        }
                    }
                    Atom::EdgeMap(ref e) => {
                        for edge in e.edges.iter() {
                            for change in &[
                                edge.from.change,
                                edge.to.change,
                                edge.introduced_by,
                                e.inode.change,
                            ] {
                                if let Some(change) = *change {
                                    if let Hash::None = change {
                                        continue;
                                    }
                                    f(change)?
                                }
                            }
                        }
                    }
                }
            }
        }
        Ok(())
    }
    pub fn write<W: Write, C: ChangeStore, F: FnMut(&Local, Position<Option<Hash>>) -> String>(
        &self,
        changes: &C,
        hash: Option<Hash>,
        mut file_name: F,
        write_header: bool,
        mut w: W,
    ) -> Result<(), TextSerError<C::Error>> {
        if let Some(h) = hash {
            // Check if we have the full contents
            let mut hasher = Hasher::default();
            hasher.update(&self.contents);
            let hash = hasher.finish();
            if hash != self.contents_hash {
                return Err((TextSerError::MissingContents { h }).into());
            }
        }
        if write_header {
            w.write_all(toml::ser::to_string_pretty(&self.header)?.as_bytes())?;
            w.write_all(b"\n")?;
        }
        let mut hashes = HashMap::new();
        let mut i = 2;
        let mut needs_newline = false;
        if !self.dependencies.is_empty() {
            w.write_all(Self::DEPS_LINE.as_bytes())?;
            needs_newline = true;
            for dep in self.dependencies.iter() {
                hashes.insert(*dep, i);
                writeln!(w, "[{}] {}", i, dep.to_base32())?;
                i += 1;
            }
        }
        self.write_all_deps(|change| {
            if let Entry::Vacant(e) = hashes.entry(change) {
                e.insert(i);
                if !needs_newline {
                    w.write_all(Self::DEPS_LINE.as_bytes())?;
                    needs_newline = true;
                }
                writeln!(w, "[{}]+{}", i, change.to_base32())?;
                i += 1;
            }
            Ok(())
        })?;
        if !self.extra_known.is_empty() {
            needs_newline = true;
            for dep in self.extra_known.iter() {
                writeln!(w, "[*] {}", dep.to_base32())?;
                i += 1;
            }
        }
        if !self.changes.is_empty() {
            if needs_newline {
                w.write_all(b"\n")?
            }
            w.write_all(Self::CHANGES_LINE.as_bytes())?;
            for (n, rec) in self.changes.iter().enumerate() {
                write!(w, "\n{}. ", n + 1)?;
                rec.write(changes, &mut file_name, &hashes, &self.contents, &mut w)?
            }
        }
        Ok(())
    }
}
impl Change {
    pub fn read_and_deps<R: BufRead, T: TxnT>(
        r: R,
        updatables: &mut HashMap<usize, crate::InodeUpdate>,
        txn: &T,
        channel: &ChannelRef<T>,
    ) -> Result<Self, TextDeError> {
        let (mut change, extra_dependencies) = Self::read_(r, updatables)?;
        let (mut deps, extra) = dependencies(txn, channel, change.hashed.changes.iter());
        deps.extend(extra_dependencies.into_iter());
        change.hashed.dependencies = deps;
        change.hashed.extra_known = extra;
        Ok(change)
    }
    pub fn read<R: BufRead>(
        r: R,
        updatables: &mut HashMap<usize, crate::InodeUpdate>,
    ) -> Result<Self, TextDeError> {
        Ok(Self::read_(r, updatables)?.0)
    }
    fn read_<R: BufRead>(
        mut r: R,
        updatables: &mut HashMap<usize, crate::InodeUpdate>,
    ) -> Result<(Self, HashSet<Hash>), TextDeError> {
        use self::text_changes::*;
        let mut section = Section::Header(String::new());
        let mut change = Change {
            offsets: Offsets::default(),
            hashed: Hashed {
                version: VERSION,
                header: ChangeHeader {
                    authors: Vec::new(),
                    message: String::new(),
                    description: None,
                    timestamp: chrono::Utc::now(),
                },
                dependencies: Vec::new(),
                extra_known: Vec::new(),
                metadata: Vec::new(),
                changes: Vec::new(),
                contents_hash: Hasher::default().finish(),
            },
            unhashed: None,
            contents: Vec::new(),
        };
        let conclude_section = |change: &mut Change,
                                section: Section,
                                contents: &mut Vec<u8>|
         -> Result<(), TextDeError> {
            match section {
                Section::Header(ref s) => {
                    debug!("header = {:?}", s);
                    change.header = toml::de::from_str(&s)?;
                    Ok(())
                }
                Section::Deps => Ok(()),
                Section::Changes {
                    mut changes,
                    current,
                    ..
                } => {
                    if has_newvertices(&current) {
                        contents.push(0)
                    }
                    if let Some(c) = current {
                        debug!("next action = {:?}", c);
                        changes.push(c)
                    }
                    change.changes = changes;
                    Ok(())
                }
            }
        };
        let mut h = String::new();
        let mut contents = Vec::new();
        let mut deps = HashMap::new();
        let mut extra_dependencies = HashSet::new();
        while r.read_line(&mut h)? > 0 {
            debug!("h = {:?}", h);
            if h == Self::DEPS_LINE {
                let section = std::mem::replace(&mut section, Section::Deps);
                conclude_section(&mut change, section, &mut contents)?;
            } else if h == Self::CHANGES_LINE {
                let section = std::mem::replace(
                    &mut section,
                    Section::Changes {
                        changes: Vec::new(),
                        current: None,
                        offsets: HashMap::new(),
                    },
                );
                conclude_section(&mut change, section, &mut contents)?;
            } else {
                use regex::Regex;
                lazy_static! {
                    static ref DEPS: Regex = Regex::new(r#"\[(\d*|\*)\](\+| ) *(\S*)"#).unwrap();
                    static ref KNOWN: Regex = Regex::new(r#"(\S*)"#).unwrap();
                }
                match section {
                    Section::Header(ref mut s) => s.push_str(&h),
                    Section::Deps => {
                        if let Some(d) = DEPS.captures(&h) {
                            let hash = Hash::from_base32(d[3].as_bytes()).unwrap();
                            if let Ok(n) = d[1].parse() {
                                if &d[2] == " " {
                                    change.hashed.dependencies.push(hash);
                                }
                                deps.insert(n, hash);
                            } else if &d[1] == "*" {
                                change.hashed.extra_known.push(hash);
                            } else {
                                extra_dependencies.insert(hash);
                            }
                        }
                    }
                    Section::Changes {
                        ref mut current,
                        ref mut changes,
                        ref mut offsets,
                    } => {
                        if let Some(next) =
                            Record::read(updatables, current, &mut contents, &deps, offsets, &h)?
                        {
                            debug!("next action = {:?}", next);
                            changes.push(next)
                        }
                    }
                }
            }
            h.clear();
        }
        conclude_section(&mut change, section, &mut contents)?;
        change.contents = contents;
        change.contents_hash = {
            let mut hasher = Hasher::default();
            hasher.update(&change.contents);
            hasher.finish()
        };
        Ok((change, extra_dependencies))
    }
}
impl Record<Option<Hash>, Local> {
    fn write<
        W: std::io::Write,
        C: ChangeStore,
        F: FnMut(&Local, Position<Option<Hash>>) -> String,
    >(
        &self,
        changes: &C,
        mut file_name: F,
        hashes: &HashMap<Hash, usize>,
        change_contents: &[u8],
        mut w: W,
    ) -> Result<(), TextSerError<C::Error>> {
        use self::text_changes::*;
        match self {
            Record::FileMove { del, add, path } => match add {
                Atom::NewVertex(ref add) => {
                    let name = std::str::from_utf8(
                        &change_contents[add.start.0 as usize + 2..add.end.0 as usize],
                    )
                    .unwrap();
                    let perms = crate::pristine::InodeMetadata::from_basename(
                        &change_contents[add.start.0 as usize..add.start.0 as usize + 2],
                    );
                    write!(w, "Moved: {:?} {:?} {:o} ", path, name, perms.0)?;
                    write_pos(&mut w, hashes, del.inode())?;
                    writeln!(w)?;
                    write_atom(&mut w, hashes, &del)?;
                    write!(w, "up")?;
                    for c in add.up_context.iter() {
                        write!(w, " ")?;
                        write_pos(&mut w, hashes, *c)?
                    }
                    write!(w, ", down")?;
                    for c in add.down_context.iter() {
                        write!(w, " ")?;
                        write_pos(&mut w, hashes, *c)?
                    }
                    w.write_all(b"\n")?;
                }
                Atom::EdgeMap(_) => {
                    write!(w, "Moved: {:?} ", path)?;
                    write_pos(&mut w, hashes, del.inode())?;
                    writeln!(w)?;
                    write_atom(&mut w, hashes, &add)?;
                    write_atom(&mut w, hashes, &del)?;
                }
            },
            Record::FileDel {
                del,
                contents,
                path,
            } => {
                write!(w, "File deletion: {:?} ", path)?;
                write_pos(&mut w, hashes, del.inode())?;
                writeln!(w)?;
                write_atom(&mut w, hashes, &del)?;
                if let Some(ref contents) = contents {
                    write_atom(&mut w, hashes, &contents)?;
                    writeln!(w)?;
                    print_change_contents(&mut w, changes, contents, change_contents)?;
                } else {
                    writeln!(w)?;
                }
            }
            Record::FileUndel {
                undel,
                contents,
                path,
            } => {
                write!(w, "File un-deletion: {:?} ", path)?;
                write_pos(&mut w, hashes, undel.inode())?;
                writeln!(w)?;
                write_atom(&mut w, hashes, &undel)?;
                if let Some(ref contents) = contents {
                    write_atom(&mut w, hashes, &contents)?;
                    print_change_contents(&mut w, changes, contents, change_contents)?;
                } else {
                    writeln!(w)?;
                }
            }
            Record::FileAdd {
                add_name,
                contents,
                path,
                ..
            } => {
                if let Atom::NewVertex(ref n) = add_name {
                    let name = std::str::from_utf8(
                        &change_contents[n.start.0 as usize + 2..n.end.0 as usize],
                    )
                    .unwrap();
                    let perms = crate::pristine::InodeMetadata::from_basename(
                        &change_contents[n.start.0 as usize..n.start.0 as usize + 2],
                    );
                    let parent = if let Some(p) = crate::path::parent(&path) {
                        if p.is_empty() {
                            "/"
                        } else {
                            p
                        }
                    } else {
                        "/"
                    };
                    write!(
                        w,
                        "File addition: {:?} in {:?} {:o}\n  up",
                        name, parent, perms.0
                    )?;
                    assert!(n.down_context.is_empty());
                    for c in n.up_context.iter() {
                        write!(w, " ")?;
                        write_pos(&mut w, hashes, *c)?
                    }
                    writeln!(w, ", new {}:{}", n.start.0, n.end.0)?;
                }
                if let Some(Atom::NewVertex(ref n)) = contents {
                    let c = &change_contents[n.start.0 as usize..n.end.0 as usize];
                    print_contents(&mut w, "+", c)?;
                    if !c.ends_with(b"\n") {
                        writeln!(w, "\\")?
                    }
                }
            }
            Record::Edit { change, local } => {
                write!(w, "Edit in {} ", file_name(&local, change.inode()))?;
                write_pos(&mut w, hashes, change.inode())?;
                writeln!(w)?;
                write_atom(&mut w, hashes, &change)?;
                print_change_contents(&mut w, changes, change, change_contents)?;
            }
            Record::Replacement {
                change,
                replacement,
                local,
            } => {
                write!(w, "Replacement in {} ", file_name(&local, change.inode()))?;
                write_pos(&mut w, hashes, change.inode())?;
                writeln!(w)?;
                write_atom(&mut w, hashes, &change)?;
                write_atom(&mut w, hashes, &replacement)?;
                print_change_contents(&mut w, changes, change, change_contents)?;
                print_change_contents(&mut w, changes, replacement, change_contents)?;
            }
            Record::SolveNameConflict { name, path } => {
                write!(w, "Solving a name conflict in {:?} ", path)?;
                write_pos(&mut w, hashes, name.inode())?;
                write!(w, ": ")?;
                write_deleted_names(&mut w, changes, name)?;
                writeln!(w)?;
                write_atom(&mut w, hashes, &name)?;
            }
            Record::UnsolveNameConflict { name, path } => {
                write!(w, "Un-solving a name conflict in {:?} ", path)?;
                write_pos(&mut w, hashes, name.inode())?;
                write!(w, ": ")?;
                write_deleted_names(&mut w, changes, name)?;
                writeln!(w)?;
                write_atom(&mut w, hashes, &name)?;
            }
            Record::SolveOrderConflict { change, local } => {
                write!(
                    w,
                    "Solving an order conflict in {} ",
                    file_name(&local, change.inode())
                )?;
                write_pos(&mut w, hashes, change.inode())?;
                writeln!(w)?;
                write_atom(&mut w, hashes, &change)?;
                print_change_contents(&mut w, changes, change, change_contents)?;
            }
            Record::UnsolveOrderConflict { change, local } => {
                write!(
                    w,
                    "Un-solving an order conflict in {} ",
                    file_name(&local, change.inode())
                )?;
                write_pos(&mut w, hashes, change.inode())?;
                writeln!(w)?;
                write_atom(&mut w, hashes, &change)?;
                print_change_contents(&mut w, changes, change, change_contents)?;
            }
            Record::ResurrectZombies { change, local } => {
                write!(
                    w,
                    "Resurrecting zombie lines in {:?}:{} ",
                    local.path, local.line
                )?;
                write_pos(&mut w, hashes, change.inode())?;
                writeln!(w)?;
                write_atom(&mut w, hashes, &change)?;
                print_change_contents(&mut w, changes, change, change_contents)?;
            }
        }
        Ok(())
    }
}
impl Record<Option<Hash>, Local> {
    fn read(
        updatables: &mut HashMap<usize, crate::InodeUpdate>,
        current: &mut Option<Self>,
        mut contents_: &mut Vec<u8>,
        changes: &HashMap<usize, Hash>,
        offsets: &mut HashMap<u64, ChangePosition>,
        h: &str,
    ) -> Result<Option<Self>, TextDeError> {
        use self::text_changes::*;
        use regex::Regex;
        lazy_static! {
            static ref FILE_ADDITION: Regex =
                Regex::new(r#"(?P<n>\d+)\. File addition: "(?P<name>[^"]*)" in "(?P<parent>[^"]*)" (?P<perm>\d+)"#).unwrap();
            static ref EDIT: Regex =
                Regex::new(r#"(\d+)\. Edit in ([^:]+):(\d+) (\d+\.\d+)"#).unwrap();
            static ref REPLACEMENT: Regex =
                Regex::new(r#"(\d+)\. Replacement in ([^:]+):(\d+) (\d+\.\d+)"#).unwrap();
            static ref FILE_DELETION: Regex =
                Regex::new(r#"(\d+)\. File deletion: "([^"]*)" (\d+\.\d+)"#).unwrap();
            static ref FILE_UNDELETION: Regex =
                Regex::new(r#"(\d+)\. File un-deletion: "([^"]*)" (\d+\.\d+)"#).unwrap();
            static ref MOVE: Regex =
                Regex::new(r#"(\d+)\. Moved: "(?P<former>[^"]*)" "(?P<new>[^"]*)" (?P<perm>\d+) (?P<inode>.*)"#).unwrap();
            static ref MOVE_: Regex = Regex::new(r#"(\d+)\. Moved: "([^"]*)" (.*)"#).unwrap();
            static ref NAME_CONFLICT: Regex = Regex::new(
                r#"(\d+)\. ((Solving)|(Un-solving)) a name conflict in "([^"]*)" (.*): .*"#
            )
            .unwrap();
            static ref ORDER_CONFLICT: Regex = Regex::new(
                r#"(\d+)\. ((Solving)|(Un-solving)) an order conflict in (.*):(\d+) (\d+\.\d+)"#
            )
            .unwrap();
            static ref ZOMBIE: Regex =
                Regex::new(r#"(\d+)\. Resurrecting zombie lines in (?P<path>"[^"]+"):(?P<line>\d+) (?P<inode>\d+\.\d+)"#)
                    .unwrap();
            static ref CONTEXT: Regex = Regex::new(
                r#"up ((\d+\.\d+ )*\d+\.\d+)(, new (\d+):(\d+))?(, down ((\d+\.\d+ )*\d+\.\d+))?"#
            )
            .unwrap();
        }
        if let Some(cap) = FILE_ADDITION.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)
            }
            let mut add_name = default_newvertex();
            add_name.start = ChangePosition(contents_.len() as u64);
            add_name.flag = EdgeFlags::FOLDER | EdgeFlags::BLOCK;
            let name = &cap.name("name").unwrap().as_str();
            let path = {
                let parent = cap.name("parent").unwrap().as_str();
                (if parent == "/" {
                    String::new()
                } else {
                    parent.to_string()
                }) + name
            };
            let meta = cap
                .name("perm")
                .unwrap()
                .as_str()
                .chars()
                .fold(0, |x, c| x * 8 + (c as u16 - b'0' as u16));
            let meta = InodeMetadata(meta);
            meta.write(&mut contents_).unwrap();
            contents_.extend(name.as_bytes());
            add_name.end = ChangePosition(contents_.len() as u64);
            let mut add_inode = default_newvertex();
            add_inode.flag = EdgeFlags::FOLDER | EdgeFlags::BLOCK;
            add_inode.up_context.push(Position {
                change: None,
                pos: ChangePosition(contents_.len() as u64),
            });
            contents_.push(0);
            add_inode.start = ChangePosition(contents_.len() as u64);
            add_inode.end = ChangePosition(contents_.len() as u64);
            contents_.push(0);
            let n = cap.name("n").unwrap().as_str().parse().unwrap();
            if let Entry::Occupied(mut e) = updatables.entry(n) {
                if let crate::InodeUpdate::Add { ref mut pos, .. } = e.get_mut() {
                    *pos = add_inode.start
                }
            }
            Ok(std::mem::replace(
                current,
                Some(Record::FileAdd {
                    add_name: Atom::NewVertex(add_name),
                    add_inode: Atom::NewVertex(add_inode),
                    contents: None,
                    path,
                }),
            ))
        } else if let Some(cap) = EDIT.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)
            }
            let mut v = default_newvertex();
            v.inode = parse_pos(changes, &cap[4]);
            Ok(std::mem::replace(
                current,
                Some(Record::Edit {
                    change: Atom::NewVertex(v),
                    local: Local {
                        path: cap[2].to_string(),
                        line: cap[3].parse().unwrap(),
                    },
                }),
            ))
        } else if let Some(cap) = REPLACEMENT.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)
            }
            let mut v = default_newvertex();
            v.inode = parse_pos(changes, &cap[4]);
            Ok(std::mem::replace(
                current,
                Some(Record::Replacement {
                    change: Atom::NewVertex(v.clone()),
                    replacement: Atom::NewVertex(v),
                    local: Local {
                        path: cap[2].to_string(),
                        line: cap[3].parse().unwrap(),
                    },
                }),
            ))
        } else if let Some(cap) = FILE_DELETION.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)
            }
            let mut del = default_edgemap();
            del.inode = parse_pos(changes, &cap[3]);
            Ok(std::mem::replace(
                current,
                Some(Record::FileDel {
                    del: Atom::EdgeMap(del),
                    contents: None,
                    path: cap[2].to_string(),
                }),
            ))
        } else if let Some(cap) = FILE_UNDELETION.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)
            }
            let mut undel = default_edgemap();
            undel.inode = parse_pos(changes, &cap[3]);
            Ok(std::mem::replace(
                current,
                Some(Record::FileUndel {
                    undel: Atom::EdgeMap(undel),
                    contents: None,
                    path: cap[2].to_string(),
                }),
            ))
        } else if let Some(cap) = NAME_CONFLICT.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)
            }
            let mut name = default_edgemap();
            debug!("cap = {:?}", cap);
            name.inode = parse_pos(changes, &cap[6]);
            Ok(std::mem::replace(
                current,
                if &cap[2] == "Solving" {
                    Some(Record::SolveNameConflict {
                        name: Atom::EdgeMap(name),
                        path: cap[5].to_string(),
                    })
                } else {
                    Some(Record::UnsolveNameConflict {
                        name: Atom::EdgeMap(name),
                        path: cap[5].to_string(),
                    })
                },
            ))
        } else if let Some(cap) = MOVE.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)
            }
            let mut add = default_newvertex();
            add.start = ChangePosition(contents_.len() as u64);
            add.flag = EdgeFlags::FOLDER | EdgeFlags::BLOCK;
            let name = cap.name("new").unwrap().as_str();
            let meta = cap
                .name("perm")
                .unwrap()
                .as_str()
                .chars()
                .fold(0, |x, c| x * 8 + (c as u16 - b'0' as u16));
            let meta = InodeMetadata(meta);
            meta.write(&mut contents_).unwrap();
            contents_.extend(name.as_bytes());
            add.end = ChangePosition(contents_.len() as u64);
            let mut del = default_edgemap();
            del.inode = parse_pos(changes, cap.name("inode").unwrap().as_str());
            Ok(std::mem::replace(
                current,
                Some(Record::FileMove {
                    del: Atom::EdgeMap(del),
                    add: Atom::NewVertex(add),
                    path: cap[2].to_string(),
                }),
            ))
        } else if let Some(cap) = MOVE_.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)
            }
            let mut add = default_edgemap();
            let mut del = default_edgemap();
            add.inode = parse_pos(changes, &cap[3]);
            del.inode = add.inode;
            Ok(std::mem::replace(
                current,
                Some(Record::FileMove {
                    del: Atom::EdgeMap(del),
                    add: Atom::EdgeMap(add),
                    path: cap[2].to_string(),
                }),
            ))
        } else if let Some(cap) = ORDER_CONFLICT.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)
            }
            Ok(std::mem::replace(
                current,
                Some(if &cap[2] == "Solving" {
                    let mut v = default_newvertex();
                    v.inode = parse_pos(changes, &cap[7]);
                    Record::SolveOrderConflict {
                        change: Atom::NewVertex(v),
                        local: Local {
                            path: cap[5].to_string(),
                            line: cap[6].parse().unwrap(),
                        },
                    }
                } else {
                    let mut v = default_edgemap();
                    v.inode = parse_pos(changes, &cap[7]);
                    Record::UnsolveOrderConflict {
                        change: Atom::EdgeMap(v),
                        local: Local {
                            path: cap[5].to_string(),
                            line: cap[6].parse().unwrap(),
                        },
                    }
                }),
            ))
        } else if let Some(cap) = ZOMBIE.captures(h) {
            if has_newvertices(current) {
                contents_.push(0)
            }
            let mut v = default_edgemap();
            v.inode = parse_pos(changes, &cap.name("inode").unwrap().as_str());
            Ok(std::mem::replace(
                current,
                Some(Record::ResurrectZombies {
                    change: Atom::EdgeMap(v),
                    local: Local {
                        path: cap.name("path").unwrap().as_str().parse().unwrap(),
                        line: cap.name("line").unwrap().as_str().parse().unwrap(),
                    },
                }),
            ))
        } else {
            match current {
                Some(Record::FileAdd {
                    ref mut contents,
                    ref mut add_name,
                    ..
                }) => {
                    if h.starts_with('+') {
                        if contents.is_none() {
                            let mut v = default_newvertex();
                            let inode = Position {
                                change: None,
                                pos: ChangePosition(contents_.len() as u64 - 1),
                            };
                            v.up_context.push(inode);
                            v.inode = inode;
                            v.start = ChangePosition(contents_.len() as u64);
                            *contents = Some(Atom::NewVertex(v));
                        }
                        if let Some(Atom::NewVertex(ref mut contents)) = contents {
                            if h.starts_with('+') {
                                text_changes::parse_line_add(h, contents, contents_)
                            }
                        }
                    } else if h.starts_with('\\') {
                        if let Some(Atom::NewVertex(ref mut contents)) = contents {
                            if contents_[contents.end.0 as usize - 1] == b'\n' {
                                assert_eq!(contents.end.0 as usize, contents_.len());
                                contents_.pop();
                                contents.end.0 -= 1;
                            }
                        }
                    } else if let Some(cap) = CONTEXT.captures(h) {
                        if let Atom::NewVertex(ref mut name) = add_name {
                            name.up_context = parse_pos_vec(changes, offsets, &cap[1])?;
                            if let (Some(new_start), Some(new_end)) = (cap.get(4), cap.get(5)) {
                                offsets.insert(new_start.as_str().parse().unwrap(), name.start);
                                offsets.insert(new_end.as_str().parse().unwrap(), name.end);
                                offsets.insert(
                                    new_end.as_str().parse::<u64>().unwrap() + 1,
                                    name.end + 1,
                                );
                            }
                        }
                    }
                    Ok(None)
                }
                Some(Record::FileDel {
                    ref mut del,
                    ref mut contents,
                    ..
                }) => {
                    if let Some(edges) = parse_edges(changes, h) {
                        if let Atom::EdgeMap(ref mut e) = del {
                            if edges[0].flag.contains(EdgeFlags::FOLDER) {
                                *e = EdgeMap {
                                    inode: e.inode,
                                    edges,
                                }
                            } else {
                                *contents = Some(Atom::EdgeMap(EdgeMap {
                                    inode: e.inode,
                                    edges,
                                }))
                            }
                        }
                    }
                    Ok(None)
                }
                Some(Record::FileUndel {
                    ref mut undel,
                    ref mut contents,
                    ..
                }) => {
                    if let Some(edges) = parse_edges(changes, h) {
                        if let Atom::EdgeMap(ref mut e) = undel {
                            if edges[0].flag.contains(EdgeFlags::FOLDER) {
                                *e = EdgeMap {
                                    inode: e.inode,
                                    edges,
                                }
                            } else {
                                *contents = Some(Atom::EdgeMap(EdgeMap {
                                    inode: e.inode,
                                    edges,
                                }))
                            }
                        }
                    }
                    Ok(None)
                }
                Some(Record::FileMove {
                    ref mut del,
                    ref mut add,
                    ..
                }) => {
                    if let Some(edges) = parse_edges(changes, h) {
                        if edges[0].flag.contains(EdgeFlags::DELETED) {
                            *del = Atom::EdgeMap(EdgeMap {
                                inode: del.inode(),
                                edges,
                            });
                            return Ok(None);
                        } else if let Atom::EdgeMap(ref mut add) = add {
                            if add.edges.is_empty() {
                                *add = EdgeMap {
                                    inode: add.inode,
                                    edges,
                                };
                                return Ok(None);
                            }
                        }
                    } else if let Some(cap) = CONTEXT.captures(h) {
                        if let Atom::NewVertex(ref mut c) = add {
                            debug!("cap = {:?}", cap);
                            c.up_context = parse_pos_vec(changes, offsets, &cap[1])?;
                            if let Some(cap) = cap.get(7) {
                                c.down_context = parse_pos_vec(changes, offsets, cap.as_str())?;
                            }
                        }
                    }
                    Ok(None)
                }
                Some(Record::Edit { ref mut change, .. }) => {
                    debug!("edit {:?}", h);
                    if h.starts_with("+ ") {
                        if let Atom::NewVertex(ref mut change) = change {
                            if change.start == change.end {
                                change.start = ChangePosition(contents_.len() as u64);
                            }
                            text_changes::parse_line_add(h, change, contents_)
                        }
                    } else if h.starts_with('\\') {
                        if let Atom::NewVertex(ref mut change) = change {
                            if contents_[change.end.0 as usize - 1] == b'\n' {
                                assert_eq!(change.end.0 as usize, contents_.len());
                                contents_.pop();
                                change.end.0 -= 1;
                            }
                        }
                    } else if let Some(cap) = CONTEXT.captures(h) {
                        if let Atom::NewVertex(ref mut c) = change {
                            debug!("cap = {:?}", cap);
                            c.up_context = parse_pos_vec(changes, offsets, &cap[1])?;
                            if let Some(cap) = cap.get(7) {
                                c.down_context = parse_pos_vec(changes, offsets, cap.as_str())?;
                            }
                        }
                    } else if let Some(edges) = parse_edges(changes, h) {
                        *change = Atom::EdgeMap(EdgeMap {
                            inode: change.inode(),
                            edges,
                        });
                    }
                    Ok(None)
                }
                Some(Record::Replacement {
                    ref mut change,
                    ref mut replacement,
                    ..
                }) => {
                    if h.starts_with("+ ") {
                        if let Atom::NewVertex(ref mut repl) = replacement {
                            if repl.start == repl.end {
                                repl.start = ChangePosition(contents_.len() as u64);
                            }
                            text_changes::parse_line_add(h, repl, contents_)
                        }
                    } else if h.starts_with('\\') {
                        if let Atom::NewVertex(ref mut repl) = replacement {
                            if contents_[repl.end.0 as usize - 1] == b'\n' {
                                assert_eq!(repl.end.0 as usize, contents_.len());
                                contents_.pop();
                                repl.end.0 -= 1;
                            }
                        }
                    } else if let Some(cap) = CONTEXT.captures(h) {
                        debug!("cap = {:?}", cap);
                        if let Atom::NewVertex(ref mut repl) = replacement {
                            repl.up_context = parse_pos_vec(changes, offsets, &cap[1])?;
                            if let Some(cap) = cap.get(7) {
                                repl.down_context = parse_pos_vec(changes, offsets, cap.as_str())?;
                            }
                        }
                    } else if let Some(edges) = parse_edges(changes, h) {
                        *change = Atom::EdgeMap(EdgeMap {
                            inode: change.inode(),
                            edges,
                        });
                    }
                    Ok(None)
                }
                Some(Record::SolveNameConflict { ref mut name, .. })
                | Some(Record::UnsolveNameConflict { ref mut name, .. }) => {
                    if let Some(edges) = parse_edges(changes, h) {
                        *name = Atom::EdgeMap(EdgeMap {
                            edges,
                            inode: name.inode(),
                        })
                    }
                    Ok(None)
                }
                Some(Record::SolveOrderConflict { ref mut change, .. }) => {
                    if h.starts_with("+ ") {
                        if let Atom::NewVertex(ref mut change) = change {
                            if change.start == change.end {
                                change.start = ChangePosition(contents_.len() as u64);
                            }
                            text_changes::parse_line_add(h, change, contents_)
                        }
                    } else if let Some(cap) = CONTEXT.captures(h) {
                        debug!("cap = {:?}", cap);
                        if let Atom::NewVertex(ref mut change) = change {
                            change.up_context = parse_pos_vec(changes, offsets, &cap[1])?;
                            if let Some(cap) = cap.get(7) {
                                change.down_context =
                                    parse_pos_vec(changes, offsets, cap.as_str())?;
                            }
                            if let (Some(new_start), Some(new_end)) = (cap.get(4), cap.get(5)) {
                                let new_start = new_start.as_str().parse::<u64>().unwrap();
                                let new_end = new_end.as_str().parse::<u64>().unwrap();
                                change.start = ChangePosition(contents_.len() as u64);
                                change.end =
                                    ChangePosition(contents_.len() as u64 + new_end - new_start);
                                offsets.insert(new_end, change.end);
                            }
                        }
                    }
                    Ok(None)
                }
                Some(Record::UnsolveOrderConflict { ref mut change, .. }) => {
                    if let Some(edges) = parse_edges(changes, h) {
                        if let Atom::EdgeMap(ref mut change) = change {
                            change.edges = edges
                        }
                    }
                    Ok(None)
                }
                Some(Record::ResurrectZombies { ref mut change, .. }) => {
                    if let Some(edges) = parse_edges(changes, h) {
                        if let Atom::EdgeMap(ref mut change) = change {
                            change.edges = edges
                        }
                    }
                    Ok(None)
                }
                None => {
                    debug!("current = {:#?}", current);
                    debug!("h = {:?}", h);
                    Ok(None)
                }
            }
        }
    }
}
lazy_static! {
    static ref POS: regex::Regex = regex::Regex::new(r#"(\d+)\.(\d+)"#).unwrap();
    static ref EDGE: regex::Regex =
        regex::Regex::new(r#"\s*(?P<prev>[BFD]*):(?P<flag>[BFD]*)\s+(?P<up_c>\d+)\.(?P<up_l>\d+)\s*->\s*(?P<c>\d+)\.(?P<l0>\d+):(?P<l1>\d+)/(?P<intro>\d+)\s*"#).unwrap();
}
pub fn default_newvertex() -> NewVertex<Option<Hash>> {
    NewVertex {
        start: ChangePosition(0),
        end: ChangePosition(0),
        flag: EdgeFlags::empty(),
        up_context: Vec::new(),
        down_context: Vec::new(),
        inode: Position {
            change: Some(Hash::None),
            pos: ChangePosition(0),
        },
    }
}
pub fn default_edgemap() -> EdgeMap<Option<Hash>> {
    EdgeMap {
        edges: Vec::new(),
        inode: Position {
            change: Some(Hash::None),
            pos: ChangePosition(0),
        },
    }
}
pub fn has_newvertices<L>(current: &Option<Record<Option<Hash>, L>>) -> bool {
    match current {
        Some(Record::FileAdd { contents: None, .. }) | None => false,
        Some(rec) => rec.iter().any(|e| matches!(e, Atom::NewVertex(_))),
    }
}
pub fn parse_pos_vec(
    changes: &HashMap<usize, Hash>,
    offsets: &HashMap<u64, ChangePosition>,
    s: &str,
) -> Result<Vec<Position<Option<Hash>>>, TextDeError> {
    let mut v = Vec::new();
    for pos in POS.captures_iter(s) {
        let change: usize = (&pos[1]).parse().unwrap();
        let pos: u64 = (&pos[2]).parse().unwrap();
        let pos = if change == 0 {
            if let Some(&pos) = offsets.get(&pos) {
                pos
            } else {
                debug!("inconsistent change: {:?} {:?}", s, offsets);
                return Err(TextDeError::MissingChange(change));
            }
        } else {
            ChangePosition(pos)
        };
        v.push(Position {
            change: change_ref(changes, change),
            pos,
        })
    }
    Ok(v)
}
fn change_ref(changes: &HashMap<usize, Hash>, change: usize) -> Option<Hash> {
    debug!("change_ref {:?} {:?}", changes, change);
    if change == 0 {
        None
    } else if change == 1 {
        Some(Hash::None)
    } else {
        Some(*changes.get(&change).unwrap())
    }
}
pub fn parse_pos(changes: &HashMap<usize, Hash>, s: &str) -> Position<Option<Hash>> {
    let pos = POS.captures(s).unwrap();
    let change: usize = (&pos[1]).parse().unwrap();
    let pos: u64 = (&pos[2]).parse().unwrap();
    Position {
        change: change_ref(changes, change),
        pos: ChangePosition(pos),
    }
}
pub fn parse_edges(changes: &HashMap<usize, Hash>, s: &str) -> Option<Vec<NewEdge<Option<Hash>>>> {
    debug!("parse_edges {:?}", s);
    let mut result = Vec::new();
    for edge in s.split(',') {
        debug!("parse edge {:?}", edge);
        if let Some(cap) = EDGE.captures(edge) {
            let previous = read_flag(cap.name("prev").unwrap().as_str());
            let flag = read_flag(cap.name("flag").unwrap().as_str());
            let change0: usize = cap.name("up_c").unwrap().as_str().parse().unwrap();
            let pos0: u64 = cap.name("up_l").unwrap().as_str().parse().unwrap();
            let change1: usize = cap.name("c").unwrap().as_str().parse().unwrap();
            let start1: u64 = cap.name("l0").unwrap().as_str().parse().unwrap();
            let end1: u64 = cap.name("l1").unwrap().as_str().parse().unwrap();
            let introduced_by: usize = cap.name("intro").unwrap().as_str().parse().unwrap();
            result.push(NewEdge {
                previous,
                flag,
                from: Position {
                    change: change_ref(changes, change0),
                    pos: ChangePosition(pos0),
                },
                to: Vertex {
                    change: change_ref(changes, change1),
                    start: ChangePosition(start1),
                    end: ChangePosition(end1),
                },
                introduced_by: change_ref(changes, introduced_by),
            })
        } else {
            debug!("not parsed");
            return None;
        }
    }
    Some(result)
}
pub fn parse_line_add(h: &str, change: &mut NewVertex<Option<Hash>>, contents_: &mut Vec<u8>) {
    let h = h.as_bytes();
    debug!("parse_line_add {:?} {:?}", change.end, change.start);
    debug!("parse_line_add {:?}", h);
    if h.len() > 2 {
        let h = &h[2..h.len()];
        contents_.extend(h);
    } else if h.len() > 1 {
        contents_.push(b'\n');
    }
    debug!("contents_.len() = {:?}", contents_.len());
    trace!("contents_ = {:?}", contents_);
    change.end = ChangePosition(contents_.len() as u64);
}
pub fn print_contents<W: std::io::Write>(
    w: &mut W,
    pref: &str,
    contents: &[u8],
) -> Result<(), std::io::Error> {
    if let Ok(mut contents) = std::str::from_utf8(&contents) {
        while let Some(n) = contents.as_bytes().iter().position(|&c| c == b'\n') {
            let (a, b) = contents.split_at(n + 1);
            contents = b;
            write!(w, "{} {}", pref, a)?;
        }
        if !contents.is_empty() {
            writeln!(w, "{} {}", pref, contents)?;
        }
    } else {
        writeln!(w, "{}b{}", pref, data_encoding::BASE64.encode(contents))?
    }
    Ok(())
}
pub fn print_change_contents<W: std::io::Write, C: ChangeStore>(
    w: &mut W,
    changes: &C,
    change: &Atom<Option<Hash>>,
    change_contents: &[u8],
) -> Result<(), TextSerError<C::Error>> {
    match change {
        Atom::NewVertex(ref n) => {
            let c = &change_contents[n.start.0 as usize..n.end.0 as usize];
            print_contents(w, "+", c)?;
            if !c.ends_with(b"\n") {
                writeln!(w, "\\")?
            }
            Ok(())
        }
        Atom::EdgeMap(ref n) if n.edges[0].flag.contains(EdgeFlags::DELETED) => {
            let mut buf = Vec::new();
            let mut current = None;
            for e in n.edges.iter() {
                if Some(e.to) == current {
                    continue;
                }
                buf.clear();
                changes
                    .get_contents_ext(e.to, &mut buf)
                    .map_err(TextSerError::C)?;
                print_contents(w, "-", &buf[..])?;
                current = Some(e.to)
            }
            Ok(())
        }
        _ => Ok(()),
    }
}
pub fn write_deleted_names<W: std::io::Write, C: ChangeStore>(
    w: &mut W,
    changes: &C,
    del: &Atom<Option<Hash>>,
) -> Result<(), TextSerError<C::Error>> {
    if let Atom::EdgeMap(ref e) = del {
        let mut buf = Vec::new();
        let mut is_first = true;
        for d in e.edges.iter() {
            buf.clear();
            changes
                .get_contents_ext(d.to, &mut buf)
                .map_err(TextSerError::C)?;
            if !buf.is_empty() {
                let name = std::str::from_utf8(buf.split_at(2).1).unwrap();
                write!(w, "{}{:?}", if is_first { "" } else { ", " }, name)?;
                is_first = false;
            }
        }
    }
    Ok(())
}
pub fn write_flag<W: std::io::Write>(mut w: W, flag: EdgeFlags) -> Result<(), std::io::Error> {
    if flag.contains(EdgeFlags::BLOCK) {
        w.write_all(b"B")?;
    }
    if flag.contains(EdgeFlags::FOLDER) {
        w.write_all(b"F")?;
    }
    if flag.contains(EdgeFlags::DELETED) {
        w.write_all(b"D")?;
    }
    assert!(!flag.contains(EdgeFlags::PARENT));
    assert!(!flag.contains(EdgeFlags::PSEUDO));
    Ok(())
}
pub fn read_flag(s: &str) -> EdgeFlags {
    let mut f = EdgeFlags::empty();
    for i in s.chars() {
        match i {
            'B' => f |= EdgeFlags::BLOCK,
            'F' => f |= EdgeFlags::FOLDER,
            'D' => f |= EdgeFlags::DELETED,
            c => panic!("read_flag: {:?}", c),
        }
    }
    f
}
pub fn write_pos<W: std::io::Write>(
    mut w: W,
    hashes: &HashMap<Hash, usize>,
    pos: Position<Option<Hash>>,
) -> Result<(), std::io::Error> {
    let change = if let Some(Hash::None) = pos.change {
        1
    } else if let Some(ref c) = pos.change {
        *hashes.get(c).unwrap()
    } else {
        0
    };
    write!(w, "{}.{}", change, pos.pos.0)?;
    Ok(())
}
pub fn write_atom<W: std::io::Write>(
    w: &mut W,
    hashes: &HashMap<Hash, usize>,
    atom: &Atom<Option<Hash>>,
) -> Result<(), std::io::Error> {
    match atom {
        Atom::NewVertex(ref n) => write_newvertex(w, hashes, n),
        Atom::EdgeMap(ref n) => write_edgemap(w, hashes, n),
    }
}
pub fn write_newvertex<W: std::io::Write>(
    mut w: W,
    hashes: &HashMap<Hash, usize>,
    n: &NewVertex<Option<Hash>>,
) -> Result<(), std::io::Error> {
    write!(w, "  up")?;
    for c in n.up_context.iter() {
        write!(w, " ")?;
        write_pos(&mut w, hashes, *c)?
    }
    write!(w, ", new {}:{}", n.start.0, n.end.0)?;
    if !n.down_context.is_empty() {
        write!(w, ", down")?;
        for c in n.down_context.iter() {
            write!(w, " ")?;
            write_pos(&mut w, hashes, *c)?
        }
    }
    w.write_all(b"\n")?;
    Ok(())
}
pub fn write_edgemap<W: std::io::Write>(
    mut w: W,
    hashes: &HashMap<Hash, usize>,
    n: &EdgeMap<Option<Hash>>,
) -> Result<(), std::io::Error> {
    let mut is_first = true;
    for c in n.edges.iter() {
        if !is_first {
            write!(w, ", ")?;
        }
        is_first = false;
        write_flag(&mut w, c.previous)?;
        write!(w, ":")?;
        write_flag(&mut w, c.flag)?;
        write!(w, " ")?;
        write_pos(&mut w, hashes, c.from)?;
        write!(w, " -> ")?;
        write_pos(&mut w, hashes, c.to.start_pos())?;
        let h = if let Some(h) = hashes.get(c.introduced_by.as_ref().unwrap()) {
            h
        } else {
            panic!("introduced_by = {:?}, not found", c.introduced_by);
        };
        write!(w, ":{}/{}", c.to.end.0, h)?;
    }
    writeln!(w)?;
    Ok(())
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Section {
    Header(String),
    Deps,
    Changes {
        changes: Vec<Record<Option<Hash>, Local>>,
        current: Option<Record<Option<Hash>, Local>>,
        offsets: HashMap<u64, ChangePosition>,
    },
}

File addition: change_file.rs (-rw-r--r--)

[17.931000]

use super::*;
/// An open, seekable change file.
#[cfg(feature = "zstd")]
pub struct ChangeFile<'a> {
    s: Option<zstd_seekable::Seekable<'a, OffFile>>,
    hashed: Hashed<Local>,
    hash: Hash,
    unhashed: Option<toml::Value>,
}
struct OffFile {
    f: std::fs::File,
    start: u64,
}
unsafe impl Send for OffFile {}
impl std::io::Read for OffFile {
    fn read(&mut self, buf: &mut [u8]) -> Result<usize, std::io::Error> {
        self.f.read(buf)
    }
}
impl std::io::Seek for OffFile {
    fn seek(&mut self, from: std::io::SeekFrom) -> Result<u64, std::io::Error> {
        use std::io::SeekFrom;
        let from = match from {
            SeekFrom::Start(s) => SeekFrom::Start(s + self.start),
            c => c,
        };
        self.f.seek(from)
    }
}
#[cfg(feature = "zstd")]
impl<'a> ChangeFile<'a> {
    /// Open a change file from a path.
    pub fn open(hash: Hash, path: &str) -> Result<Self, ChangeError> {
        use std::io::Read;
        let mut r = std::fs::File::open(path)?;
        let mut buf = Vec::new();
        buf.resize(Change::OFFSETS_SIZE as usize, 0);
        r.read_exact(&mut buf)?;
        let offsets: Offsets = bincode::deserialize(&buf)?;
        if offsets.version != VERSION {
            return Err(ChangeError::VersionMismatch);
        }
        buf.clear();
        buf.resize((offsets.unhashed_off - Change::OFFSETS_SIZE) as usize, 0);
        r.read_exact(&mut buf)?;
        let mut buf2 = vec![0u8; offsets.hashed_len as usize];
        let hashed: Hashed<Local> = {
            let mut s = zstd_seekable::Seekable::init_buf(&buf)?;
            s.decompress(&mut buf2, 0)?;
            bincode::deserialize(&buf2)?
        };
        buf.resize((offsets.contents_off - offsets.unhashed_off) as usize, 0);
        let unhashed = if buf.is_empty() {
            None
        } else {
            r.read_exact(&mut buf)?;
            let mut s = zstd_seekable::Seekable::init_buf(&buf)?;
            buf2.resize(offsets.unhashed_len as usize, 0);
            s.decompress(&mut buf2, 0)?;
            Some(toml::de::from_slice(&buf2)?)
        };
        let m = r.metadata()?;
        let s = if offsets.contents_off >= m.len() {
            None
        } else {
            Some(zstd_seekable::Seekable::init(Box::new(OffFile {
                f: r,
                start: offsets.contents_off,
            }))?)
        };
        Ok(ChangeFile {
            s,
            hashed,
            hash,
            unhashed,
        })
    }
    pub fn has_contents(&self) -> bool {
        self.s.is_some()
    }
    /// Reads the contents at an offset into `buf`, and returns the
    /// number of bytes read. The bounds of the change's "contents"
    /// section are not checked.
    pub fn read_contents(&mut self, offset: u64, buf: &mut [u8]) -> Result<usize, ChangeError> {
        debug!("read_contents {:?} {:?}", offset, buf.len());
        if let Some(ref mut s) = self.s {
            Ok(s.decompress(buf, offset)?)
        } else {
            Err(ChangeError::MissingContents { hash: self.hash })
        }
    }
    pub fn hashed(&self) -> &Hashed<Local> {
        &self.hashed
    }
    pub fn unhashed(&self) -> &Option<toml::Value> {
        &self.unhashed
    }
}

Deletion in libpijul/src/apply.rs at line 1 [17.944089]
B:BD[17.944089] → [17.944090:944145]
```
// org id g5piHODDo9cz2FFDRisMQw4h8fj1SqTfQ3I/i2p+EGc=
```
Deletion in libpijul/src/apply.rs at line 7 [17.944089]
B:BD[17.944344] → [17.944344:944362]
```
use crate::Error;
```

Replacement in libpijul/src/apply.rs at line 8 [17.944089]

B:BD[17.944404] → [17.944404:944459]

// org id Fn0IzU5GRCA4xymOneQzYPhm7xvcbR8viQt+xz5AzSU=

[17.944404]

[17.944459]

use thiserror::Error;
#[derive(Debug, Error)]
pub enum ApplyError<ChangestoreError: std::error::Error, TxnError: std::error::Error + 'static> {
    #[error("Changestore error: {0}")]
    Changestore(ChangestoreError),
    #[error("Local change error: {err}")]
    LocalChange {
        #[from]
        err: LocalApplyError<TxnError>,
    },
}
#[derive(Debug, Error)]
pub enum LocalApplyError<TxnError: std::error::Error> {
    #[error("Dependency missing: {:?}", hash)]
    DependencyMissing { hash: crate::pristine::Hash },
    #[error("Change already on channel: {:?}", hash)]
    ChangeAlreadyOnChannel { hash: crate::pristine::Hash },
    #[error("Transaction error: {0}")]
    Txn(TxnError),
    #[error(transparent)]
    Block(#[from] crate::pristine::BlockError),
    #[error(transparent)]
    InconsistentChange(#[from] crate::pristine::InconsistentChange),
}
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) => LocalApplyError::Block(e),
            MissingError::Inconsistent(e) => LocalApplyError::InconsistentChange(e),
        }
    }
}

Replacement in libpijul/src/apply.rs at line 55 [17.944089]
B:BD[17.944880] → [17.944880:944924]
```
) -> Result<(u64, Merkle), anyhow::Error> {
```
[17.944880]
[17.944924]
```
) -> Result<(u64, Merkle), ApplyError<P::Error, T::Error>> {
```

Replacement in libpijul/src/apply.rs at line 59 [17.944089]

B:BD[17.945044] → [17.945044:945089]

    let change = changes.get_change(&hash)?;

[17.945044]

[17.945089]

    let change = changes.get_change(&hash).map_err(ApplyError::Changestore)?;

Replacement in libpijul/src/apply.rs at line 70 [17.944089]

B:BD[17.945379] → [17.945379:945443]

        return Err((Error::DependencyMissing { hash }).into());

[17.945379]

[17.945443]

        return Err((LocalApplyError::DependencyMissing { hash }).into());

Replacement in libpijul/src/apply.rs at line 77 [17.944089]

B:BD[19.67075] → [19.67075:67131]

        register_change(txn, internal, hash, &change)?;

[19.67075]

[17.945648]

        register_change(txn, internal, hash, &change).map_err(LocalApplyError::Txn)?;

Replacement in libpijul/src/apply.rs at line 81 [17.944089]

B:BD[17.945713] → [37.0:84]

    apply_change_to_channel(txn, &mut channel, internal, &hash, &change, workspace)

[17.945713]

[17.945917]

    Ok(apply_change_to_channel(
        txn,
        &mut channel,
        internal,
        &hash,
        &change,
        workspace,
    )?)

Replacement in libpijul/src/apply.rs at line 98 [17.944089]
B:BD[17.946111] → [17.946111:946144]
```
) -> Result<(), anyhow::Error> {
```
[17.946111]
[17.946144]
```
) -> Result<(), ApplyError<P::Error, T::Error>> {
```

Replacement in libpijul/src/apply.rs at line 106 [17.944089]

B:BD[17.946391] → [17.946391:946440]

        let change = changes.get_change(&hash)?;

[17.946391]

[17.946440]

        let change = changes.get_change(&hash).map_err(ApplyError::Changestore)?;

Replacement in libpijul/src/apply.rs at line 138 [17.944089]

B:BD[19.67204] → [19.67204:67272]

                    register_change(txn, internal, hash, &change)?;

[19.67204]

[17.947248]

                    register_change(txn, internal, hash, &change).map_err(LocalApplyError::Txn)?;

Replacement in libpijul/src/apply.rs at line 156 [17.944089]
B:BD[17.947938] → [17.947938:947982]
```
) -> Result<(u64, Merkle), anyhow::Error> {
```
[17.947938]
[17.947982]
```
) -> Result<(u64, Merkle), ApplyError<P::Error, T::Error>> {
```
Replacement in libpijul/src/apply.rs at line 167 [17.944089]
B:BD[17.948278] → [17.948278:948311]
```
) -> Result<(), anyhow::Error> {
```
[17.948278]
[17.948311]
```
) -> Result<(), ApplyError<P::Error, T::Error>> {
```
Replacement in libpijul/src/apply.rs at line 186 [17.944089]
B:BD[17.948861] → [17.948861:948905]
```
) -> Result<(u64, Merkle), anyhow::Error> {
```
[17.948861]
[17.948905]
```
) -> Result<(u64, Merkle), LocalApplyError<T::Error>> {
```

Replacement in libpijul/src/apply.rs at line 189 [17.944089]

B:BD[17.948963] → [17.948963:948980]

B:BD[17.948980] → [17.948980:949073]

B:BD[17.949073] → [17.949073:949104]

B:BD[17.949104] → [17.949104:949184]

B:BD[17.949184] → [17.949184:949195]

    let merkle =
        if let Some(m) = txn.put_changes(channel, change_id, channel.apply_counter, hash)? {
            m
        } else {
            return Err((Error::ChangeAlreadyOnChannel { hash: *hash }).into());
        };

[17.948963]

[17.949195]

    let merkle = if let Some(m) = txn
        .put_changes(channel, change_id, channel.apply_counter, hash)
        .map_err(LocalApplyError::Txn)?
    {
        m
    } else {
        return Err(LocalApplyError::ChangeAlreadyOnChannel { hash: *hash });
    };

Replacement in libpijul/src/apply.rs at line 214 [17.944089]

B:BD[17.950014] → [17.950014:950069]

                                |_, _, _, _| Ok(true),

[17.950014]

[17.950069]

                                |_, _, _, _| Ok::<bool, LocalApplyError<T::Error>>(true),

Replacement in libpijul/src/apply.rs at line 229 [17.944089]

B:BD[32.981] → [32.981:1018]

                            Ok(true)

[32.981]

[32.1018]

                            Ok::<bool, LocalApplyError<T::Error>>(true)

Deletion in libpijul/src/apply.rs at line 231 [17.944089]

B:BD[32.1047] → [32.1047:1126]

                        // org id aNVimxa4oSqbTYJ033w2QbZTCVMG/+tO2ymc1QSWPH0=

Replacement in libpijul/src/apply.rs at line 239 [17.944089]

B:BD[32.1481] → [32.1481:1508]

B:BD[32.1508] → [32.1508:1587]

                        )?
                        // org id hXW9eN25ZM8EQ5B2Ew8NMra+xi7hFv6CN8no+qg8GpY=

[32.1481]

[17.951533]

                        )
                        .map_err(LocalApplyError::from_missing)?

Replacement in libpijul/src/apply.rs at line 254 [17.944089]

B:BD[17.951945] → [17.951945:952082]

    channel.last_modified = std::time::SystemTime::now()
        .duration_since(std::time::SystemTime::UNIX_EPOCH)?
        .as_secs();

[17.951945]

[17.952082]

    if let Ok(duration) =
        std::time::SystemTime::now().duration_since(std::time::SystemTime::UNIX_EPOCH)
    {
        channel.last_modified = duration.as_secs();
    }

Replacement in libpijul/src/apply.rs at line 274 [17.944089]
B:BD[17.952657] → [17.952657:952701]
```
) -> Result<(u64, Merkle), anyhow::Error> {
```
[17.952657]
[17.952760]
```
) -> Result<(u64, Merkle), LocalApplyError<T::Error>> {
```

Replacement in libpijul/src/apply.rs at line 287 [17.944089]

B:BD[6.290] → [6.290:354]

        return Err((Error::DependencyMissing { hash }).into());

[6.290]

[6.354]

        return Err((LocalApplyError::DependencyMissing { hash }).into());

Replacement in libpijul/src/apply.rs at line 290 [17.944089]
∅:D[6.361] → [19.67329:67381]
B:BD[19.67329] → [19.67329:67381]
```
    register_change(txn, internal, hash, &change)?;
```
[6.361]
[37.227]
```
    register_change(txn, internal, hash, &change).map_err(LocalApplyError::Txn)?;
```
Replacement in libpijul/src/apply.rs at line 306 [17.944089]
B:BD[17.953616] → [17.953616:953660]
```
) -> Result<(u64, Merkle), anyhow::Error> {
```
[17.953616]
[17.953660]
```
) -> Result<(u64, Merkle), LocalApplyError<T::Error>> {
```
Replacement in libpijul/src/apply.rs at line 322 [17.944089]
B:BD[17.953986] → [17.953986:954019]
```
) -> Result<(), anyhow::Error> {
```
[17.953986]
[17.954019]
```
) -> Result<(), LocalApplyError<T::Error>> {
```

Replacement in libpijul/src/apply.rs at line 335 [17.944089]

B:BD[17.954497] → [19.67382:67440]

                put_inodes_with_rev(txn, inode, vertex)?;

[17.954497]

[17.954554]

                put_inodes_with_rev(txn, inode, vertex).map_err(LocalApplyError::Txn)?;

Replacement in libpijul/src/apply.rs at line 342 [17.944089]

B:BD[17.954864] → [27.3409:3478]

                del_tree_with_rev(txn, parent.as_file_id(), inode)?;

[17.954864]

[17.954997]

                del_tree_with_rev(txn, parent.as_file_id(), inode).map_err(LocalApplyError::Txn)?;

Replacement in libpijul/src/apply.rs at line 352 [17.944089]
B:BD[17.955259] → [17.955259:955275]
```
            )?;
```
[17.955259]
[17.955275]
```
            )
            .map_err(LocalApplyError::Txn)?;
```

Replacement in libpijul/src/apply.rs at line 355 [17.944089]

B:BD[17.955339] → [27.3532:3590]

                del_inodes_with_rev(txn, inode, vertex)?;

[17.955339]

[17.955450]

                del_inodes_with_rev(txn, inode, vertex).map_err(LocalApplyError::Txn)?;

Replacement in libpijul/src/apply.rs at line 369 [17.944089]
B:BD[17.955721] → [17.955721:955754]
```
) -> Result<(), anyhow::Error> {
```
[17.955721]
[17.955754]
```
) -> Result<(), LocalApplyError<T::Error>> {
```

Replacement in libpijul/src/apply.rs at line 395 [17.944089]

B:BD[17.956626] → [19.67545:67623]

                put_graph_with_rev(txn, channel, flag, up, vertex, *change)?;

[17.956626]

[17.956703]

                put_graph_with_rev(txn, channel, flag, up, vertex, *change)
                    .map_err(LocalApplyError::Txn)?;

Replacement in libpijul/src/apply.rs at line 405 [17.944089]

B:BD[14.354] → [14.354:423]

        put_graph_with_rev(txn, channel, flag, up, vertex, change)?;

[14.354]

[17.956816]

        put_graph_with_rev(txn, channel, flag, up, vertex, change).map_err(LocalApplyError::Txn)?;

Replacement in libpijul/src/apply.rs at line 418 [17.944089]
B:BD[19.68059] → [19.68059:68075]
```
            )?;
```
[19.68059]
[17.957404]
```
            )
            .map_err(LocalApplyError::Txn)?;
```
Replacement in libpijul/src/apply.rs at line 428 [17.944089]
B:BD[19.68267] → [19.68267:68283]
```
            )?;
```
[19.68267]
[17.957497]
```
            )
            .map_err(LocalApplyError::Txn)?;
```
Replacement in libpijul/src/apply.rs at line 443 [17.944089]
B:BD[17.957790] → [17.957790:957823]
```
) -> Result<(), anyhow::Error> {
```
[17.957790]
[17.957823]
```
) -> Result<(), LocalApplyError<T::Error>> {
```

Replacement in libpijul/src/apply.rs at line 459 [17.944089]

B:BD[17.958453] → [19.68336:68386]

            split_block(txn, channel, k, up.pos)?

[17.958453]

[17.958502]

            split_block(txn, channel, k, up.pos).map_err(LocalApplyError::Txn)?

Replacement in libpijul/src/apply.rs at line 498 [17.944089]
B:BD[17.959448] → [17.959448:959495]
```
) -> Result<Vertex<ChangeId>, anyhow::Error> {
```
[17.959448]
[19.69263]
```
) -> Result<Vertex<ChangeId>, LocalApplyError<T::Error>> {
```

Replacement in libpijul/src/apply.rs at line 515 [17.944089]

B:BD[17.960068] → [19.69310:69358]

        split_block(txn, channel, k, down.pos)?

[17.960068]

[17.960115]

        split_block(txn, channel, k, down.pos).map_err(LocalApplyError::Txn)?

Replacement in libpijul/src/apply.rs at line 590 [17.944089]
B:BD[17.962677] → [17.962677:962732]
B:BD[17.962732] → [37.322:355]
```
// org id wwZDqGk+qPaB9Oabmhr4ziOpXgWClHLLbxpCOAo1zpI=
pub(crate) fn put_newedge<T, F>(
```
[17.962677]
[17.962794]
```
pub(crate) fn put_newedge<T, E, F>(
```
Replacement in libpijul/src/apply.rs at line 599 [17.944089]
B:BD[17.962973] → [17.962973:963004]
```
) -> Result<(), anyhow::Error>
```
[17.962973]
[17.963004]
```
) -> Result<(), E>
```

Replacement in libpijul/src/apply.rs at line 602 [17.944089]

B:BD[17.963175] → [17.963175:963279]

B:BD[17.963279] → [17.963279:963317]

    F: Fn(
        &mut T,
        &mut Channel<T>,
        Vertex<ChangeId>,
        Vertex<ChangeId>,
    ) -> Result<bool, anyhow::Error>,

[17.963026]

[17.963317]

    E: From<LocalApplyError<T::Error>>,
    F: Fn(&mut T, &mut Channel<T>, Vertex<ChangeId>, Vertex<ChangeId>) -> Result<bool, E>,

Replacement in libpijul/src/apply.rs at line 606 [17.944089]

B:BD[17.963364] → [17.963364:963425]

        ws.missing_context.load_graph(txn, channel, inode)?;

[17.963364]

[17.963425]

        ws.missing_context
            .load_graph(txn, channel, inode)
            .map_err(LocalApplyError::InconsistentChange)?;

Replacement in libpijul/src/apply.rs at line 617 [17.944089]

B:BD[17.963660] → [17.963660:963721]

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

[17.963660]

[17.963721]

        return Err(
            LocalApplyError::InconsistentChange(crate::pristine::InconsistentChange {}).into(),
        );

Replacement in libpijul/src/apply.rs at line 646 [17.944089]

B:BD[17.964639] → [19.69742:69800]

            split_block(txn, channel, target, n.to.end)?;

[17.964639]

[17.964696]

            split_block(txn, channel, target, n.to.end).map_err(LocalApplyError::Txn)?;

Replacement in libpijul/src/apply.rs at line 659 [17.944089]

B:BD[17.965101] → [19.69801:69899]

        let del = del_graph_with_rev(txn, channel, n.previous, source, target, n_introduced_by)?;

[17.965101]

[17.965198]

        let del = del_graph_with_rev(txn, channel, n.previous, source, target, n_introduced_by)
            .map_err(LocalApplyError::Txn)?;

Replacement in libpijul/src/apply.rs at line 665 [17.944089]

B:BD[17.965798] → [19.69900:69979]

            put_graph_with_rev(txn, channel, n.flag, source, target, change)?;

[17.965798]

[17.965876]

            put_graph_with_rev(txn, channel, n.flag, source, target, change)
                .map_err(LocalApplyError::Txn)?;

Replacement in libpijul/src/apply.rs at line 675 [17.944089]

B:BD[17.966024] → [19.69980:70042]

        target = find_block(txn, channel, target.end_pos())?;

[17.966024]

[17.966085]

        target = find_block(txn, channel, target.end_pos()).map_err(LocalApplyError::Block)?;

Replacement in libpijul/src/apply.rs at line 690 [17.944089]
B:BD[17.966415] → [17.966415:966462]
```
) -> Result<Vertex<ChangeId>, anyhow::Error> {
```
[17.966415]
[17.966462]
```
) -> Result<Vertex<ChangeId>, LocalApplyError<T::Error>> {
```

Replacement in libpijul/src/apply.rs at line 714 [17.944089]

B:BD[17.967280] → [19.70132:70186]

        split_block(txn, channel, source, from.pos)?;

[17.967280]

[17.967333]

        split_block(txn, channel, source, from.pos).map_err(LocalApplyError::Txn)?;

Replacement in libpijul/src/apply.rs at line 728 [17.944089]
B:BD[17.967603] → [17.967603:967650]
```
) -> Result<Vertex<ChangeId>, anyhow::Error> {
```
[17.967603]
[19.70187]
```
) -> Result<Vertex<ChangeId>, LocalApplyError<T::Error>> {
```

Replacement in libpijul/src/apply.rs at line 753 [17.944089]

B:BD[17.968473] → [19.70307:70361]

        split_block(txn, channel, target, to.start)?;

[17.968473]

[17.968526]

        split_block(txn, channel, target, to.start).map_err(LocalApplyError::Txn)?;

Replacement in libpijul/src/apply.rs at line 765 [17.944089]
B:BD[17.968808] → [17.968808:968841]
```
) -> Result<(), anyhow::Error> {
```
[17.968808]
[19.70362]
```
) -> Result<(), LocalApplyError<T::Error>> {
```
Replacement in libpijul/src/apply.rs at line 798 [17.944089]
B:BD[17.969811] → [17.969811:969844]
```
) -> Result<(), anyhow::Error> {
```
[17.969811]
[17.969844]
```
) -> Result<(), LocalApplyError<T::Error>> {
```

Replacement in libpijul/src/apply.rs at line 820 [17.944089]

B:BD[17.970375] → [17.970375:970436]

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

[17.970375]

[17.970436]

        return Err((InconsistentChange {}).into());

Replacement in libpijul/src/apply.rs at line 842 [17.944089]

B:BD[19.70659] → [19.70659:70752]

                put_graph_with_rev(txn, channel, EdgeFlags::PSEUDO, p, *c, ChangeId::ROOT)?;

[19.70659]

[17.971153]

                put_graph_with_rev(txn, channel, EdgeFlags::PSEUDO, p, *c, ChangeId::ROOT)
                    .map_err(LocalApplyError::Txn)?;

Replacement in libpijul/src/apply.rs at line 854 [17.944089]
B:BD[17.971377] → [17.971377:971410]
```
) -> Result<(), anyhow::Error> {
```
[17.971377]
[17.971410]
```
) -> Result<(), LocalApplyError<T::Error>> {
```

Replacement in libpijul/src/apply.rs at line 885 [17.944089]

B:BD[17.973164] → [17.973164:973185]

                )? {

[17.973164]

[17.973185]

                )
                .map_err(LocalApplyError::Txn)?
                {

Replacement in libpijul/src/apply.rs at line 896 [17.944089]

B:BD[17.973501] → [17.973501:973524]

)?

[17.973501]

[17.973524]

                    )
                    .map_err(LocalApplyError::from_missing)?

Replacement in libpijul/src/apply.rs at line 909 [17.944089]

B:BD[19.71255] → [19.71255:71272]

            )? {

[19.71255]

[17.973739]

            )
            .map_err(LocalApplyError::Txn)?
            {

Replacement in libpijul/src/apply.rs at line 921 [17.944089]

B:BD[17.974075] → [17.974075:974094]

)?

[17.974075]

[17.974094]

                )
                .map_err(LocalApplyError::from_missing)?

Replacement in libpijul/src/apply.rs at line 932 [17.944089]
B:BD[19.71466] → [19.71466:71482]
```
            )?;
```
[19.71466]
[17.974222]
```
            )
            .map_err(LocalApplyError::Txn)?;
```
Replacement in libpijul/src/apply.rs at line 945 [17.944089]
B:BD[17.974463] → [17.974463:974496]
```
) -> Result<(), anyhow::Error> {
```
[17.974463]
[17.974496]
```
) -> Result<(), LocalApplyError<T::Error>> {
```

Replacement in libpijul/src/apply.rs at line 947 [17.944089]

B:BD[17.974537] → [17.974537:974632]

    crate::missing_context::repair_parents_of_deleted(txn, channel, &mut ws.missing_context)?;

[17.974537]

[17.974632]

    crate::missing_context::repair_parents_of_deleted(txn, channel, &mut ws.missing_context)
        .map_err(LocalApplyError::from_missing)?;

Replacement in libpijul/src/apply.rs at line 971 [17.944089]

B:BD[17.975617] → [17.975617:975644]

)?

[17.975617]

[17.975644]

                        )
                        .map_err(LocalApplyError::from_missing)?

Replacement in libpijul/src/apply.rs at line 996 [17.944089]

B:BD[17.976780] → [17.976780:976811]

)?

[17.976780]

[17.976811]

                            )
                            .map_err(LocalApplyError::from_missing)?

Replacement in libpijul/src/apply.rs at line 1016 [17.944089]

B:BD[17.977570] → [17.977570:977597]

)?

[17.977570]

[17.977597]

                        )
                        .map_err(LocalApplyError::from_missing)?

Replacement in libpijul/src/apply.rs at line 1036 [17.944089]

B:BD[23.7639] → [23.7639:7662]

)?

[23.7639]

[17.978338]

                    )
                    .map_err(LocalApplyError::from_missing)?

Replacement in libpijul/src/apply.rs at line 1042 [17.944089]

B:BD[17.978406] → [17.978406:978495]

    crate::missing_context::delete_pseudo_edges(txn, channel, &mut ws.missing_context)?;

[17.978406]

[17.978495]

    crate::missing_context::delete_pseudo_edges(txn, channel, &mut ws.missing_context)
        .map_err(LocalApplyError::from_missing)?;

Replacement in libpijul/src/apply.rs at line 1054 [17.944089]
B:BD[17.978783] → [17.978783:978816]
```
) -> Result<(), anyhow::Error> {
```
[17.978783]
[17.978816]
```
) -> Result<(), LocalApplyError<T::Error>> {
```
Replacement in libpijul/src/apply.rs at line 1076 [17.944089]
B:BD[17.979642] → [17.979642:979675]
```
) -> Result<(), anyhow::Error> {
```
[17.979642]
[17.979675]
```
) -> Result<(), LocalApplyError<T::Error>> {
```

Replacement in libpijul/src/apply.rs at line 1087 [17.944089]

B:BD[17.979933] → [17.979933:979998]

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

[17.979933]

[17.979998]

            return Err((crate::pristine::InconsistentChange {}).into());

Replacement in libpijul/src/apply.rs at line 1112 [17.944089]
B:BD[17.980783] → [17.980783:980795]
```
        )?;
```
[17.980783]
[17.980795]
```
        )
        .map_err(LocalApplyError::Txn)?;
```
Replacement in libpijul/src/apply.rs at line 1123 [17.944089]
B:BD[17.980926] → [17.980926:980960]
```
) -> Result<bool, crate::Error> {
```
[17.980926]
[17.980960]
```
) -> Result<bool, LocalApplyError<T::Error>> {
```
Replacement in libpijul/src/alive/retrieve.rs at line 113 [17.984582]
B:BD[17.987781] → [17.987781:987814]
```
) -> Result<(), anyhow::Error> {
```
[17.987781]
[17.987814]
```
) -> Result<(), T::Error> {
```
Deletion in libpijul/src/alive/output.rs at line 1 [17.988425]
B:BD[17.988425] → [17.988426:988481]
```
// org id rugGQSda+7h3fgWnFg5o6rrh0FxPthevqf1C7yFpDXo=
```
Insertion in libpijul/src/alive/output.rs at line 4 [17.988425]
[17.988592]
[17.988592]
```
use crate::output::FileError;
```
Replacement in libpijul/src/alive/output.rs at line 8 [17.988425]
B:BD[17.988685] → [17.988685:988740]
```
// org id 83qmEYXouVuMdaYiRx+rqfb1HtaYFvovt7XmeQIpuuI=
```
[17.988685]
[17.988740]
Insertion in libpijul/src/alive/output.rs at line 15 [17.988425]
[17.988843]
[17.988843]
Replacement in libpijul/src/alive/output.rs at line 24 [17.988425]
B:BD[17.989052] → [17.989052:989085]
```
) -> Result<(), anyhow::Error> {
```
[17.989052]
[17.989085]
```
) -> Result<(), FileError<P::Error>> {
```
Deletion in libpijul/src/alive/output.rs at line 32 [17.988425]
B:BD[17.989290] → [17.989290:989353]
```
        // org id OQlVwkimOiJb/Ruz+/oEO0Pz1khIxRkvwN+/W8om9Nc=
```
Deletion in libpijul/src/alive/output.rs at line 34 [17.988425]
B:BD[17.989451] → [17.989451:989518]
```
            // org id roGnEVojWYAOJ0zF3ObAAA8Kuqfjs3on9NNRV0mgRIc=
```
Replacement in libpijul/src/alive/output.rs at line 50 [17.988425]
B:BD[17.990056] → [17.990056:990119]
```
        // org id GmZmOnTyQotgknRlrewBJc6+O1mQfhuF2lNOYlgkys4=
```
[17.990056]
[17.990119]
Replacement in libpijul/src/alive/output.rs at line 77 [17.988425]
B:BD[17.991141] → [17.991141:991204]
```
        // org id TAF52f6cZFJyHIBx5wfYk6RR2l7NG8tOHboIyrGFakc=
```
[17.991141]
[17.991204]
Replacement in libpijul/src/alive/output.rs at line 89 [17.988425]
B:BD[17.991435] → [17.991435:991490]
```
// org id U/M8FDWU06DAEBXf7bvPvuN33e6GPJLmgvUK84CFuJg=
```
[17.991435]
[17.991490]
Replacement in libpijul/src/alive/output.rs at line 131 [17.988425]
B:BD[17.992880] → [17.992880:992935]
```
// org id 4fCwUx872WHp3z4W0/WwwMhX1cFRa2iPigNaXNpaEpA=
```
[17.992880]
[17.992935]
Replacement in libpijul/src/alive/output.rs at line 138 [17.988425]
B:BD[17.993081] → [17.993081:993114]
```
) -> Result<(), anyhow::Error> {
```
[17.993081]
[17.993114]
```
) -> Result<(), FileError<P::Error>> {
```
Replacement in libpijul/src/alive/output.rs at line 140 [17.988425]
B:BD[17.993137] → [17.993137:993175]
```
        vbuf.begin_cyclic_conflict()?
```
[17.993137]
[17.993175]
```
        vbuf.begin_cyclic_conflict()?;
```
Deletion in libpijul/src/alive/output.rs at line 151 [17.988425]
B:BD[17.993466] → [17.993466:993511]
```
        let now = std::time::Instant::now();
```

Replacement in libpijul/src/alive/output.rs at line 152 [17.988425]

B:BD[17.993560] → [17.993560:993652]

            changes.get_contents(|p| txn.get_external(p), vertex, buf)?;
            Ok(())

[17.993560]

[17.993652]

            let now = std::time::Instant::now();
            let result = changes
                .get_contents(|p| txn.get_external(p), vertex, buf)
                .map(|_| ())
                .map_err(FileError::Changestore);
            crate::TIMERS.lock().unwrap().alive_contents += now.elapsed();
            result

Deletion in libpijul/src/alive/output.rs at line 160 [17.988425]
B:BD[17.993663] → [17.993663:993734]
```
        crate::TIMERS.lock().unwrap().alive_contents += now.elapsed();
```
Replacement in libpijul/src/alive/output.rs at line 176 [17.988425]
B:BD[17.994226] → [17.994226:994281]
```
// org id RA5o6M3qAtAD3/CSapAI6tIWd7yWNmsb/uCKXtvMf6c=
```
[17.994226]
[17.994281]
Replacement in libpijul/src/alive/output.rs at line 184 [17.988425]
B:BD[17.994494] → [17.994494:994527]
```
) -> Result<(), anyhow::Error> {
```
[17.994494]
[17.994527]
```
) -> Result<(), crate::output::FileError<P::Error>> {
```
Deletion in libpijul/src/alive/mod.rs at line 1 [17.995164]
B:BD[17.995164] → [17.995165:995220]
```
// org id ae+cN7ii/nf6mJV7ygVX+QzaT1iUIKfCuf/x9VMpjjQ=
```
Replacement in libpijul/src/alive/mod.rs at line 10 [17.995164]
B:BD[17.995384] → [17.995384:995439]
```
// org id ccK061RVWq8mU8p92w938EIRcX5xf53Y/5klJaCYV5c=
```
[17.995384]
[17.995439]
Replacement in libpijul/src/alive/mod.rs at line 29 [17.995164]
B:BD[17.995775] → [17.995775:995830]
```
// org id vnQ9DifkEHpAgUd3zjGq5N9u+oBkZGdVua6BJxF9jTg=
```
[17.995775]
[17.995830]
Replacement in libpijul/src/alive/mod.rs at line 75 [17.995164]
B:BD[17.996870] → [17.996870:996925]
```
// org id SzNAy0qgvhYjwiibrE05FzjomcwRYrc00kLuPE6TWsA=
```
[17.996870]
[17.996925]
Replacement in libpijul/src/alive/mod.rs at line 86 [17.995164]
B:BD[17.997255] → [17.997255:997310]
```
// org id IhdHg3+NO19nL+0XTy56j0KXgReFfEe/3TjQW3vU47s=
```
[17.997255]
[17.997310]
Deletion in libpijul/src/alive/mod.rs at line 128 [17.995164]
B:BD[17.998481] → [17.998481:998536]
```
// org id YjNtUksz6F4FDjsnoWIdFtsnyqrhhwGB81kMPoQh1y0=
```
Deletion in libpijul/src/alive/dfs.rs at line 1 [17.1000429]
B:BD[17.1000429] → [17.1000430:1000485]
```
// org id FN4X/UQj4sOrdr1L/34stLjMnN7aRX6dGB8ovnXm4g4=
```
Replacement in libpijul/src/alive/dfs.rs at line 5 [17.1000429]
B:BD[17.1000599] → [17.1000599:1000654]
```
// org id a6g8r8xMc72herurxBoGK09TlqlNFesqMxOlGye7+wU=
```
[17.1000599]
[17.1000654]
Replacement in libpijul/src/alive/dfs.rs at line 28 [17.1000429]
B:BD[17.1001042] → [17.1001042:1001097]
```
// org id Evvo1XwskiRIPyqRTa8pr3UJx6bL0a0ky0UqCjDbj7k=
```
[17.1001042]
[17.1001097]
Replacement in libpijul/src/alive/dfs.rs at line 48 [17.1000429]
B:BD[17.1001397] → [17.1001397:1001452]
```
// org id rs9ua+JLr5uzyFxLi79zXVVGmVsbPAbn4+J7Pz+itfQ=
```
[17.1001397]
[17.1001452]
Deletion in libpijul/src/alive/dfs.rs at line 52 [17.1000429]
B:BD[17.1001502] → [17.1001502:1001561]
```
    // org id 1jLjvnQC+CzGcbSN/yGdM+O7tiu5ytCDkvQ7ddM/K8s=
```
Deletion in libpijul/src/alive/dfs.rs at line 53 [17.1000429]
B:BD[17.1001602] → [17.1001602:1001661]
```
    // org id ops5Ku702mQyuAsCratzGLyafN90+9XdMoqHYonqqiY=
```
Deletion in libpijul/src/alive/dfs.rs at line 54 [17.1000429]
B:BD[17.1001685] → [17.1001685:1001744]
```
    // org id I6sttXHyuv42p25LtpQ6rm+GHXz6XX3RSkXdPtw++rs=
```
Deletion in libpijul/src/alive/dfs.rs at line 55 [17.1000429]
B:BD[17.1001773] → [17.1001773:1001832]
```
    // org id tLdXR6Nj0fAJXI2MuYhja197v7oPjfGj5UsZwSsPFfc=
```
Replacement in libpijul/src/alive/dfs.rs at line 57 [17.1000429]
B:BD[17.1001864] → [17.1001864:1001919]
```
// org id ZKZCQZOOiAuzQ2hplUivR12avMGPrw2HbcBPp1dM96U=
```
[17.1001864]
[17.1001919]
Deletion in libpijul/src/alive/dfs.rs at line 148 [17.1000429]
B:BD[17.1004414] → [17.1004414:1004477]
```
        // org id fTBj4yfBA4uziK5nATQHePJ03VSVY5lNtqx3jpU4djc=
```
Deletion in libpijul/src/alive/dfs.rs at line 156 [17.1000429]
B:BD[17.1004833] → [17.1004833:1004900]
```
            // org id GWpsS0aAAfDTvTAz0PS0OxCQeAXMwg/YHlEzPlHN6OA=
```
Deletion in libpijul/src/alive/dfs.rs at line 185 [17.1000429]
B:BD[17.1006337] → [17.1006337:1006404]
```
            // org id +IS4jNPNEDK5HDBm4U7DLoNFfhwvHzn40JAm4tKnBHk=
```
Deletion in libpijul/src/alive/dfs.rs at line 199 [17.1000429]
B:BD[17.1006964] → [17.1006964:1007027]
```
        // org id FHiJPM0yAi0g9oxzzog93HBlJMVO+zkyPcyOIqCcvwI=
```
Replacement in libpijul/src/alive/dfs.rs at line 202 [17.1000429]
B:BD[17.1007094] → [17.1007094:1007149]
```
// org id iFf2gT1lTCyh5S5G9chCOQSV/yv6LUhW94o0G2+xy8s=
```
[17.1007094]
[17.1007149]
Deletion in libpijul/src/alive/dfs.rs at line 210 [17.1000429]
B:BD[17.1007315] → [17.1007315:1007374]
```
    // org id +ptaxUWOVF6qdFxwHAnI2hr3kJfCBRh7am0SWZ+zdOg=
```
Deletion in libpijul/src/alive/dfs.rs at line 213 [17.1000429]
B:BD[17.1007495] → [17.1007495:1007554]
```
    // org id gf22ooM9FpFRowUF1cPE6ISPMkymBIWZOjPS3Y1ktgQ=
```
Deletion in libpijul/src/alive/dfs.rs at line 218 [17.1000429]
B:BD[17.1007703] → [17.1007703:1007762]
```
    // org id I/pQaV+bTryz+byZO/sdFhxqPD1EYTVf6PbC+JNJFTM=
```

Deletion in libpijul/src/alive/dfs.rs at line 225 [17.1000429]

B:BD[17.1008050] → [17.1008050:1008181]

                // let mut f = std::fs::File::create("debug_alive").unwrap();
                // graph.debug_raw(&mut f).unwrap();

Deletion in libpijul/src/alive/dfs.rs at line 238 [17.1000429]
B:BD[17.1008690] → [17.1008690:1008749]
```
    // org id tppibf8fu/NgBP2gA4yEeGMCsZjARmQ3FsU1mfY8/VY=
```
Replacement in libpijul/src/alive/dfs.rs at line 246 [17.1000429]
B:BD[17.1008973] → [17.1008973:1009028]
```
// org id PAb27lKMvw3ODopZ9ed0R1+VLBapBvGicfts0Qfgoyk=
```
[17.1008973]
[17.1009028]
Replacement in libpijul/src/alive/dfs.rs at line 263 [17.1000429]
B:BD[17.1009549] → [17.1009549:1009604]
```
// org id +EtEUqu55ysMiPbQtSxlpzsP1Ghbgr/qJg/w1dYu0Tw=
```
[17.1009549]
[17.1009604]
Deletion in libpijul/src/alive/dfs.rs at line 273 [17.1000429]
B:BD[17.1009932] → [17.1009932:1009991]
```
    // org id UnhSWIMI7GsPiN8g1SS8LsKzx++g5mrRn7+M1c+VfV4=
```
Deletion in libpijul/src/alive/dfs.rs at line 274 [17.1000429]
B:BD[17.1010050] → [17.1010050:1010109]
```
    // org id Bd49Fx5qUr95VSDjZvf4LiwAmliSU/tlBb1NId/a1H8=
```
Deletion in libpijul/src/alive/dfs.rs at line 280 [17.1000429]
B:BD[17.1010253] → [17.1010253:1010312]
```
    // org id Kh9EOwJWoqxbWMdM/TBylYAtuhQKoDTzX9am56rGfAU=
```
Deletion in libpijul/src/alive/dfs.rs at line 283 [17.1000429]
B:BD[17.1010446] → [17.1010446:1010509]
```
        // org id eDtZjLZ89YmK+LQZwf0JXAHwC8hahJ+UmZGJJY9FPyw=
```
Deletion in libpijul/src/alive/dfs.rs at line 293 [17.1000429]
B:BD[17.1010778] → [17.1010778:1010841]
```
        // org id X+Vkv6E9j5wcfbqV6wd0zJcU5h4pk/xoB0fNy+jTt1w=
```
Deletion in libpijul/src/alive/dfs.rs at line 300 [17.1000429]
B:BD[17.1011077] → [17.1011077:1011140]
```
        // org id Jzso6NctQ7yQrJvt+kp4n6+R+C/j21VYuljDPYbovE0=
```
Deletion in libpijul/src/alive/dfs.rs at line 302 [17.1000429]
B:BD[17.1011221] → [17.1011221:1011280]
```
    // org id XJWvAQc9UuYzztlyavXZtb9f5v+8Q3s9dKVWBgc9Cnc=
```
Replacement in libpijul/src/alive/dfs.rs at line 315 [17.1000429]
B:BD[17.1011573] → [17.1011573:1011628]
```
// org id 99XChhgQdUuM9P0XMZXaiLSvZkshZYwisljAQKwv5ZA=
```
[17.1011573]
[17.1011628]
Deletion in libpijul/src/alive/dfs.rs at line 327 [17.1000429]
B:BD[17.1012008] → [17.1012008:1012067]
```
    // org id t4p2vXw81IHi1A61czKB1ySau+YllpLXCs+03dU030Q=
```
Deletion in libpijul/src/alive/dfs.rs at line 330 [17.1000429]
B:BD[17.1012236] → [17.1012236:1012295]
```
    // org id XkcQPnFnid03vRjpdNnv8fkp8TtbYYOh0VE3JOtW6xw=
```
Deletion in libpijul/src/alive/dfs.rs at line 345 [17.1000429]
B:BD[17.1012726] → [17.1012726:1012785]
```
    // org id qQ8ru9vhgn8xaCAW63XcBxFqrHy0K6dYJZQWCeoXNMA=
```
Replacement in libpijul/src/alive/dfs.rs at line 357 [17.1000429]
B:BD[17.1013072] → [17.1013072:1013127]
```
// org id LsKadSAjaUm19infXAsCqtTnGC1RMQq6d6h3WfZwioo=
```
[17.1013072]
[17.1013127]

Deletion in libpijul/src/alive/dfs.rs at line 374 [17.1000429]

B:BD[17.1013695] → [17.1013695:1013774]

                        // org id duMgQ0jpJDLTmJMPqpgkKy6QBJyDJpNZzOsgqHhs/EI=

Deletion in libpijul/src/alive/debug.rs at line 1 [17.1014531]
B:BD[17.1014531] → [17.1014532:1014587]
```
// org id rTQeEfoXKaEkHQXFyQtWhOFf2crR1lhKU0pRUjLxfb0=
```
Replacement in libpijul/src/alive/debug.rs at line 18 [17.1014531]
B:BD[17.1015080] → [17.1015080:1015117]
```
    ) -> Result<(), anyhow::Error> {
```
[17.1015080]
[17.1015117]
```
    ) -> Result<(), std::io::Error> {
```

Replacement in libpijul/src/alive/debug.rs at line 35 [17.1014531]

B:BD[17.1015654] → [17.1015654:1015737]

            changes.get_contents(|h| txn.get_external(h), line.vertex, &mut buf)?;

[17.1015654]

[17.1015737]

            changes
                .get_contents(|h| txn.get_external(h), line.vertex, &mut buf)
                .unwrap();

Replacement in libpijul/src/alive/debug.rs at line 136 [17.1014531]

B:BD[17.1019545] → [17.1019545:1019624]

    pub fn debug_raw<W: Write>(&self, mut w: W) -> Result<(), anyhow::Error> {

[17.1019545]

[17.1019624]

    pub fn debug_raw<W: Write>(&self, mut w: W) -> Result<(), std::io::Error> {

Deletion in libpijul/Cargo.toml at line 99 [17.1020742]
B:BD[17.1023083] → [17.1023083:1023098]
```
anyhow = "1.0"
```
Deletion in Cargo.lock at line 968 [17.1030385]
B:BD[38.746] → [38.746:757]
```
 "anyhow",
```