pijul/pijul - Change EUZFFJSOWV4PXDFFPDAFBHFUUMOFEU6ST7JH57YYRRR2SEOXLN6QC

Updating Pijul with the latest changes in Libpijul

Created by pmeunier on July 10, 2021

EUZFFJSOWV4PXDFFPDAFBHFUUMOFEU6ST7JH57YYRRR2SEOXLN6QC

Dependencies

In channels

main

Change contents

Deletion in pijul/src/repository.rs at line 2 [9.21431]
B:BD[9.21540] → [10.0:20]
```
use std::sync::Arc;
```

Replacement in pijul/src/repository.rs at line 11 [9.21431]

B:BD[9.21688] → [10.21:96]

    pub working_copy: Arc<libpijul::working_copy::filesystem::FileSystem>,

[9.21688]

[9.21758]

    pub working_copy: libpijul::working_copy::filesystem::FileSystem,

Replacement in pijul/src/repository.rs at line 72 [9.21431]

B:BD[11.5906] → [10.247:341]

            working_copy: Arc::new(libpijul::working_copy::filesystem::FileSystem::from_root(

[11.5906]

[9.24052]

            working_copy: libpijul::working_copy::filesystem::FileSystem::from_root(

Replacement in pijul/src/repository.rs at line 74 [9.21431]
B:BD[9.24087] → [10.342:358]
```
            )),
```
[9.24087]
[9.24102]
```
            ),
```

Replacement in pijul/src/repository.rs at line 98 [9.21431]

B:BD[11.6006] → [10.359:503]

                working_copy: Arc::new(libpijul::working_copy::filesystem::FileSystem::from_root(
                    &cur,
                )),

[11.6006]

[9.25068]

                working_copy: libpijul::working_copy::filesystem::FileSystem::from_root(&cur),

Replacement in pijul/src/remote/mod.rs at line 176 [9.52474]

B:BD[9.57008] → [10.504:567]

            .dichotomy_changelist(txn, &remote.lock()?.remote)

[9.57008]

[9.57072]

            .dichotomy_changelist(txn, &remote.lock().remote)

Replacement in pijul/src/remote/mod.rs at line 180 [9.52474]

B:BD[9.57166] → [10.568:621]

            .iter_remote(&remote.lock()?.remote, n)?

[9.57166]

[12.8398]

            .iter_remote(&remote.lock().remote, n)?

Replacement in pijul/src/remote/mod.rs at line 276 [9.52474]

B:BD[13.7116] → [13.7116:7181]

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

[13.7116]

[14.2110]

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

Replacement in pijul/src/remote/mod.rs at line 424 [9.52474]
B:BD[13.7708] → [5.1665:1701]
```
        remote.set_id_revision(r)?;
```
[13.7708]
[5.1701]
```
        remote.set_id_revision(r);
```

Replacement in pijul/src/remote/mod.rs at line 525 [9.52474]

B:BD[15.3600] → [16.0:60]

                let mut channel = channel.write().unwrap();

[15.3600]

[16.60]

                let mut channel = channel.write();

Replacement in pijul/src/remote/mod.rs at line 598 [9.52474]

B:BD[16.150] → [16.150:207]

            let mut channel_ = channel.write().unwrap();

[16.150]

[16.207]

            let mut channel_ = channel.write();

Replacement in pijul/src/remote/mod.rs at line 622 [9.52474]

B:BD[9.74338] → [10.622:685]

        for x in txn.iter_remote(&remote.lock()?.remote, 0)? {

[9.74338]

[11.7808]

        for x in txn.iter_remote(&remote.lock().remote, 0)? {

Replacement in pijul/src/remote/mod.rs at line 701 [9.52474]

B:BD[9.76875] → [10.686:735]

            let channel = local_channel.read()?;

[9.76875]

[17.2348]

            let channel = local_channel.read();

Replacement in pijul/src/remote/mod.rs at line 730 [9.52474]

B:BD[9.78229] → [18.2758:2802]

∅:D[18.2802] → [14.2883:2988]

B:BD[14.2883] → [14.2883:2988]

        let (inodes, remote_changes) = self
            .update_changelist(txn, path)
            .await?
            .expect("Remote is not self");

[9.77979]

[9.78300]

        let (inodes, remote_changes) = if let Some(x) = self.update_changelist(txn, path).await? {
            x
        } else {
            bail!("Channel not found")
        };

Replacement in pijul/src/remote/mod.rs at line 737 [9.52474]

B:BD[13.8218] → [13.8218:8264]

            let rem = remote_changes.lock()?;

[13.8218]

[13.8264]

            let rem = remote_changes.lock();

Replacement in pijul/src/remote/local.rs at line 3 [9.79745]
B:BD[19.11587] → [10.808:838]
```
use std::sync::{Arc, RwLock};
```
[19.11587]
[20.534]
```
use std::sync::Arc;
```

Replacement in pijul/src/remote/local.rs at line 27 [9.79745]

B:BD[14.3239] → [10.839:909]

        Ok(txn.reverse_log(&*channel.read()?, None)?.next().map(|n| {

[14.3239]

[12.10054]

        Ok(txn.reverse_log(&*channel.read(), None)?.next().map(|n| {

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

B:BD[13.8812] → [13.8812:8869]

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

[13.8812]

[13.8869]

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

Replacement in pijul/src/remote/local.rs at line 84 [9.79745]

B:BD[12.10533] → [10.910:965]

                        &remote_channel.read()?.graph,

[12.10533]

[12.10589]

                        &remote_channel.read().graph,

Replacement in pijul/src/remote/local.rs at line 93 [9.79745]

∅:D[13.8962] → [10.966:1033]

B:BD[18.4961] → [10.966:1033]

        for x in remote_txn.log(&*remote_channel.read()?, from)? {

[13.8962]

[12.10768]

        for x in remote_txn.log(&*remote_channel.read(), from)? {

Replacement in pijul/src/remote/local.rs at line 119 [9.79745]

B:BD[9.82358] → [21.64:118]

∅:D[21.118] → [9.82411:82503]

B:BD[9.82411] → [9.82411:82503]

        let mut txn = self.pristine.mut_txn_begin()?;
        let mut channel = txn.open_or_create_channel(to_channel.unwrap_or(&self.channel))?;

[9.82358]

[9.82557]

        let txn = self.pristine.arc_txn_begin()?;
        let channel = txn
            .write()
            .open_or_create_channel(to_channel.unwrap_or(&self.channel))?;

Replacement in pijul/src/remote/local.rs at line 138 [9.79745]

∅:D[10.1124] → [22.0:66]

B:BD[9.83322] → [22.0:66]

B:BD[22.66] → [10.1125:1204]

        upload_changes(&store, &mut txn, &mut channel, changes)?;
        let txn = Arc::new(RwLock::new(txn));
        let wc = Arc::new(repo);

[10.1124]

[10.1204]

        upload_changes(&store, &mut *txn.write(), &channel, changes)?;

Replacement in pijul/src/remote/local.rs at line 140 [9.79745]
B:BD[10.1260] → [10.1260:1276]
```
            wc,
```
[10.1260]
[10.1276]
```
            &repo,
```

Replacement in pijul/src/remote/local.rs at line 142 [9.79745]

B:BD[10.1296] → [10.1296:1350]

            txn.clone(),
            channel.clone(),

[10.1296]

[10.1350]

            &txn,
            &channel,

Deletion in pijul/src/remote/local.rs at line 150 [9.79745]

B:BD[10.1443] → [10.1443:1594]

        let txn = if let Ok(txn) = Arc::try_unwrap(txn) {
            txn.into_inner().unwrap()
        } else {
            unreachable!()
        };

Replacement in pijul/src/remote/local.rs at line 224 [9.79745]
B:BD[14.4093] → [16.395:443]
```
    let mut channel = channel.write().unwrap();
```
[14.4093]
[14.4093]
```
    let mut channel = channel.write();
```
Deletion in pijul/src/commands/unrecord.rs at line 2 [9.95630]
B:BD[9.95785] → [10.1929:1959]
```
use std::sync::{Arc, RwLock};
```

Replacement in pijul/src/commands/unrecord.rs at line 37 [9.95630]

B:BD[23.362] → [10.1960:2010]

B:BD[10.2010] → [24.0:75]

        let txn = repo.pristine.mut_txn_begin()?;
        let cur = txn.current_channel().unwrap_or(crate::DEFAULT_CHANNEL);

[9.96273]

[24.75]

        let txn = repo.pristine.arc_txn_begin()?;
        let cur = txn
            .read()
            .current_channel()
            .unwrap_or(crate::DEFAULT_CHANNEL)
            .to_string();

Replacement in pijul/src/commands/unrecord.rs at line 46 [9.95630]
B:BD[24.169] → [24.169:185]
```
            cur
```
[24.169]
[24.185]
```
            cur.as_str()
```

Replacement in pijul/src/commands/unrecord.rs at line 49 [9.95630]

B:BD[24.250] → [24.250:330]

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

[24.250]

[10.2089]

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

Replacement in pijul/src/commands/unrecord.rs at line 72 [9.95630]
B:BD[25.2791] → [26.0:43]
```
            let txn = txn.read().unwrap();
```
[25.2791]
[10.3331]
```
            let txn = txn.read();
```

Replacement in pijul/src/commands/unrecord.rs at line 74 [9.95630]

B:BD[10.3361] → [10.3361:3416]

                .reverse_log(&*channel.read()?, None)?

[10.3361]

[10.3416]

                .reverse_log(&*channel.read(), None)?

Replacement in pijul/src/commands/unrecord.rs at line 83 [9.95630]
B:BD[10.3800] → [26.44:87]
```
            let txn = txn.read().unwrap();
```
[10.3800]
[10.3800]
```
            let txn = txn.read();
```
Replacement in pijul/src/commands/unrecord.rs at line 89 [9.95630]
B:BD[10.3958] → [10.3958:3998]
```
        let channel_ = channel.read()?;
```
[10.3958]
[10.3998]
```
        let channel_ = channel.read();
```
Replacement in pijul/src/commands/unrecord.rs at line 92 [9.95630]
B:BD[26.98] → [26.98:141]
```
            let txn = txn.read().unwrap();
```
[26.98]
[26.141]
```
            let txn = txn.read();
```

Replacement in pijul/src/commands/unrecord.rs at line 112 [9.95630]

B:BD[10.4436] → [10.4436:4480]

B:BD[10.4480] → [26.711:755]

            let channel_ = channel.read()?;
            let txn_ = txn.read().unwrap();

[10.4436]

[26.755]

            let channel_ = channel.read();
            let txn_ = txn.read();

Replacement in pijul/src/commands/unrecord.rs at line 139 [9.95630]

B:BD[26.998] → [27.0:113]

            txn.write()
                .unwrap()
                .unrecord(&repo.changes, &channel, &hash, 0)?;

[26.998]

[10.5477]

            txn.write().unrecord(&repo.changes, &channel, &hash, 0)?;

Replacement in pijul/src/commands/unrecord.rs at line 144 [9.95630]
B:BD[10.5640] → [10.5640:5683]
```
                repo.working_copy.clone(),
```
[10.5640]
[10.5683]
```
                &repo.working_copy,
```

Replacement in pijul/src/commands/unrecord.rs at line 146 [9.95630]

B:BD[10.5714] → [10.5714:5776]

                txn.clone(),
                channel.clone(),

[10.5714]

[10.5776]

                &txn,
                &channel,

Replacement in pijul/src/commands/unrecord.rs at line 156 [9.95630]

B:BD[10.5939] → [27.114:224]

            txn.write()
                .unwrap()
                .unrecord(&repo.changes, &channel, &h, 0)?;

[10.5939]

[10.6012]

            txn.write().unrecord(&repo.changes, &channel, &h, 0)?;

Deletion in pijul/src/commands/unrecord.rs at line 161 [9.95630]

B:BD[9.97592] → [10.6107:6258]

        let txn = if let Ok(txn) = Arc::try_unwrap(txn) {
            txn.into_inner().unwrap()
        } else {
            unreachable!()
        };

Deletion in pijul/src/commands/unrecord.rs at line 165 [9.95630]
B:BD[10.2195] → [10.2195:2241]
```
        let txn = Arc::new(RwLock::new(txn));
```
Solving an order conflict in pijul/src/commands/unrecord.rs at line 165 [9.95630]
[9.97638]
Deletion in pijul/src/commands/tag.rs at line 3 [28.74]
B:BD[28.119] → [28.119:149]
```
use std::sync::{Arc, RwLock};
```

Replacement in pijul/src/commands/tag.rs at line 9 [28.74]

B:BD[28.255] → [28.255:332]

use libpijul::{Base32, ChannelMutTxnT, ChannelTxnT, MutTxnT, TxnT, TxnTExt};

[28.255]

[6.0]

use libpijul::{ArcTxn, Base32, ChannelMutTxnT, ChannelTxnT, MutTxnT, TxnT, TxnTExt};

Replacement in pijul/src/commands/tag.rs at line 61 [28.74]

B:BD[29.92] → [6.13:71]

                let txn = repo.pristine.mut_txn_begin()?;

[29.92]

[6.71]

                let txn = repo.pristine.arc_txn_begin()?;

Replacement in pijul/src/commands/tag.rs at line 65 [28.74]

B:BD[24.506] → [6.134:176]

                    txn.current_channel()

[24.506]

[6.176]

                    txn.read()
                        .current_channel()

Deletion in pijul/src/commands/tag.rs at line 71 [28.74]
B:BD[6.334] → [6.334:388]
```
                let txn = Arc::new(RwLock::new(txn));
```

Replacement in pijul/src/commands/tag.rs at line 72 [28.74]

B:BD[6.456] → [6.456:651]

∅:D[6.651] → [28.2135:2305]

B:BD[28.2135] → [28.2135:2305]

                let mut txn = if let Ok(txn) = Arc::try_unwrap(txn) {
                    txn.into_inner().unwrap()
                } else {
                    unreachable!()
                };
                let channel = txn.load_channel(&channel_name)?.unwrap();
                let last_t = if let Some(n) = txn.reverse_log(&*channel.read()?, None)?.next() {

[6.456]

[28.2305]

                let channel = txn.read().load_channel(&channel_name)?.unwrap();
                let last_t = if let Some(n) = txn.read().reverse_log(&*channel.read(), None)?.next()
                {

Replacement in pijul/src/commands/tag.rs at line 80 [28.74]

B:BD[28.2499] → [28.2499:2576]

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

[28.2499]

[28.2576]

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

Replacement in pijul/src/commands/tag.rs at line 96 [28.74]

B:BD[28.3053] → [28.3053:3145]

                let h = libpijul::tag::from_channel(&txn, &channel_name, &header, &mut w)?;

[28.3053]

[28.3145]

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

Replacement in pijul/src/commands/tag.rs at line 101 [28.74]

B:BD[28.3358] → [28.3358:3432]

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

[28.3358]

[28.3432]

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

Replacement in pijul/src/commands/tag.rs at line 148 [28.74]

B:BD[29.849] → [29.849:930]

                for t in txn.rev_iter_tags(txn.tags(&*channel.read()?), None)? {

[29.849]

[29.930]

                for t in txn.rev_iter_tags(txn.tags(&*channel.read()), None)? {

Replacement in pijul/src/commands/tag.rs at line 212 [28.74]
B:BD[6.744] → [6.744:769]
```
    txn: Arc<RwLock<T>>,
```
[6.744]
[6.769]
```
    txn: ArcTxn<T>,
```

Replacement in pijul/src/commands/tag.rs at line 215 [28.74]

B:BD[6.821] → [6.821:907]

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

[6.821]

[6.907]

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

Replacement in pijul/src/commands/tag.rs at line 225 [28.74]
B:BD[6.1071] → [6.1071:1106]
```
        repo.working_copy.clone(),
```
[6.1071]
[6.1106]
```
        &repo.working_copy,
```
Deletion in pijul/src/commands/reset.rs at line 3 [9.97650]
B:BD[20.1313] → [10.6259:6289]
```
use std::sync::{Arc, RwLock};
```
Replacement in pijul/src/commands/reset.rs at line 41 [9.97650]
∅:D[13.13910] → [10.6431:6481]
B:BD[10.6431] → [10.6431:6481]
```
        let txn = repo.pristine.mut_txn_begin()?;
```
[13.13910]
[10.6481]
```
        let txn = repo.pristine.arc_txn_begin()?;
```

Insertion in pijul/src/commands/reset.rs at line 43 [9.97650]

[10.6482]

[24.770]

        let cur = txn
            .read()
            .current_channel()
            .unwrap_or(crate::DEFAULT_CHANNEL)
            .to_string();

Replacement in pijul/src/commands/reset.rs at line 51 [9.97650]

B:BD[24.864] → [24.864:932]

            txn.current_channel().unwrap_or(crate::DEFAULT_CHANNEL)

[24.864]

[24.932]

            cur.as_str()

Replacement in pijul/src/commands/reset.rs at line 54 [9.97650]

B:BD[30.108] → [10.6652:6732]

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

[30.108]

[9.98538]

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

Replacement in pijul/src/commands/reset.rs at line 69 [9.97650]

∅:D[31.150] → [9.99169:99241]

∅:D[30.186] → [9.99169:99241]

B:BD[9.99169] → [9.99169:99241]

                txn.follow_oldest_path(&repo.changes, &channel, &path)?

[31.150]

[9.99241]

                txn.read()
                    .follow_oldest_path(&repo.changes, &channel, &path)?

Replacement in pijul/src/commands/reset.rs at line 78 [9.97650]

∅:D[32.174] → [9.99322:99394]

∅:D[30.264] → [9.99322:99394]

∅:D[31.301] → [9.99322:99394]

B:BD[9.99322] → [9.99322:99394]

                txn.follow_oldest_path(&repo.changes, &channel, &path)?

[31.301]

[9.99394]

                txn.read()
                    .follow_oldest_path(&repo.changes, &channel, &path)?

Replacement in pijul/src/commands/reset.rs at line 83 [9.97650]

B:BD[9.99469] → [10.6779:6843]

                &txn,
                &channel.read().unwrap(),

[9.99469]

[9.99495]

                &*txn.read(),
                &channel.read(),

Deletion in pijul/src/commands/reset.rs at line 91 [9.97650]
B:BD[10.6882] → [10.6882:6928]
B:BD[10.6928] → [10.6928:6929]
```
        let txn = Arc::new(RwLock::new(txn));
```
Deletion in pijul/src/commands/reset.rs at line 93 [9.97650]
B:BD[24.998] → [24.998:1020]
```
            .unwrap()
```

Replacement in pijul/src/commands/reset.rs at line 105 [9.97650]

B:BD[10.7359] → [10.7359:7406]

                let txn = txn.read().unwrap();

[10.7359]

[24.1188]

                let txn = txn.read();

Replacement in pijul/src/commands/reset.rs at line 114 [9.97650]

B:BD[10.7733] → [10.7733:7780]

                    repo.working_copy.clone(),

[10.7733]

[10.7780]

                    &repo.working_copy,

Replacement in pijul/src/commands/reset.rs at line 130 [9.97650]

∅:D[24.1334] → [10.8307:8400]

B:BD[10.8307] → [10.8307:8400]

                let last_modified = last_modified(&*txn.read().unwrap(), &*channel.read()?);

[24.1334]

[10.8400]

                let last_modified = last_modified(&*txn.read(), &*channel.read());

Replacement in pijul/src/commands/reset.rs at line 132 [9.97650]

B:BD[10.8464] → [10.8464:8511]

                    repo.working_copy.clone(),

[10.8464]

[10.8511]

                    &repo.working_copy,

Replacement in pijul/src/commands/reset.rs at line 134 [9.97650]

B:BD[10.8546] → [10.8546:8616]

                    txn.clone(),
                    channel.clone(),

[10.8546]

[10.8616]

                    &txn,
                    &channel,

Replacement in pijul/src/commands/reset.rs at line 142 [9.97650]

B:BD[10.8764] → [10.8764:9024]

                let mut txn = if let Ok(txn) = Arc::try_unwrap(txn) {
                    txn.into_inner().unwrap()
                } else {
                    unreachable!()
                };
                txn.touch_channel(&mut *channel.write()?, None);

[10.8764]

[10.9024]

                txn.write().touch_channel(&mut *channel.write(), None);

Replacement in pijul/src/commands/reset.rs at line 147 [9.97650]
B:BD[10.9145] → [24.1335:1384]
```
            let mut txn_ = txn.write().unwrap();
```
[10.9145]
[24.1384]
```
            let mut txn_ = txn.write();
```

Replacement in pijul/src/commands/reset.rs at line 150 [9.97650]

B:BD[10.9311] → [10.9311:9504]

                let (a, b, s) = libpijul::pristine::last_common_state(
                    &*txn_,
                    &*cur.read()?,
                    &*channel.read()?,
                )?;

[10.9311]

[3.0]

                let (a, b, s) =
                    libpijul::pristine::last_common_state(&*txn_, &*cur.read(), &*channel.read())?;

Replacement in pijul/src/commands/reset.rs at line 159 [9.97650]

∅:D[3.233] → [10.9557:9737]

B:BD[10.9557] → [10.9557:9737]

                changes_after(&*txn_, &*cur.read()?, a, &mut changediff, &mut inodes)?;
                changes_after(&*txn_, &*channel.read()?, b, &mut changediff, &mut inodes)?;

[3.233]

[10.9737]

                changes_after(&*txn_, &*cur.read(), a, &mut changediff, &mut inodes)?;
                changes_after(&*txn_, &*channel.read(), b, &mut changediff, &mut inodes)?;

Replacement in pijul/src/commands/reset.rs at line 169 [9.97650]

B:BD[10.10047] → [10.10047:10147]

                    libpijul::fs::find_path(&repo.changes, &*txn_, &*channel.read()?, false, *pos)?

[10.10047]

[10.10147]

                    libpijul::fs::find_path(&repo.changes, &*txn_, &*channel.read(), false, *pos)?

Replacement in pijul/src/commands/reset.rs at line 188 [9.97650]

B:BD[10.10723] → [10.10723:10770]

                    repo.working_copy.clone(),

[10.10723]

[10.10770]

                    &repo.working_copy,

Replacement in pijul/src/commands/reset.rs at line 190 [9.97650]

B:BD[10.10805] → [10.10805:10875]

                    txn.clone(),
                    channel.clone(),

[10.10805]

[10.10875]

                    &txn,
                    &channel,

Replacement in pijul/src/commands/reset.rs at line 201 [9.97650]
B:BD[10.11123] → [10.11123:11162]
```
                    repo.working_copy,
```
[10.11123]
[10.11162]
```
                    &repo.working_copy,
```

Replacement in pijul/src/commands/reset.rs at line 203 [9.97650]

B:BD[10.11197] → [10.11197:11259]

                    txn.clone(),
                    channel,

[10.11197]

[10.11259]

                    &txn,
                    &channel,

Replacement in pijul/src/commands/reset.rs at line 227 [9.97650]

B:BD[10.11929] → [10.11929:11976]

                    repo.working_copy.clone(),

[10.11929]

[10.11976]

                    &repo.working_copy,

Replacement in pijul/src/commands/reset.rs at line 229 [9.97650]

B:BD[10.12011] → [10.12011:12081]

                    txn.clone(),
                    channel.clone(),

[10.12011]

[10.12081]

                    &txn,
                    &channel,

Deletion in pijul/src/commands/reset.rs at line 240 [9.97650]

B:BD[9.101723] → [10.12248:12399]

        let txn = if let Ok(txn) = Arc::try_unwrap(txn) {
            txn.into_inner().unwrap()
        } else {
            unreachable!()
        };

Replacement in pijul/src/commands/record.rs at line 3 [9.101759]
B:BD[33.24] → [10.12484:12514]
```
use std::sync::{Arc, RwLock};
```
[33.24]
[20.1485]
```
use std::sync::Arc;
```

Replacement in pijul/src/commands/record.rs at line 12 [9.101759]

B:BD[10.12531] → [10.12531:12620]

    Base32, ChannelMutTxnT, ChannelRef, ChannelTxnT, MutTxnT, MutTxnTExt, TxnT, TxnTExt,

[10.12531]

[10.12620]

    ArcTxn, Base32, ChannelMutTxnT, ChannelRef, ChannelTxnT, MutTxnTExt, TxnT, TxnTExt,

Replacement in pijul/src/commands/record.rs at line 70 [9.101759]

B:BD[9.103545] → [21.229:283]

        let mut txn = repo.pristine.mut_txn_begin()?;

[9.103545]

[24.1549]

        let txn = repo.pristine.arc_txn_begin()?;
        let cur = txn
            .read()
            .current_channel()
            .unwrap_or(crate::DEFAULT_CHANNEL)
            .to_string();

Replacement in pijul/src/commands/record.rs at line 79 [9.101759]

B:BD[24.1638] → [24.1638:1706]

            txn.current_channel().unwrap_or(crate::DEFAULT_CHANNEL)

[24.1638]

[24.1706]

            cur.as_str()

Replacement in pijul/src/commands/record.rs at line 81 [9.101759]

∅:D[24.1717] → [34.82:160]

B:BD[34.82] → [34.82:160]

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

[24.1717]

[34.160]

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

Replacement in pijul/src/commands/record.rs at line 89 [9.101759]

B:BD[35.287] → [35.287:338]

            let (h, c) = txn.hash_from_prefix(h)?;

[35.287]

[35.338]

            let (h, c) = txn.read().hash_from_prefix(h)?;

Replacement in pijul/src/commands/record.rs at line 91 [9.101759]

B:BD[35.357] → [10.12732:12800]

                .get_changeset(txn.changes(&*channel.read()?), &c)?

[35.357]

[35.424]

                .read()
                .get_changeset(txn.read().changes(&*channel.read()), &c)?

Replacement in pijul/src/commands/record.rs at line 98 [9.101759]

B:BD[35.590] → [10.12801:12850]

                    channel.read().unwrap().name

[35.590]

[35.632]

                    channel.read().name

Replacement in pijul/src/commands/record.rs at line 106 [9.101759]

B:BD[36.128] → [36.128:174]

B:BD[36.174] → [10.12851:12938]

                txn.hash_from_prefix(hash)?.0
            } else if let Some(h) = txn.reverse_log(&*channel.read()?, None)?.next() {

[36.128]

[11.10134]

                txn.read().hash_from_prefix(hash)?.0
            } else if let Some(h) = txn.read().reverse_log(&*channel.read(), None)?.next() {

Replacement in pijul/src/commands/record.rs at line 121 [9.101759]
B:BD[37.282] → [27.342:368]
```
            txn.unrecord(
```
[37.282]
[27.368]
```
            txn.write().unrecord(
```

Replacement in pijul/src/commands/record.rs at line 136 [9.101759]

B:BD[38.506] → [10.13021:13154]

                Some(Arc::new(
                    libpijul::working_copy::filesystem::FileSystem::from_root(w),
                )),

[38.506]

[38.590]

                Some(libpijul::working_copy::filesystem::FileSystem::from_root(w)),

Deletion in pijul/src/commands/record.rs at line 141 [9.101759]
B:BD[38.696] → [10.13155:13201]
```
        let txn = Arc::new(RwLock::new(txn));
```

Replacement in pijul/src/commands/record.rs at line 147 [9.101759]

B:BD[10.13231] → [10.13231:13302]

            working_copy.clone().unwrap_or(repo.working_copy.clone()),

[10.13231]

[9.104172]

            working_copy.as_ref().unwrap_or(&repo.working_copy),

Replacement in pijul/src/commands/record.rs at line 159 [9.101759]

∅:D[39.2058] → [40.1145:1421]

B:BD[9.105101] → [40.1145:1421]

                let mut txn = if let Ok(txn) = Arc::try_unwrap(txn) {
                    txn.into_inner().unwrap()
                } else {
                    unreachable!()
                };
                txn.apply_local_change(&mut channel, &change, &hash, &updates)?;

[39.2058]

[13.14018]

                let mut txn_ = txn.write();
                txn_.apply_local_change(&mut channel, &change, &hash, &updates)?;

Replacement in pijul/src/commands/record.rs at line 184 [9.101759]

B:BD[40.2172] → [40.2172:2249]

                    txn.touch_channel(&mut *channel.write()?, Some(oldest));

[40.2172]

[41.681]

                    txn_.touch_channel(&mut *channel.write(), Some(oldest));

Insertion in pijul/src/commands/record.rs at line 186 [9.101759]
[41.699]
[40.2250]
```
                std::mem::drop(txn_);
```

Replacement in pijul/src/commands/record.rs at line 191 [9.101759]

B:BD[40.2360] → [40.2360:2644]

                    let mut txn = if let Ok(txn) = Arc::try_unwrap(txn) {
                        txn.into_inner().unwrap()
                    } else {
                        unreachable!()
                    };
                    txn.touch_channel(&mut *channel.write()?, None);

[40.2360]

[40.2644]

                    txn.write().touch_channel(&mut *channel.write(), None);

Replacement in pijul/src/commands/record.rs at line 270 [9.101759]
B:BD[9.106516] → [10.13756:13785]
```
        txn: Arc<RwLock<T>>,
```
[9.106516]
[10.13785]
```
        txn: ArcTxn<T>,
```

Replacement in pijul/src/commands/record.rs at line 272 [9.101759]

B:BD[10.13817] → [10.13817:13880]

        working_copy: Arc<libpijul::working_copy::FileSystem>,

[10.13817]

[9.106637]

        working_copy: &libpijul::working_copy::FileSystem,

Replacement in pijul/src/commands/record.rs at line 280 [9.101759]
B:BD[27.572] → [27.572:604]
```
                Arc<RwLock<T>>,
```
[27.572]
[27.604]
```
                ArcTxn<T>,
```
Replacement in pijul/src/commands/record.rs at line 286 [9.101759]
∅:D[27.777] → [10.13881:13909]
∅:D[40.2771] → [10.13881:13909]
B:BD[9.106748] → [10.13881:13909]
```
            Arc<RwLock<T>>,
```
[27.777]
[27.778]
```
            ArcTxn<T>,
```

Replacement in pijul/src/commands/record.rs at line 305 [9.101759]

B:BD[10.14035] → [10.14035:14085]

                            working_copy.clone(),

[10.14035]

[38.1408]

                            working_copy,

Replacement in pijul/src/commands/record.rs at line 317 [9.101759]
B:BD[10.14233] → [10.14233:14275]
```
                    working_copy.clone(),
```
[10.14233]
[38.1757]
```
                    working_copy,
```
Replacement in pijul/src/commands/record.rs at line 342 [9.101759]
B:BD[10.14659] → [10.14659:14700]
```
        let txn_ = txn.write().unwrap();
```
[10.14659]
[9.107617]
```
        let txn_ = txn.write();
```
Replacement in pijul/src/commands/record.rs at line 349 [9.101759]
B:BD[10.14827] → [10.14827:14863]
```
            c.into_inner().unwrap()
```
[10.14827]
[10.14863]
```
            c.into_inner()
```
Deletion in pijul/src/commands/pushpull.rs at line 4 [9.111631]
B:BD[20.1695] → [10.15142:15172]
```
use std::sync::{Arc, RwLock};
```

Replacement in pijul/src/commands/pushpull.rs at line 43 [9.111631]

B:BD[12.12956] → [13.14737:14829]

                    writeln!(stdout, "  {}: {}", r.id(), r.lock().unwrap().path.as_str())?;

[12.12956]

[9.112628]

                    writeln!(stdout, "  {}: {}", r.id(), r.lock().path.as_str())?;

Replacement in pijul/src/commands/pushpull.rs at line 131 [9.111631]

B:BD[9.114607] → [24.1718:1772]

        let mut txn = repo.pristine.mut_txn_begin()?;

[9.114607]

[24.1772]

        let txn = repo.pristine.arc_txn_begin()?;
        let cur = txn
            .read()
            .current_channel()
            .unwrap_or(crate::DEFAULT_CHANNEL)
            .to_string();

Replacement in pijul/src/commands/pushpull.rs at line 140 [9.111631]

B:BD[24.1871] → [24.1871:1971]

            txn.current_channel().unwrap_or(crate::DEFAULT_CHANNEL)
        }
        .to_string();

[24.1871]

[9.114690]

            cur.as_str()
        };

Replacement in pijul/src/commands/pushpull.rs at line 155 [9.111631]
B:BD[9.115226] → [24.1972:2010]
```
                channel_name.as_str()
```
[9.115226]
[9.115255]
```
                channel_name
```
Replacement in pijul/src/commands/pushpull.rs at line 160 [9.111631]
B:BD[9.115325] → [24.2011:2045]
```
            channel_name.as_str()
```
[9.115325]
[9.115350]
```
            channel_name
```

Replacement in pijul/src/commands/pushpull.rs at line 172 [9.111631]

∅:D[21.401] → [18.6954:7038]

B:BD[9.115611] → [18.6954:7038]

B:BD[18.7038] → [24.2046:2112]

        let remote_changes = remote.update_changelist(&mut txn, &self.path).await?;
        let channel = txn.open_or_create_channel(&channel_name)?;

[9.115558]

[9.115888]

        let remote_changes = remote
            .update_changelist(&mut *txn.write(), &self.path)
            .await?;
        let channel = txn.write().open_or_create_channel(&channel_name)?;

Replacement in pijul/src/commands/pushpull.rs at line 179 [9.111631]

B:BD[18.7118] → [18.7118:7207]

            let (p, ambiguous) = txn.follow_oldest_path(&repo.changes, &channel, path)?;

[18.7118]

[9.116032]

            let (p, ambiguous) = txn
                .read()
                .follow_oldest_path(&repo.changes, &channel, path)?;

Replacement in pijul/src/commands/pushpull.rs at line 187 [9.111631]

B:BD[12.12983] → [10.15173:15260]

                libpijul::fs::iter_graph_descendants(&txn, &channel.read()?.graph, p)?

[12.12983]

[12.13071]

                libpijul::fs::iter_graph_descendants(&*txn.read(), &channel.read().graph, p)?

Replacement in pijul/src/commands/pushpull.rs at line 193 [9.111631]

B:BD[11.10513] → [10.15261:15322]

∅:D[10.15322] → [12.13190:13224]

B:BD[12.13190] → [12.13190:13224]

∅:D[12.13224] → [18.7456:7524]

B:BD[9.116338] → [18.7456:7524]

B:BD[18.7524] → [11.10514:10577]

∅:D[11.10577] → [14.4622:4667]

∅:D[12.13287] → [14.4622:4667]

B:BD[14.4622] → [14.4622:4667]

B:BD[14.4667] → [12.13288:13347]

B:BD[12.13347] → [11.10578:10644]

∅:D[11.10644] → [18.7525:7567]

∅:D[12.13412] → [18.7525:7567]

B:BD[14.4789] → [18.7525:7567]

B:BD[18.7567] → [11.10645:10694]

∅:D[11.10694] → [18.7609:7686]

B:BD[18.7609] → [18.7609:7686]

B:BD[18.7686] → [11.10695:10835]

∅:D[11.10835] → [18.7819:7888]

B:BD[18.7819] → [18.7819:7888]

∅:D[18.7888] → [14.4961:4987]

B:BD[14.4961] → [14.4961:4987]

        for x in txn.reverse_log(&*channel.read()?, None)? {
            let (_, (h, m)) = x?;
            if let Some((_, ref remote_changes)) = remote_changes {
                if txn.remote_has_state(remote_changes, &m)? {
                    break;
                }
                let h_int = txn.get_internal(h)?.unwrap();
                if !txn.remote_has_change(&remote_changes, &h)? {
                    if paths.is_empty() {
                        to_upload.push(h.into())
                    } else {
                        for p in paths.iter() {
                            if txn.get_touched_files(p, Some(h_int))?.is_some() {
                                to_upload.push(h.into());
                                break;
                            }
                        }

[11.10513]

[9.116707]

        {
            let txn = txn.read();
            for x in txn.reverse_log(&*channel.read(), None)? {
                let (_, (h, m)) = x?;
                if let Some((_, ref remote_changes)) = remote_changes {
                    if txn.remote_has_state(remote_changes, &m)? {
                        break;

Deletion in pijul/src/commands/pushpull.rs at line 201 [9.111631]

B:BD[9.116729] → [14.5017:5132]

B:BD[14.5132] → [12.13497:13572]

B:BD[12.13572] → [10.15323:15374]

                }
            } else if let crate::remote::RemoteRepo::LocalChannel(ref remote_channel) = remote {
                if let Some(channel) = txn.load_channel(remote_channel)? {
                    let channel = channel.read()?;

Replacement in pijul/src/commands/pushpull.rs at line 202 [9.111631]

B:BD[12.13636] → [42.344:428]

                    if txn.get_changeset(txn.changes(&channel), h_int)?.is_none() {

[12.13636]

[18.7889]

                    if !txn.remote_has_change(&remote_changes, &h)? {

Insertion in pijul/src/commands/pushpull.rs at line 214 [9.111631]

[14.5745]

[9.116792]

                } else if let crate::remote::RemoteRepo::LocalChannel(ref remote_channel) = remote {
                    if let Some(channel) = txn.load_channel(remote_channel)? {
                        let channel = channel.read();
                        let h_int = txn.get_internal(h)?.unwrap();
                        if txn.get_changeset(txn.changes(&channel), h_int)?.is_none() {
                            if paths.is_empty() {
                                to_upload.push(h.into())
                            } else {
                                for p in paths.iter() {
                                    if txn.get_touched_files(p, Some(h_int))?.is_some() {
                                        to_upload.push(h.into());
                                        break;
                                    }
                                }
                            }
                        }
                    }

Insertion in pijul/src/commands/pushpull.rs at line 246 [9.111631]
[43.506]
[43.506]
```
            let txn = txn.read();
```
Insertion in pijul/src/commands/pushpull.rs at line 273 [9.111631]
[18.8408]
[44.69]
```
            let txn = txn.read();
```

Replacement in pijul/src/commands/pushpull.rs at line 276 [9.111631]

B:BD[44.158] → [45.0:97]

                let comp = complete_deps(&txn, &remote_changes, &repo.changes, &to_upload, &d)?;

[44.158]

[44.232]

                let comp = complete_deps(&*txn, &remote_changes, &repo.changes, &to_upload, &d)?;

Replacement in pijul/src/commands/pushpull.rs at line 292 [9.111631]

B:BD[9.117334] → [46.2417:2507]

            .upload_changes(&mut txn, repo.changes_dir.clone(), push_channel, &to_upload)

[9.117334]

[9.117414]

            .upload_changes(
                &mut *txn.write(),
                repo.changes_dir.clone(),
                push_channel,
                &to_upload,
            )

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

∅:D[13.15372] → [21.402:456]

B:BD[47.6765] → [21.402:456]

B:BD[21.456] → [24.2113:2188]

        let mut txn = repo.pristine.mut_txn_begin()?;
        let cur = txn.current_channel().unwrap_or(crate::DEFAULT_CHANNEL);

[13.15372]

[7.0]

        let txn = repo.pristine.arc_txn_begin()?;
        let cur = txn
            .read()
            .current_channel()
            .unwrap_or(crate::DEFAULT_CHANNEL)
            .to_string();

Replacement in pijul/src/commands/pushpull.rs at line 318 [9.111631]

B:BD[24.2287] → [24.2287:2335]

            cur
        }
        .to_string();

[24.2287]

[24.2335]

            cur.as_str()
        };

Replacement in pijul/src/commands/pushpull.rs at line 321 [9.111631]

B:BD[24.2389] → [24.2389:2459]

        let mut channel = txn.open_or_create_channel(&channel_name)?;

[24.2389]

[9.117853]

        let mut channel = txn.write().open_or_create_channel(&channel_name)?;

Replacement in pijul/src/commands/pushpull.rs at line 347 [9.111631]

B:BD[18.8542] → [13.15396:15480]

        let remote_changes = remote.update_changelist(&mut txn, &self.path).await?;

[18.8542]

        let remote_changes = remote
            .update_changelist(&mut *txn.write(), &self.path)
            .await?;

Replacement in pijul/src/commands/pushpull.rs at line 355 [9.111631]

B:BD[18.8812] → [10.15375:15454]

                for x in txn.iter_remote(&remote_changes.lock()?.remote, 0)? {

[18.8812]

[11.11155]

                let txn = txn.read();
                for x in txn.iter_remote(&remote_changes.lock().remote, 0)? {

Replacement in pijul/src/commands/pushpull.rs at line 359 [9.111631]

B:BD[48.27] → [10.15455:15536]

                        .channel_has_state(txn.states(&*channel.read()?), &p.b)?

[48.27]

[48.105]

                        .channel_has_state(txn.states(&*channel.read()), &p.b)?

Insertion in pijul/src/commands/pushpull.rs at line 369 [9.111631]
[18.8863]
[18.8863]
```
                let txn = txn.read();
```

Replacement in pijul/src/commands/pushpull.rs at line 377 [9.111631]

B:BD[12.14103] → [10.15537:15632]

                        libpijul::fs::iter_graph_descendants(&txn, &channel.read()?.graph, p)?

[12.14103]

[12.14199]

                        libpijul::fs::iter_graph_descendants(&*txn, &channel.read().graph, p)?

Replacement in pijul/src/commands/pushpull.rs at line 386 [9.111631]

B:BD[12.14430] → [10.15633:15698]

                    let remote_channel = remote_channel.read()?;

[12.14430]

[12.14431]

                    let remote_channel = remote_channel.read();

Replacement in pijul/src/commands/pushpull.rs at line 390 [9.111631]

B:BD[48.194] → [10.15699:15782]

                            .channel_has_state(txn.states(&*channel.read()?), &m)?

[48.194]

[48.276]

                            .channel_has_state(txn.states(&*channel.read()), &m)?

Replacement in pijul/src/commands/pushpull.rs at line 397 [9.111631]

B:BD[14.7561] → [10.15783:15866]

                            .get_changeset(txn.changes(&*channel.read()?), h_int)?

[14.7561]

[14.7644]

                            .get_changeset(txn.changes(&*channel.read()), h_int)?

Insertion in pijul/src/commands/pushpull.rs at line 419 [9.111631]
[9.119192]
[46.2508]
```
            let txn = txn.read();
```
Deletion in pijul/src/commands/pushpull.rs at line 428 [9.111631]
B:BD[18.9828] → [10.15867:15913]
```
        let txn = Arc::new(RwLock::new(txn));
```

Deletion in pijul/src/commands/pushpull.rs at line 429 [9.111631]

B:BD[10.15987] → [10.15987:16142]

        let mut txn = if let Ok(txn) = Arc::try_unwrap(txn) {
            txn.into_inner().unwrap()
        } else {
            unreachable!()
        };

Replacement in pijul/src/commands/pushpull.rs at line 432 [9.111631]
B:BD[18.9978] → [18.9978:10004]
```
                &mut txn,
```
[18.9978]
[18.10004]
```
                &mut *txn.write(),
```

Replacement in pijul/src/commands/pushpull.rs at line 454 [9.111631]

B:BD[44.566] → [45.98:187]

                let comp = complete_deps(&txn, &None, &repo.changes, &to_download, &d)?;

[44.566]

[44.642]

                let comp = complete_deps(&*txn.read(), &None, &repo.changes, &to_download, &d)?;

Replacement in pijul/src/commands/pushpull.rs at line 469 [9.111631]

B:BD[49.267] → [16.509:565]

            let mut channel = channel.write().unwrap();

[49.267]

[50.155]

            let mut channel = channel.write();
            let mut txn = txn.write();

Replacement in pijul/src/commands/pushpull.rs at line 478 [9.111631]

B:BD[9.120642] → [9.120642:120724]

            .complete_changes(&repo, &txn, &mut channel, &to_download, self.full)

[9.120642]

[9.120724]

            .complete_changes(&repo, &*txn.read(), &mut channel, &to_download, self.full)

Insertion in pijul/src/commands/pushpull.rs at line 485 [9.111631]
[51.801]
[51.801]
```
        let txn_ = txn.read();
```

Replacement in pijul/src/commands/pushpull.rs at line 487 [9.111631]

B:BD[51.839] → [11.11873:11935]

∅:D[11.11935] → [51.894:952]

B:BD[51.894] → [51.894:952]

            if let Some(int) = txn.get_internal(&d.into())? {
                for inode in txn.iter_rev_touched(int)? {

[51.839]

[51.952]

            if let Some(int) = txn_.get_internal(&d.into())? {
                for inode in txn_.iter_rev_touched(int)? {

Replacement in pijul/src/commands/pushpull.rs at line 496 [9.111631]

B:BD[51.1227] → [11.11936:12018]

                        change: txn.get_external(&inode.change)?.unwrap().into(),

[51.1227]

[51.1301]

                        change: txn_.get_external(&inode.change)?.unwrap().into(),

Replacement in pijul/src/commands/pushpull.rs at line 505 [9.111631]
B:BD[51.1543] → [10.16192:16238]
```
        let txn = Arc::new(RwLock::new(txn));
```
[51.1543]
[23.847]
```
        std::mem::drop(txn_);
```

Replacement in pijul/src/commands/pushpull.rs at line 508 [9.111631]

B:BD[23.935] → [23.935:974]

B:BD[23.974] → [10.16239:16493]

∅:D[10.16493] → [23.1129:1269]

B:BD[23.1129] → [23.1129:1269]

            for &i in touched.iter() {
                if let Some((path, _)) = libpijul::fs::find_path(
                    &repo.changes,
                    &*txn.read().unwrap(),
                    &*channel.read()?,
                    false,
                    i,
                )? {
                    touched_paths.push(path)
                } else {
                    touched_paths.clear();
                    break;

[23.935]

[23.1269]

            {
                let txn_ = txn.read();
                for &i in touched.iter() {
                    if let Some((path, _)) =
                        libpijul::fs::find_path(&repo.changes, &*txn_, &*channel.read(), false, i)?
                    {
                        touched_paths.push(path)
                    } else {
                        touched_paths.clear();
                        break;
                    }

Replacement in pijul/src/commands/pushpull.rs at line 538 [9.111631]

B:BD[10.16641] → [10.16641:16692]

                        repo.working_copy.clone(),

[10.16641]

[10.16692]

                        &repo.working_copy,

Replacement in pijul/src/commands/pushpull.rs at line 540 [9.111631]

B:BD[10.16731] → [10.16731:16809]

                        txn.clone(),
                        channel.clone(),

[10.16731]

[10.16809]

                        &txn,
                        &channel,

Replacement in pijul/src/commands/pushpull.rs at line 555 [9.111631]

B:BD[10.17119] → [10.17119:17170]

                        repo.working_copy.clone(),

[10.17119]

[10.17170]

                        &repo.working_copy,

Replacement in pijul/src/commands/pushpull.rs at line 557 [9.111631]

B:BD[10.17209] → [10.17209:17287]

                        txn.clone(),
                        channel.clone(),

[10.17209]

[10.17287]

                        &txn,
                        &channel,

Deletion in pijul/src/commands/pushpull.rs at line 570 [9.111631]

B:BD[18.11136] → [10.17493:17648]

        let mut txn = if let Ok(txn) = Arc::try_unwrap(txn) {
            txn.into_inner().unwrap()
        } else {
            unreachable!()
        };

Replacement in pijul/src/commands/pushpull.rs at line 571 [9.111631]

B:BD[9.120988] → [52.731:794]

            txn.unrecord(&repo.changes, &mut channel, &h, 0)?;

[9.120988]

[9.121048]

            txn.write().unrecord(&repo.changes, &mut channel, &h, 0)?;

Deletion in pijul/src/commands/protocol.rs at line 5 [9.123281]
B:BD[20.1913] → [10.17649:17679]
```
use std::sync::{Arc, RwLock};
```
Replacement in pijul/src/commands/protocol.rs at line 53 [9.123281]
∅:D[13.15837] → [21.457:511]
B:BD[47.6929] → [21.457:511]
```
        let mut txn = repo.pristine.mut_txn_begin()?;
```
[13.15837]
[9.124930]
```
        let txn = repo.pristine.arc_txn_begin()?;
```

Replacement in pijul/src/commands/protocol.rs at line 67 [9.123281]

B:BD[13.15889] → [13.15889:15998]

                let channel = load_channel(&txn, &cap[1])?;
                let c = channel.read().unwrap();

[13.15889]

[13.15998]

                let channel = load_channel(&*txn.read(), &cap[1])?;
                let c = channel.read();

Replacement in pijul/src/commands/protocol.rs at line 72 [9.123281]
∅:D[13.16129] → [9.125465:125525]
B:BD[9.125465] → [9.125465:125525]
```
                let channel = load_channel(&txn, &cap[1])?;
```
[13.16129]
[9.125525]
```
                let channel = load_channel(&*txn.read(), &cap[1])?;
```

Replacement in pijul/src/commands/protocol.rs at line 79 [9.123281]

B:BD[9.125737] → [10.17680:17744]

                    for x in txn.log(&*channel.read()?, pos)? {

[9.125737]

[12.15402]

                    for x in txn.read().log(&*channel.read(), pos)? {

Replacement in pijul/src/commands/protocol.rs at line 94 [9.123281]

B:BD[9.126196] → [10.17745:17836]

                } else if let Some(x) = txn.reverse_log(&*channel.read()?, None)?.next() {

[9.126196]

[12.15540]

                } else if let Some(x) = txn.read().reverse_log(&*channel.read(), None)?.next() {

Replacement in pijul/src/commands/protocol.rs at line 103 [9.123281]

B:BD[9.126588] → [9.126588:126648]

                let channel = load_channel(&txn, &cap[1])?;

[9.126588]

[9.126648]

                let channel = load_channel(&*txn.read(), &cap[1])?;

Insertion in pijul/src/commands/protocol.rs at line 107 [9.123281]
[18.11419]
[9.126749]
```
                let txn = txn.read();
```

Replacement in pijul/src/commands/protocol.rs at line 119 [9.123281]

B:BD[12.15745] → [10.17837:17936]

                            libpijul::fs::iter_graph_descendants(&txn, &channel.read()?.graph, p)?

[12.15745]

[12.15845]

                            libpijul::fs::iter_graph_descendants(&*txn, &channel.read().graph, p)?

Replacement in pijul/src/commands/protocol.rs at line 128 [9.123281]

B:BD[18.11929] → [10.17937:17998]

                for x in txn.log(&*channel.read()?, from)? {

[18.11929]

[12.16097]

                for x in txn.log(&*channel.read(), from)? {

Replacement in pijul/src/commands/protocol.rs at line 191 [9.123281]

B:BD[9.130373] → [16.566:626]

                let channel = load_channel(&txn, &cap[1])?;

[9.130373]

[16.626]

                let channel = load_channel(&*txn.read(), &cap[1])?;

Replacement in pijul/src/commands/protocol.rs at line 193 [9.123281]

B:BD[16.644] → [16.644:794]

                    let mut channel_ = channel.write().unwrap();
                    txn.apply_change_ws(&repo.changes, &mut channel_, &h, &mut ws)?;

[16.644]

[16.794]

                    let mut channel_ = channel.write();
                    txn.write()
                        .apply_change_ws(&repo.changes, &mut channel_, &h, &mut ws)?;

Replacement in pijul/src/commands/protocol.rs at line 205 [9.123281]

B:BD[9.131201] → [9.131201:131261]

                let channel = load_channel(&txn, &cap[1])?;

[9.131201]

[9.131261]

                let channel = load_channel(&*txn.read(), &cap[1])?;

Replacement in pijul/src/commands/protocol.rs at line 212 [9.123281]

B:BD[9.131779] → [10.17999:18091]

∅:D[53.91] → [9.131876:131952]

∅:D[12.16769] → [9.131876:131952]

∅:D[10.18091] → [9.131876:131952]

B:BD[9.131876] → [9.131876:131952]

                    if txn.current_state(&*channel.read()?)? == state && extra.is_empty() {
                        txn.archive(&repo.changes, &channel, &mut tarball)?

[9.131779]

[9.131952]

                    if txn.read().current_state(&*channel.read())? == state && extra.is_empty() {
                        txn.read().archive(&repo.changes, &channel, &mut tarball)?

Insertion in pijul/src/commands/protocol.rs at line 221 [9.123281]
[9.132242]
[9.132242]
```
                        let mut txn = txn.write();
```

Replacement in pijul/src/commands/protocol.rs at line 235 [9.123281]

B:BD[9.132737] → [9.132737:132809]

                    txn.archive(&repo.changes, &channel, &mut tarball)?

[9.132737]

[9.132809]

                    txn.write().archive(&repo.changes, &channel, &mut tarball)?

Deletion in pijul/src/commands/protocol.rs at line 325 [9.123281]
B:BD[9.133262] → [10.18092:18138]
```
        let txn = Arc::new(RwLock::new(txn));
```
Replacement in pijul/src/commands/protocol.rs at line 327 [9.123281]
B:BD[10.18236] → [10.18236:18279]
```
                repo.working_copy.clone(),
```
[10.18236]
[9.133390]
```
                &repo.working_copy,
```

Replacement in pijul/src/commands/protocol.rs at line 329 [9.123281]

B:BD[9.133421] → [10.18280:18342]

                txn.clone(),
                channel.clone(),

[9.133421]

[9.133451]

                &txn,
                &channel,

Deletion in pijul/src/commands/protocol.rs at line 339 [9.123281]

B:BD[9.133549] → [10.18377:18548]

            let txn = if let Ok(txn) = Arc::try_unwrap(txn) {
                txn.into_inner().unwrap()
            } else {
                unreachable!()
            };

Replacement in pijul/src/commands/mod.rs at line 70 [9.133619]
B:BD[10.18685] → [10.18685:18732]
```
    txn: std::sync::Arc<std::sync::RwLock<T>>,
```
[10.18685]
[10.18732]
```
    txn: libpijul::ArcTxn<T>,
```
Replacement in pijul/src/commands/mod.rs at line 81 [9.133619]
B:BD[10.18896] → [10.18896:18931]
```
        repo.working_copy.clone(),
```
[10.18896]
[54.2068]
```
        &repo.working_copy,
```
Replacement in pijul/src/commands/mod.rs at line 90 [9.133619]
B:BD[54.2179] → [10.18996:19036]
```
    let mut txn = txn.write().unwrap();
```
[54.2179]
[54.2179]
```
    let mut txn = txn.write();
```
Replacement in pijul/src/commands/mod.rs at line 97 [9.133619]
B:BD[10.19170] → [10.19170:19202]
```
        c.into_inner().unwrap()
```
[10.19170]
[10.19202]
```
        c.into_inner()
```

Replacement in pijul/src/commands/mod.rs at line 110 [9.133619]

B:BD[54.2561] → [10.19281:19379]

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

[54.2561]

[54.2646]

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

Replacement in pijul/src/commands/log.rs at line 50 [9.134376]

B:BD[9.135542] → [10.19380:19445]

            for h in txn.reverse_log(&*channel.read()?, None)? {

[9.135542]

[11.12912]

            for h in txn.reverse_log(&*channel.read(), None)? {

Replacement in pijul/src/commands/log.rs at line 60 [9.134376]

∅:D[55.986] → [10.19446:19511]

B:BD[9.135743] → [10.19446:19511]

            for h in txn.reverse_log(&*channel.read()?, None)? {

[55.986]

[12.17247]

            for h in txn.reverse_log(&*channel.read(), None)? {

Deletion in pijul/src/commands/git.rs at line 12 [9.137210]
B:BD[9.137436] → [16.813:843]
```
use std::sync::{Arc, RwLock};
```
Replacement in pijul/src/commands/git.rs at line 164 [9.137210]
B:BD[9.141594] → [16.844:873]
```
        txn: Arc<RwLock<T>>,
```
[9.141594]
[9.141615]
```
        txn: &ArcTxn<T>,
```

Replacement in pijul/src/commands/git.rs at line 174 [9.137210]

B:BD[9.142007] → [16.874:930]

                    let mut txn = txn.write().unwrap();

[9.142007]

                    let mut txn = txn.write();

Replacement in pijul/src/commands/git.rs at line 252 [9.137210]
B:BD[9.144061] → [56.0:51]
```
    let txn = repo.repo.pristine.mut_txn_begin()?;
```
[9.144061]
[9.144111]
```
    let txn = repo.repo.pristine.arc_txn_begin()?;
```

Replacement in pijul/src/commands/git.rs at line 256 [9.137210]

B:BD[9.144237] → [2.0:70]

            let channel = if let Some(c) = txn.load_channel(&oid_)? {

[9.144237]

[2.70]

            let channel = if let Some(c) = txn.read().load_channel(&oid_)? {

Replacement in pijul/src/commands/git.rs at line 261 [9.137210]

∅:D[2.179] → [57.976:1005]

B:BD[58.162] → [57.976:1005]

B:BD[57.1005] → [16.931:995]

            let (_, p) = txn
                .changeid_reverse_log(&*channel.read()?, None)?

[2.179]

[9.144396]

            let (_, &p) = txn
                .read()
                .changeid_reverse_log(&*channel.read(), None)?

Replacement in pijul/src/commands/git.rs at line 293 [9.137210]

B:BD[9.145484] → [16.996:1105]

            let txn = repo.repo.pristine.mut_txn_begin()?;
            let txn = Arc::new(RwLock::new(txn));

[9.145484]

            let txn = repo.repo.pristine.arc_txn_begin()?;

Replacement in pijul/src/commands/git.rs at line 303 [9.137210]

B:BD[9.145980] → [16.1184:1240]

                    let mut txn = txn.write().unwrap();

[9.145980]

[58.389]

                    let mut txn = txn.write();

Replacement in pijul/src/commands/git.rs at line 313 [9.137210]

B:BD[9.146349] → [16.1241:1297]

                    let mut txn = txn.write().unwrap();

[9.146349]

                    let mut txn = txn.write();

Replacement in pijul/src/commands/git.rs at line 319 [9.137210]

B:BD[9.146516] → [9.146516:146606]

B:BD[9.146606] → [16.1298:1368]

∅:D[16.1368] → [9.146670:146777]

B:BD[9.146670] → [9.146670:146777]

B:BD[9.146777] → [27.971:1094]

                import_commit_parents(
                    repo,
                    dag,
                    txn.clone(),
                    channel.clone(),
                    &oid,
                    &mut ws,
                    &mut stats,
                )?;
                let state =
                    import_commit(git, repo, txn.clone(), channel.clone(), &oid, &mut stats)?;

[9.146516]

[9.146874]

                import_commit_parents(repo, dag, &txn, &channel, &oid, &mut ws, &mut stats)?;
                let state = import_commit(git, repo, &txn, &channel, &oid, &mut stats)?;

Replacement in pijul/src/commands/git.rs at line 322 [9.137210]

B:BD[9.146925] → [16.1473:1546]

                dag.collect_dead_parents(&oid, &mut todo, txn.clone())?;

[9.146925]

[9.146995]

                dag.collect_dead_parents(&oid, &mut todo, &txn)?;

Deletion in pijul/src/commands/git.rs at line 335 [9.137210]

B:BD[9.147512] → [16.1547:1718]

            let txn = if let Ok(txn) = Arc::try_unwrap(txn) {
                txn.into_inner().unwrap()
            } else {
                unreachable!()
            };

Replacement in pijul/src/commands/git.rs at line 363 [9.137210]

B:BD[9.148197] → [16.1719:1772]

    txn: Arc<RwLock<T>>,
    channel: ChannelRef<T>,

[9.148197]

[9.148239]

    txn: &ArcTxn<T>,
    channel: &ChannelRef<T>,

Replacement in pijul/src/commands/git.rs at line 372 [9.137210]
B:BD[9.148491] → [16.1773:1812]
```
        let txn = txn.read().unwrap();
```
[9.148491]
[9.148491]
```
        let txn = txn.read();
```

Replacement in pijul/src/commands/git.rs at line 386 [9.137210]

B:BD[59.131] → [16.1813:1869]

            for x in txn.log(&*p_channel.read()?, 0)? {

[59.131]

[58.594]

            for x in txn.log(&*p_channel.read(), 0)? {

Replacement in pijul/src/commands/git.rs at line 412 [9.137210]

B:BD[9.149856] → [16.1958:2011]

    txn: Arc<RwLock<T>>,
    channel: ChannelRef<T>,

[9.149856]

[9.149906]

    txn: &ArcTxn<T>,
    channel: &ChannelRef<T>,

Replacement in pijul/src/commands/git.rs at line 419 [9.137210]

B:BD[9.150070] → [16.2012:2111]

    let (needs_output, to_apply) = make_apply_plan(repo, txn.clone(), channel.clone(), dag, oid)?;

[9.150070]

[9.150152]

    let (needs_output, to_apply) = make_apply_plan(repo, &txn, &channel, dag, oid)?;

Replacement in pijul/src/commands/git.rs at line 424 [9.137210]
B:BD[9.150285] → [16.2112:2153]
```
    let mut txn_ = txn.write().unwrap();
```
[9.150285]
[9.150285]
```
    let mut txn_ = txn.write();
```
Replacement in pijul/src/commands/git.rs at line 426 [9.137210]
B:BD[9.150321] → [16.2154:2207]
```
        let mut channel_ = channel.write().unwrap();
```
[9.150321]
[16.2207]
```
        let mut channel_ = channel.write();
```

Replacement in pijul/src/commands/git.rs at line 435 [9.137210]

B:BD[9.150649] → [16.2428:2512]

        check_alive_debug(&repo.repo.changes, &*txn_, &*channel.read()?, line!())?;

[9.150649]

[9.150714]

        check_alive_debug(&repo.repo.changes, &*txn_, &*channel.read(), line!())?;

Replacement in pijul/src/commands/git.rs at line 447 [9.137210]
B:BD[16.2635] → [16.2635:2679]
```
            repo.repo.working_copy.clone(),
```
[16.2635]
[9.151374]
```
            &repo.repo.working_copy,
```

Replacement in pijul/src/commands/git.rs at line 449 [9.137210]

B:BD[9.151406] → [16.2680:2734]

            txn.clone(),
            channel.clone(),

[9.151406]

[9.151427]

            &txn,
            &channel,

Replacement in pijul/src/commands/git.rs at line 459 [9.137210]

B:BD[9.151569] → [16.2765:2902]

            let txn = txn.read().unwrap();
            check_alive_debug(&repo.repo.changes, &*txn, &channel.read().unwrap(), line!())?;

[9.151569]

[9.151638]

            let txn = txn.read();
            check_alive_debug(&repo.repo.changes, &*txn, &channel.read(), line!())?;

Replacement in pijul/src/commands/git.rs at line 467 [9.137210]

B:BD[9.151772] → [16.2903:3014]

        let txn = txn.read().unwrap();
        check_tree_inodes(&*txn, txn.graph(&*channel.read().unwrap()));

[9.151772]

[9.151823]

        let txn = txn.read();
        check_tree_inodes(&*txn, txn.graph(&*channel.read()));

Replacement in pijul/src/commands/git.rs at line 479 [9.137210]

B:BD[9.152048] → [16.3015:3068]

    txn: Arc<RwLock<T>>,
    channel: ChannelRef<T>,

[9.152048]

[9.152098]

    txn: &ArcTxn<T>,
    channel: &ChannelRef<T>,

Replacement in pijul/src/commands/git.rs at line 534 [9.137210]
B:BD[9.153980] → [16.3069:3117]
```
            let mut txn = txn.write().unwrap();
```
[9.153980]
[9.153980]
```
            let mut txn = txn.write();
```

Replacement in pijul/src/commands/git.rs at line 621 [9.137210]

B:BD[9.157665] → [16.3302:3355]

    txn: Arc<RwLock<T>>,
    channel: ChannelRef<T>,

[9.157665]

[9.157715]

    txn: &ArcTxn<T>,
    channel: &ChannelRef<T>,

Replacement in pijul/src/commands/git.rs at line 626 [9.137210]

B:BD[46.3958] → [16.3356:3452]

    let (object, prefixes) = git_reset(git, repo, txn.clone(), channel.clone(), child, stats)?;

[46.3958]

[60.319]

    let (object, prefixes) = git_reset(git, repo, &txn, &channel, child, stats)?;

Replacement in pijul/src/commands/git.rs at line 628 [9.137210]
∅:D[60.360] → [16.3452:3493]
B:BD[16.3452] → [16.3452:3493]
```
    let mut txn_ = txn.write().unwrap();
```
[60.360]
[9.157898]
```
    let mut txn_ = txn.write();
```

Replacement in pijul/src/commands/git.rs at line 643 [9.137210]

B:BD[9.158287] → [27.1231:1331]

    debug!(
        "recording on channel {:?}",
        txn_.name(&channel.read().unwrap())
    );

[9.158287]

[9.158352]

    debug!("recording on channel {:?}", txn_.name(&channel.read()));

Replacement in pijul/src/commands/git.rs at line 670 [9.137210]

B:BD[9.158491] → [16.3733:3819]

        txn.clone(),
        channel.clone(),
        repo.repo.working_copy.clone(),

[9.158491]

[9.158558]

        &txn,
        &channel,
        &repo.repo.working_copy,

Replacement in pijul/src/commands/git.rs at line 691 [9.137210]

B:BD[4.354] → [4.354:465]

        let mut txn = txn.write().unwrap();
        let name = txn.name(&channel.read().unwrap()).to_string();

[4.354]

[4.465]

        let mut txn = txn.write();
        let name = txn.name(&channel.read()).to_string();

Replacement in pijul/src/commands/git.rs at line 695 [9.137210]
∅:D[4.513] → [16.3820:3855]
B:BD[9.159191] → [16.3820:3855]
```
    let txn = txn.read().unwrap();
```
[4.512]
[9.159191]
```
    let txn = txn.read();
```

Replacement in pijul/src/commands/git.rs at line 700 [9.137210]

B:BD[61.404] → [16.3856:3925]

            return Ok(txn.current_state(&channel.read().unwrap())?);

[61.404]

[61.474]

            return Ok(txn.current_state(&channel.read())?);

Replacement in pijul/src/commands/git.rs at line 707 [9.137210]

B:BD[9.159718] → [16.3926:4016]

        check_alive_debug(&repo.repo.changes, &*txn, &channel.read().unwrap(), line!())?;

[9.159718]

[9.159783]

        check_alive_debug(&repo.repo.changes, &*txn, &channel.read(), line!())?;

Replacement in pijul/src/commands/git.rs at line 714 [9.137210]

B:BD[9.160168] → [16.4173:4244]

        check_tree_inodes(&*txn, txn.graph(&channel.read().unwrap()));

[9.160168]

[9.160219]

        check_tree_inodes(&*txn, txn.graph(&channel.read()));

Replacement in pijul/src/commands/git.rs at line 724 [9.137210]

∅:D[27.1625] → [16.4382:4494]

B:BD[16.4382] → [16.4382:4494]

    txn: Arc<RwLock<T>>,
    channel: ChannelRef<T>,
    working_copy: Arc<libpijul::working_copy::FileSystem>,

[27.1625]

[9.160570]

    txn: &ArcTxn<T>,
    channel: &ChannelRef<T>,
    working_copy: &libpijul::working_copy::FileSystem,

Replacement in pijul/src/commands/git.rs at line 757 [9.137210]
B:BD[9.161002] → [16.4997:5037]
```
    let mut txn = txn.write().unwrap();
```
[9.161002]
[9.161002]
```
    let mut txn = txn.write();
```

Replacement in pijul/src/commands/git.rs at line 759 [9.137210]

B:BD[9.161034] → [59.1394:1447]

B:BD[59.1447] → [27.1626:1717]

∅:D[27.1717] → [59.1514:1526]

∅:D[16.5112] → [59.1514:1526]

B:BD[59.1514] → [59.1514:1526]

        return Ok((
            0,
            None,
            txn.current_state(&channel.read().unwrap())
                .map_err(TxnErr)?,
        ));

[9.161034]

[9.161102]

        return Ok((0, None, txn.current_state(&channel.read()).map_err(TxnErr)?));

Replacement in pijul/src/commands/git.rs at line 768 [9.137210]

B:BD[59.1614] → [16.5164:5254]

        libpijul::change::dependencies(&*txn, &channel.read().unwrap(), actions.iter())?;

[59.1614]

[9.161362]

        libpijul::change::dependencies(&*txn, &channel.read(), actions.iter())?;

Replacement in pijul/src/commands/git.rs at line 773 [9.137210]

B:BD[9.161474] → [16.5289:5364]

        std::mem::replace(&mut *rec.contents.lock().unwrap(), Vec::new()),

[9.161474]

[9.161496]

        std::mem::replace(&mut *rec.contents.lock(), Vec::new()),

Replacement in pijul/src/commands/fork.rs at line 32 [9.167873]

B:BD[16.5516] → [16.5516:5572]

            let mut channel = channel.write().unwrap();

[16.5516]

[11.13204]

            let mut channel = channel.write();

Insertion in pijul/src/commands/fork.rs at line 35 [9.167873]

[9.168764]

[24.2740]

            let cur = txn
                .current_channel()
                .unwrap_or(crate::DEFAULT_CHANNEL)
                .to_string();

Replacement in pijul/src/commands/fork.rs at line 42 [9.167873]

B:BD[24.2846] → [24.2846:2958]

                txn.current_channel().unwrap_or(crate::DEFAULT_CHANNEL)
            }
            .to_string();

[24.2846]

[24.2958]

                cur.as_str()
            };

Deletion in pijul/src/commands/file_operations.rs at line 3 [9.169058]
B:BD[62.32] → [10.19512:19542]
```
use std::sync::{Arc, RwLock};
```
Replacement in pijul/src/commands/file_operations.rs at line 121 [9.169058]
∅:D[8.405] → [10.19543:19593]
∅:D[13.23934] → [10.19543:19593]
B:BD[11.13499] → [10.19543:19593]
```
        let txn = repo.pristine.mut_txn_begin()?;
```
[8.405]
[63.192]
```
        let txn = repo.pristine.arc_txn_begin()?;
```
Deletion in pijul/src/commands/file_operations.rs at line 125 [9.169058]
B:BD[64.44] → [10.19594:19640]
```
        let txn = Arc::new(RwLock::new(txn));
```
Replacement in pijul/src/commands/file_operations.rs at line 151 [9.169058]
B:BD[9.172105] → [10.19679:19731]
```
                let mut txn = txn.write().unwrap();
```
[9.172105]
[64.562]
```
                let mut txn = txn.write();
```

Deletion in pijul/src/commands/file_operations.rs at line 165 [9.169058]

B:BD[9.172406] → [9.172406:172416]

B:BD[9.172416] → [10.19732:19873]

        }
        if let Ok(txn) = Arc::try_unwrap(txn) {
            txn.into_inner().unwrap().commit()?;
        } else {
            unreachable!()

Insertion in pijul/src/commands/file_operations.rs at line 166 [9.169058]
[10.19883]
[9.172439]
```
        txn.commit()?;
```
Deletion in pijul/src/commands/diff.rs at line 4 [9.173551]
B:BD[9.173738] → [10.19884:19914]
```
use std::sync::{Arc, RwLock};
```
Replacement in pijul/src/commands/diff.rs at line 37 [9.173551]
∅:D[10.20012] → [21.787:841]
∅:D[13.24070] → [21.787:841]
B:BD[47.15538] → [21.787:841]
```
        let mut txn = repo.pristine.mut_txn_begin()?;
```
[13.24070]
[9.174231]
```
        let txn = repo.pristine.arc_txn_begin()?;
```

Insertion in pijul/src/commands/diff.rs at line 39 [9.173551]

[9.174275]

[24.3061]

        let cur = txn
            .read()
            .current_channel()
            .unwrap_or(crate::DEFAULT_CHANNEL)
            .to_string();

Replacement in pijul/src/commands/diff.rs at line 47 [9.173551]

B:BD[24.3150] → [24.3150:3311]

            txn.current_channel().unwrap_or(crate::DEFAULT_CHANNEL)
        }
        .to_string();
        let channel = txn.open_or_create_channel(&channel)?;

[24.3150]

[9.174398]

            cur.as_str()
        };
        let channel = txn.write().open_or_create_channel(&channel)?;

Deletion in pijul/src/commands/diff.rs at line 52 [9.173551]
B:BD[9.174455] → [10.20036:20082]
```
        let txn = Arc::new(RwLock::new(txn));
```
Replacement in pijul/src/commands/diff.rs at line 57 [9.173551]
B:BD[10.20172] → [10.20172:20215]
```
                repo.working_copy.clone(),
```
[10.20172]
[9.174663]
```
                &repo.working_copy,
```
Replacement in pijul/src/commands/diff.rs at line 79 [9.173551]
B:BD[9.175145] → [10.20313:20353]
```
        let txn = txn.write().unwrap();
```
[9.175145]
[9.175145]
```
        let txn = txn.write();
```
Replacement in pijul/src/commands/diff.rs at line 86 [9.173551]
B:BD[10.20493] → [10.20493:20532]
```
            cont.into_inner().unwrap()
```
[10.20493]
[10.20532]
```
            cont.into_inner()
```

Replacement in pijul/src/commands/diff.rs at line 102 [9.173551]

B:BD[9.175615] → [10.20680:20755]

            dependencies(&*txn, &*channel.read()?, change.changes.iter())?

[9.175615]

[9.175679]

            dependencies(&*txn, &*channel.read(), change.changes.iter())?

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

B:BD[10.21604] → [10.21604:21648]

                    &channel.read()?.graph,

[10.21604]

[10.21648]

                    &channel.read().graph,

Replacement in pijul/src/commands/debug.rs at line 52 [9.177758]

B:BD[10.21794] → [10.21794:21841]

                let channel = channel.read()?;

[10.21794]

[10.21841]

                let channel = channel.read();

Replacement in pijul/src/commands/debug.rs at line 55 [9.177758]

B:BD[10.21940] → [10.21940:22035]

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

[10.21940]

[65.177]

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

Replacement in pijul/src/commands/debug.rs at line 59 [9.177758]
B:BD[66.50] → [10.22036:22075]
```
        let channel = channel.read()?;
```
[66.50]
[10.22075]
```
        let channel = channel.read();
```
Replacement in pijul/src/commands/credit.rs at line 53 [9.178684]
B:BD[67.237] → [10.22165:22212]
```
        let channel = channel.read().unwrap();
```
[67.237]
[68.0]
```
        let channel = channel.read();
```
Deletion in pijul/src/commands/clone.rs at line 8 [9.182891]
B:BD[20.2958] → [10.22363:22393]
```
use std::sync::{Arc, RwLock};
```

Replacement in pijul/src/commands/clone.rs at line 76 [9.182891]

B:BD[47.15873] → [21.842:896]

∅:D[21.896] → [9.184837:184907]

B:BD[9.184837] → [9.184837:184907]

        let mut txn = repo.pristine.mut_txn_begin()?;
        let mut channel = txn.open_or_create_channel(&self.channel)?;

[47.15873]

[9.184907]

        let txn = repo.pristine.arc_txn_begin()?;
        let mut channel = txn.write().open_or_create_channel(&self.channel)?;

Replacement in pijul/src/commands/clone.rs at line 81 [9.182891]

B:BD[9.185011] → [9.185011:185079]

                .clone_tag(&mut repo, &mut txn, &mut channel, &[h])

[9.185011]

[9.185079]

                .clone_tag(&mut repo, &mut *txn.write(), &mut channel, &[h])

Replacement in pijul/src/commands/clone.rs at line 86 [9.182891]

B:BD[9.185211] → [11.13751:13818]

                .clone_state(&mut repo, &mut txn, &mut channel, h)

[9.185211]

[9.185289]

                .clone_state(&mut repo, &mut *txn.write(), &mut channel, h)

Replacement in pijul/src/commands/clone.rs at line 90 [9.182891]

B:BD[9.185349] → [11.13819:13906]

                .clone_channel(&mut repo, &mut txn, &mut channel, &self.partial_paths)

[9.185349]

[9.185566]

                .clone_channel(
                    &mut repo,
                    &mut *txn.write(),
                    &mut channel,
                    &self.partial_paths,
                )

Deletion in pijul/src/commands/clone.rs at line 99 [9.182891]
B:BD[10.22558] → [10.22558:22604]
```
        let txn = Arc::new(RwLock::new(txn));
```
Replacement in pijul/src/commands/clone.rs at line 100 [9.182891]
B:BD[10.22660] → [10.22660:22699]
```
            repo.working_copy.clone(),
```
[10.22660]
[9.185679]
```
            &repo.working_copy,
```

Replacement in pijul/src/commands/clone.rs at line 102 [9.182891]

B:BD[9.185706] → [10.22700:22746]

            txn.clone(),
            channel,

[9.185706]

[9.185732]

            &txn,
            &channel,

Replacement in pijul/src/commands/clone.rs at line 111 [9.182891]

B:BD[69.534] → [24.3747:3807]

∅:D[24.3807] → [10.22833:22924]

B:BD[10.22833] → [10.22833:22924]

B:BD[10.22924] → [24.3808:3857]

        let mut txn = if let Ok(t) = Arc::try_unwrap(txn) {
            t.into_inner().unwrap()
        } else {
            unreachable!()
        };
        txn.set_current_channel(&self.channel)?;

[69.534]

[9.185778]

        txn.write().set_current_channel(&self.channel)?;

Replacement in pijul/src/commands/channel.rs at line 47 [9.186892]

B:BD[10.23190] → [10.23190:23241]

                    let channel = channel.read()?;

[10.23190]

[10.23241]

                    let channel = channel.read();

Replacement in pijul/src/commands/change.rs at line 35 [9.189306]
B:BD[70.243] → [10.23294:23337]
```
            let channel = channel.read()?;
```
[70.243]
[10.23337]
```
            let channel = channel.read();
```
Deletion in pijul/src/commands/apply.rs at line 2 [9.194289]
B:BD[20.3361] → [10.23410:23440]
```
use std::sync::{Arc, RwLock};
```

Replacement in pijul/src/commands/apply.rs at line 6 [9.194289]

B:BD[9.194383] → [71.553:617]

use libpijul::{DepsTxnT, GraphTxnT, MutTxnT, MutTxnTExt, TxnT};

[9.194383]

[10.23441]

use libpijul::{DepsTxnT, GraphTxnT, MutTxnTExt, TxnT};

Replacement in pijul/src/commands/apply.rs at line 31 [9.194289]

∅:D[10.23541] → [21.1086:1140]

∅:D[13.25009] → [21.1086:1140]

B:BD[47.16700] → [21.1086:1140]

B:BD[21.1140] → [24.4820:4895]

        let mut txn = repo.pristine.mut_txn_begin()?;
        let cur = txn.current_channel().unwrap_or(crate::DEFAULT_CHANNEL);

[13.25009]

[24.4895]

        let txn = repo.pristine.arc_txn_begin()?;
        let cur = txn
            .read()
            .current_channel()
            .unwrap_or(crate::DEFAULT_CHANNEL)
            .to_string();

Replacement in pijul/src/commands/apply.rs at line 40 [9.194289]
B:BD[24.4989] → [24.4989:5005]
```
            cur
```
[24.4989]
[24.5005]
```
            cur.as_str()
```

Replacement in pijul/src/commands/apply.rs at line 43 [9.194289]

∅:D[24.5070] → [16.5573:5653]

B:BD[23.2922] → [16.5573:5653]

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

[24.5070]

[9.195133]

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

Replacement in pijul/src/commands/apply.rs at line 50 [9.194289]

B:BD[72.855] → [72.855:921]

            hashes.push(if let Ok(h) = txn.hash_from_prefix(ch) {

[72.855]

[9.195519]

            hashes.push(if let Ok(h) = txn.read().hash_from_prefix(ch) {

Replacement in pijul/src/commands/apply.rs at line 77 [9.194289]

B:BD[72.1173] → [16.5654:5710]

∅:D[16.5710] → [11.14215:14301]

B:BD[72.1173] → [11.14215:14301]

            let mut channel = channel.write().unwrap();
            txn.apply_deps_rec(&repo.changes, &mut channel, hashes.last().unwrap())?;

[72.1173]

[9.196040]

            let mut channel = channel.write();
            txn.write()
                .apply_deps_rec(&repo.changes, &mut channel, hashes.last().unwrap())?;

Replacement in pijul/src/commands/apply.rs at line 81 [9.194289]

B:BD[9.196057] → [16.5711:5767]

            let mut channel = channel.write().unwrap();

[9.196057]

[11.14302]

            let mut channel = channel.write();
            let mut txn = txn.write();

Insertion in pijul/src/commands/apply.rs at line 89 [9.194289]
[10.23685]
[71.661]
```
        let txn_ = txn.read();
```

Replacement in pijul/src/commands/apply.rs at line 91 [9.194289]

B:BD[71.694] → [11.14343:14405]

            if let Some(int) = txn.get_internal(&d.into())? {

[71.694]

[11.14405]

            if let Some(int) = txn_.get_internal(&d.into())? {

Replacement in pijul/src/commands/apply.rs at line 93 [9.194289]

∅:D[11.14448] → [71.749:807]

B:BD[71.749] → [71.749:807]

                for inode in txn.iter_rev_touched(int)? {

[11.14448]

[11.14449]

                for inode in txn_.iter_rev_touched(int)? {

Insertion in pijul/src/commands/apply.rs at line 105 [9.194289]
[71.1106]
[71.1106]
```
        std::mem::drop(txn_);
```
Deletion in pijul/src/commands/apply.rs at line 107 [9.194289]
B:BD[71.1107] → [10.23686:23732]
```
        let txn = Arc::new(RwLock::new(txn));
```
Replacement in pijul/src/commands/apply.rs at line 109 [9.194289]
B:BD[23.3026] → [10.23733:23777]
```
            let txn_ = txn.read().unwrap();
```
[23.3026]
[23.3026]
```
            let txn_ = txn.read();
```

Replacement in pijul/src/commands/apply.rs at line 112 [9.194289]

B:BD[23.3098] → [10.23778:23875]

                    libpijul::fs::find_path(&repo.changes, &*txn_, &*channel.read()?, false, i)?

[23.3098]

[23.3193]

                    libpijul::fs::find_path(&repo.changes, &*txn_, &*channel.read(), false, i)?

Replacement in pijul/src/commands/apply.rs at line 130 [9.194289]

B:BD[10.23975] → [10.23975:24022]

                    repo.working_copy.clone(),

[10.23975]

[23.3524]

                    &repo.working_copy,

Replacement in pijul/src/commands/apply.rs at line 132 [9.194289]

B:BD[23.3559] → [10.24023:24093]

                    txn.clone(),
                    channel.clone(),

[23.3559]

[23.3593]

                    &txn,
                    &channel,

Replacement in pijul/src/commands/apply.rs at line 143 [9.194289]

B:BD[10.24196] → [10.24196:24243]

                    repo.working_copy.clone(),

[10.24196]

[23.3843]

                    &repo.working_copy,

Replacement in pijul/src/commands/apply.rs at line 145 [9.194289]

B:BD[23.3878] → [10.24244:24314]

                    txn.clone(),
                    channel.clone(),

[23.3878]

[23.3912]

                    &txn,
                    &channel,

Deletion in pijul/src/commands/apply.rs at line 156 [9.194289]

B:BD[73.1652] → [10.24353:24504]

        let txn = if let Ok(txn) = Arc::try_unwrap(txn) {
            txn.into_inner().unwrap()
        } else {
            unreachable!()
        };