copies-rust: start recording overwrite as they happens If a revision has information overwriting data from another revision, the overwriting revision is a descendant of the overwritten one. So we could warm the Oracle cache with such information to avoid potential future `is_ancestors` call. This provide us with a large speedup in the most expensive cases: Repo Case Source-Rev Dest-Rev # of revisions old time new time Difference Factor time per rev --------------------------------------------------------------------------------------------------------------------------------------------------------------- mozilla-try x00000_revs_x00000_added_x0000_copies 1b661134e2ca 1ae03d022d6d : 228985 revs, 41.113063 s, 36.001255 s, -5.111808 s, × 0.8757, 157 µs/rev mozilla-try x00000_revs_x00000_added_x000_copies 9b2a99adc05e 8e29777b48e6 : 382065 revs, 27.891612 s, 14.340641 s, -13.550971 s, × 0.5142, 37 µs/rev Full comparison below: Repo Case Source-Rev Dest-Rev # of revisions old time new time Difference Factor time per rev --------------------------------------------------------------------------------------------------------------------------------------------------------------- mercurial x_revs_x_added_0_copies ad6b123de1c7 39cfcef4f463 : 1 revs, 0.000042 s, 0.000042 s, +0.000000 s, × 1.0000, 42 µs/rev mercurial x_revs_x_added_x_copies 2b1c78674230 0c1d10351869 : 6 revs, 0.000114 s, 0.000109 s, -0.000005 s, × 0.9561, 18 µs/rev mercurial x000_revs_x000_added_x_copies 81f8ff2a9bf2 dd3267698d84 : 1032 revs, 0.004934 s, 0.004953 s, +0.000019 s, × 1.0039, 4 µs/rev pypy x_revs_x_added_0_copies aed021ee8ae8 099ed31b181b : 9 revs, 0.000195 s, 0.000237 s, +0.000042 s, × 1.2154, 26 µs/rev pypy x_revs_x000_added_0_copies 4aa4e1f8e19a 359343b9ac0e : 1 revs, 0.000050 s, 0.000050 s, +0.000000 s, × 1.0000, 50 µs/rev pypy x_revs_x_added_x_copies ac52eb7bbbb0 72e022663155 : 7 revs, 0.000113 s, 0.000113 s, +0.000000 s, × 1.0000, 16 µs/rev pypy x_revs_x00_added_x_copies c3b14617fbd7 ace7255d9a26 : 1 revs, 0.6f1f4a s, 0.6f1f4a s, +0.000000 s, × 1.0000, 322 µs/rev pypy x_revs_x000_added_x000_copies df6f7a526b60 a83dc6a2d56f : 6 revs, 0.010788 s, 0.010702 s, -0.000086 s, × 0.9920, 1783 µs/rev pypy x000_revs_xx00_added_0_copies 89a76aede314 2f22446ff07e : 4785 revs, 0.050880 s, 0.050504 s, -0.000376 s, × 0.9926, 10 µs/rev pypy x000_revs_x000_added_x_copies 8a3b5bfd266e 2c68e87c3efe : 6780 revs, 0.081760 s, 0.080159 s, -0.001601 s, × 0.9804, 11 µs/rev pypy x000_revs_x000_added_x000_copies 89a76aede314 7b3dda341c84 : 5441 revs, 0.061382 s, 0.060058 s, -0.001324 s, × 0.9784, 11 µs/rev pypy x0000_revs_x_added_0_copies d1defd0dc478 c9cb1334cc78 : 43645 revs, 0.585802 s, 0.536950 s, -0.048852 s, × 0.9166, 12 µs/rev pypy x0000_revs_xx000_added_0_copies bf2c629d0071 4ffed77c095c : 2 revs, 0.012803 s, 0.012868 s, +0.000065 s, × 1.0051, 6434 µs/rev pypy x0000_revs_xx000_added_x000_copies 08ea3258278e d9fa043f30c0 : 11316 revs, 0.113558 s, 0.112806 s, -0.000752 s, × 0.9934, 9 µs/rev netbeans x_revs_x_added_0_copies fb0955ffcbcd a01e9239f9e7 : 2 revs, 0.000085 s, 0.000084 s, -0.000001 s, × 0.9882, 42 µs/rev netbeans x_revs_x000_added_0_copies 6f360122949f 20eb231cc7d0 : 2 revs, 0.000106 s, 0.000106 s, +0.000000 s, × 1.0000, 53 µs/rev netbeans x_revs_x_added_x_copies 1ada3faf6fb6 5a39d12eecf4 : 3 revs, 0.000175 s, 0.000174 s, -0.000001 s, × 0.9943, 58 µs/rev netbeans x_revs_x00_added_x_copies 35be93ba1e2c 9eec5e90c05f : 9 revs, 0.000721 s, 0.000726 s, +0.000005 s, × 1.0069, 80 µs/rev netbeans x000_revs_xx00_added_0_copies eac3045b4fdd 51d4ae7f1290 : 1421 revs, 0.010127 s, 0.010105 s, -0.000022 s, × 0.9978, 7 µs/rev netbeans x000_revs_x000_added_x_copies e2063d266acd 6081d72689dc : 1533 revs, 0.015616 s, 0.015748 s, +0.000132 s, × 1.0085, 10 µs/rev netbeans x000_revs_x000_added_x000_copies ff453e9fee32 411350406ec2 : 5750 revs, 0.061341 s, 0.060357 s, -0.000984 s, × 0.9840, 10 µs/rev netbeans x0000_revs_xx000_added_x000_copies 588c2d1ced70 1aad62e59ddd : 66949 revs, 0.542214 s, 0.499356 s, -0.042858 s, × 0.9210, 7 µs/rev mozilla-central x_revs_x_added_0_copies 3697f962bb7b 7015fcdd43a2 : 2 revs, 0.000089 s, 0.000092 s, +0.000003 s, × 1.0337, 46 µs/rev mozilla-central x_revs_x000_added_0_copies dd390860c6c9 40d0c5bed75d : 8 revs, 0.000279 s, 0.000279 s, +0.000000 s, × 1.0000, 34 µs/rev mozilla-central x_revs_x_added_x_copies 8d198483ae3b 14207ffc2b2f : 9 revs, 0.000184 s, 0.000186 s, +0.000002 s, × 1.0109, 20 µs/rev mozilla-central x_revs_x00_added_x_copies 98cbc58cc6bc 446a150332c3 : 7 revs, 0.000661 s, 0.000660 s, -0.000001 s, × 0.9985, 94 µs/rev mozilla-central x_revs_x000_added_x000_copies 3c684b4b8f68 0a5e72d1b479 : 3 revs, 0.003377 s, 0.003372 s, -0.000005 s, × 0.9985, 1124 µs/rev mozilla-central x_revs_x0000_added_x0000_copies effb563bb7e5 c07a39dc4e80 : 6 revs, 0.070508 s, 0.070294 s, -0.000214 s, × 0.9970, 11715 µs/rev mozilla-central x000_revs_xx00_added_0_copies 6100d773079a 04a55431795e : 1593 revs, 0.006576 s, 0.006545 s, -0.000031 s, × 0.9953, 4 µs/rev mozilla-central x000_revs_x000_added_x_copies 9f17a6fc04f9 2d37b966abed : 41 revs, 0.004809 s, 0.004998 s, +0.000189 s, × 1.0393, 121 µs/rev mozilla-central x000_revs_x000_added_x000_copies 7c97034feb78 4407bd0c6330 : 7839 revs, 0.064872 s, 0.063348 s, -0.001524 s, × 0.9765, 8 µs/rev mozilla-central x0000_revs_xx000_added_0_copies 9eec5917337d 67118cc6dcad : 615 revs, 0.026142 s, 0.026154 s, +0.000012 s, × 1.0005, 42 µs/rev mozilla-central x0000_revs_xx000_added_x000_copies f78c615a656c 96a38b690156 : 30263 revs, 0.203956 s, 0.199063 s, -0.004893 s, × 0.9760, 6 µs/rev mozilla-central x00000_revs_x0000_added_x0000_copies 6832ae71433c 4c222a1d9a00 : 153721 revs, 1.763853 s, 1.277320 s, -0.486533 s, × 0.7242, 8 µs/rev mozilla-central x00000_revs_x00000_added_x000_copies 76caed42cf7c 1daa622bbe42 : 204976 revs, 2.609761 s, 1.698794 s, -0.910967 s, × 0.6509, 8 µs/rev mozilla-try x_revs_x_added_0_copies aaf6dde0deb8 9790f499805a : 2 revs, 0.000847 s, 0.000842 s, -0.000005 s, × 0.9941, 421 µs/rev mozilla-try x_revs_x000_added_0_copies d8d0222927b4 5bb8ce8c7450 : 2 revs, 0.000867 s, 0.000865 s, -0.000002 s, × 0.9977, 432 µs/rev mozilla-try x_revs_x_added_x_copies 092fcca11bdb 936255a0384a : 4 revs, 0.000161 s, 0.000160 s, -0.000001 s, × 0.9938, 40 µs/rev mozilla-try x_revs_x00_added_x_copies b53d2fadbdb5 017afae788ec : 2 revs, 0.001131 s, 0.001122 s, -0.000009 s, × 0.9920, 561 µs/rev mozilla-try x_revs_x000_added_x000_copies 20408ad61ce5 6f0ee96e21ad : 1 revs, 0.033114 s, 0.032743 s, -0.000371 s, × 0.9888, 32743 µs/rev mozilla-try x_revs_x0000_added_x0000_copies effb563bb7e5 c07a39dc4e80 : 6 revs, 0.071092 s, 0.071529 s, +0.000437 s, × 1.0061, 11921 µs/rev mozilla-try x000_revs_xx00_added_0_copies 6100d773079a 04a55431795e : 1593 revs, 0.006554 s, 0.006593 s, +0.000039 s, × 1.0060, 4 µs/rev mozilla-try x000_revs_x000_added_x_copies 9f17a6fc04f9 2d37b966abed : 41 revs, 0.005160 s, 0.005311 s, +0.000151 s, × 1.0293, 129 µs/rev mozilla-try x000_revs_x000_added_x000_copies 1346fd0130e4 4c65cbdabc1f : 6657 revs, 0.065063 s, 0.063063 s, -0.002000 s, × 0.9693, 9 µs/rev mozilla-try x0000_revs_x_added_0_copies 63519bfd42ee a36a2a865d92 : 40314 revs, 0.297118 s, 0.312363 s, +0.015245 s, × 1.0513, 7 µs/rev mozilla-try x0000_revs_x_added_x_copies 9fe69ff0762d bcabf2a78927 : 38690 revs, 0.284002 s, 0.283106 s, -0.000896 s, × 0.9968, 7 µs/rev mozilla-try x0000_revs_xx000_added_x_copies 156f6e2674f2 4d0f2c178e66 : 8598 revs, 0.086311 s, 0.083817 s, -0.002494 s, × 0.9711, 9 µs/rev mozilla-try x0000_revs_xx000_added_0_copies 9eec5917337d 67118cc6dcad : 615 revs, 0.026738 s, 0.026516 s, -0.000222 s, × 0.9917, 43 µs/rev mozilla-try x0000_revs_xx000_added_x000_copies 89294cd501d9 7ccb2fc7ccb5 : 97052 revs, 1.514270 s, 1.304865 s, -0.209405 s, × 0.8617, 13 µs/rev mozilla-try x0000_revs_x0000_added_x0000_copies e928c65095ed e951f4ad123a : 52031 revs, 0.735875 s, 0.681088 s, -0.054787 s, × 0.9255, 13 µs/rev mozilla-try x00000_revs_x_added_0_copies 6a320851d377 1ebb79acd503 : 363753 revs, 4.843329 s, 4.454320 s, -0.389009 s, × 0.9197, 12 µs/rev mozilla-try x00000_revs_x00000_added_0_copies dc8a3ca7010e d16fde900c9c : 34414 revs, 0.591752 s, 0.567913 s, -0.023839 s, × 0.9597, 16 µs/rev mozilla-try x00000_revs_x_added_x_copies 5173c4b6f97c 95d83ee7242d : 362229 revs, 4.760563 s, 4.547043 s, -0.213520 s, × 0.9551, 12 µs/rev mozilla-try x00000_revs_x000_added_x_copies 9126823d0e9c ca82787bb23c : 359344 revs, 4.751942 s, 4.378579 s, -0.373363 s, × 0.9214, 12 µs/rev mozilla-try x00000_revs_x0000_added_x0000_copies 8d3fafa80d4b eb884023b810 : 192665 revs, 2.605014 s, 1.703622 s, -0.901392 s, × 0.6540, 8 µs/rev mozilla-try x00000_revs_x00000_added_x0000_copies 1b661134e2ca 1ae03d022d6d : 228985 revs, 41.113063 s, 36.001255 s, -5.111808 s, × 0.8757, 157 µs/rev mozilla-try x00000_revs_x00000_added_x000_copies 9b2a99adc05e 8e29777b48e6 : 382065 revs, 27.891612 s, 14.340641 s, -13.550971 s, × 0.5142, 37 µs/rev Differential Revision: https://phab.mercurial-scm.org/D9497

     1

use crate::utils::hg_path::HgPath;

     2

use crate::utils::hg_path::HgPathBuf;

     3

use crate::Revision;

     4

use crate::NULL_REVISION;

     5

     6

use im_rc::ordmap::DiffItem;

     7

use im_rc::ordmap::Entry;

     8

use im_rc::ordmap::OrdMap;

     9

    10

use std::cmp::Ordering;

    11

use std::collections::HashMap;

    12

use std::convert::TryInto;

    13

    14

pub type PathCopies = HashMap<HgPathBuf, HgPathBuf>;

    15

    16

type PathToken = usize;

    17

    18

#[derive(Clone, Debug, PartialEq, Copy)]

    19

struct TimeStampedPathCopy {

    20

    /// revision at which the copy information was added

    21

    rev: Revision,

    22

    /// the copy source, (Set to None in case of deletion of the associated

    23

    /// key)

    24

    path: Option<PathToken>,

    25

}

    26

    27

/// maps CopyDestination to Copy Source (+ a "timestamp" for the operation)

    28

type TimeStampedPathCopies = OrdMap<PathToken, TimeStampedPathCopy>;

    29

    30

/// hold parent 1, parent 2 and relevant files actions.

    31

pub type RevInfo<'a> = (Revision, Revision, ChangedFiles<'a>);

    32

    33

/// represent the files affected by a changesets

    34

///

    35

/// This hold a subset of mercurial.metadata.ChangingFiles as we do not need

    36

/// all the data categories tracked by it.

    37

/// This hold a subset of mercurial.metadata.ChangingFiles as we do not need

    38

/// all the data categories tracked by it.

    39

pub struct ChangedFiles<'a> {

    40

    nb_items: u32,

    41

    index: &'a [u8],

    42

    data: &'a [u8],

    43

}

    44

    45

/// Represent active changes that affect the copy tracing.

    46

enum Action<'a> {

    47

    /// The parent ? children edge is removing a file

    48

    ///

    49

    /// (actually, this could be the edge from the other parent, but it does

    50

    /// not matters)

    51

    Removed(&'a HgPath),

    52

    /// The parent ? children edge introduce copy information between (dest,

    53

    /// source)

    54

    Copied(&'a HgPath, &'a HgPath),

    55

}

    56

    57

/// This express the possible "special" case we can get in a merge

    58

///

    59

/// See mercurial/metadata.py for details on these values.

    60

#[derive(PartialEq)]

    61

enum MergeCase {

    62

    /// Merged: file had history on both side that needed to be merged

    63

    Merged,

    64

    /// Salvaged: file was candidate for deletion, but survived the merge

    65

    Salvaged,

    66

    /// Normal: Not one of the two cases above

    67

    Normal,

    68

}

    69

    70

type FileChange<'a> = (u8, &'a HgPath, &'a HgPath);

    71

    72

const EMPTY: &[u8] = b"";

    73

const COPY_MASK: u8 = 3;

    74

const P1_COPY: u8 = 2;

    75

const P2_COPY: u8 = 3;

    76

const ACTION_MASK: u8 = 28;

    77

const REMOVED: u8 = 12;

    78

const MERGED: u8 = 8;

    79

const SALVAGED: u8 = 16;

    80

    81

impl<'a> ChangedFiles<'a> {

    82

    const INDEX_START: usize = 4;

    83

    const ENTRY_SIZE: u32 = 9;

    84

    const FILENAME_START: u32 = 1;

    85

    const COPY_SOURCE_START: u32 = 5;

    86

    87

    pub fn new(data: &'a [u8]) -> Self {

    88

        assert!(

    89

            data.len() >= 4,

    90

            "data size ({}) is too small to contain the header (4)",

    91

            data.len()

    92

        );

    93

        let nb_items_raw: [u8; 4] = (&data[0..=3])

    94

            .try_into()

    95

            .expect("failed to turn 4 bytes into 4 bytes");

    96

        let nb_items = u32::from_be_bytes(nb_items_raw);

    97

    98

        let index_size = (nb_items * Self::ENTRY_SIZE) as usize;

    99

        let index_end = Self::INDEX_START + index_size;

   100

   101

        assert!(

   102

            data.len() >= index_end,

   103

            "data size ({}) is too small to fit the index_data ({})",

   104

            data.len(),

   105

            index_end

   106

        );

   107

   108

        let ret = ChangedFiles {

   109

            nb_items,

   110

            index: &data[Self::INDEX_START..index_end],

   111

            data: &data[index_end..],

   112

        };

   113

        let max_data = ret.filename_end(nb_items - 1) as usize;

   114

        assert!(

   115

            ret.data.len() >= max_data,

   116

            "data size ({}) is too small to fit all data ({})",

   117

            data.len(),

   118

            index_end + max_data

   119

        );

   120

        ret

   121

    }

   122

   123

    pub fn new_empty() -> Self {

   124

        ChangedFiles {

   125

            nb_items: 0,

   126

            index: EMPTY,

   127

            data: EMPTY,

   128

        }

   129

    }

   130

   131

    /// internal function to return an individual entry at a given index

   132

    fn entry(&'a self, idx: u32) -> FileChange<'a> {

   133

        if idx >= self.nb_items {

   134

            panic!(

   135

                "index for entry is higher that the number of file {} >= {}",

   136

                idx, self.nb_items

   137

            )

   138

        }

   139

        let flags = self.flags(idx);

   140

        let filename = self.filename(idx);

   141

        let copy_idx = self.copy_idx(idx);

   142

        let copy_source = self.filename(copy_idx);

   143

        (flags, filename, copy_source)

   144

    }

   145

   146

    /// internal function to return the filename of the entry at a given index

   147

    fn filename(&self, idx: u32) -> &HgPath {

   148

        let filename_start;

   149

        if idx == 0 {

   150

            filename_start = 0;

   151

        } else {

   152

            filename_start = self.filename_end(idx - 1)

   153

        }

   154

        let filename_end = self.filename_end(idx);

   155

        let filename_start = filename_start as usize;

   156

        let filename_end = filename_end as usize;

   157

        HgPath::new(&self.data[filename_start..filename_end])

   158

    }

   159

   160

    /// internal function to return the flag field of the entry at a given

   161

    /// index

   162

    fn flags(&self, idx: u32) -> u8 {

   163

        let idx = idx as usize;

   164

        self.index[idx * (Self::ENTRY_SIZE as usize)]

   165

    }

   166

   167

    /// internal function to return the end of a filename part at a given index

   168

    fn filename_end(&self, idx: u32) -> u32 {

   169

        let start = (idx * Self::ENTRY_SIZE) + Self::FILENAME_START;

   170

        let end = (idx * Self::ENTRY_SIZE) + Self::COPY_SOURCE_START;

   171

        let start = start as usize;

   172

        let end = end as usize;

   173

        let raw = (&self.index[start..end])

   174

            .try_into()

   175

            .expect("failed to turn 4 bytes into 4 bytes");

   176

        u32::from_be_bytes(raw)

   177

    }

   178

   179

    /// internal function to return index of the copy source of the entry at a

   180

    /// given index

   181

    fn copy_idx(&self, idx: u32) -> u32 {

   182

        let start = (idx * Self::ENTRY_SIZE) + Self::COPY_SOURCE_START;

   183

        let end = (idx + 1) * Self::ENTRY_SIZE;

   184

        let start = start as usize;

   185

        let end = end as usize;

   186

        let raw = (&self.index[start..end])

   187

            .try_into()

   188

            .expect("failed to turn 4 bytes into 4 bytes");

   189

        u32::from_be_bytes(raw)

   190

    }

   191

   192

    /// Return an iterator over all the `Action` in this instance.

   193

    fn iter_actions(&self, parent: Parent) -> ActionsIterator {

   194

        ActionsIterator {

   195

            changes: &self,

   196

            parent: parent,

   197

            current: 0,

   198

        }

   199

    }

   200

   201

    /// return the MergeCase value associated with a filename

   202

    fn get_merge_case(&self, path: &HgPath) -> MergeCase {

   203

        if self.nb_items == 0 {

   204

            return MergeCase::Normal;

   205

        }

   206

        let mut low_part = 0;

   207

        let mut high_part = self.nb_items;

   208

   209

        while low_part < high_part {

   210

            let cursor = (low_part + high_part - 1) / 2;

   211

            let (flags, filename, _source) = self.entry(cursor);

   212

            match path.cmp(filename) {

   213

                Ordering::Less => low_part = cursor + 1,

   214

                Ordering::Greater => high_part = cursor,

   215

                Ordering::Equal => {

   216

                    return match flags & ACTION_MASK {

   217

                        MERGED => MergeCase::Merged,

   218

                        SALVAGED => MergeCase::Salvaged,

   219

                        _ => MergeCase::Normal,

   220

                    };

   221

                }

   222

            }

   223

        }

   224

        MergeCase::Normal

   225

    }

   226

}

   227

   228

/// A struct responsible for answering "is X ancestors of Y" quickly

   229

///

   230

/// The structure will delegate ancestors call to a callback, and cache the

   231

/// result.

   232

#[derive(Debug)]

   233

struct AncestorOracle<'a, A: Fn(Revision, Revision) -> bool> {

   234

    inner: &'a A,

   235

    pairs: HashMap<(Revision, Revision), bool>,

   236

}

   237

   238

impl<'a, A: Fn(Revision, Revision) -> bool> AncestorOracle<'a, A> {

   239

    fn new(func: &'a A) -> Self {

   240

        Self {

   241

            inner: func,

   242

            pairs: HashMap::default(),

   243

        }

   244

    }

   245

   246

    fn record_overwrite(&mut self, anc: Revision, desc: Revision) {

   247

        self.pairs.insert((anc, desc), true);

   248

    }

   249

   250

    /// returns `true` if `anc` is an ancestors of `desc`, `false` otherwise

   251

    fn is_overwrite(&mut self, anc: Revision, desc: Revision) -> bool {

   252

        if anc > desc {

   253

            false

   254

        } else if anc == desc {

   255

            true

   256

        } else {

   257

            if let Some(b) = self.pairs.get(&(anc, desc)) {

   258

                *b

   259

            } else {

   260

                let b = (self.inner)(anc, desc);

   261

                self.pairs.insert((anc, desc), b);

   262

                b

   263

            }

   264

        }

   265

    }

   266

}

   267

   268

struct ActionsIterator<'a> {

   269

    changes: &'a ChangedFiles<'a>,

   270

    parent: Parent,

   271

    current: u32,

   272

}

   273

   274

impl<'a> Iterator for ActionsIterator<'a> {

   275

    type Item = Action<'a>;

   276

   277

    fn next(&mut self) -> Option<Action<'a>> {

   278

        let copy_flag = match self.parent {

   279

            Parent::FirstParent => P1_COPY,

   280

            Parent::SecondParent => P2_COPY,

   281

        };

   282

        while self.current < self.changes.nb_items {

   283

            let (flags, file, source) = self.changes.entry(self.current);

   284

            self.current += 1;

   285

            if (flags & ACTION_MASK) == REMOVED {

   286

                return Some(Action::Removed(file));

   287

            }

   288

            let copy = flags & COPY_MASK;

   289

            if copy == copy_flag {

   290

                return Some(Action::Copied(file, source));

   291

            }

   292

        }

   293

        return None;

   294

    }

   295

}

   296

   297

/// A small struct whose purpose is to ensure lifetime of bytes referenced in

   298

/// ChangedFiles

   299

///

   300

/// It is passed to the RevInfoMaker callback who can assign any necessary

   301

/// content to the `data` attribute. The copy tracing code is responsible for

   302

/// keeping the DataHolder alive at least as long as the ChangedFiles object.

   303

pub struct DataHolder<D> {

   304

    /// RevInfoMaker callback should assign data referenced by the

   305

    /// ChangedFiles struct it return to this attribute. The DataHolder

   306

    /// lifetime will be at least as long as the ChangedFiles one.

   307

    pub data: Option<D>,

   308

}

   309

   310

pub type RevInfoMaker<'a, D> =

   311

    Box<dyn for<'r> Fn(Revision, &'r mut DataHolder<D>) -> RevInfo<'r> + 'a>;

   312

   313

/// enum used to carry information about the parent → child currently processed

   314

#[derive(Copy, Clone, Debug)]

   315

enum Parent {

   316

    /// The `p1(x) → x` edge

   317

    FirstParent,

   318

    /// The `p2(x) → x` edge

   319

    SecondParent,

   320

}

   321

   322

/// A small "tokenizer" responsible of turning full HgPath into lighter

   323

/// PathToken

   324

///

   325

/// Dealing with small object, like integer is much faster, so HgPath input are

   326

/// turned into integer "PathToken" and converted back in the end.

   327

#[derive(Clone, Debug, Default)]

   328

struct TwoWayPathMap {

   329

    token: HashMap<HgPathBuf, PathToken>,

   330

    path: Vec<HgPathBuf>,

   331

}

   332

   333

impl TwoWayPathMap {

   334

    fn tokenize(&mut self, path: &HgPath) -> PathToken {

   335

        match self.token.get(path) {

   336

            Some(a) => *a,

   337

            None => {

   338

                let a = self.token.len();

   339

                let buf = path.to_owned();

   340

                self.path.push(buf.clone());

   341

                self.token.insert(buf, a);

   342

                a

   343

            }

   344

        }