jcdickinson/pijul - Change GA3P7FOMATKDOGCZDYWLZJHAUNOWMRIP3BXTYFEH7PNWTTYYVLIAC

Nicer conflict markers

Created by pmeunier on December 8, 2021

GA3P7FOMATKDOGCZDYWLZJHAUNOWMRIP3BXTYFEH7PNWTTYYVLIAC

Dependencies

In channels

main

Change contents

Replacement in pijul/src/commands/credit.rs at line 157 [4.178684]

B:BD[4.182632] → [5.1109:1191]

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

[4.182632]

[4.182713]

    fn output_conflict_marker(
        &mut self,
        marker: &str,
        id: usize,
        sides: &[&Hash],
    ) -> Result<(), std::io::Error> {

Replacement in pijul/src/commands/credit.rs at line 164 [4.178684]

B:BD[4.182741] → [6.0:45]

∅:D[6.45] → [4.182782:182799]

B:BD[4.182782] → [4.182782:182799]

B:BD[4.182799] → [6.46:97]

            self.w.write_all(s.as_bytes())?;
        } else {
            self.w.write_all(&s.as_bytes()[1..])?;

[4.182741]

[4.182846]

            self.w.write_all(b"\n")?;
        }
        write!(self.w, "{} {}", marker, id)?;
        for side in sides {
            let h = side.to_base32();
            write!(self.w, " [{}]", h.split_at(8).0)?;

Insertion in pijul/src/commands/credit.rs at line 171 [4.178684]
[4.182856]
[4.182856]
```
        self.w.write_all(b"\n")?;
```

Replacement in libpijul/src/working_copy/filesystem.rs at line 65 [4.208900]

B:BD[2.743] → [2.743:838]

                Component::CurDir => {},
                Component::ParentDir => { p.pop(); },

[2.743]

[2.838]

                Component::CurDir => {}
                Component::ParentDir => {
                    p.pop();
                }

Replacement in libpijul/src/vertex_buffer.rs at line 3 [4.217202]
B:BD[4.217283] → [7.172:243]
```
pub const START_MARKER: &str = "\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n";
```
[4.217283]
[4.217362]
```
pub const START_MARKER: &str = ">>>>>>>";
```
Replacement in libpijul/src/vertex_buffer.rs at line 5 [4.217202]
B:BD[4.217363] → [7.244:312]
```
pub const SEPARATOR: &str = "\n================================\n";
```
[4.217363]
[4.217439]
```
pub const SEPARATOR: &str = "=======";
```
Replacement in libpijul/src/vertex_buffer.rs at line 7 [4.217202]
B:BD[4.217440] → [7.313:382]
```
pub const END_MARKER: &str = "\n<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n";
```
[4.217440]
[4.217517]
```
pub const END_MARKER: &str = "<<<<<<<";
```

Replacement in libpijul/src/vertex_buffer.rs at line 19 [4.217202]

B:BD[4.217953] → [5.5173:5319]

∅:D[5.5319] → [4.218097:218147]

B:BD[4.218097] → [4.218097:218147]

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

[4.217953]

[4.218147]

    fn output_conflict_marker(
        &mut self,
        s: &str,
        id: usize,
        sides: &[&Hash],
    ) -> Result<(), std::io::Error>;
    fn begin_conflict(&mut self, id: usize, side: &[&Hash]) -> Result<(), std::io::Error> {
        self.output_conflict_marker(START_MARKER, id, side)

Replacement in libpijul/src/vertex_buffer.rs at line 28 [4.217202]

B:BD[4.218153] → [5.5320:5392]

∅:D[5.5392] → [4.218224:218254]

B:BD[4.218224] → [4.218224:218254]

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

[4.218153]

[4.218254]

    fn begin_zombie_conflict(
        &mut self,
        id: usize,
        add_del: &[&Hash],
    ) -> Result<(), std::io::Error> {
        self.output_conflict_marker(START_MARKER, id, add_del)

Replacement in libpijul/src/vertex_buffer.rs at line 35 [4.217202]

B:BD[4.218260] → [5.5393:5465]

∅:D[5.5465] → [4.218331:218361]

B:BD[4.218331] → [4.218331:218361]

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

[4.218260]

[4.218361]

    fn begin_cyclic_conflict(&mut self, id: usize) -> Result<(), std::io::Error> {
        self.output_conflict_marker(START_MARKER, id, &[])

Replacement in libpijul/src/vertex_buffer.rs at line 38 [4.217202]

B:BD[4.218367] → [5.5466:5530]

∅:D[5.5530] → [4.218430:218477]

B:BD[4.218430] → [4.218430:218477]

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

[4.218367]

[4.218477]

    fn conflict_next(&mut self, id: usize, side: &[&Hash]) -> Result<(), std::io::Error> {
        self.output_conflict_marker(SEPARATOR, id, side)

Replacement in libpijul/src/vertex_buffer.rs at line 41 [4.217202]

B:BD[4.218483] → [5.5531:5594]

∅:D[5.5594] → [4.218545:218593]

B:BD[4.218545] → [4.218545:218593]

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

[4.218483]

[4.218593]

    fn end_conflict(&mut self, id: usize) -> Result<(), std::io::Error> {
        self.output_conflict_marker(END_MARKER, id, &[])

Replacement in libpijul/src/vertex_buffer.rs at line 44 [4.217202]

B:BD[4.218599] → [5.5595:5665]

B:BD[5.5665] → [8.0:28]

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

[4.218599]

[4.218716]

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

Replacement in libpijul/src/vertex_buffer.rs at line 47 [4.217202]

B:BD[4.218722] → [5.5666:5736]

∅:D[5.5736] → [4.218791:218839]

B:BD[4.218791] → [4.218791:218839]

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

[4.218722]

[4.218839]

    fn end_cyclic_conflict(&mut self, id: usize) -> Result<(), std::io::Error> {
        self.output_conflict_marker(END_MARKER, id, &[])

Replacement in libpijul/src/vertex_buffer.rs at line 107 [4.217202]

B:BD[4.220451] → [5.5917:5999]

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

[4.220451]

[4.220532]

    fn output_conflict_marker(
        &mut self,
        s: &str,
        id: usize,
        sides: &[&Hash],
    ) -> Result<(), std::io::Error> {

Replacement in libpijul/src/vertex_buffer.rs at line 116 [4.217202]
B:BD[4.220651] → [6.98:143]
```
            self.w.write_all(s.as_bytes())?;
```
[4.220651]
[4.220692]
```
            self.w.write_all(b"\n")?;
```

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

B:BD[4.220738] → [4.220738:220786]

B:BD[4.220786] → [6.144:195]

            debug!("{:?}", &s.as_bytes()[1..]);
            self.w.write_all(&s.as_bytes()[1..])?;

[4.220738]

[4.220833]

            debug!("{:?}", s.as_bytes());
        }
        write!(self.w, "{} {}", s, id)?;
        for side in sides {
            let h = side.to_base32();
            write!(self.w, " [{}]", h.split_at(8).0)?;

Insertion in libpijul/src/vertex_buffer.rs at line 126 [4.217202]
[4.220843]
[4.220843]
```
        self.w.write_all(b"\n")?;
```

Replacement in libpijul/src/vertex_buffer.rs at line 131 [4.217202]

B:BD[4.220895] → [5.6000:6065]

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

[4.220895]

[4.220959]

    fn begin_conflict(&mut self, id: usize, side: &[&Hash]) -> Result<(), std::io::Error> {

Replacement in libpijul/src/vertex_buffer.rs at line 136 [4.217202]

B:BD[4.221103] → [4.221103:221153]

        self.output_conflict_marker(START_MARKER)

[4.221103]

[4.221153]

        self.output_conflict_marker(START_MARKER, id, side)

Replacement in libpijul/src/vertex_buffer.rs at line 138 [4.217202]

B:BD[4.221159] → [5.6066:6138]

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

[4.221159]

[4.221230]

    fn begin_zombie_conflict(
        &mut self,
        id: usize,
        add_del: &[&Hash],
    ) -> Result<(), std::io::Error> {

Replacement in libpijul/src/vertex_buffer.rs at line 147 [4.217202]

B:BD[4.221375] → [4.221375:221425]

        self.output_conflict_marker(START_MARKER)

[4.221375]

[4.221425]

        self.output_conflict_marker(START_MARKER, id, add_del)

Replacement in libpijul/src/vertex_buffer.rs at line 149 [4.217202]

B:BD[4.221431] → [5.6139:6211]

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

[4.221431]

[4.221502]

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

Replacement in libpijul/src/vertex_buffer.rs at line 154 [4.217202]

B:BD[4.221647] → [4.221647:221697]

        self.output_conflict_marker(START_MARKER)

[4.221647]

[4.221697]

        self.output_conflict_marker(START_MARKER, id, &[])

Replacement in libpijul/src/vertex_buffer.rs at line 211 [4.217202]

B:BD[4.222923] → [5.6392:6474]

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

[4.222923]

[4.223004]

    fn output_conflict_marker(
        &mut self,
        s: &str,
        id: usize,
        sides: &[&Hash],
    ) -> Result<(), std::io::Error> {

Replacement in libpijul/src/vertex_buffer.rs at line 219 [4.217202]

B:BD[4.223094] → [6.196:241]

∅:D[6.241] → [4.223135:223200]

B:BD[4.223135] → [4.223135:223200]

B:BD[4.223200] → [6.242:293]

            self.w.write_all(s.as_bytes())?;
        } else {
            debug!("{:?}", &s.as_bytes()[1..]);
            self.w.write_all(&s.as_bytes()[1..])?;

[4.223094]

[4.223247]

            self.w.write_all(b"\n")?;
        }
        write!(self.w, "{} {}", s, id)?;
        for side in sides {
            let h = side.to_base32();
            write!(self.w, " [{}]", h.split_at(8).0)?;

Insertion in libpijul/src/vertex_buffer.rs at line 226 [4.217202]
[4.223257]
[4.223257]
```
        self.w.write_all(b"\n")?;
```

Replacement in libpijul/src/vertex_buffer.rs at line 230 [4.217202]

B:BD[4.223279] → [5.6475:6540]

∅:D[5.6540] → [4.223343:223393]

B:BD[4.223343] → [4.223343:223393]

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

[4.223279]

[4.223393]

    fn begin_conflict(&mut self, id: usize, side: &[&Hash]) -> Result<(), std::io::Error> {
        self.output_conflict_marker(START_MARKER, id, side)

Replacement in libpijul/src/vertex_buffer.rs at line 233 [4.217202]

B:BD[4.223399] → [9.71:134]

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

[4.223399]

[9.134]

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

Replacement in libpijul/src/vertex_buffer.rs at line 235 [4.217202]

B:BD[9.166] → [9.166:214]

        self.output_conflict_marker(END_MARKER)

[9.166]

[9.214]

        self.output_conflict_marker(END_MARKER, id, &[])

Replacement in libpijul/src/vertex_buffer.rs at line 237 [4.217202]

∅:D[9.220] → [5.6541:6613]

B:BD[4.223399] → [5.6541:6613]

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

[9.220]

[9.221]

    fn begin_zombie_conflict(
        &mut self,
        id: usize,
        add_del: &[&Hash],
    ) -> Result<(), std::io::Error> {

Replacement in libpijul/src/vertex_buffer.rs at line 246 [4.217202]

B:BD[9.320] → [9.320:354]

            self.begin_conflict()

[9.320]

[9.354]

            self.output_conflict_marker(START_MARKER, id, add_del)

Replacement in libpijul/src/vertex_buffer.rs at line 249 [4.217202]

B:BD[9.370] → [9.370:440]

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

[9.370]

[9.440]

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

Replacement in libpijul/src/vertex_buffer.rs at line 251 [4.217202]

B:BD[9.472] → [9.472:520]

        self.output_conflict_marker(END_MARKER)

[9.472]

[4.223520]

        self.output_conflict_marker(END_MARKER, id, &[])

Replacement in libpijul/src/vertex_buffer.rs at line 253 [4.217202]

B:BD[4.223526] → [5.6614:6686]

∅:D[5.6686] → [4.223597:223647]

B:BD[4.223597] → [4.223597:223647]

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

[4.223526]

[4.223647]

    fn begin_cyclic_conflict(&mut self, id: usize) -> Result<(), std::io::Error> {
        self.output_conflict_marker(START_MARKER, id, &[])

Replacement in libpijul/src/diff/vertex_buffer.rs at line 157 [4.768903]

B:BD[5.32714] → [5.32714:32779]

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

[5.32714]

[4.774201]

    fn begin_conflict(&mut self, id: usize, side: &[&Hash]) -> Result<(), std::io::Error> {

Replacement in libpijul/src/diff/vertex_buffer.rs at line 159 [4.768903]

B:BD[4.774252] → [4.774252:774317]

        self.output_conflict_marker(vertex_buffer::START_MARKER)

[4.774252]

[4.774317]

        self.output_conflict_marker(vertex_buffer::START_MARKER, id, side)

Replacement in libpijul/src/diff/vertex_buffer.rs at line 162 [4.768903]

B:BD[4.774324] → [5.32780:32852]

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

[4.774324]

[4.774395]

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

Replacement in libpijul/src/diff/vertex_buffer.rs at line 166 [4.768903]

B:BD[4.774541] → [4.774541:774606]

        self.output_conflict_marker(vertex_buffer::START_MARKER)

[4.774541]

[4.774606]

        self.output_conflict_marker(vertex_buffer::START_MARKER, id, &[])

Replacement in libpijul/src/diff/vertex_buffer.rs at line 169 [4.768903]

B:BD[4.774613] → [5.32853:32925]

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

[4.774613]

[4.774684]

    fn begin_zombie_conflict(
        &mut self,
        id: usize,
        add_del: &[&Hash],
    ) -> Result<(), std::io::Error> {

Replacement in libpijul/src/diff/vertex_buffer.rs at line 175 [4.768903]

B:BD[4.774736] → [4.774736:774801]

        self.output_conflict_marker(vertex_buffer::START_MARKER)

[4.774736]

[4.774801]

        self.output_conflict_marker(vertex_buffer::START_MARKER, id, add_del)

Replacement in libpijul/src/diff/vertex_buffer.rs at line 178 [4.768903]

B:BD[5.32927] → [5.32927:32990]

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

[5.32927]

[4.774928]

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

Replacement in libpijul/src/diff/vertex_buffer.rs at line 187 [4.768903]

B:BD[4.775223] → [4.775223:775288]

        self.output_conflict_marker(vertex_buffer::END_MARKER)?;

[4.775223]

[4.775288]

        self.output_conflict_marker(vertex_buffer::END_MARKER, id, &[])?;

Replacement in libpijul/src/diff/vertex_buffer.rs at line 194 [4.768903]

B:BD[4.775540] → [5.32991:33061]

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

[4.775540]

[4.775609]

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

Replacement in libpijul/src/diff/vertex_buffer.rs at line 196 [4.768903]
B:BD[4.775648] → [4.775648:775678]
```
        self.end_conflict()?;
```
[4.775648]
[4.775678]
```
        self.end_conflict(id)?;
```

Replacement in libpijul/src/diff/vertex_buffer.rs at line 201 [4.768903]

B:BD[5.33063] → [5.33063:33127]

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

[5.33063]

[4.775903]

    fn conflict_next(&mut self, id: usize, side: &[&Hash]) -> Result<(), std::io::Error> {

Replacement in libpijul/src/diff/vertex_buffer.rs at line 211 [4.768903]

B:BD[4.776274] → [4.776274:776336]

        self.output_conflict_marker(vertex_buffer::SEPARATOR)

[4.776274]

[4.776336]

        self.output_conflict_marker(vertex_buffer::SEPARATOR, id, side)

Replacement in libpijul/src/diff/vertex_buffer.rs at line 214 [4.768903]

B:BD[5.33129] → [5.33129:33216]

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

[5.33129]

[4.776487]

    fn output_conflict_marker(
        &mut self,
        marker: &str,
        id: usize,
        sides: &[&Hash],
    ) -> Result<(), std::io::Error> {

Replacement in libpijul/src/diff/vertex_buffer.rs at line 228 [4.768903]

B:BD[4.776719] → [4.776719:777145]

        let pos = match self.contents_a.last() {
            Some(&b'\n') | None => {
                let len = self.contents_a.len();
                self.contents_a.extend(marker.as_bytes().iter().skip(1));
                len
            }
            _ => {
                let len = self.contents_a.len() + 1;
                self.contents_a.extend(marker.as_bytes().iter());
                len
            }
        };

[4.776719]

[4.777145]

        match self.contents_a.last() {
            Some(&b'\n') | None => {}
            _ => self.contents_a.push(b'\n'),
        }
        let pos = self.contents_a.len();
        use std::io::Write;
        write!(self.contents_a, "{} {}", marker, id)?;
        for side in sides {
            let h = side.to_base32();
            write!(self.contents_a, " [{}]", h.split_at(8).0)?;
        }
        self.contents_a.write_all(b"\n")?;

Replacement in libpijul/src/diff/diff.rs at line 15 [4.801479]

B:BD[4.801776] → [3.480:582]

pub(super) fn diff(lines_a: &[Line], lines_b: &[Line], algorithm: Algorithm, stop_early: bool) -> D {

[4.801776]

[3.582]

pub(super) fn diff(
    lines_a: &[Line],
    lines_b: &[Line],
    algorithm: Algorithm,
    stop_early: bool,
) -> D {

Replacement in libpijul/src/diff/diff.rs at line 45 [4.801479]
B:BD[4.802409] → [3.739:767]
```
            .unwrap_or(()),
```
[4.802409]
[4.802428]
```
        .unwrap_or(()),
```
Replacement in libpijul/src/alive/output.rs at line 30 [4.988425]
B:BD[4.989204] → [8.507:538]
```
    let mut is_zombie = false;
```
[4.989204]
[4.989204]
```
    let mut is_zombie = None;
    let mut id = 0;
```
Insertion in libpijul/src/alive/output.rs at line 34 [4.988425]
[4.989290]
[4.989353]
```
        let id0 = id;
```

Insertion in libpijul/src/alive/output.rs at line 51 [4.988425]

[4.990046]

            match elt.conflict[elt.side].path[elt.idx] {
                PathElement::Scc { scc } => {
                    let vid = sccs[scc][0];
                    let ext = txn.get_external(&graph[vid].vertex.change)?.unwrap();
                    line_buf.begin_conflict(id, &[&ext.into()])?;
                }
                _ => {
                    line_buf.begin_conflict(id, &[])?;
                }
            }
            id += 1;

Replacement in libpijul/src/alive/output.rs at line 67 [4.988425]

B:BD[4.990237] → [8.539:662]

                if is_zombie {
                    is_zombie = false;
                    line_buf.end_zombie_conflict()?;

[4.990237]

[8.662]

                if let Some(id) = is_zombie.take() {
                    line_buf.end_zombie_conflict(id)?;

Replacement in libpijul/src/alive/output.rs at line 70 [4.988425]

∅:D[8.680] → [4.990237:990280]

B:BD[4.990237] → [4.990237:990280]

                line_buf.conflict_next()?;

[8.680]

[4.990280]

                match elt.conflict[elt.side].path[elt.idx] {
                    PathElement::Scc { scc } => {
                        let vid = sccs[scc][0];
                        let ext = txn.get_external(&graph[vid].vertex.change)?.unwrap();
                        line_buf.conflict_next(id0, &[&ext.into()])?;
                    }
                    _ => {
                        line_buf.conflict_next(id0, &[])?;
                    }
                }

Replacement in libpijul/src/alive/output.rs at line 84 [4.988425]

B:BD[4.990469] → [8.681:777]

                        output_scc(changes, txn, graph, &sccs[scc], &mut is_zombie, line_buf)?;

[4.990469]

[4.990549]

                        output_scc(
                            changes,
                            txn,
                            graph,
                            &sccs[scc],
                            &mut is_zombie,
                            &mut id,
                            line_buf,
                        )?;

Replacement in libpijul/src/alive/output.rs at line 113 [4.988425]

B:BD[4.991266] → [8.778:901]

                if is_zombie {
                    is_zombie = false;
                    line_buf.end_zombie_conflict()?;

[4.991266]

[8.901]

                if let Some(id) = is_zombie.take() {
                    line_buf.end_zombie_conflict(id)?;

Replacement in libpijul/src/alive/output.rs at line 116 [4.988425]
∅:D[8.919] → [4.991266:991308]
B:BD[4.991266] → [4.991266:991308]
```
                line_buf.end_conflict()?;
```
[8.919]
[4.991308]
```
                line_buf.end_conflict(id0)?;
```

Replacement in libpijul/src/alive/output.rs at line 119 [4.988425]

B:BD[4.991339] → [8.920:1031]

            if is_zombie {
                is_zombie = false;
                line_buf.end_zombie_conflict()?;

[4.991339]

[8.1031]

            if let Some(id) = is_zombie.take() {
                line_buf.end_zombie_conflict(id)?;

Replacement in libpijul/src/alive/output.rs at line 126 [4.988425]

B:BD[8.1052] → [8.1052:1112]

    if is_zombie {
        line_buf.end_zombie_conflict()?;

[8.1052]

[4.991416]

    if let Some(id) = is_zombie.take() {
        line_buf.end_zombie_conflict(id)?;

Replacement in libpijul/src/alive/output.rs at line 188 [4.988425]
B:BD[4.993063] → [8.1113:1139]
```
    is_zombie: &mut bool,
```
[4.993063]
[4.993063]
```
    is_zombie: &mut Option<usize>,
    id: &mut usize,
```
Insertion in libpijul/src/alive/output.rs at line 192 [4.988425]
[10.137371]
[4.993114]
```
    let id_cyclic = *id;
```
Replacement in libpijul/src/alive/output.rs at line 194 [4.988425]
B:BD[4.993137] → [5.100525:100564]
```
        vbuf.begin_cyclic_conflict()?;
```
[4.993137]
[4.993175]
```
        vbuf.begin_cyclic_conflict(*id)?;
        *id += 1;
```

Replacement in libpijul/src/alive/output.rs at line 200 [4.988425]

B:BD[4.993305] → [8.1140:1251]

            if !*is_zombie {
                *is_zombie = true;
                vbuf.begin_zombie_conflict()?;

[4.993305]

[8.1251]

            if is_zombie.is_none() {
                *is_zombie = Some(*id);
                let hash = txn.get_external(&graph[v].vertex.change)?.unwrap();
                vbuf.begin_zombie_conflict(*id, &[&hash.into()])?;
                *id += 1

Replacement in libpijul/src/alive/output.rs at line 206 [4.988425]

B:BD[8.1265] → [8.1265:1369]

        } else if *is_zombie {
            *is_zombie = false;
            vbuf.end_zombie_conflict()?;

[8.1265]

[4.993348]

        } else if let Some(id) = is_zombie.take() {
            vbuf.end_zombie_conflict(id)?;

Replacement in libpijul/src/alive/output.rs at line 234 [4.988425]
B:BD[4.994106] → [4.994106:994143]
```
        vbuf.end_cyclic_conflict()?;
```
[4.994106]
[4.994143]
```
        vbuf.end_cyclic_conflict(id_cyclic)?;
```
Deletion in libpijul/src/alive/output.rs at line 263 [4.988425]
B:BD[4.989411] → [4.989411:989451]
```
            line_buf.begin_conflict()?;
```