mercurial-scm/hg-stable: rust/hg-core/src/copy

annotate rust/hg-core/src/copy_tracing.rs @ 46155:fce2f20a54ce

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

author	Pierre-Yves David <pierre-yves.david@octobus.net>
date	Sat, 21 Nov 2020 17:00:32 +0100
parents	ecbb2fc9418c
children	7d99614b7b77

rev	line source
45988 ed0e1339e4a8 copies-rust: combine the iteration over remove and copies into one Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45987 diff changeset	1 use crate::utils::hg_path::HgPath;
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	2 use crate::utils::hg_path::HgPathBuf;
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	3 use crate::Revision;
46149 294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	4 use crate::NULL_REVISION;
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	5
45986 cc759d3db1e8 copies-rust: leverage the immutability for efficient update Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45979 diff changeset	6 use im_rc::ordmap::DiffItem;
46153 0a721fc457bf copies-rust: use the `entry` API for copy information too Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46152 diff changeset	7 use im_rc::ordmap::Entry;
45978 0d99778af68a copies-rust: use immutable "OrdMap" to store copies information Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45959 diff changeset	8 use im_rc::ordmap::OrdMap;
0d99778af68a copies-rust: use immutable "OrdMap" to store copies information Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45959 diff changeset	9
46061 e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	10 use std::cmp::Ordering;
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	11 use std::collections::HashMap;
46061 e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	12 use std::convert::TryInto;
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	13
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	14 pub type PathCopies = HashMap<HgPathBuf, HgPathBuf>;
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	15
46151 c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	16 type PathToken = usize;
46130 818502d2f5e3 copies-rust: pre-introduce a PathToken type and use it where applicable Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46129 diff changeset	17
46151 c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	18 #[derive(Clone, Debug, PartialEq, Copy)]
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	19 struct TimeStampedPathCopy {
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	20 /// revision at which the copy information was added
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	21 rev: Revision,
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	22 /// the copy source, (Set to None in case of deletion of the associated
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	23 /// key)
46130 818502d2f5e3 copies-rust: pre-introduce a PathToken type and use it where applicable Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46129 diff changeset	24 path: Option<PathToken>,
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	25 }
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	26
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	27 /// maps CopyDestination to Copy Source (+ a "timestamp" for the operation)
46130 818502d2f5e3 copies-rust: pre-introduce a PathToken type and use it where applicable Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46129 diff changeset	28 type TimeStampedPathCopies = OrdMap<PathToken, TimeStampedPathCopy>;
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	29
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	30 /// hold parent 1, parent 2 and relevant files actions.
46061 e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	31 pub type RevInfo<'a> = (Revision, Revision, ChangedFiles<'a>);
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	32
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	33 /// represent the files affected by a changesets
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	34 ///
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	35 /// This hold a subset of mercurial.metadata.ChangingFiles as we do not need
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	36 /// all the data categories tracked by it.
46061 e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	37 /// This hold a subset of mercurial.metadata.ChangingFiles as we do not need
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	38 /// all the data categories tracked by it.
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	39 pub struct ChangedFiles<'a> {
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	40 nb_items: u32,
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	41 index: &'a [u8],
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	42 data: &'a [u8],
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	43 }
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	44
45988 ed0e1339e4a8 copies-rust: combine the iteration over remove and copies into one Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45987 diff changeset	45 /// Represent active changes that affect the copy tracing.
ed0e1339e4a8 copies-rust: combine the iteration over remove and copies into one Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45987 diff changeset	46 enum Action<'a> {
ed0e1339e4a8 copies-rust: combine the iteration over remove and copies into one Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45987 diff changeset	47 /// The parent ? children edge is removing a file
ed0e1339e4a8 copies-rust: combine the iteration over remove and copies into one Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45987 diff changeset	48 ///
ed0e1339e4a8 copies-rust: combine the iteration over remove and copies into one Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45987 diff changeset	49 /// (actually, this could be the edge from the other parent, but it does
ed0e1339e4a8 copies-rust: combine the iteration over remove and copies into one Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45987 diff changeset	50 /// not matters)
ed0e1339e4a8 copies-rust: combine the iteration over remove and copies into one Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45987 diff changeset	51 Removed(&'a HgPath),
ed0e1339e4a8 copies-rust: combine the iteration over remove and copies into one Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45987 diff changeset	52 /// The parent ? children edge introduce copy information between (dest,
ed0e1339e4a8 copies-rust: combine the iteration over remove and copies into one Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45987 diff changeset	53 /// source)
ed0e1339e4a8 copies-rust: combine the iteration over remove and copies into one Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45987 diff changeset	54 Copied(&'a HgPath, &'a HgPath),
ed0e1339e4a8 copies-rust: combine the iteration over remove and copies into one Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45987 diff changeset	55 }
ed0e1339e4a8 copies-rust: combine the iteration over remove and copies into one Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45987 diff changeset	56
45990 2367937982ba copies-rust: encapsulate internal sets on `changes` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45989 diff changeset	57 /// This express the possible "special" case we can get in a merge
2367937982ba copies-rust: encapsulate internal sets on `changes` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45989 diff changeset	58 ///
2367937982ba copies-rust: encapsulate internal sets on `changes` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45989 diff changeset	59 /// See mercurial/metadata.py for details on these values.
2367937982ba copies-rust: encapsulate internal sets on `changes` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45989 diff changeset	60 #[derive(PartialEq)]
2367937982ba copies-rust: encapsulate internal sets on `changes` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45989 diff changeset	61 enum MergeCase {
2367937982ba copies-rust: encapsulate internal sets on `changes` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45989 diff changeset	62 /// Merged: file had history on both side that needed to be merged
2367937982ba copies-rust: encapsulate internal sets on `changes` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45989 diff changeset	63 Merged,
2367937982ba copies-rust: encapsulate internal sets on `changes` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45989 diff changeset	64 /// Salvaged: file was candidate for deletion, but survived the merge
2367937982ba copies-rust: encapsulate internal sets on `changes` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45989 diff changeset	65 Salvaged,
2367937982ba copies-rust: encapsulate internal sets on `changes` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45989 diff changeset	66 /// Normal: Not one of the two cases above
2367937982ba copies-rust: encapsulate internal sets on `changes` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45989 diff changeset	67 Normal,
2367937982ba copies-rust: encapsulate internal sets on `changes` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45989 diff changeset	68 }
2367937982ba copies-rust: encapsulate internal sets on `changes` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45989 diff changeset	69
46061 e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	70 type FileChange<'a> = (u8, &'a HgPath, &'a HgPath);
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	71
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	72 const EMPTY: &[u8] = b"";
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	73 const COPY_MASK: u8 = 3;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	74 const P1_COPY: u8 = 2;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	75 const P2_COPY: u8 = 3;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	76 const ACTION_MASK: u8 = 28;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	77 const REMOVED: u8 = 12;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	78 const MERGED: u8 = 8;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	79 const SALVAGED: u8 = 16;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	80
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	81 impl<'a> ChangedFiles<'a> {
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	82 const INDEX_START: usize = 4;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	83 const ENTRY_SIZE: u32 = 9;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	84 const FILENAME_START: u32 = 1;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	85 const COPY_SOURCE_START: u32 = 5;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	86
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	87 pub fn new(data: &'a [u8]) -> Self {
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	88 assert!(
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	89 data.len() >= 4,
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	90 "data size ({}) is too small to contain the header (4)",
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	91 data.len()
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	92 );
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	93 let nb_items_raw: [u8; 4] = (&data[0..=3])
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	94 .try_into()
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	95 .expect("failed to turn 4 bytes into 4 bytes");
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	96 let nb_items = u32::from_be_bytes(nb_items_raw);
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	97
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	98 let index_size = (nb_items * Self::ENTRY_SIZE) as usize;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	99 let index_end = Self::INDEX_START + index_size;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	100
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	101 assert!(
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	102 data.len() >= index_end,
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	103 "data size ({}) is too small to fit the index_data ({})",
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	104 data.len(),
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	105 index_end
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	106 );
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	107
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	108 let ret = ChangedFiles {
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	109 nb_items,
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	110 index: &data[Self::INDEX_START..index_end],
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	111 data: &data[index_end..],
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	112 };
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	113 let max_data = ret.filename_end(nb_items - 1) as usize;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	114 assert!(
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	115 ret.data.len() >= max_data,
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	116 "data size ({}) is too small to fit all data ({})",
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	117 data.len(),
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	118 index_end + max_data
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	119 );
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	120 ret
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	121 }
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	122
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	123 pub fn new_empty() -> Self {
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	124 ChangedFiles {
46061 e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	125 nb_items: 0,
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	126 index: EMPTY,
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	127 data: EMPTY,
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	128 }
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	129 }
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	130
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	131 /// internal function to return an individual entry at a given index
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	132 fn entry(&'a self, idx: u32) -> FileChange<'a> {
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	133 if idx >= self.nb_items {
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	134 panic!(
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	135 "index for entry is higher that the number of file {} >= {}",
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	136 idx, self.nb_items
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	137 )
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	138 }
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	139 let flags = self.flags(idx);
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	140 let filename = self.filename(idx);
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	141 let copy_idx = self.copy_idx(idx);
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	142 let copy_source = self.filename(copy_idx);
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	143 (flags, filename, copy_source)
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	144 }
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	145
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	146 /// internal function to return the filename of the entry at a given index
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	147 fn filename(&self, idx: u32) -> &HgPath {
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	148 let filename_start;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	149 if idx == 0 {
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	150 filename_start = 0;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	151 } else {
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	152 filename_start = self.filename_end(idx - 1)
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	153 }
46061 e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	154 let filename_end = self.filename_end(idx);
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	155 let filename_start = filename_start as usize;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	156 let filename_end = filename_end as usize;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	157 HgPath::new(&self.data[filename_start..filename_end])
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	158 }
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	159
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	160 /// internal function to return the flag field of the entry at a given
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	161 /// index
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	162 fn flags(&self, idx: u32) -> u8 {
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	163 let idx = idx as usize;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	164 self.index[idx * (Self::ENTRY_SIZE as usize)]
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	165 }
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	166
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	167 /// internal function to return the end of a filename part at a given index
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	168 fn filename_end(&self, idx: u32) -> u32 {
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	169 let start = (idx * Self::ENTRY_SIZE) + Self::FILENAME_START;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	170 let end = (idx * Self::ENTRY_SIZE) + Self::COPY_SOURCE_START;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	171 let start = start as usize;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	172 let end = end as usize;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	173 let raw = (&self.index[start..end])
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	174 .try_into()
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	175 .expect("failed to turn 4 bytes into 4 bytes");
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	176 u32::from_be_bytes(raw)
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	177 }
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	178
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	179 /// internal function to return index of the copy source of the entry at a
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	180 /// given index
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	181 fn copy_idx(&self, idx: u32) -> u32 {
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	182 let start = (idx * Self::ENTRY_SIZE) + Self::COPY_SOURCE_START;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	183 let end = (idx + 1) * Self::ENTRY_SIZE;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	184 let start = start as usize;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	185 let end = end as usize;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	186 let raw = (&self.index[start..end])
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	187 .try_into()
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	188 .expect("failed to turn 4 bytes into 4 bytes");
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	189 u32::from_be_bytes(raw)
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	190 }
45988 ed0e1339e4a8 copies-rust: combine the iteration over remove and copies into one Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45987 diff changeset	191
ed0e1339e4a8 copies-rust: combine the iteration over remove and copies into one Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45987 diff changeset	192 /// Return an iterator over all the `Action` in this instance.
46062 12192fdbf3ac copies-rust: move the parent token to an enum Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46061 diff changeset	193 fn iter_actions(&self, parent: Parent) -> ActionsIterator {
46061 e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	194 ActionsIterator {
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	195 changes: &self,
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	196 parent: parent,
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	197 current: 0,
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	198 }
45988 ed0e1339e4a8 copies-rust: combine the iteration over remove and copies into one Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45987 diff changeset	199 }
45990 2367937982ba copies-rust: encapsulate internal sets on `changes` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45989 diff changeset	200
2367937982ba copies-rust: encapsulate internal sets on `changes` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45989 diff changeset	201 /// return the MergeCase value associated with a filename
2367937982ba copies-rust: encapsulate internal sets on `changes` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45989 diff changeset	202 fn get_merge_case(&self, path: &HgPath) -> MergeCase {
46061 e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	203 if self.nb_items == 0 {
45990 2367937982ba copies-rust: encapsulate internal sets on `changes` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45989 diff changeset	204 return MergeCase::Normal;
2367937982ba copies-rust: encapsulate internal sets on `changes` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45989 diff changeset	205 }
46061 e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	206 let mut low_part = 0;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	207 let mut high_part = self.nb_items;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	208
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	209 while low_part < high_part {
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	210 let cursor = (low_part + high_part - 1) / 2;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	211 let (flags, filename, _source) = self.entry(cursor);
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	212 match path.cmp(filename) {
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	213 Ordering::Less => low_part = cursor + 1,
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	214 Ordering::Greater => high_part = cursor,
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	215 Ordering::Equal => {
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	216 return match flags & ACTION_MASK {
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	217 MERGED => MergeCase::Merged,
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	218 SALVAGED => MergeCase::Salvaged,
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	219 _ => MergeCase::Normal,
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	220 };
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	221 }
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	222 }
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	223 }
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	224 MergeCase::Normal
45990 2367937982ba copies-rust: encapsulate internal sets on `changes` Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45989 diff changeset	225 }
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	226 }
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	227
45987 8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	228 /// A struct responsible for answering "is X ancestors of Y" quickly
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	229 ///
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	230 /// The structure will delegate ancestors call to a callback, and cache the
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	231 /// result.
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	232 #[derive(Debug)]
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	233 struct AncestorOracle<'a, A: Fn(Revision, Revision) -> bool> {
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	234 inner: &'a A,
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	235 pairs: HashMap<(Revision, Revision), bool>,
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	236 }
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	237
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	238 impl<'a, A: Fn(Revision, Revision) -> bool> AncestorOracle<'a, A> {
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	239 fn new(func: &'a A) -> Self {
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	240 Self {
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	241 inner: func,
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	242 pairs: HashMap::default(),
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	243 }
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	244 }
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	245
46155 fce2f20a54ce copies-rust: start recording overwrite as they happens Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46154 diff changeset	246 fn record_overwrite(&mut self, anc: Revision, desc: Revision) {
fce2f20a54ce copies-rust: start recording overwrite as they happens Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46154 diff changeset	247 self.pairs.insert((anc, desc), true);
fce2f20a54ce copies-rust: start recording overwrite as they happens Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46154 diff changeset	248 }
fce2f20a54ce copies-rust: start recording overwrite as they happens Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46154 diff changeset	249
45987 8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	250 /// returns `true` if `anc` is an ancestors of `desc`, `false` otherwise
46154 ecbb2fc9418c copies-rust: rename Oracle.is_ancestor to Oracle.is_overwrite Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46153 diff changeset	251 fn is_overwrite(&mut self, anc: Revision, desc: Revision) -> bool {
45987 8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	252 if anc > desc {
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	253 false
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	254 } else if anc == desc {
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	255 true
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	256 } else {
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	257 if let Some(b) = self.pairs.get(&(anc, desc)) {
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	258 *b
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	259 } else {
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	260 let b = (self.inner)(anc, desc);
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	261 self.pairs.insert((anc, desc), b);
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	262 b
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	263 }
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	264 }
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	265 }
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	266 }
8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	267
46061 e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	268 struct ActionsIterator<'a> {
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	269 changes: &'a ChangedFiles<'a>,
46062 12192fdbf3ac copies-rust: move the parent token to an enum Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46061 diff changeset	270 parent: Parent,
46061 e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	271 current: u32,
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	272 }
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	273
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	274 impl<'a> Iterator for ActionsIterator<'a> {
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	275 type Item = Action<'a>;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	276
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	277 fn next(&mut self) -> Option<Action<'a>> {
46062 12192fdbf3ac copies-rust: move the parent token to an enum Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46061 diff changeset	278 let copy_flag = match self.parent {
12192fdbf3ac copies-rust: move the parent token to an enum Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46061 diff changeset	279 Parent::FirstParent => P1_COPY,
12192fdbf3ac copies-rust: move the parent token to an enum Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46061 diff changeset	280 Parent::SecondParent => P2_COPY,
12192fdbf3ac copies-rust: move the parent token to an enum Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46061 diff changeset	281 };
46061 e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	282 while self.current < self.changes.nb_items {
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	283 let (flags, file, source) = self.changes.entry(self.current);
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	284 self.current += 1;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	285 if (flags & ACTION_MASK) == REMOVED {
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	286 return Some(Action::Removed(file));
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	287 }
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	288 let copy = flags & COPY_MASK;
46062 12192fdbf3ac copies-rust: move the parent token to an enum Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46061 diff changeset	289 if copy == copy_flag {
46061 e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	290 return Some(Action::Copied(file, source));
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	291 }
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	292 }
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	293 return None;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	294 }
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	295 }
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	296
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	297 /// A small struct whose purpose is to ensure lifetime of bytes referenced in
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	298 /// ChangedFiles
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	299 ///
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	300 /// It is passed to the RevInfoMaker callback who can assign any necessary
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	301 /// content to the `data` attribute. The copy tracing code is responsible for
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	302 /// keeping the DataHolder alive at least as long as the ChangedFiles object.
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	303 pub struct DataHolder<D> {
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	304 /// RevInfoMaker callback should assign data referenced by the
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	305 /// ChangedFiles struct it return to this attribute. The DataHolder
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	306 /// lifetime will be at least as long as the ChangedFiles one.
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	307 pub data: Option<D>,
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	308 }
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	309
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	310 pub type RevInfoMaker<'a, D> =
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	311 Box<dyn for<'r> Fn(Revision, &'r mut DataHolder<D>) -> RevInfo<'r> + 'a>;
e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	312
46062 12192fdbf3ac copies-rust: move the parent token to an enum Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46061 diff changeset	313 /// enum used to carry information about the parent → child currently processed
12192fdbf3ac copies-rust: move the parent token to an enum Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46061 diff changeset	314 #[derive(Copy, Clone, Debug)]
12192fdbf3ac copies-rust: move the parent token to an enum Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46061 diff changeset	315 enum Parent {
12192fdbf3ac copies-rust: move the parent token to an enum Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46061 diff changeset	316 /// The `p1(x) → x` edge
12192fdbf3ac copies-rust: move the parent token to an enum Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46061 diff changeset	317 FirstParent,
12192fdbf3ac copies-rust: move the parent token to an enum Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46061 diff changeset	318 /// The `p2(x) → x` edge
12192fdbf3ac copies-rust: move the parent token to an enum Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46061 diff changeset	319 SecondParent,
12192fdbf3ac copies-rust: move the parent token to an enum Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46061 diff changeset	320 }
12192fdbf3ac copies-rust: move the parent token to an enum Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46061 diff changeset	321
46151 c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	322 /// A small "tokenizer" responsible of turning full HgPath into lighter
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	323 /// PathToken
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	324 ///
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	325 /// Dealing with small object, like integer is much faster, so HgPath input are
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	326 /// turned into integer "PathToken" and converted back in the end.
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	327 #[derive(Clone, Debug, Default)]
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	328 struct TwoWayPathMap {
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	329 token: HashMap<HgPathBuf, PathToken>,
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	330 path: Vec<HgPathBuf>,
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	331 }
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	332
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	333 impl TwoWayPathMap {
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	334 fn tokenize(&mut self, path: &HgPath) -> PathToken {
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	335 match self.token.get(path) {
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	336 Some(a) => *a,
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	337 None => {
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	338 let a = self.token.len();
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	339 let buf = path.to_owned();
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	340 self.path.push(buf.clone());
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	341 self.token.insert(buf, a);
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	342 a
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	343 }
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	344 }
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	345 }
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	346
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	347 fn untokenize(&self, token: PathToken) -> &HgPathBuf {
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	348 assert!(token < self.path.len(), format!("Unknown token: {}", token));
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	349 &self.path[token]
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	350 }
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	351 }
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	352
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	353 /// Same as mercurial.copies._combine_changeset_copies, but in Rust.
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	354 ///
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	355 /// Arguments are:
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	356 ///
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	357 /// revs: all revisions to be considered
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	358 /// children: a {parent ? [childrens]} mapping
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	359 /// target_rev: the final revision we are combining copies to
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	360 /// rev_info(rev): callback to get revision information:
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	361 /// * first parent
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	362 /// * second parent
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	363 /// * ChangedFiles
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	364 /// isancestors(low_rev, high_rev): callback to check if a revision is an
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	365 /// ancestor of another
46061 e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	366 pub fn combine_changeset_copies<A: Fn(Revision, Revision) -> bool, D>(
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	367 revs: Vec<Revision>,
46149 294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	368 mut children_count: HashMap<Revision, usize>,
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	369 target_rev: Revision,
46061 e0313b0a6f7e copies-rust: parse the changed-file sidedata directly in rust Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45990 diff changeset	370 rev_info: RevInfoMaker<D>,
45987 8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	371 is_ancestor: &A,
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	372 ) -> PathCopies {
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	373 let mut all_copies = HashMap::new();
45987 8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	374 let mut oracle = AncestorOracle::new(is_ancestor);
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	375
46151 c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	376 let mut path_map = TwoWayPathMap::default();
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	377
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	378 for rev in revs {
46149 294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	379 let mut d: DataHolder<D> = DataHolder { data: None };
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	380 let (p1, p2, changes) = rev_info(rev, &mut d);
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	381
46149 294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	382 // We will chain the copies information accumulated for the parent with
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	383 // the individual copies information the curent revision. Creating a
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	384 // new TimeStampedPath for each `rev` → `children` vertex.
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	385 let mut copies: Option<TimeStampedPathCopies> = None;
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	386 if p1 != NULL_REVISION {
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	387 // Retrieve data computed in a previous iteration
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	388 let parent_copies = get_and_clean_parent_copies(
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	389 &mut all_copies,
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	390 &mut children_count,
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	391 p1,
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	392 );
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	393 if let Some(parent_copies) = parent_copies {
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	394 // combine it with data for that revision
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	395 let vertex_copies = add_from_changes(
46151 c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	396 &mut path_map,
46155 fce2f20a54ce copies-rust: start recording overwrite as they happens Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46154 diff changeset	397 &mut oracle,
46149 294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	398 &parent_copies,
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	399 &changes,
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	400 Parent::FirstParent,
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	401 rev,
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	402 );
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	403 // keep that data around for potential later combination
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	404 copies = Some(vertex_copies);
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	405 }
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	406 }
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	407 if p2 != NULL_REVISION {
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	408 // Retrieve data computed in a previous iteration
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	409 let parent_copies = get_and_clean_parent_copies(
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	410 &mut all_copies,
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	411 &mut children_count,
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	412 p2,
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	413 );
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	414 if let Some(parent_copies) = parent_copies {
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	415 // combine it with data for that revision
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	416 let vertex_copies = add_from_changes(
46151 c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	417 &mut path_map,
46155 fce2f20a54ce copies-rust: start recording overwrite as they happens Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46154 diff changeset	418 &mut oracle,
46149 294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	419 &parent_copies,
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	420 &changes,
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	421 Parent::SecondParent,
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	422 rev,
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	423 );
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	424
46149 294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	425 copies = match copies {
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	426 None => Some(vertex_copies),
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	427 // Merge has two parents needs to combines their copy
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	428 // information.
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	429 //
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	430 // If we got data from both parents, We need to combine
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	431 // them.
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	432 Some(copies) => Some(merge_copies_dict(
46151 c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	433 &path_map,
46149 294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	434 vertex_copies,
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	435 copies,
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	436 &changes,
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	437 &mut oracle,
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	438 )),
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	439 };
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	440 }
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	441 }
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	442 match copies {
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	443 Some(copies) => {
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	444 all_copies.insert(rev, copies);
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	445 }
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	446 _ => {}
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	447 }
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	448 }
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	449
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	450 // Drop internal information (like the timestamp) and return the final
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	451 // mapping.
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	452 let tt_result = all_copies
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	453 .remove(&target_rev)
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	454 .expect("target revision was not processed");
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	455 let mut result = PathCopies::default();
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	456 for (dest, tt_source) in tt_result {
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	457 if let Some(path) = tt_source.path {
46151 c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	458 let path_dest = path_map.untokenize(dest).to_owned();
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	459 let path_path = path_map.untokenize(path).to_owned();
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	460 result.insert(path_dest, path_path);
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	461 }
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	462 }
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	463 result
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	464 }
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	465
46149 294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	466 /// fetch previous computed information
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	467 ///
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	468 /// If no other children are expected to need this information, we drop it from
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	469 /// the cache.
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	470 ///
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	471 /// If parent is not part of the set we are expected to walk, return None.
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	472 fn get_and_clean_parent_copies(
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	473 all_copies: &mut HashMap<Revision, TimeStampedPathCopies>,
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	474 children_count: &mut HashMap<Revision, usize>,
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	475 parent_rev: Revision,
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	476 ) -> Option<TimeStampedPathCopies> {
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	477 let count = children_count.get_mut(&parent_rev)?;
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	478 *count -= 1;
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	479 if *count == 0 {
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	480 match all_copies.remove(&parent_rev) {
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	481 Some(c) => Some(c),
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	482 None => Some(TimeStampedPathCopies::default()),
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	483 }
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	484 } else {
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	485 match all_copies.get(&parent_rev) {
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	486 Some(c) => Some(c.clone()),
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	487 None => Some(TimeStampedPathCopies::default()),
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	488 }
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	489 }
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	490 }
294d5aca4ff5 copies: iterate over children directly (instead of parents) Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46130 diff changeset	491
46063 dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	492 /// Combine ChangedFiles with some existing PathCopies information and return
dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	493 /// the result
46155 fce2f20a54ce copies-rust: start recording overwrite as they happens Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46154 diff changeset	494 fn add_from_changes<A: Fn(Revision, Revision) -> bool>(
46151 c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	495 path_map: &mut TwoWayPathMap,
46155 fce2f20a54ce copies-rust: start recording overwrite as they happens Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46154 diff changeset	496 oracle: &mut AncestorOracle<A>,
46063 dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	497 base_copies: &TimeStampedPathCopies,
dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	498 changes: &ChangedFiles,
dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	499 parent: Parent,
dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	500 current_rev: Revision,
dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	501 ) -> TimeStampedPathCopies {
dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	502 let mut copies = base_copies.clone();
dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	503 for action in changes.iter_actions(parent) {
dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	504 match action {
46151 c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	505 Action::Copied(path_dest, path_source) => {
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	506 let dest = path_map.tokenize(path_dest);
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	507 let source = path_map.tokenize(path_source);
46063 dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	508 let entry;
46151 c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	509 if let Some(v) = base_copies.get(&source) {
46063 dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	510 entry = match &v.path {
dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	511 Some(path) => Some((*(path)).to_owned()),
dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	512 None => Some(source.to_owned()),
dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	513 }
dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	514 } else {
dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	515 entry = Some(source.to_owned());
dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	516 }
dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	517 // Each new entry is introduced by the children, we
dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	518 // record this information as we will need it to take
dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	519 // the right decision when merging conflicting copy
dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	520 // information. See merge_copies_dict for details.
46153 0a721fc457bf copies-rust: use the `entry` API for copy information too Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46152 diff changeset	521 match copies.entry(dest) {
0a721fc457bf copies-rust: use the `entry` API for copy information too Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46152 diff changeset	522 Entry::Vacant(slot) => {
0a721fc457bf copies-rust: use the `entry` API for copy information too Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46152 diff changeset	523 let ttpc = TimeStampedPathCopy {
0a721fc457bf copies-rust: use the `entry` API for copy information too Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46152 diff changeset	524 rev: current_rev,
0a721fc457bf copies-rust: use the `entry` API for copy information too Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46152 diff changeset	525 path: entry,
0a721fc457bf copies-rust: use the `entry` API for copy information too Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46152 diff changeset	526 };
0a721fc457bf copies-rust: use the `entry` API for copy information too Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46152 diff changeset	527 slot.insert(ttpc);
0a721fc457bf copies-rust: use the `entry` API for copy information too Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46152 diff changeset	528 }
0a721fc457bf copies-rust: use the `entry` API for copy information too Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46152 diff changeset	529 Entry::Occupied(mut slot) => {
0a721fc457bf copies-rust: use the `entry` API for copy information too Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46152 diff changeset	530 let mut ttpc = slot.get_mut();
46155 fce2f20a54ce copies-rust: start recording overwrite as they happens Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46154 diff changeset	531 oracle.record_overwrite(ttpc.rev, current_rev);
46153 0a721fc457bf copies-rust: use the `entry` API for copy information too Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46152 diff changeset	532 ttpc.rev = current_rev;
0a721fc457bf copies-rust: use the `entry` API for copy information too Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46152 diff changeset	533 ttpc.path = entry;
0a721fc457bf copies-rust: use the `entry` API for copy information too Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46152 diff changeset	534 }
0a721fc457bf copies-rust: use the `entry` API for copy information too Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46152 diff changeset	535 }
46063 dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	536 }
46151 c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	537 Action::Removed(deleted_path) => {
46063 dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	538 // We must drop copy information for removed file.
dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	539 //
dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	540 // We need to explicitly record them as dropped to
dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	541 // propagate this information when merging two
dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	542 // TimeStampedPathCopies object.
46151 c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	543 let deleted = path_map.tokenize(deleted_path);
46152 e166e8a035a7 copies-rust: use the entry API to overwrite deleted entry Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46151 diff changeset	544 copies.entry(deleted).and_modify(\|old\| {
46155 fce2f20a54ce copies-rust: start recording overwrite as they happens Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46154 diff changeset	545 oracle.record_overwrite(old.rev, current_rev);
46152 e166e8a035a7 copies-rust: use the entry API to overwrite deleted entry Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46151 diff changeset	546 old.rev = current_rev;
e166e8a035a7 copies-rust: use the entry API to overwrite deleted entry Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46151 diff changeset	547 old.path = None;
e166e8a035a7 copies-rust: use the entry API to overwrite deleted entry Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46151 diff changeset	548 });
46063 dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	549 }
dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	550 }
dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	551 }
dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	552 copies
dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	553 }
dacb771f6dd2 copies-rust: extract the processing of a ChangedFiles in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46062 diff changeset	554
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	555 /// merge two copies-mapping together, minor and major
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	556 ///
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	557 /// In case of conflict, value from "major" will be picked, unless in some
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	558 /// cases. See inline documentation for details.
45987 8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	559 fn merge_copies_dict<A: Fn(Revision, Revision) -> bool>(
46151 c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	560 path_map: &TwoWayPathMap,
46129 c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	561 mut minor: TimeStampedPathCopies,
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	562 mut major: TimeStampedPathCopies,
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	563 changes: &ChangedFiles,
45987 8b99c473aae2 copies-rust: move is_ancestor caching within the rust code Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45986 diff changeset	564 oracle: &mut AncestorOracle<A>,
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	565 ) -> TimeStampedPathCopies {
46128 c58c8f1d63b1 copies-rust: hide most of the comparison details inside a closure Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46127 diff changeset	566 // This closure exist as temporary help while multiple developper are
c58c8f1d63b1 copies-rust: hide most of the comparison details inside a closure Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46127 diff changeset	567 // actively working on this code. Feel free to re-inline it once this
c58c8f1d63b1 copies-rust: hide most of the comparison details inside a closure Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46127 diff changeset	568 // code is more settled.
c58c8f1d63b1 copies-rust: hide most of the comparison details inside a closure Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46127 diff changeset	569 let mut cmp_value =
46130 818502d2f5e3 copies-rust: pre-introduce a PathToken type and use it where applicable Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46129 diff changeset	570 \|dest: &PathToken,
46128 c58c8f1d63b1 copies-rust: hide most of the comparison details inside a closure Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46127 diff changeset	571 src_minor: &TimeStampedPathCopy,
c58c8f1d63b1 copies-rust: hide most of the comparison details inside a closure Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46127 diff changeset	572 src_major: &TimeStampedPathCopy\| {
46151 c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	573 compare_value(
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	574 path_map, changes, oracle, dest, src_minor, src_major,
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	575 )
46128 c58c8f1d63b1 copies-rust: hide most of the comparison details inside a closure Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46127 diff changeset	576 };
45986 cc759d3db1e8 copies-rust: leverage the immutability for efficient update Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45979 diff changeset	577 if minor.is_empty() {
46127 94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	578 major
45986 cc759d3db1e8 copies-rust: leverage the immutability for efficient update Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45979 diff changeset	579 } else if major.is_empty() {
46127 94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	580 minor
46129 c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	581 } else if minor.len() * 2 < major.len() {
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	582 // Lets says we are merging two TimeStampedPathCopies instance A and B.
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	583 //
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	584 // If A contains N items, the merge result will never contains more
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	585 // than N values differents than the one in A
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	586 //
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	587 // If B contains M items, with M > N, the merge result will always
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	588 // result in a minimum of M - N value differents than the on in
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	589 // A
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	590 //
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	591 // As a result, if N < (M-N), we know that simply iterating over A will
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	592 // yield less difference than iterating over the difference
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	593 // between A and B.
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	594 //
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	595 // This help performance a lot in case were a tiny
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	596 // TimeStampedPathCopies is merged with a much larger one.
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	597 for (dest, src_minor) in minor {
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	598 let src_major = major.get(&dest);
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	599 match src_major {
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	600 None => major.insert(dest, src_minor),
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	601 Some(src_major) => {
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	602 match cmp_value(&dest, &src_minor, src_major) {
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	603 MergePick::Any \| MergePick::Major => None,
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	604 MergePick::Minor => major.insert(dest, src_minor),
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	605 }
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	606 }
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	607 };
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	608 }
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	609 major
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	610 } else if major.len() * 2 < minor.len() {
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	611 // This use the same rational than the previous block.
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	612 // (Check previous block documentation for details.)
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	613 for (dest, src_major) in major {
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	614 let src_minor = minor.get(&dest);
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	615 match src_minor {
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	616 None => minor.insert(dest, src_major),
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	617 Some(src_minor) => {
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	618 match cmp_value(&dest, src_minor, &src_major) {
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	619 MergePick::Any \| MergePick::Minor => None,
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	620 MergePick::Major => minor.insert(dest, src_major),
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	621 }
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	622 }
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	623 };
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	624 }
c94d013e2299 copies-rust: add smarter approach for merging small mapping with large mapping Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46128 diff changeset	625 minor
46127 94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	626 } else {
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	627 let mut override_minor = Vec::new();
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	628 let mut override_major = Vec::new();
45986 cc759d3db1e8 copies-rust: leverage the immutability for efficient update Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45979 diff changeset	629
46130 818502d2f5e3 copies-rust: pre-introduce a PathToken type and use it where applicable Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46129 diff changeset	630 let mut to_major = \|k: &PathToken, v: &TimeStampedPathCopy\| {
46127 94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	631 override_major.push((k.clone(), v.clone()))
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	632 };
46130 818502d2f5e3 copies-rust: pre-introduce a PathToken type and use it where applicable Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46129 diff changeset	633 let mut to_minor = \|k: &PathToken, v: &TimeStampedPathCopy\| {
46127 94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	634 override_minor.push((k.clone(), v.clone()))
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	635 };
45986 cc759d3db1e8 copies-rust: leverage the immutability for efficient update Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45979 diff changeset	636
46127 94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	637 // The diff function leverage detection of the identical subpart if
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	638 // minor and major has some common ancestors. This make it very
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	639 // fast is most case.
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	640 //
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	641 // In case where the two map are vastly different in size, the current
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	642 // approach is still slowish because the iteration will iterate over
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	643 // all the "exclusive" content of the larger on. This situation can be
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	644 // frequent when the subgraph of revision we are processing has a lot
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	645 // of roots. Each roots adding they own fully new map to the mix (and
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	646 // likely a small map, if the path from the root to the "main path" is
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	647 // small.
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	648 //
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	649 // We could do better by detecting such situation and processing them
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	650 // differently.
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	651 for d in minor.diff(&major) {
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	652 match d {
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	653 DiffItem::Add(k, v) => to_minor(k, v),
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	654 DiffItem::Remove(k, v) => to_major(k, v),
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	655 DiffItem::Update { old, new } => {
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	656 let (dest, src_major) = new;
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	657 let (_, src_minor) = old;
46128 c58c8f1d63b1 copies-rust: hide most of the comparison details inside a closure Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46127 diff changeset	658 match cmp_value(dest, src_minor, src_major) {
46127 94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	659 MergePick::Major => to_minor(dest, src_major),
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	660 MergePick::Minor => to_major(dest, src_minor),
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	661 // If the two entry are identical, no need to do
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	662 // anything (but diff should not have yield them)
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	663 MergePick::Any => unreachable!(),
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	664 }
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	665 }
46127 94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	666 };
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	667 }
45986 cc759d3db1e8 copies-rust: leverage the immutability for efficient update Pierre-Yves David <pierre-yves.david@octobus.net> parents: 45979 diff changeset	668
46127 94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	669 let updates;
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	670 let mut result;
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	671 if override_major.is_empty() {
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	672 result = major
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	673 } else if override_minor.is_empty() {
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	674 result = minor
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	675 } else {
46127 94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	676 if override_minor.len() < override_major.len() {
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	677 updates = override_minor;
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	678 result = minor;
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	679 } else {
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	680 updates = override_major;
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	681 result = major;
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	682 }
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	683 for (k, v) in updates {
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	684 result.insert(k, v);
94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	685 }
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	686 }
46127 94300498491e copies-rust: move the mapping merging into a else clause Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46126 diff changeset	687 result
45959 595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	688 }
595979dc924e copies: introduce a basic Rust function for `combine_changeset_copies` Pierre-Yves David <pierre-yves.david@octobus.net> parents: diff changeset	689 }
46126 61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	690
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	691 /// represent the side that should prevail when merging two
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	692 /// TimeStampedPathCopies
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	693 enum MergePick {
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	694 /// The "major" (p1) side prevails
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	695 Major,
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	696 /// The "minor" (p2) side prevails
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	697 Minor,
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	698 /// Any side could be used (because they are the same)
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	699 Any,
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	700 }
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	701
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	702 /// decide which side prevails in case of conflicting values
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	703 #[allow(clippy::if_same_then_else)]
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	704 fn compare_value<A: Fn(Revision, Revision) -> bool>(
46151 c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	705 path_map: &TwoWayPathMap,
46126 61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	706 changes: &ChangedFiles,
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	707 oracle: &mut AncestorOracle<A>,
46130 818502d2f5e3 copies-rust: pre-introduce a PathToken type and use it where applicable Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46129 diff changeset	708 dest: &PathToken,
46126 61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	709 src_minor: &TimeStampedPathCopy,
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	710 src_major: &TimeStampedPathCopy,
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	711 ) -> MergePick {
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	712 if src_major.path == src_minor.path {
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	713 // we have the same value, but from other source;
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	714 if src_major.rev == src_minor.rev {
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	715 // If the two entry are identical, they are both valid
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	716 MergePick::Any
46154 ecbb2fc9418c copies-rust: rename Oracle.is_ancestor to Oracle.is_overwrite Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46153 diff changeset	717 } else if oracle.is_overwrite(src_major.rev, src_minor.rev) {
46126 61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	718 MergePick::Minor
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	719 } else {
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	720 MergePick::Major
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	721 }
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	722 } else if src_major.rev == src_minor.rev {
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	723 // We cannot get copy information for both p1 and p2 in the
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	724 // same rev. So this is the same value.
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	725 unreachable!(
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	726 "conflict information from p1 and p2 in the same revision"
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	727 );
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	728 } else {
46151 c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	729 let dest_path = path_map.untokenize(*dest);
c6bc77f7e593 copies-rust: tokenize all paths into integer Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46149 diff changeset	730 let action = changes.get_merge_case(dest_path);
46126 61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	731 if src_major.path.is_none() && action == MergeCase::Salvaged {
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	732 // If the file is "deleted" in the major side but was
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	733 // salvaged by the merge, we keep the minor side alive
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	734 MergePick::Minor
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	735 } else if src_minor.path.is_none() && action == MergeCase::Salvaged {
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	736 // If the file is "deleted" in the minor side but was
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	737 // salvaged by the merge, unconditionnaly preserve the
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	738 // major side.
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	739 MergePick::Major
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	740 } else if action == MergeCase::Merged {
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	741 // If the file was actively merged, copy information
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	742 // from each side might conflict. The major side will
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	743 // win such conflict.
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	744 MergePick::Major
46154 ecbb2fc9418c copies-rust: rename Oracle.is_ancestor to Oracle.is_overwrite Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46153 diff changeset	745 } else if oracle.is_overwrite(src_major.rev, src_minor.rev) {
46126 61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	746 // If the minor side is strictly newer than the major
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	747 // side, it should be kept.
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	748 MergePick::Minor
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	749 } else if src_major.path.is_some() {
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	750 // without any special case, the "major" value win
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	751 // other the "minor" one.
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	752 MergePick::Major
46154 ecbb2fc9418c copies-rust: rename Oracle.is_ancestor to Oracle.is_overwrite Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46153 diff changeset	753 } else if oracle.is_overwrite(src_minor.rev, src_major.rev) {
46126 61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	754 // the "major" rev is a direct ancestors of "minor",
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	755 // any different value should
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	756 // overwrite
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	757 MergePick::Major
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	758 } else {
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	759 // major version is None (so the file was deleted on
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	760 // that branch) and that branch is independant (neither
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	761 // minor nor major is an ancestors of the other one.)
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	762 // We preserve the new
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	763 // information about the new file.
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	764 MergePick::Minor
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	765 }
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	766 }
61afe6215aef copies-rust: extract conflicting value comparison in its own function Pierre-Yves David <pierre-yves.david@octobus.net> parents: 46063 diff changeset	767 }

Mercurial > public > mercurial-scm > hg-stable

annotate rust/hg-core/src/copy_tracing.rs @ 46155:fce2f20a54ce