mx00s/pijul - Change C267PHOH3QJBSBEWQB3J7PPOOXIUKM3DIIZIPLHPU4D5OXRCGLZAC

Tags: dropping useless Hashes in favour of Merkles

Created by pmeunier on December 17, 2021

C267PHOH3QJBSBEWQB3J7PPOOXIUKM3DIIZIPLHPU4D5OXRCGLZAC

Dependencies

In channels

main

Change contents

Replacement in pijul/src/commands/tag.rs at line 97 [4.74]

B:BD[4.2499] → [5.2762:2924]

                if txn
                    .read()
                    .get_tags(&channel.read().tags, &last_t)?
                    .is_some()
                {

[4.2499]

[4.2576]

                if txn.read().is_tagged(&channel.read().tags, last_t)? {

Replacement in pijul/src/commands/tag.rs at line 108 [4.74]

B:BD[4.3053] → [5.2925:3025]

∅:D[5.3025] → [4.3145:3230]

B:BD[4.3145] → [4.3145:3230]

B:BD[4.3230] → [3.102:149]

                let h = libpijul::tag::from_channel(&*txn.read(), &channel_name, &header, &mut w)?;
                libpijul::changestore::filesystem::push_filename(&mut tag_path, &h);
                tag_path.set_extension("tag");

[4.3053]

[4.3230]

                let h: libpijul::Merkle =
                    libpijul::tag::from_channel(&*txn.read(), &channel_name, &header, &mut w)?;
                libpijul::changestore::filesystem::push_tag_filename(&mut tag_path, &h);

Replacement in pijul/src/commands/tag.rs at line 114 [4.74]

B:BD[4.3358] → [5.3026:3128]

                txn.write()
                    .put_tags(&mut *channel.write(), last_t.into(), &h)?;

[4.3358]

[4.3432]

                txn.write().put_tags(&mut *channel.write(), last_t.into())?;

Replacement in pijul/src/commands/tag.rs at line 125 [4.74]

∅:D[6.157] → [4.3591:3678]

∅:D[3.211] → [4.3591:3678]

∅:D[7.222] → [4.3591:3678]

B:BD[4.3591] → [4.3591:3678]

B:BD[4.3678] → [7.223:312]

B:BD[7.312] → [3.212:263]

                let h = if let Some(h) = libpijul::Hash::from_base32(tag.as_bytes()) {
                    libpijul::changestore::filesystem::push_filename(&mut tag_path, &h);
                    tag_path.set_extension("tag");

[3.211]

[4.3678]

                let h = if let Some(h) = libpijul::Merkle::from_base32(tag.as_bytes()) {
                    libpijul::changestore::filesystem::push_tag_filename(&mut tag_path, &h);

Replacement in pijul/src/commands/tag.rs at line 142 [4.74]

B:BD[4.4198] → [3.264:368]

                let mut f = libpijul::tag::OpenTagFile::open(&tag_path)?;
                f.check(&h)?;

[4.4198]

[4.4457]

                let f = libpijul::tag::OpenTagFile::open(&tag_path, &h)?;

Replacement in pijul/src/commands/tag.rs at line 150 [4.74]

∅:D[3.430] → [8.5830:6006]

B:BD[8.5830] → [8.5830:6006]

B:BD[8.6006] → [3.431:482]

                let h = if let Some(h) = libpijul::Hash::from_base32(tag.as_bytes()) {
                    libpijul::changestore::filesystem::push_filename(&mut tag_path, &h);
                    tag_path.set_extension("tag");

[3.430]

[8.6006]

                let h = if let Some(h) = libpijul::Merkle::from_base32(tag.as_bytes()) {
                    libpijul::changestore::filesystem::push_tag_filename(&mut tag_path, &h);

Replacement in pijul/src/commands/tag.rs at line 196 [4.74]

∅:D[5.3209] → [6.930:1110]

B:BD[6.930] → [6.930:1110]

B:BD[6.1110] → [3.621:672]

∅:D[3.672] → [6.1110:1188]

B:BD[6.1110] → [6.1110:1188]

                    let (_, h) = t?;
                    let h: libpijul::Hash = h.into();
                    libpijul::changestore::filesystem::push_filename(&mut tag_path, &h);
                    tag_path.set_extension("tag");
                    let mut f = libpijul::tag::OpenTagFile::open(&tag_path)?;

[5.3209]

[6.1188]

                    let t = (*t?).into();
                    let (_, m) = txn.get_changes(&channel, t)?.unwrap();
                    libpijul::changestore::filesystem::push_tag_filename(&mut tag_path, &m);
                    let mut f = libpijul::tag::OpenTagFile::open(&tag_path, &m)?;

Replacement in pijul/src/commands/tag.rs at line 201 [4.74]

B:BD[6.1234] → [6.1234:1298]

                    writeln!(stdout, "Tag {}", h.to_base32())?;

[6.1234]

[6.1298]

                    writeln!(stdout, "State {}", m.to_base32())?;

Deletion in pijul/src/commands/tag.rs at line 204 [4.74]

B:BD[6.1438] → [6.1438:1513]

                    writeln!(stdout, "State: {}", f.state().to_base32())?;

Replacement in pijul/src/commands/mod.rs at line 267 [10.133619]

B:BD[9.69] → [9.69:194]

fn find_hash(path: &mut std::path::PathBuf, hash: &str) -> Result<libpijul::Hash, anyhow::Error> {
    use libpijul::Base32;

[9.69]

[9.194]

fn find_hash<B: libpijul::Base32>(
    path: &mut std::path::PathBuf,
    hash: &str,
) -> Result<B, anyhow::Error> {

Replacement in pijul/src/commands/mod.rs at line 298 [10.133619]

B:BD[9.912] → [9.912:981]

        if let Some(h) = libpijul::Hash::from_base32(f.as_bytes()) {

[9.912]

[9.981]

        if let Some(h) = B::from_base32(f.as_bytes()) {

Replacement in libpijul/src/tag.rs at line 60 [4.6397]

B:BD[4.7538] → [3.673:805]

    #[error("Wrong hash, expected {}, got {}", expected.to_base32(), got.to_base32())]
    WrongHash { expected: Hash, got: Hash },

[4.7538]

    #[error("Wrong state, expected {}, got {}", expected.to_base32(), got.to_base32())]
    WrongHash { expected: Merkle, got: Merkle },

Replacement in libpijul/src/tag.rs at line 77 [4.6397]

B:BD[4.7694] → [4.7694:7760]

    pub fn open<P: AsRef<Path>>(p: P) -> Result<Self, TagError> {

[4.7694]

[4.7760]

    pub fn open<P: AsRef<Path>>(p: P, expected: &Merkle) -> Result<Self, TagError> {

Replacement in libpijul/src/tag.rs at line 81 [4.6397]

B:BD[4.7917] → [11.140:219]

∅:D[11.219] → [4.7967:8008]

B:BD[4.7967] → [4.7967:8008]

        let header = bincode::deserialize(&off).map_err(TagError::BincodeDe)?;
        Ok(OpenTagFile { header, file })

[4.7917]

[6.1662]

        let header: FileHeader = bincode::deserialize(&off).map_err(TagError::BincodeDe)?;
        if &header.state == expected {
            Ok(OpenTagFile { header, file })
        } else {
            Err(TagError::WrongHash {
                expected: *expected,
                got: header.state,
            })
        }

Deletion in libpijul/src/tag.rs at line 99 [4.6397]

B:BD[6.1977] → [6.1977:1983]

B:BD[6.1983] → [3.806:1736]

    }
    pub fn check(&mut self, expected: &Hash) -> Result<(), TagError> {
        let mut hasher = Hasher::default();
        self.file.seek(SeekFrom::Start(0))?;
        let mut buf = Vec::new();
        // Reading the FileHeader
        buf.resize(self.header.header as usize, 0);
        self.file.read_exact(&mut buf)?;
        hasher.update(&buf);
        // Reading the Header
        buf.resize((self.header.channel - self.header.header) as usize, 0);
        self.file.read_exact(&mut buf)?;
        hasher.update(&buf);
        // Reading the Header
        buf.resize((self.header.unhashed - self.header.channel) as usize, 0);
        self.file.read_exact(&mut buf)?;
        hasher.update(&buf);
        let got = hasher.finish();
        if &got != expected {
            Err(TagError::WrongHash {
                expected: *expected,
                got,
            })
        } else {
            Ok(())
        }

Replacement in libpijul/src/tag.rs at line 227 [4.6397]

B:BD[4.12064] → [4.12064:12122]

        |_, _, k: &L64, v: &SerializedHash| Ok((*k, *v)),

[4.12064]

[4.12122]

        |_, _, k: &L64, v: &()| Ok((*k, *v)),

Replacement in libpijul/src/tag.rs at line 351 [4.6397]
B:BD[4.15209] → [4.15209:15239]
```
) -> Result<Hash, TagError> {
```
[4.15209]
[4.15239]
```
) -> Result<Merkle, TagError> {
```
Replacement in libpijul/src/tag.rs at line 366 [4.6397]
B:BD[4.15714] → [4.15714:15729]
```
        state,
```
[4.15714]
[4.15729]
```
        state: state.clone(),
```
Replacement in libpijul/src/tag.rs at line 372 [4.6397]
B:BD[4.15923] → [4.15923:15963]
```
    let mut hasher = Hasher::default();
```
[4.15923]
[4.15963]
Deletion in libpijul/src/tag.rs at line 377 [4.6397]
B:BD[4.16149] → [4.16149:16178]
```
    hasher.update(&off_buf);
```
Deletion in libpijul/src/tag.rs at line 379 [4.6397]
B:BD[4.16260] → [4.16260:16292]
```
    hasher.update(&header_buf);
```
Replacement in libpijul/src/tag.rs at line 381 [4.6397]
B:BD[4.16353] → [4.16353:16402]
```
    hasher.update(&out);
    Ok(hasher.finish())
```
[4.16353]
[4.16402]
```
    Ok(state)
```

Replacement in libpijul/src/tag/txn.rs at line 53 [12.48]

B:BD[12.1336] → [2.142:228]

    pub fn new<P: AsRef<std::path::Path>>(p: P, h: &Hash) -> Result<Self, TagError> {

[12.1336]

[12.1412]

    pub fn new<P: AsRef<std::path::Path>>(p: P, expected: &Merkle) -> Result<Self, TagError> {

Insertion in libpijul/src/tag/txn.rs at line 58 [12.48]

[2.332]

        if &header.state != expected {
            return Err(TagError::WrongHash {
                expected: *expected,
                got: header.state,
            })
        }

Deletion in libpijul/src/tag/txn.rs at line 68 [12.48]
B:BD[2.415] → [2.415:437]
```
        ch.check(h)?;
```

Replacement in libpijul/src/tag/txn.rs at line 405 [12.48]

B:BD[12.12692] → [12.12692:13093]

    fn get_tags(
        &self,
        channel: &Self::Tags,
        c: &L64,
    ) -> Result<Option<&SerializedHash>, TxnErr<Self::GraphError>> {
        use crate::pristine::sanakirja::UDb;
        let db: UDb<L64, SerializedHash> = UDb::from_page(*channel);
        match ::sanakirja::btree::get(self, &db, c, None)? {
            Some((k, v)) if k == c => Ok(Some(v)),
            _ => Ok(None),

[12.12692]

[12.13093]

    type TagsCursor =
        ::sanakirja::btree::cursor::Cursor<L64, (), P<L64, ()>>;
    fn is_tagged(&self, tags: &Self::Tags, t: u64) -> Result<bool, TxnErr<Self::GraphError>> {
        use crate::pristine::sanakirja::Db;
        let db: Db<L64, ()> = Db::from_page(*tags);
        let t: L64 = t.into();
        match ::sanakirja::btree::get(self, &db, &t, None)? {
            Some((k, _)) => Ok(k == &t),
            _ => Ok(false)

Deletion in libpijul/src/tag/txn.rs at line 418 [12.48]

B:BD[12.13110] → [12.13110:13222]

    type TagsCursor =
        ::sanakirja::btree::cursor::Cursor<L64, SerializedHash, UP<L64, SerializedHash>>;

Replacement in libpijul/src/tag/txn.rs at line 423 [12.48]

B:BD[12.13339] → [12.13339:13429]

        crate::pristine::Cursor<Self, &'txn Self, Self::TagsCursor, L64, SerializedHash>,

[12.13339]

[12.13429]

        crate::pristine::Cursor<Self, &'txn Self, Self::TagsCursor, L64, ()>,

Replacement in libpijul/src/tag/txn.rs at line 426 [12.48]

B:BD[12.13471] → [12.13471:13585]

        use crate::pristine::sanakirja::UDb;
        let db: UDb<L64, SerializedHash> = UDb::from_page(*channel);

[12.13471]

[12.13585]

        use crate::pristine::sanakirja::Db;
        let db: Db<L64, ()> = Db::from_page(*channel);

Replacement in libpijul/src/tag/txn.rs at line 443 [12.48]

B:BD[12.14025] → [12.14025:14102]

    ) -> Result<Option<(&L64, &SerializedHash)>, TxnErr<Self::GraphError>> {

[12.14025]

[12.14102]

    ) -> Result<Option<&L64>, TxnErr<Self::GraphError>> {

Replacement in libpijul/src/tag/txn.rs at line 445 [12.48]
B:BD[12.14145] → [12.14145:14163]
```
            Ok(x)
```
[12.14145]
[12.14163]
```
            Ok(x.map(|(a, _)| a))
```

Replacement in libpijul/src/tag/txn.rs at line 454 [12.48]

B:BD[12.14340] → [12.14340:14417]

    ) -> Result<Option<(&L64, &SerializedHash)>, TxnErr<Self::GraphError>> {

[12.14340]

[12.14417]

    ) -> Result<Option<&L64>, TxnErr<Self::GraphError>> {

Replacement in libpijul/src/tag/txn.rs at line 456 [12.48]
B:BD[12.14460] → [12.14460:14478]
```
            Ok(x)
```
[12.14460]
[12.14478]
```
            Ok(x.map(|(a, _)| a))
```

Replacement in libpijul/src/tag/txn.rs at line 467 [12.48]

B:BD[12.14675] → [12.14675:14760]

        crate::pristine::Cursor<Self, &Self, Self::TagsCursor, L64, SerializedHash>,

[12.14675]

[12.14760]

        crate::pristine::Cursor<Self, &Self, Self::TagsCursor, L64, ()>,

Replacement in libpijul/src/tag/txn.rs at line 478 [12.48]

B:BD[12.14973] → [12.14973:15061]

        crate::pristine::RevCursor<Self, &Self, Self::TagsCursor, L64, SerializedHash>,

[12.14973]

[12.15061]

        crate::pristine::RevCursor<Self, &Self, Self::TagsCursor, L64, ()>,

Replacement in libpijul/src/tag/txn.rs at line 481 [12.48]

B:BD[12.15103] → [12.15103:15217]

        use crate::pristine::sanakirja::UDb;
        let db: UDb<L64, SerializedHash> = UDb::from_page(*channel);

[12.15103]

[12.15217]

        use crate::pristine::sanakirja::Db;
        let db: Db<L64, ()> = Db::from_page(*channel);

Insertion in libpijul/src/tag/txn.rs at line 640 [12.48]

[12.19490]

    fn is_tagged(&self, tags: &Self::Tags, t: u64) -> Result<bool, TxnErr<Self::GraphError>> {
        self.tag.is_tagged(tags, t)
    }

Deletion in libpijul/src/tag/txn.rs at line 746 [12.48]

B:BD[12.22648] → [12.22648:22841]

    fn get_tags(
        &self,
        channel: &Self::Tags,
        c: &L64,
    ) -> Result<Option<&SerializedHash>, TxnErr<Self::GraphError>> {
        self.tag.get_tags(channel, c)
    }

Replacement in libpijul/src/tag/txn.rs at line 752 [12.48]

B:BD[12.23017] → [12.23017:23107]

        crate::pristine::Cursor<Self, &'txn Self, Self::TagsCursor, L64, SerializedHash>,

[12.23017]

[12.23107]

        crate::pristine::Cursor<Self, &'txn Self, Self::TagsCursor, L64, ()>,

Replacement in libpijul/src/tag/txn.rs at line 760 [12.48]

B:BD[12.23298] → [12.23298:23375]

    ) -> Result<Option<(&L64, &SerializedHash)>, TxnErr<Self::GraphError>> {

[12.23298]

[12.23375]

    ) -> Result<Option<&L64>, TxnErr<Self::GraphError>> {

Replacement in libpijul/src/tag/txn.rs at line 767 [12.48]

B:BD[12.23503] → [12.23503:23580]

    ) -> Result<Option<(&L64, &SerializedHash)>, TxnErr<Self::GraphError>> {

[12.23503]

[12.23580]

    ) -> Result<Option<&L64>, TxnErr<Self::GraphError>> {

Replacement in libpijul/src/tag/txn.rs at line 776 [12.48]

B:BD[12.23728] → [12.23728:23813]

        crate::pristine::Cursor<Self, &Self, Self::TagsCursor, L64, SerializedHash>,

[12.23728]

[12.23813]

        crate::pristine::Cursor<Self, &Self, Self::TagsCursor, L64, ()>,

Replacement in libpijul/src/tag/txn.rs at line 787 [12.48]

B:BD[12.24038] → [12.24038:24126]

        crate::pristine::RevCursor<Self, &Self, Self::TagsCursor, L64, SerializedHash>,

[12.24038]

[12.24126]

        crate::pristine::RevCursor<Self, &Self, Self::TagsCursor, L64, ()>,

Replacement in libpijul/src/pristine/sanakirja.rs at line 726 [10.531056]
B:BD[13.70500] → [4.23047:23087]
```
    pub tags: UDb<L64, SerializedHash>,
```
[13.70500]
[14.39127]
```
    pub tags: Db<L64, ()>,
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 926 [10.531056]

B:BD[4.23105] → [4.23105:23430]

    type Tags = UDb<L64, SerializedHash>;
    fn get_tags(
        &self,
        channel: &Self::Tags,
        c: &L64,
    ) -> Result<Option<&SerializedHash>, TxnErr<Self::GraphError>> {
        match btree::get(&self.txn, channel, c, None)? {
            Some((k, v)) if k == c => Ok(Some(v)),
            _ => Ok(None),

[4.23105]

[4.23430]

    type Tags = Db<L64, ()>;
    fn is_tagged(&self, tags: &Self::Tags, t: u64) -> Result<bool, TxnErr<Self::GraphError>> {
        let t: L64 = t.into();
        match btree::get(&self.txn, tags, &t, None)? {
            Some((k, _)) => Ok(k == &t),
            _ => Ok(false)

Replacement in libpijul/src/pristine/sanakirja.rs at line 937 [10.531056]

B:BD[4.23469] → [4.23469:23559]

        ::sanakirja::btree::cursor::Cursor<L64, SerializedHash, UP<L64, SerializedHash>>;

[4.23469]

[4.23559]

        ::sanakirja::btree::cursor::Cursor<L64, (), P<L64, ()>>;

Replacement in libpijul/src/pristine/sanakirja.rs at line 943 [10.531056]

B:BD[4.23676] → [4.23676:23766]

        crate::pristine::Cursor<Self, &'txn Self, Self::TagsCursor, L64, SerializedHash>,

[4.23676]

[4.23766]

        crate::pristine::Cursor<Self, &'txn Self, Self::TagsCursor, L64, ()>,

Replacement in libpijul/src/pristine/sanakirja.rs at line 961 [10.531056]

B:BD[4.24249] → [4.24249:24326]

    ) -> Result<Option<(&L64, &SerializedHash)>, TxnErr<Self::GraphError>> {

[4.24249]

[4.24326]

    ) -> Result<Option<&L64>, TxnErr<Self::GraphError>> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 963 [10.531056]
B:BD[4.24374] → [4.24374:24392]
```
            Ok(x)
```
[4.24374]
[4.24392]
```
            Ok(x.map(|(a, _)| a))
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 972 [10.531056]

B:BD[4.24562] → [4.24562:24639]

    ) -> Result<Option<(&L64, &SerializedHash)>, TxnErr<Self::GraphError>> {

[4.24562]

[4.24639]

    ) -> Result<Option<&L64>, TxnErr<Self::GraphError>> {

Replacement in libpijul/src/pristine/sanakirja.rs at line 974 [10.531056]
B:BD[4.24687] → [4.24687:24705]
```
            Ok(x)
```
[4.24687]
[4.24705]
```
            Ok(x.map(|(a, _)| a))
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 985 [10.531056]

B:BD[6.2184] → [6.2184:2259]

        super::Cursor<Self, &Self, Self::TagsCursor, L64, SerializedHash>,

[6.2184]

[6.2259]

        super::Cursor<Self, &Self, Self::TagsCursor, L64, ()>,

Replacement in libpijul/src/pristine/sanakirja.rs at line 996 [10.531056]

B:BD[6.2472] → [6.2472:2550]

        super::RevCursor<Self, &Self, Self::TagsCursor, L64, SerializedHash>,

[6.2472]

[6.2550]

        super::RevCursor<Self, &Self, Self::TagsCursor, L64, ()>,

Replacement in libpijul/src/pristine/sanakirja.rs at line 1174 [10.531056]

B:BD[15.26643] → [15.26643:26702]

                    tags: UDb::from_page(tup.tags.into()),

[15.26643]

[15.26702]

                    tags: Db::from_page(tup.tags.into()),

Deletion in libpijul/src/pristine/sanakirja.rs at line 1731 [10.531056]
B:BD[4.25300] → [4.25300:25318]
```
        h: &Hash,
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1732 [10.531056]

B:BD[4.25366] → [4.25366:25443]

        btree::put(&mut self.txn, &mut channel.tags, &t.into(), &h.into())?;

[4.25366]

[4.25443]

        btree::put(&mut self.txn, &mut channel.tags, &t.into(), &())?;

Replacement in libpijul/src/pristine/sanakirja.rs at line 1838 [10.531056]

B:BD[15.28817] → [15.28817:28882]

                            tags: UDb::from_page(b.tags.into()),

[15.28817]

[15.28882]

                            tags: Db::from_page(b.tags.into()),

Replacement in libpijul/src/pristine/sanakirja.rs at line 1983 [10.531056]

B:BD[15.30119] → [15.30119:30173]

                    UDb::from_page(chan.tags.into()),

[15.30119]

[16.1017]

                    Db::from_page(chan.tags.into()),

Replacement in libpijul/src/pristine/sanakirja.rs at line 2188 [10.531056]

B:BD[15.31856] → [15.31856:31913]

                    tags: UDb::from_page(c.tags.into()),

[15.31856]

[15.31913]

                    tags: Db::from_page(c.tags.into()),

Replacement in libpijul/src/pristine/mod.rs at line 451 [10.586748]

B:BD[4.26541] → [4.26541:26688]

    fn get_tags(
        &self,
        channel: &Self::Tags,
        c: &L64,
    ) -> Result<Option<&SerializedHash>, TxnErr<Self::GraphError>>;

[4.26541]

[4.26688]

    fn is_tagged(&self, tags: &Self::Tags, t: u64) -> Result<bool, TxnErr<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 459 [10.586748]

B:BD[4.26829] → [4.26829:26919]

        crate::pristine::Cursor<Self, &'txn Self, Self::TagsCursor, L64, SerializedHash>,

[4.26829]

[4.26919]

        crate::pristine::Cursor<Self, &'txn Self, Self::TagsCursor, L64, ()>,

Replacement in libpijul/src/pristine/mod.rs at line 466 [10.586748]

B:BD[4.27039] → [4.27039:27115]

    ) -> Result<Option<(&L64, &SerializedHash)>, TxnErr<Self::GraphError>>;

[4.27039]

[4.27115]

    ) -> Result<Option<&L64>, TxnErr<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 471 [10.586748]

B:BD[4.27195] → [4.27195:27271]

    ) -> Result<Option<(&L64, &SerializedHash)>, TxnErr<Self::GraphError>>;

[4.27195]

[6.3106]

    ) -> Result<Option<&L64>, TxnErr<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 477 [10.586748]

B:BD[6.3189] → [17.2544:2647]

    ) -> Result<Cursor<Self, &Self, Self::TagsCursor, L64, SerializedHash>, TxnErr<Self::GraphError>>;

[6.3189]

[6.3315]

    ) -> Result<Cursor<Self, &Self, Self::TagsCursor, L64, ()>, TxnErr<Self::GraphError>>;

Replacement in libpijul/src/pristine/mod.rs at line 484 [10.586748]

B:BD[6.3427] → [6.3427:3498]

        RevCursor<Self, &Self, Self::TagsCursor, L64, SerializedHash>,

[6.3427]

[6.3498]

        RevCursor<Self, &Self, Self::TagsCursor, L64, ()>,

Replacement in libpijul/src/pristine/mod.rs at line 1501 [10.586748]

∅:D[8.22745] → [6.3540:3690]

B:BD[18.68729] → [6.3540:3690]

initialized_cursor!(tags, L64, SerializedHash, ChannelTxnT, GraphError);
initialized_rev_cursor!(tags, L64, SerializedHash, ChannelTxnT, GraphError);

[8.22745]

[10.621548]


impl<'a, T: ChannelTxnT> Iterator for crate::pristine::RevCursor<T, &'a T, T::TagsCursor, L64, ()>
{
    type Item = Result<&'a L64, TxnErr<T::GraphError>>;
    fn next(&mut self) -> Option<Self::Item> {
        match self.txn.cursor_tags_prev(&mut self.cursor) {
            Ok(Some(x)) => Some(Ok(x)),
            Ok(None) => None,
            Err(e) => Some(Err(e)),
        }
    }
}
impl<'a, T: ChannelTxnT>
    crate::pristine::Cursor<T, &'a T, T::TagsCursor, L64, ()>
{
    pub fn prev(&mut self) -> Option<Result<u64, TxnErr<T::GraphError>>> {
        match self.txn.cursor_tags_prev(&mut self.cursor) {
            Ok(Some(x)) => Some(Ok((*x).into())),
            Ok(None) => None,
            Err(e) => Some(Err(e)),
        }
    }
}
impl<'a, T: ChannelTxnT> Iterator for crate::pristine::Cursor<T, &'a T, T::TagsCursor, L64, ()>
{
    type Item = Result<u64, TxnErr<T::GraphError>>;
    fn next(&mut self) -> Option<Self::Item> {
        match self.txn.cursor_tags_next(&mut self.cursor) {
            Ok(Some(x)) => Some(Ok((*x).into())),
            Ok(None) => None,
            Err(e) => Some(Err(e)),
        }
    }
}

Deletion in libpijul/src/pristine/mod.rs at line 1789 [10.586748]
B:BD[4.27411] → [4.27411:27429]
```
        h: &Hash,
```
Replacement in libpijul/src/changestore/filesystem.rs at line 3 [10.824013]
B:BD[10.824124] → [10.824124:824179]
```
use crate::pristine::{Base32, ChangeId, Hash, Vertex};
```
[10.824124]
[19.1356]
```
use crate::pristine::{Base32, ChangeId, Hash, Vertex, Merkle};
```

Insertion in libpijul/src/changestore/filesystem.rs at line 41 [10.824013]

[10.824742]

}
pub fn push_tag_filename(changes_dir: &mut PathBuf, hash: &Merkle) {
    let h32 = hash.to_base32();
    let (a, b) = h32.split_at(2);
    changes_dir.push(a);
    changes_dir.push(b);
    changes_dir.set_extension("tag");