jcdickinson/pijul - Change YXAVFTPP2PQAYMKGQH7QNKFVGKDI2UHVWB7SIDA4QEYSBP75ZGUQC

Allowing vertex buffer to use references to the transaction, by changing `output::output` to take an ArcTxn<T> instead of a simple T

Created by pmeunier on April 29, 2022

YXAVFTPP2PQAYMKGQH7QNKFVGKDI2UHVWB7SIDA4QEYSBP75ZGUQC

Dependencies

In channels

main

Change contents

Replacement in pijul/src/remote/mod.rs at line 936 [7.52474]

B:BD[7.61269] → [8.0:63]

∅:D[8.63] → [9.8957:9035]

B:BD[7.61331] → [9.8957:9035]

B:BD[9.9035] → [10.0:100]

                    let mut txn = l.pristine.mut_txn_begin()?;
                    let mut channel = txn.load_channel(&l.channel)?.unwrap();
                    txn.archive_with_state(&changes, &mut channel, &state, extra, &mut tarball, 0)?

[7.61269]

[7.61504]

                    let txn = l.pristine.arc_txn_begin()?;
                    let channel = {
                        let txn = txn.read();
                        txn.load_channel(&l.channel)?.unwrap()
                    };
                    txn.archive_with_state(&changes, &channel, &state, extra, &mut tarball, 0)?

Replacement in pijul/src/remote/mod.rs at line 943 [7.52474]

B:BD[7.61529] → [7.61529:61584]

B:BD[7.61584] → [9.9036:9110]

                    let txn = l.pristine.txn_begin()?;
                    let channel = txn.load_channel(&l.channel)?.unwrap();

[7.61529]

[7.61657]

                    let txn = l.pristine.arc_txn_begin()?;
                    let channel = {
                        let txn = txn.read();
                        txn.load_channel(&l.channel)?.unwrap()
                    };

Replacement in pijul/src/commands/reset.rs at line 86 [7.97650]

B:BD[7.99469] → [11.3852:3915]

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

[7.99469]

[7.99495]

                &txn,
                &channel,

Replacement in pijul/src/commands/protocol.rs at line 297 [7.123281]

B:BD[11.12446] → [11.12446:12529]

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

[11.12446]

[7.131952]

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

Replacement in pijul/src/commands/protocol.rs at line 305 [7.123281]

B:BD[7.132242] → [11.12530:12581]

∅:D[11.12581] → [7.132242:132314]

B:BD[7.132242] → [7.132242:132314]

                        let mut txn = txn.write();
                        let mut fork = txn.fork(&channel, &fork_name)?;

[7.132242]

[7.132314]

                        let mut fork = {
                            let mut txn = txn.write();
                            txn.fork(&channel, &fork_name)?
                        };

Replacement in pijul/src/commands/protocol.rs at line 317 [7.123281]

B:BD[7.132601] → [7.132601:132656]

                        txn.drop_channel(&fork_name)?;

[7.132601]

[7.132656]

                        txn.write().drop_channel(&fork_name)?;

Replacement in pijul/src/commands/protocol.rs at line 321 [7.123281]

B:BD[7.132737] → [11.12582:12662]

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

[7.132737]

[7.132809]

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

Replacement in pijul/src/commands/credit.rs at line 29 [7.178684]
∅:D[12.3572] → [7.179302:179348]
∅:D[13.13643] → [7.179302:179348]
∅:D[14.15812] → [7.179302:179348]
∅:D[15.24306] → [7.179302:179348]
B:BD[7.179302] → [7.179302:179348]
```
        let txn = repo.pristine.txn_begin()?;
```
[15.24306]
[12.3573]
```
        let txn_ = repo.pristine.arc_txn_begin()?;
        let txn = txn_.read();
```
Replacement in pijul/src/commands/credit.rs at line 54 [7.178684]
B:BD[16.237] → [11.16703:16741]
```
        let channel = channel.read();
```
[16.237]
[17.0]
```
        std::mem::drop(txn);
```
Replacement in pijul/src/commands/credit.rs at line 57 [7.178684]
B:BD[7.180336] → [18.22252:22270]
```
            &txn,
```
[7.180336]
[7.180336]
```
            &txn_,
```

Replacement in pijul/src/commands/credit.rs at line 60 [7.178684]

B:BD[7.180375] → [18.22271:22338]

            &mut Creditor::new(std::io::stdout(), &txn, &channel),

[7.180375]

[17.46]

            &mut Creditor::new(std::io::stdout(), txn_.clone(), channel.clone()),

Replacement in pijul/src/commands/credit.rs at line 75 [7.178684]
B:BD[7.180479] → [9.18260:18321]
```
pub struct Creditor<'a, W: std::io::Write, T: ChannelTxnT> {
```
[7.180479]
[7.180533]
```
pub struct Creditor<W: std::io::Write, T: ChannelTxnT> {
```
Replacement in pijul/src/commands/credit.rs at line 80 [7.178684]
∅:D[2.28] → [7.180613:180629]
B:BD[7.180613] → [7.180613:180629]
B:BD[7.180629] → [19.844:873]
```
    txn: &'a T,
    channel: &'a T::Channel,
```
[2.28]
[7.180658]
```
    txn: ArcTxn<T>,
    channel: ChannelRef<T>,
```

Replacement in pijul/src/commands/credit.rs at line 84 [7.178684]

B:BD[7.180661] → [9.18322:18387]

B:BD[9.18387] → [19.874:942]

impl<'a, W: std::io::Write, T: ChannelTxnT> Creditor<'a, W, T> {
    pub fn new(w: W, txn: &'a T, channel: &'a T::Channel) -> Self {

[7.180661]

[7.180787]

impl<W: std::io::Write, T: ChannelTxnT> Creditor<W, T> {
    pub fn new(w: W, txn: ArcTxn<T>, channel: ChannelRef<T>) -> Self {

Replacement in pijul/src/commands/credit.rs at line 97 [7.178684]

B:BD[7.180972] → [20.6081:6159]

impl<'a, W: std::io::Write, T: TxnTExt> VertexBuffer for Creditor<'a, W, T> {

[7.180972]

[5.0]

impl<W: std::io::Write, T: TxnTExt> VertexBuffer for Creditor<W, T> {

Replacement in pijul/src/commands/credit.rs at line 112 [7.178684]

B:BD[7.181426] → [7.181426:181558]

            for e in self
                .txn
                .iter_adjacent(self.channel, v, EdgeFlags::PARENT, EdgeFlags::all())

[7.181426]

[9.18388]

            let txn = self.txn.read();
            let channel = self.channel.read();
            for e in txn
                .iter_adjacent(&channel, v, EdgeFlags::PARENT, EdgeFlags::all())

Replacement in pijul/src/commands/credit.rs at line 122 [7.178684]

B:BD[9.18546] → [2.29:114]

                if let Ok(Some(intro)) = self.txn.get_external(&e.introduced_by()) {

[9.18546]

[2.114]

                if let Ok(Some(intro)) = txn.get_external(&e.introduced_by()) {

Replacement in pijul/src/commands/archive.rs at line 5 [7.191083]
∅:D[21.1637] → [20.6427:6484]
B:BD[22.3169] → [20.6427:6484]
```
use libpijul::{Hash, Merkle, MutTxnTExt, TxnT, TxnTExt};
```
[21.1637]
[22.3252]
```
use libpijul::{Hash, Merkle, TxnT};
```

Replacement in pijul/src/commands/archive.rs at line 114 [7.191083]

B:BD[7.193436] → [8.1023:1085]

B:BD[8.1085] → [12.4392:4586]

                let mut txn = repo.pristine.mut_txn_begin()?;
                let channel_name = if let Some(ref c) = self.channel {
                    c
                } else {
                    txn.current_channel().unwrap_or(crate::DEFAULT_CHANNEL)

[7.193436]

[12.4586]

                let txn = repo.pristine.arc_txn_begin()?;
                let channel = {
                    let txn = txn.read();
                    let channel_name = if let Some(ref c) = self.channel {
                        c
                    } else {
                        txn.current_channel().unwrap_or(crate::DEFAULT_CHANNEL)
                    };
                    txn.load_channel(&channel_name)?.unwrap()

Deletion in pijul/src/commands/archive.rs at line 124 [7.191083]
∅:D[8.1085] → [9.19221:19298]
∅:D[12.4605] → [9.19221:19298]
B:BD[7.193497] → [9.19221:19298]
```
                let mut channel = txn.load_channel(&channel_name)?.unwrap();
```
Replacement in pijul/src/commands/archive.rs at line 126 [7.191083]
B:BD[7.193648] → [7.193648:193682]
```
                    &mut channel,
```
[7.193648]
[13.14173]
```
                    &channel,
```

Replacement in pijul/src/commands/archive.rs at line 133 [7.191083]

B:BD[7.193815] → [7.193815:193869]

B:BD[7.193869] → [12.4606:4800]

                let txn = repo.pristine.txn_begin()?;
                let channel_name = if let Some(ref c) = self.channel {
                    c
                } else {
                    txn.current_channel().unwrap_or(crate::DEFAULT_CHANNEL)

[7.193815]

[12.4800]

                let txn = repo.pristine.arc_txn_begin()?;
                let channel = {
                    let txn = txn.read();
                    let channel_name = if let Some(ref c) = self.channel {
                        c
                    } else {
                        txn.current_channel().unwrap_or(crate::DEFAULT_CHANNEL)
                    };
                    if let Some(channel) = txn.load_channel(&channel_name)? {
                        channel
                    } else {
                        bail!("No such channel: {:?}", channel_name);
                    }

Replacement in pijul/src/commands/archive.rs at line 147 [7.191083]

B:BD[12.4819] → [4.0:255]

                if let Some(channel) = txn.load_channel(&channel_name)? {
                    txn.archive(&repo.changes, &channel, &mut tarball)?
                } else {
                    bail!("No such channel: {:?}", channel_name);
                }

[12.4819]

[7.194009]

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

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

B:BD[7.500045] → [23.98128:98198]

B:BD[23.98198] → [3.40:93]

∅:D[3.93] → [24.6768:6853]

B:BD[24.6768] → [24.6768:6853]

        let txn_ = txn.read();
        let channel_ = channel.read();
        let (former_parents, is_deleted, encoding) =
            collect_former_parents::<C, W, T>(changes, &*txn_, &*channel_, vertex)?;

[7.499882]

[7.501222]

        let (former_parents, is_deleted, encoding) = {
            let txn_ = txn.read();
            let channel_ = channel.read();
            collect_former_parents::<C, W, T>(changes, &*txn_, &*channel_, vertex)?
        };

Replacement in libpijul/src/record.rs at line 918 [7.488880]
B:BD[24.6890] → [24.6890:6914]
```
                &*txn_,
```
[24.6890]
[24.6914]
```
                txn,
```
Replacement in libpijul/src/record.rs at line 922 [7.488880]
B:BD[24.6972] → [24.6972:7000]
```
                &*channel_,
```
[24.6972]
[24.7000]
```
                channel,
```

Insertion in libpijul/src/record.rs at line 935 [7.488880]

[7.503210]

[19.28919]

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

Replacement in libpijul/src/record.rs at line 951 [7.488880]
B:BD[24.7491] → [24.7491:7508]
```
        txn: &T,
```
[24.7491]
[24.7508]
```
        txn: &ArcTxn<T>,
```
Replacement in libpijul/src/record.rs at line 955 [7.488880]
B:BD[24.7589] → [24.7589:7619]
```
        channel: &T::Channel,
```
[24.7589]
[24.7619]
```
        channel: &ChannelRef<T>,
```

Insertion in libpijul/src/record.rs at line 979 [7.488880]

[3.681]

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

Replacement in libpijul/src/record.rs at line 983 [7.488880]

B:BD[3.753] → [3.753:799]

                txn,
                channel,

[3.753]

[3.799]

                &*txn,
                &*channel,

Insertion in libpijul/src/record.rs at line 997 [7.488880]

[24.8323]

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

Replacement in libpijul/src/record.rs at line 1001 [7.488880]

B:BD[25.2335] → [24.8371:8417]

                txn,
                channel,

[25.2335]

[24.8417]

                &*txn,
                &*channel,

Replacement in libpijul/src/record.rs at line 1011 [7.488880]

B:BD[24.8626] → [24.8626:8720]

                || modified_since_last_commit(txn, channel, &working_copy, &item.full_path)?)

[24.8626]

[24.8720]

                || modified_since_last_commit(
                    &*txn.read(),
                    &*channel.read(),
                    &working_copy,
                    &item.full_path,
                )?)

Replacement in libpijul/src/record.rs at line 1018 [7.488880]

B:BD[24.8730] → [24.8730:8800]

            let mut ret = retrieve(txn, txn.graph(channel), vertex)?;

[24.8730]

[24.8800]

            let mut ret = {
                let txn = txn.read();
                let channel = channel.read();
                retrieve(&*txn, txn.graph(&*channel), vertex)?
            };

Replacement in libpijul/src/output/output.rs at line 649 [7.671807]

B:BD[26.26402] → [6.158:368]

    {
        let txn = txn.read();
        let channel = channel.read();
        alive::output_graph(changes, &*txn, &*channel, &mut f, &mut l, forward)
            .map_err(PristineOutputError::from)?;
    }

[26.26402]

[26.26524]

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

Replacement in libpijul/src/output/mod.rs at line 316 [7.686190]
B:BD[18.82736] → [18.82736:82775]
```
    txn: &T,
    channel: &T::Channel,
```
[18.82736]
[18.82775]
```
    txn: &ArcTxn<T>,
    channel: &ChannelRef<T>,
```

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

B:BD[18.82908] → [18.82908:83077]

    let mut graph = crate::alive::retrieve(&*txn, txn.graph(&*channel), v0)?;
    crate::alive::output_graph(changes, &*txn, &*channel, out, &mut graph, &mut forward)?;

[18.82908]

[18.83077]

    let mut graph = {
        let txn = txn.read();
        let channel = channel.read();
        crate::alive::retrieve(&*txn, txn.graph(&*channel), v0)?
    };
    crate::alive::output_graph(changes, txn, channel, out, &mut graph, &mut forward)?;

Replacement in libpijul/src/output/archive.rs at line 150 [7.690044]
B:BD[7.692279] → [7.692279:692292]
```
    txn: &T,
```
[7.692279]
[7.692292]
```
    txn: &ArcTxn<T>,
```
Deletion in libpijul/src/output/archive.rs at line 155 [7.690044]
∅:D[26.32374] → [23.103479:103513]
B:BD[9.88013] → [23.103479:103513]
```
    let channel = channel.read();
```

Replacement in libpijul/src/output/archive.rs at line 159 [7.690044]

B:BD[7.692602] → [7.692602:692654]

B:BD[7.692654] → [27.5033:5062]

∅:D[27.5062] → [7.692672:692729]

∅:D[19.58587] → [7.692672:692729]

∅:D[9.88038] → [7.692672:692729]

B:BD[7.692672] → [7.692672:692729]

B:BD[7.692729] → [28.1472:1486]

∅:D[28.1486] → [7.692729:692788]

B:BD[7.692729] → [7.692729:692788]

    collect_children(
        txn,
        changes,
        txn.graph(&channel),
        Position::ROOT,
        Inode::ROOT,
        "",
        None,
        next_prefix_basename,
        &mut files,
    )?;

[7.692602]

[29.4963]

    {
        let txn_ = txn.read();
        let channel_ = channel.read();
        collect_children(
            &*txn_,
            changes,
            txn_.graph(&channel_),
            Position::ROOT,
            Inode::ROOT,
            "",
            None,
            next_prefix_basename,
            &mut files,
        )?;
    }

Replacement in libpijul/src/output/archive.rs at line 183 [7.690044]

B:BD[7.693101] → [7.693101:693132]

B:BD[7.693132] → [13.122535:122605]

∅:D[27.5132] → [7.693202:693232]

∅:D[19.58656] → [7.693202:693232]

∅:D[13.122605] → [7.693202:693232]

B:BD[7.693202] → [7.693202:693232]

B:BD[7.693232] → [30.907:933]

B:BD[30.933] → [13.122606:122685]

∅:D[13.122685] → [30.1011:1072]

B:BD[30.1011] → [30.1011:1072]

∅:D[30.1072] → [7.693398:693414]

∅:D[27.5222] → [7.693398:693414]

∅:D[19.58745] → [7.693398:693414]

B:BD[7.693398] → [7.693398:693414]

            b.sort_by(|u, v| {
                txn.get_changeset(txn.changes(&channel), &u.0.change)
                    .unwrap()
                    .cmp(
                        &txn.get_changeset(txn.changes(&channel), &v.0.change)
                            .unwrap(),
                    )
            });

[7.693101]

[7.693414]

            {
                let txn_ = txn.read();
                let channel_ = channel.read();
                b.sort_by(|u, v| {
                    txn_.get_changeset(txn_.changes(&channel_), &u.0.change)
                        .unwrap()
                        .cmp(
                            &txn_
                                .get_changeset(txn_.changes(&channel_), &v.0.change)
                                .unwrap(),
                        )
                });
            }

Insertion in libpijul/src/output/archive.rs at line 198 [7.690044]

[7.693507]

[29.5043]

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

Replacement in libpijul/src/output/archive.rs at line 233 [7.690044]

B:BD[31.40] → [13.122686:122769]

                    crate::fs::get_latest_touch(txn, &channel, &output_item.pos)?;

[31.40]

[31.122]

                    crate::fs::get_latest_touch(&*txn_, &channel_, &output_item.pos)?;

Replacement in libpijul/src/output/archive.rs at line 235 [7.690044]

B:BD[31.159] → [13.122770:122843]

                    let ext = txn.get_external(&latest_touch)?.unwrap();

[31.159]

[13.122843]

                    let ext = txn_.get_external(&latest_touch)?.unwrap();

Replacement in libpijul/src/output/archive.rs at line 242 [7.690044]
B:BD[7.694976] → [7.694976:695005]
```
                        txn,
```
[7.694976]
[7.695005]
```
                        &*txn_,
```

Replacement in libpijul/src/output/archive.rs at line 244 [7.690044]

B:BD[7.695038] → [27.5223:5268]

                        txn.graph(&channel),

[7.695038]

[7.695072]

                        txn_.graph(&channel_),

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

B:BD[32.1275] → [27.5269:5369]

                    let mut l = crate::alive::retrieve(txn, txn.graph(&channel), output_item.pos)?;

[32.1275]

[33.0]

                    let mut l =
                        crate::alive::retrieve(&*txn_, txn_.graph(&channel_), output_item.pos)?;

Insertion in libpijul/src/output/archive.rs at line 272 [7.690044]

[7.695759]

                        std::mem::drop(channel_);
                        std::mem::drop(txn_);

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

B:BD[7.695881] → [7.695881:695919]

                            &channel,

[7.695881]

[7.695919]

                            channel,

Deletion in libpijul/src/lib.rs at line 261 [7.717381]

B:BD[7.727750] → [7.727750:727756]

B:BD[7.727756] → [18.84622:84623]

∅:D[18.84623] → [34.2901:2969]

∅:D[13.126273] → [34.2901:2969]

B:BD[7.727757] → [34.2901:2969]

∅:D[34.2969] → [7.727829:727919]

B:BD[7.727829] → [7.727829:727919]

B:BD[7.727919] → [13.126274:126308]

∅:D[13.126308] → [7.727952:728008]

B:BD[7.727952] → [7.727952:728008]

B:BD[7.728008] → [10.4880:4899]

B:BD[10.4899] → [26.33677:33766]

∅:D[35.29838] → [7.728064:728239]

∅:D[26.33766] → [7.728064:728239]

∅:D[9.95462] → [7.728064:728239]

B:BD[7.728064] → [7.728064:728239]

B:BD[7.728239] → [10.4900:4918]

∅:D[10.4918] → [7.728239:728644]

B:BD[7.728239] → [7.728239:728644]

B:BD[7.728644] → [13.126309:126343]

∅:D[13.126343] → [7.728677:728757]

B:BD[7.728677] → [7.728677:728757]

B:BD[7.728757] → [10.4919:4938]

B:BD[10.4938] → [26.33767:33856]

∅:D[35.29935] → [7.728813:728883]

∅:D[26.33856] → [7.728813:728883]

∅:D[9.95568] → [7.728813:728883]

B:BD[7.728813] → [7.728813:728883]

B:BD[7.728883] → [23.103863:103939]

∅:D[18.84709] → [13.126344:126445]

∅:D[23.103939] → [13.126344:126445]

B:BD[9.95647] → [13.126344:126445]

∅:D[13.126445] → [7.728987:729061]

B:BD[7.728987] → [7.728987:729061]

B:BD[7.729061] → [13.126446:126488]

∅:D[13.126488] → [7.729094:729182]

B:BD[7.729094] → [7.729094:729182]

B:BD[7.729182] → [13.126489:126591]

B:BD[13.126591] → [10.4939:4999]

∅:D[10.4999] → [7.729333:729347]

B:BD[7.729333] → [7.729333:729347]

B:BD[7.729347] → [36.5958:5972]

B:BD[36.5972] → [23.103940:103992]

∅:D[23.103992] → [36.6033:6165]

B:BD[36.6033] → [36.6033:6165]

∅:D[36.6165] → [7.729448:729545]

∅:D[13.126654] → [7.729448:729545]

B:BD[7.729448] → [7.729448:729545]

B:BD[7.729545] → [13.126655:126726]

∅:D[35.29999] → [7.729602:729612]

∅:D[13.126726] → [7.729602:729612]

B:BD[7.729602] → [7.729602:729612]

    }
    fn archive_with_state<P: changestore::ChangeStore, A: Archive>(
        &mut self,
        changes: &P,
        channel: &mut pristine::ChannelRef<Self>,
        state: &pristine::Merkle,
        extra: &[pristine::Hash],
        arch: &mut A,
        salt: u64,
    ) -> Result<Vec<output::Conflict>, output::ArchiveError<P::Error, Self, A::Error>> {
        self.archive_prefix_with_state(
            changes,
            channel,
            state,
            extra,
            &mut std::iter::empty(),
            arch,
            salt,
        )
    }
    /// Warning: this method unrecords changes until finding the
    /// state. If this is not wanted, please fork the channel before
    /// calling.
    fn archive_prefix_with_state<
        'a,
        P: changestore::ChangeStore,
        A: Archive,
        I: Iterator<Item = &'a str>,
    >(
        &mut self,
        changes: &P,
        channel: &mut pristine::ChannelRef<Self>,
        state: &pristine::Merkle,
        extra: &[pristine::Hash],
        prefix: &mut I,
        arch: &mut A,
        salt: u64,
    ) -> Result<Vec<output::Conflict>, output::ArchiveError<P::Error, Self, A::Error>> {
        let mut unrecord = Vec::new();
        let mut found = false;
        for x in pristine::changeid_rev_log(self, &channel.read(), None)? {
            let (_, p) = x?;
            let m: Merkle = (&p.b).into();
            if &m == state {
                found = true;
                break;
            } else {
                unrecord.push(p.a.into())
            }
        }
        debug!("unrecord = {:?}", unrecord);
        if found {
            for h in unrecord.iter() {
                let h = self.get_external(h)?.unwrap().into();
                self.unrecord(changes, channel, &h, salt)?;
            }
            {
                let mut channel_ = channel.write();
                for app in extra.iter() {
                    self.apply_change_rec(changes, &mut channel_, app)?
                }
            }
            output::archive(changes, self, channel, prefix, arch)
        } else {
            Err(output::ArchiveError::StateNotFound { state: *state })
        }

Replacement in libpijul/src/lib.rs at line 456 [7.717381]

B:BD[7.733559] → [34.3109:3166]

    fn archive<C: changestore::ChangeStore, A: Archive>(

[7.733559]

[7.733620]

    fn iter_adjacent<'txn>(
        &'txn self,
        graph: &'txn Self::Channel,
        key: Vertex<pristine::ChangeId>,
        min_flag: pristine::EdgeFlags,
        max_flag: pristine::EdgeFlags,
    ) -> Result<pristine::AdjacentIterator<'txn, Self>, pristine::TxnErr<Self::GraphError>> {
        pristine::iter_adjacent(self, self.graph(graph), key, min_flag, max_flag)
    }
}
impl<T: ChannelTxnT + TreeTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>> ArcTxn<T> {
    pub fn archive<C: changestore::ChangeStore, A: Archive>(

Replacement in libpijul/src/lib.rs at line 471 [7.717381]
B:BD[7.733656] → [7.733656:733702]
```
        channel: &pristine::ChannelRef<Self>,
```
[7.733656]
[7.733702]
```
        channel: &pristine::ChannelRef<T>,
```

Replacement in libpijul/src/lib.rs at line 473 [7.717381]

B:BD[7.733724] → [26.34110:34199]

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

[7.733724]

[7.733780]

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

Replacement in libpijul/src/lib.rs at line 477 [7.717381]

B:BD[7.733866] → [7.733866:733963]

    fn archive_prefix<'a, C: changestore::ChangeStore, I: Iterator<Item = &'a str>, A: Archive>(

[7.733866]

[7.733963]

    pub fn archive_prefix<
        'a,
        C: changestore::ChangeStore,
        I: Iterator<Item = &'a str>,
        A: Archive,
    >(

Replacement in libpijul/src/lib.rs at line 485 [7.717381]
B:BD[7.733999] → [7.733999:734045]
```
        channel: &pristine::ChannelRef<Self>,
```
[7.733999]
[7.734045]
```
        channel: &pristine::ChannelRef<T>,
```

Replacement in libpijul/src/lib.rs at line 488 [7.717381]

B:BD[7.734091] → [26.34200:34289]

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

[7.734091]

[7.734147]

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

Insertion in libpijul/src/lib.rs at line 490 [7.717381]

[7.734209]

    }
}
impl<T: MutTxnT> ArcTxn<T> {
    pub fn archive_with_state<P: changestore::ChangeStore, A: Archive>(
        &self,
        changes: &P,
        channel: &pristine::ChannelRef<T>,
        state: &pristine::Merkle,
        extra: &[pristine::Hash],
        arch: &mut A,
        salt: u64,
    ) -> Result<Vec<output::Conflict>, output::ArchiveError<P::Error, T, A::Error>> {
        self.archive_prefix_with_state(
            changes,
            channel,
            state,
            extra,
            &mut std::iter::empty(),
            arch,
            salt,
        )

Replacement in libpijul/src/lib.rs at line 514 [7.717381]

B:BD[20.62357] → [19.60581:60609]

∅:D[19.60609] → [20.62395:62415]

B:BD[20.62395] → [20.62395:62415]

B:BD[20.62415] → [19.60610:60646]

∅:D[19.60646] → [20.62462:62581]

∅:D[9.99401] → [20.62462:62581]

B:BD[20.62462] → [20.62462:62581]

B:BD[20.62581] → [9.99402:99496]

B:BD[9.99496] → [27.5729:5811]

    fn iter_adjacent<'txn>(
        &'txn self,
        graph: &'txn Self::Channel,
        key: Vertex<pristine::ChangeId>,
        min_flag: pristine::EdgeFlags,
        max_flag: pristine::EdgeFlags,
    ) -> Result<pristine::AdjacentIterator<'txn, Self>, pristine::TxnErr<Self::GraphError>> {
        pristine::iter_adjacent(self, self.graph(graph), key, min_flag, max_flag)

[20.62357]

[20.62703]

    /// Warning: this method unrecords changes until finding the
    /// state. If this is not wanted, please fork the channel before
    /// calling.
    pub fn archive_prefix_with_state<
        'a,
        P: changestore::ChangeStore,
        A: Archive,
        I: Iterator<Item = &'a str>,
    >(
        &self,
        changes: &P,
        channel: &pristine::ChannelRef<T>,
        state: &pristine::Merkle,
        extra: &[pristine::Hash],
        prefix: &mut I,
        arch: &mut A,
        salt: u64,
    ) -> Result<Vec<output::Conflict>, output::ArchiveError<P::Error, T, A::Error>> {
        let mut unrecord = Vec::new();
        let mut found = false;
        let mut txn = self.write();
        for x in pristine::changeid_rev_log(&*txn, &channel.read(), None)? {
            let (_, p) = x?;
            let m: Merkle = (&p.b).into();
            if &m == state {
                found = true;
                break;
            } else {
                unrecord.push(p.a.into())
            }
        }
        debug!("unrecord = {:?}", unrecord);
        if found {
            for h in unrecord.iter() {
                let h = txn.get_external(h)?.unwrap().into();
                unrecord::unrecord(&mut *txn, channel, changes, &h, salt)?;
            }
            {
                let mut channel_ = channel.write();
                for app in extra.iter() {
                    crate::apply::apply_change_rec(changes, &mut *txn, &mut channel_, app, false)?
                }
            }
            std::mem::drop(txn);
            output::archive(changes, self, channel, prefix, arch)
        } else {
            Err(output::ArchiveError::StateNotFound { state: *state })
        }

Replacement in libpijul/src/diff/mod.rs at line 132 [7.793247]
B:BD[7.794205] → [7.794205:794222]
B:BD[7.794222] → [19.63534:63564]
```
        txn: &T,
        channel: &T::Channel,
```
[7.794205]
[7.794252]
```
        txn: &ArcTxn<T>,
        channel: &ChannelRef<T>,
```

Insertion in libpijul/src/diff/mod.rs at line 147 [7.793247]

[7.794648]

[37.716]

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

Replacement in libpijul/src/diff/mod.rs at line 176 [7.793247]

B:BD[7.796878] → [7.796878:796903]

B:BD[7.796903] → [27.6761:6801]

                    txn,
                    txn.graph(channel),

[7.796878]

[7.796932]

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

Replacement in libpijul/src/alive/output.rs at line 19 [7.988425]
B:BD[7.988922] → [7.988922:988935]
B:BD[7.988935] → [19.67155:67181]
```
    txn: &T,
    channel: &T::Channel,
```
[7.988922]
[7.988961]
```
    txn: &ArcTxn<T>,
    channel: &ChannelRef<T>,
```

Insertion in libpijul/src/alive/output.rs at line 37 [7.988425]

[7.989411]

[7.989518]

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

Replacement in libpijul/src/alive/output.rs at line 43 [7.988425]

B:BD[7.989641] → [9.135742:135833]

                    .map(|a| a.oldest_vertex(changes, txn, channel, graph, sccs).unwrap())

[7.989641]

[7.989723]

                    .map(|a| {
                        a.oldest_vertex(changes, &*txn, &*channel, graph, sccs)
                            .unwrap()
                    })

Replacement in libpijul/src/alive/output.rs at line 52 [7.988425]

B:BD[7.989862] → [9.135834:135925]

                    .map(|b| b.oldest_vertex(changes, txn, channel, graph, sccs).unwrap())

[7.989862]

[7.989944]

                    .map(|b| {
                        b.oldest_vertex(changes, &*txn, &*channel, graph, sccs)
                            .unwrap()
                    })

Insertion in libpijul/src/alive/output.rs at line 81 [7.988425]
[38.6440]
[38.6440]
```
                        let txn = txn.read();
```
Replacement in libpijul/src/alive/output.rs at line 196 [7.988425]
B:BD[7.993009] → [7.993009:993022]
```
    txn: &T,
```
[7.993009]
[7.993022]
```
    txn: &ArcTxn<T>,
```
Insertion in libpijul/src/alive/output.rs at line 213 [7.988425]
[38.7638]
[38.7638]
```
                let txn = txn.read();
```

Replacement in libpijul/src/alive/output.rs at line 229 [7.988425]

B:BD[39.22286] → [39.22286:22359]

                    |p| txn.get_external(&p).unwrap().map(|x| x.into()),

[39.22286]

[39.22359]

                    |p| txn.read().get_external(&p).unwrap().map(|x| x.into()),

Replacement in libpijul/src/alive/output.rs at line 254 [7.988425]
B:BD[7.994361] → [7.994361:994374]
B:BD[7.994374] → [19.67393:67419]
```
    txn: &T,
    channel: &T::Channel,
```
[7.994361]
[7.994400]
```
    txn: &ArcTxn<T>,
    channel: &ChannelRef<T>,
```

Replacement in libpijul/src/alive/output.rs at line 266 [7.988425]

B:BD[7.994757] → [27.8316:8404]

∅:D[27.8404] → [7.994833:994834]

∅:D[19.67507] → [7.994833:994834]

∅:D[9.137675] → [7.994833:994834]

B:BD[7.994833] → [7.994833:994834]

    graph.collect_forward_edges(txn, txn.graph(channel), &scc, &forward_scc, forward)?;

[7.994757]

[7.994834]

    {
        let txn = txn.read();
        let channel = channel.read();
        graph.collect_forward_edges(&*txn, txn.graph(&*channel), &scc, &forward_scc, forward)?;
    }

Allowing vertex buffer to use references to the transaction, by changing `output::output` to take an ArcTxn<T> instead of a simple T

Dependencies

In channels

Change contents

Replacement in pijul/src/remote/mod.rs at line 936 [7.52474]

Replacement in pijul/src/remote/mod.rs at line 943 [7.52474]

Replacement in pijul/src/commands/reset.rs at line 86 [7.97650]

Replacement in pijul/src/commands/protocol.rs at line 297 [7.123281]

Replacement in pijul/src/commands/protocol.rs at line 305 [7.123281]

Replacement in pijul/src/commands/protocol.rs at line 317 [7.123281]

Replacement in pijul/src/commands/protocol.rs at line 321 [7.123281]

Replacement in pijul/src/commands/credit.rs at line 29 [7.178684]

Replacement in pijul/src/commands/credit.rs at line 54 [7.178684]

Replacement in pijul/src/commands/credit.rs at line 57 [7.178684]

Replacement in pijul/src/commands/credit.rs at line 60 [7.178684]

Replacement in pijul/src/commands/credit.rs at line 75 [7.178684]

Replacement in pijul/src/commands/credit.rs at line 80 [7.178684]

Replacement in pijul/src/commands/credit.rs at line 84 [7.178684]

Replacement in pijul/src/commands/credit.rs at line 97 [7.178684]

Replacement in pijul/src/commands/credit.rs at line 112 [7.178684]

Replacement in pijul/src/commands/credit.rs at line 122 [7.178684]

Replacement in pijul/src/commands/archive.rs at line 5 [7.191083]

Replacement in pijul/src/commands/archive.rs at line 114 [7.191083]

Deletion in pijul/src/commands/archive.rs at line 124 [7.191083]

Replacement in pijul/src/commands/archive.rs at line 126 [7.191083]

Replacement in pijul/src/commands/archive.rs at line 133 [7.191083]

Replacement in pijul/src/commands/archive.rs at line 147 [7.191083]

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

Replacement in libpijul/src/record.rs at line 918 [7.488880]

Replacement in libpijul/src/record.rs at line 922 [7.488880]

Insertion in libpijul/src/record.rs at line 935 [7.488880]

Replacement in libpijul/src/record.rs at line 951 [7.488880]

Replacement in libpijul/src/record.rs at line 955 [7.488880]