Mercurial > jhg
annotate src/org/tmatesoft/hg/repo/HgManifest.java @ 477:9c9d09111aee
Tests for file flags(exec, link, regular)
author | Artem Tikhomirov <tikhomirov.artem@gmail.com> |
---|---|
date | Thu, 12 Jul 2012 18:07:51 +0200 |
parents | 909306e412e2 |
children | b3c16d1aede0 |
rev | line source |
---|---|
13
df8c67f3006a
Basic manifest parsing to analyze what's in there
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
2
diff
changeset
|
1 /* |
390
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
2 * Copyright (c) 2010-2012 TMate Software Ltd |
74
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
28
diff
changeset
|
3 * |
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
28
diff
changeset
|
4 * This program is free software; you can redistribute it and/or modify |
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
28
diff
changeset
|
5 * it under the terms of the GNU General Public License as published by |
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
28
diff
changeset
|
6 * the Free Software Foundation; version 2 of the License. |
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
28
diff
changeset
|
7 * |
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
28
diff
changeset
|
8 * This program is distributed in the hope that it will be useful, |
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
28
diff
changeset
|
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
28
diff
changeset
|
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
28
diff
changeset
|
11 * GNU General Public License for more details. |
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
28
diff
changeset
|
12 * |
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
28
diff
changeset
|
13 * For information on how to redistribute this software under |
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
28
diff
changeset
|
14 * the terms of a license other than GNU General Public License |
102
a3a2e5deb320
Updated contact address to support@hg4j.com
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
77
diff
changeset
|
15 * contact TMate Software at support@hg4j.com |
2
08db726a0fb7
Shaping out low-level Hg structures
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
16 */ |
74
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
28
diff
changeset
|
17 package org.tmatesoft.hg.repo; |
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
28
diff
changeset
|
18 |
390
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
19 import static org.tmatesoft.hg.core.Nodeid.NULL; |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
20 import static org.tmatesoft.hg.repo.HgRepository.*; |
456
909306e412e2
Refactor LogFacility and SessionContext, better API for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
431
diff
changeset
|
21 import static org.tmatesoft.hg.util.LogFacility.Severity.Info; |
218
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
22 |
232
b7347daa50e3
Allow to cat a file with changeset revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
222
diff
changeset
|
23 import java.io.ByteArrayOutputStream; |
157
d5268ca7715b
Merged branch wrap-data-access into default for resource-friendly data access. Updated API to promote that friendliness to clients (channels, not byte[]). More exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
diff
changeset
|
24 import java.io.IOException; |
218
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
25 import java.util.ArrayList; |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
26 import java.util.Arrays; |
157
d5268ca7715b
Merged branch wrap-data-access into default for resource-friendly data access. Updated API to promote that friendliness to clients (channels, not byte[]). More exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
diff
changeset
|
27 |
417
ccd7d25e5aea
New and better name for HgFileInformer - HgChangesetFileSneaker. Explain (comments) ties between HgManifest, HgDataFile, HgChangesetFileSneaker and reasons for method placement
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
415
diff
changeset
|
28 import org.tmatesoft.hg.core.HgChangesetFileSneaker; |
74
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
28
diff
changeset
|
29 import org.tmatesoft.hg.core.Nodeid; |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
30 import org.tmatesoft.hg.internal.Callback; |
157
d5268ca7715b
Merged branch wrap-data-access into default for resource-friendly data access. Updated API to promote that friendliness to clients (channels, not byte[]). More exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
diff
changeset
|
31 import org.tmatesoft.hg.internal.DataAccess; |
266
0a2f445de774
Improve manifest parsing: reduce number of arrays instantiated for Nodeid
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
264
diff
changeset
|
32 import org.tmatesoft.hg.internal.DigestHelper; |
320
678e326fd27c
Issue 15: Exception accessing oddly named file from history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
313
diff
changeset
|
33 import org.tmatesoft.hg.internal.EncodingHelper; |
415
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
34 import org.tmatesoft.hg.internal.IntMap; |
312
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
35 import org.tmatesoft.hg.internal.IterateControlMediator; |
218
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
36 import org.tmatesoft.hg.internal.Lifecycle; |
431
12f668401613
FIXMEs: awkward API refactored, what need to be internal got hidden; public aspects got captured in slim interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
426
diff
changeset
|
37 import org.tmatesoft.hg.internal.IdentityPool; |
77
c677e1593919
Moved RevlogStream implementation into .internal
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
74
diff
changeset
|
38 import org.tmatesoft.hg.internal.RevlogStream; |
312
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
39 import org.tmatesoft.hg.util.CancelSupport; |
232
b7347daa50e3
Allow to cat a file with changeset revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
222
diff
changeset
|
40 import org.tmatesoft.hg.util.Path; |
312
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
41 import org.tmatesoft.hg.util.ProgressSupport; |
456
909306e412e2
Refactor LogFacility and SessionContext, better API for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
431
diff
changeset
|
42 import org.tmatesoft.hg.util.LogFacility.Severity; |
74
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
28
diff
changeset
|
43 |
2
08db726a0fb7
Shaping out low-level Hg structures
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
44 |
08db726a0fb7
Shaping out low-level Hg structures
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
45 /** |
425
48f993aa2f41
FIXMEs: exceptions, javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
424
diff
changeset
|
46 * Representation of Mercurial manifest file (list of file names and their revisions in a particular changeset) |
48f993aa2f41
FIXMEs: exceptions, javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
424
diff
changeset
|
47 * |
48f993aa2f41
FIXMEs: exceptions, javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
424
diff
changeset
|
48 * @see http://mercurial.selenic.com/wiki/Manifest |
74
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
28
diff
changeset
|
49 * @author Artem Tikhomirov |
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
28
diff
changeset
|
50 * @author TMate Software Ltd. |
2
08db726a0fb7
Shaping out low-level Hg structures
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
51 */ |
426
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
52 public final class HgManifest extends Revlog { |
218
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
53 private RevisionMapper revisionMap; |
412
63c5a9d7ca3f
Follow-up for Issue 29: unify path translation for manifest and dirstate
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
54 private EncodingHelper encodingHelper; |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
55 |
415
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
56 /** |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
57 * File flags recorded in manifest |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
58 */ |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
59 public enum Flags { |
415
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
60 /** |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
61 * Executable bit set |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
62 */ |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
63 Exec, |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
64 /** |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
65 * Symbolic link |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
66 */ |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
67 Link, |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
68 /** |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
69 * Regular file |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
70 */ |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
71 RegularFile; |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
72 |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
73 static Flags parse(String flags) { |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
74 if ("x".equalsIgnoreCase(flags)) { |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
75 return Exec; |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
76 } |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
77 if ("l".equalsIgnoreCase(flags)) { |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
78 return Link; |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
79 } |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
80 if (flags == null) { |
415
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
81 return RegularFile; |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
82 } |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
83 throw new IllegalStateException(flags); |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
84 } |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
85 |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
86 static Flags parse(byte[] data, int start, int length) { |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
87 if (length == 0) { |
415
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
88 return RegularFile; |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
89 } |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
90 if (length == 1) { |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
91 if (data[start] == 'x') { |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
92 return Exec; |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
93 } |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
94 if (data[start] == 'l') { |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
95 return Link; |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
96 } |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
97 // FALL THROUGH |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
98 } |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
99 throw new IllegalStateException(new String(data, start, length)); |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
100 } |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
101 |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
102 String nativeString() { |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
103 if (this == Exec) { |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
104 return "x"; |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
105 } |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
106 if (this == Link) { |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
107 return "l"; |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
108 } |
415
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
109 if (this == RegularFile) { |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
110 return ""; |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
111 } |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
112 throw new IllegalStateException(toString()); |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
113 } |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
114 } |
2
08db726a0fb7
Shaping out low-level Hg structures
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
115 |
412
63c5a9d7ca3f
Follow-up for Issue 29: unify path translation for manifest and dirstate
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
116 /*package-local*/ HgManifest(HgRepository hgRepo, RevlogStream content, EncodingHelper eh) { |
21
e929cecae4e1
Refactor to move revlog content to base class
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
20
diff
changeset
|
117 super(hgRepo, content); |
412
63c5a9d7ca3f
Follow-up for Issue 29: unify path translation for manifest and dirstate
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
118 encodingHelper = eh; |
13
df8c67f3006a
Basic manifest parsing to analyze what's in there
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
2
diff
changeset
|
119 } |
df8c67f3006a
Basic manifest parsing to analyze what's in there
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
2
diff
changeset
|
120 |
218
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
121 /** |
390
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
122 * Walks manifest revisions that correspond to specified range of changesets. The order in which manifest versions get reported |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
123 * to the inspector corresponds to physical order of manifest revisions, not that of changesets (with few exceptions as noted below). |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
124 * That is, for cset-manifest revision pairs: |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
125 * <pre> |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
126 * 3 8 |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
127 * 4 7 |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
128 * 5 9 |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
129 * </pre> |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
130 * call <code>walk(3,5, insp)</code> would yield (4,7), (3,8) and (5,9) to the inspector; |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
131 * different order of arguments, <code>walk(5, 3, insp)</code>, makes no difference. |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
132 * |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
133 * <p>Physical layout of mercurial files (revlog) doesn't impose any restriction on whether manifest and changeset revisions shall go |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
134 * incrementally, nor it mandates presence of manifest version for a changeset. Thus, there might be changesets that record {@link Nodeid#NULL} |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
135 * as corresponding manifest revision. This situation is deemed exceptional now and what would <code>inspector</code> get depends on whether |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
136 * <code>start</code> or <code>end</code> arguments point to such changeset, or such changeset happen to be somewhere inside the range |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
137 * <code>[start..end]</code>. Implementation does it best to report empty manifests |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
138 * (<code>Inspector.begin(HgRepository.NO_REVISION, NULL, csetRevIndex);</code> |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
139 * followed immediately by <code>Inspector.end(HgRepository.NO_REVISION)</code> |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
140 * when <code>start</code> and/or <code>end</code> point to changeset with no associated |
390
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
141 * manifest revision. However, if changeset-manifest revision pairs look like: |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
142 * <pre> |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
143 * 3 8 |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
144 * 4 -1 (cset records null revision for manifest) |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
145 * 5 9 |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
146 * </pre> |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
147 * call <code>walk(3,5, insp)</code> would yield only (3,8) and (5,9) to the inspector, without additional empty |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
148 * <code>Inspector.begin(); Inspector.end()</code> call pair. |
218
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
149 * |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
150 * @see HgRepository#NO_REVISION |
218
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
151 * @param start changelog (not manifest!) revision to begin with |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
152 * @param end changelog (not manifest!) revision to stop, inclusive. |
390
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
153 * @param inspector manifest revision visitor, can't be <code>null</code> |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
154 * @throws HgRuntimeException subclass thereof to indicate issues with the library. <em>Runtime exception</em> |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
155 * @throws IllegalArgumentException if inspector callback is <code>null</code> |
218
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
156 */ |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
157 public void walk(int start, int end, final Inspector inspector) throws HgRuntimeException, IllegalArgumentException { |
196
e2115da4cf6a
Pool objects to avoid memory polution with duplicates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
158 if (inspector == null) { |
e2115da4cf6a
Pool objects to avoid memory polution with duplicates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
159 throw new IllegalArgumentException(); |
e2115da4cf6a
Pool objects to avoid memory polution with duplicates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
160 } |
390
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
161 final int csetFirst = start <= end ? start : end, csetLast = start > end ? start : end; |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
162 int manifestFirst, manifestLast, i = 0; |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
163 do { |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
164 manifestFirst = fromChangelog(csetFirst+i); |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
165 if (manifestFirst == BAD_REVISION) { |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
166 inspector.begin(NO_REVISION, NULL, csetFirst+i); |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
167 inspector.end(NO_REVISION); |
390
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
168 } |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
169 i++; |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
170 } while (manifestFirst == BAD_REVISION && csetFirst+i <= csetLast); |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
171 if (manifestFirst == BAD_REVISION) { |
456
909306e412e2
Refactor LogFacility and SessionContext, better API for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
431
diff
changeset
|
172 getRepo().getContext().getLog().dump(getClass(), Info, "None of changesets [%d..%d] have associated manifest revision", csetFirst, csetLast); |
390
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
173 // we ran through all revisions in [start..end] and none of them had manifest. |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
174 // we reported that to inspector and proceeding is done now. |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
175 return; |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
176 } |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
177 i = 0; |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
178 do { |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
179 manifestLast = fromChangelog(csetLast-i); |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
180 if (manifestLast == BAD_REVISION) { |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
181 inspector.begin(NO_REVISION, NULL, csetLast-i); |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
182 inspector.end(NO_REVISION); |
390
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
183 } |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
184 i++; |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
185 } while (manifestLast == BAD_REVISION && csetLast-i >= csetFirst); |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
186 if (manifestLast == BAD_REVISION) { |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
187 // hmm, manifestFirst != BAD_REVISION here, hence there's i from [csetFirst..csetLast] for which manifest entry exists, |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
188 // and thus it's impossible to run into manifestLast == BAD_REVISION. Nevertheless, never hurts to check. |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
189 throw new HgInvalidStateException(String.format("Manifest %d-%d(!) for cset range [%d..%d] ", manifestFirst, manifestLast, csetFirst, csetLast)); |
390
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
190 } |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
191 if (manifestLast < manifestFirst) { |
300
650b45d290b1
Share range check code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
285
diff
changeset
|
192 // there are tool-constructed repositories that got order of changeset revisions completely different from that of manifest |
390
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
193 int x = manifestLast; |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
194 manifestLast = manifestFirst; |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
195 manifestFirst = x; |
300
650b45d290b1
Share range check code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
285
diff
changeset
|
196 } |
412
63c5a9d7ca3f
Follow-up for Issue 29: unify path translation for manifest and dirstate
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
197 content.iterate(manifestFirst, manifestLast, true, new ManifestParser(inspector, encodingHelper)); |
19
40532cdc92fc
Inspector (visitor) for manifest
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
16
diff
changeset
|
198 } |
218
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
199 |
254
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
232
diff
changeset
|
200 /** |
390
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
201 * "Sparse" iteration of the manifest, more effective than accessing revisions one by one. |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
202 * <p> Inspector is invoked for each changeset revision supplied, even when there's no manifest |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
203 * revision associated with a changeset (@see {@link #walk(int, int, Inspector)} for more details when it happens). Order inspector |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
204 * gets invoked doesn't resemble order of changeset revisions supplied, manifest revisions are reported in the order they appear |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
205 * in manifest revlog (with exception of changesets with missing manifest that may be reported in any order). |
254
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
232
diff
changeset
|
206 * |
390
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
207 * @param inspector manifest revision visitor, can't be <code>null</code> |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
208 * @param revisionIndexes local indexes of changesets to visit, non-<code>null</code> |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
209 * @throws HgRuntimeException subclass thereof to indicate issues with the library. <em>Runtime exception</em> |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
210 * @throws InvalidArgumentException if supplied arguments are <code>null</code>s |
254
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
232
diff
changeset
|
211 */ |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
212 public void walk(final Inspector inspector, int... revisionIndexes) throws HgRuntimeException, IllegalArgumentException { |
367
2fadf8695f8a
Use 'revision index' instead of the vague 'local revision number' concept in the API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
366
diff
changeset
|
213 if (inspector == null || revisionIndexes == null) { |
254
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
232
diff
changeset
|
214 throw new IllegalArgumentException(); |
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
232
diff
changeset
|
215 } |
390
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
216 int[] manifestRevs = toManifestRevisionIndexes(revisionIndexes, inspector); |
412
63c5a9d7ca3f
Follow-up for Issue 29: unify path translation for manifest and dirstate
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
217 content.iterate(manifestRevs, true, new ManifestParser(inspector, encodingHelper)); |
254
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
232
diff
changeset
|
218 } |
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
232
diff
changeset
|
219 |
390
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
220 // |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
221 /** |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
222 * Tells manifest revision number that corresponds to the given changeset. May return {@link HgRepository#BAD_REVISION} |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
223 * if changeset has no associated manifest (cset records NULL nodeid for manifest). |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
224 * @return manifest revision index, non-negative, or {@link HgRepository#BAD_REVISION}. |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
225 * @throws HgInvalidRevisionException if method argument specifies non-existent revision index |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
226 * @throws HgInvalidControlFileException if access to revlog index/data entry failed |
390
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
227 */ |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
228 /*package-local*/ int fromChangelog(int changesetRevisionIndex) throws HgInvalidRevisionException, HgInvalidControlFileException { |
368
8107b95f4280
Update Javadoc with 'revision index'
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
367
diff
changeset
|
229 if (HgInternals.wrongRevisionIndex(changesetRevisionIndex)) { |
425
48f993aa2f41
FIXMEs: exceptions, javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
424
diff
changeset
|
230 throw new HgInvalidRevisionException(changesetRevisionIndex); |
218
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
231 } |
368
8107b95f4280
Update Javadoc with 'revision index'
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
367
diff
changeset
|
232 if (changesetRevisionIndex == HgRepository.WORKING_COPY || changesetRevisionIndex == HgRepository.BAD_REVISION) { |
425
48f993aa2f41
FIXMEs: exceptions, javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
424
diff
changeset
|
233 throw new HgInvalidRevisionException("Can't use constants like WORKING_COPY or BAD_REVISION", null, changesetRevisionIndex); |
257
f39fb6b3cc76
Handle revision constants correctly
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
254
diff
changeset
|
234 } |
f39fb6b3cc76
Handle revision constants correctly
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
254
diff
changeset
|
235 // revisionNumber == TIP is processed by RevisionMapper |
218
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
236 if (revisionMap == null) { |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
237 revisionMap = new RevisionMapper(getRepo()); |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
238 content.iterate(0, TIP, false, revisionMap); |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
239 } |
368
8107b95f4280
Update Javadoc with 'revision index'
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
367
diff
changeset
|
240 return revisionMap.at(changesetRevisionIndex); |
218
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
241 } |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
242 |
232
b7347daa50e3
Allow to cat a file with changeset revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
222
diff
changeset
|
243 /** |
b7347daa50e3
Allow to cat a file with changeset revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
222
diff
changeset
|
244 * Extracts file revision as it was known at the time of given changeset. |
426
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
245 * <p>For more thorough details about file at specific changeset, use {@link HgChangesetFileSneaker}. |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
246 * <p>To visit few changesets for the same file, use {@link #walkFileRevisions(Path, Inspector, int...)} |
232
b7347daa50e3
Allow to cat a file with changeset revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
222
diff
changeset
|
247 * |
426
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
248 * @see #walkFileRevisions(Path, Inspector, int...) |
417
ccd7d25e5aea
New and better name for HgFileInformer - HgChangesetFileSneaker. Explain (comments) ties between HgManifest, HgDataFile, HgChangesetFileSneaker and reasons for method placement
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
415
diff
changeset
|
249 * @see HgChangesetFileSneaker |
367
2fadf8695f8a
Use 'revision index' instead of the vague 'local revision number' concept in the API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
366
diff
changeset
|
250 * @param changelogRevisionIndex local changeset index |
232
b7347daa50e3
Allow to cat a file with changeset revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
222
diff
changeset
|
251 * @param file path to file in question |
b7347daa50e3
Allow to cat a file with changeset revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
222
diff
changeset
|
252 * @return file revision or <code>null</code> if manifest at specified revision doesn't list such file |
425
48f993aa2f41
FIXMEs: exceptions, javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
424
diff
changeset
|
253 * @throws HgRuntimeException subclass thereof to indicate issues with the library. <em>Runtime exception</em> |
232
b7347daa50e3
Allow to cat a file with changeset revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
222
diff
changeset
|
254 */ |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
255 public Nodeid getFileRevision(int changelogRevisionIndex, final Path file) throws HgInvalidRevisionException, HgInvalidControlFileException { |
417
ccd7d25e5aea
New and better name for HgFileInformer - HgChangesetFileSneaker. Explain (comments) ties between HgManifest, HgDataFile, HgChangesetFileSneaker and reasons for method placement
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
415
diff
changeset
|
256 // there's no need for HgDataFile to own this method, or get a delegate |
ccd7d25e5aea
New and better name for HgFileInformer - HgChangesetFileSneaker. Explain (comments) ties between HgManifest, HgDataFile, HgChangesetFileSneaker and reasons for method placement
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
415
diff
changeset
|
257 // as most of HgDataFile API is using file revision indexes, and there's easy step from file revision index to |
ccd7d25e5aea
New and better name for HgFileInformer - HgChangesetFileSneaker. Explain (comments) ties between HgManifest, HgDataFile, HgChangesetFileSneaker and reasons for method placement
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
415
diff
changeset
|
258 // both file revision and changeset revision index. But there's no easy way to go from changesetRevisionIndex to |
ccd7d25e5aea
New and better name for HgFileInformer - HgChangesetFileSneaker. Explain (comments) ties between HgManifest, HgDataFile, HgChangesetFileSneaker and reasons for method placement
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
415
diff
changeset
|
259 // file revision (the task this method solves), exept for HgFileInformer |
ccd7d25e5aea
New and better name for HgFileInformer - HgChangesetFileSneaker. Explain (comments) ties between HgManifest, HgDataFile, HgChangesetFileSneaker and reasons for method placement
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
415
diff
changeset
|
260 // I feel methods dealing with changeset indexes shall be more exposed in HgChangelog and HgManifest API. |
426
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
261 // TODO need tests |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
262 int manifestRevIndex = fromChangelog(changelogRevisionIndex); |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
263 if (manifestRevIndex == BAD_REVISION) { |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
264 return null; |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
265 } |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
266 IntMap<Nodeid> resMap = new IntMap<Nodeid>(3); |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
267 FileLookupInspector parser = new FileLookupInspector(encodingHelper, file, resMap, null); |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
268 parser.walk(manifestRevIndex, content); |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
269 return resMap.get(changelogRevisionIndex); |
326
d42a45a2c9d6
Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
324
diff
changeset
|
270 } |
426
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
271 |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
272 /** |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
273 * Visit file revisions as they were recorded at the time of given changesets. Same file revision may be reported as many times as |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
274 * there are changesets that refer to that revision. Both {@link Inspector#begin(int, Nodeid, int)} and {@link Inspector#end(int)} |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
275 * with appropriate values are invoked around {@link Inspector#next(Nodeid, Path, Flags)} call for the supplied file |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
276 * |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
277 * <p>NOTE, this method doesn't respect return values from callback (i.e. to stop iteration), as it's lookup of a single file |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
278 * and canceling it seems superfluous. However, this may change in future and it's recommended to return <code>true</code> from |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
279 * all {@link Inspector} methods. |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
280 * |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
281 * @see #getFileRevision(int, Path) |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
282 * @param file path of interest |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
283 * @param inspector callback to receive details about selected file |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
284 * @param changelogRevisionIndexes changeset indexes to visit |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
285 * @throws HgRuntimeException subclass thereof to indicate issues with the library. <em>Runtime exception</em> |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
286 */ |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
287 public void walkFileRevisions(Path file, Inspector inspector, int... changelogRevisionIndexes) throws HgRuntimeException { |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
288 if (file == null || inspector == null || changelogRevisionIndexes == null) { |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
289 throw new IllegalArgumentException(); |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
290 } |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
291 // TODO [post-1.0] need tests. There's Main#checkWalkFileRevisions that may be a starting point |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
292 int[] manifestRevIndexes = toManifestRevisionIndexes(changelogRevisionIndexes, null); |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
293 FileLookupInspector parser = new FileLookupInspector(encodingHelper, file, inspector); |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
294 parser.walk(manifestRevIndexes, content); |
232
b7347daa50e3
Allow to cat a file with changeset revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
222
diff
changeset
|
295 } |
326
d42a45a2c9d6
Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
324
diff
changeset
|
296 |
415
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
297 /** |
417
ccd7d25e5aea
New and better name for HgFileInformer - HgChangesetFileSneaker. Explain (comments) ties between HgManifest, HgDataFile, HgChangesetFileSneaker and reasons for method placement
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
415
diff
changeset
|
298 * Extract file {@link Flags flags} as they were recorded in appropriate manifest version. |
ccd7d25e5aea
New and better name for HgFileInformer - HgChangesetFileSneaker. Explain (comments) ties between HgManifest, HgDataFile, HgChangesetFileSneaker and reasons for method placement
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
415
diff
changeset
|
299 * |
ccd7d25e5aea
New and better name for HgFileInformer - HgChangesetFileSneaker. Explain (comments) ties between HgManifest, HgDataFile, HgChangesetFileSneaker and reasons for method placement
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
415
diff
changeset
|
300 * @see HgDataFile#getFlags(int) |
415
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
301 * @param changesetRevIndex changeset revision index |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
302 * @param file path to look up |
417
ccd7d25e5aea
New and better name for HgFileInformer - HgChangesetFileSneaker. Explain (comments) ties between HgManifest, HgDataFile, HgChangesetFileSneaker and reasons for method placement
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
415
diff
changeset
|
303 * @return one of predefined enum values, or <code>null</code> if file was not known in the specified revision |
425
48f993aa2f41
FIXMEs: exceptions, javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
424
diff
changeset
|
304 * @throws HgRuntimeException subclass thereof to indicate issues with the library. <em>Runtime exception</em> |
415
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
305 */ |
417
ccd7d25e5aea
New and better name for HgFileInformer - HgChangesetFileSneaker. Explain (comments) ties between HgManifest, HgDataFile, HgChangesetFileSneaker and reasons for method placement
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
415
diff
changeset
|
306 public Flags getFileFlags(int changesetRevIndex, Path file) throws HgInvalidRevisionException, HgInvalidControlFileException { |
415
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
307 int manifestRevIdx = fromChangelog(changesetRevIndex); |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
308 IntMap<Flags> resMap = new IntMap<Flags>(2); |
426
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
309 FileLookupInspector parser = new FileLookupInspector(encodingHelper, file, null, resMap); |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
310 parser.walk(manifestRevIdx, content); |
415
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
311 return resMap.get(changesetRevIndex); |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
312 } |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
313 |
326
d42a45a2c9d6
Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
324
diff
changeset
|
314 |
390
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
315 /** |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
316 * @param changelogRevisionIndexes non-null |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
317 * @param inspector may be null if reporting of missing manifests is not needed |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
318 * @throws HgInvalidRevisionException if arguments specify non-existent revision index |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
319 * @throws IllegalArgumentException if any index argument is not a revision index |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
320 * @throws HgInvalidControlFileException if access to revlog index/data entry failed |
390
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
321 */ |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
322 private int[] toManifestRevisionIndexes(int[] changelogRevisionIndexes, Inspector inspector) throws HgInvalidRevisionException, HgInvalidControlFileException { |
368
8107b95f4280
Update Javadoc with 'revision index'
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
367
diff
changeset
|
323 int[] manifestRevs = new int[changelogRevisionIndexes.length]; |
326
d42a45a2c9d6
Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
324
diff
changeset
|
324 boolean needsSort = false; |
390
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
325 int j = 0; |
367
2fadf8695f8a
Use 'revision index' instead of the vague 'local revision number' concept in the API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
366
diff
changeset
|
326 for (int i = 0; i < changelogRevisionIndexes.length; i++) { |
2fadf8695f8a
Use 'revision index' instead of the vague 'local revision number' concept in the API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
366
diff
changeset
|
327 final int manifestRevisionIndex = fromChangelog(changelogRevisionIndexes[i]); |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
328 if (manifestRevisionIndex == BAD_REVISION) { |
390
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
329 if (inspector != null) { |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
330 inspector.begin(NO_REVISION, NULL, changelogRevisionIndexes[i]); |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
331 inspector.end(NO_REVISION); |
390
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
332 } |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
333 // othrwise, ignore changeset without manifest |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
334 } else { |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
335 manifestRevs[j] = manifestRevisionIndex; |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
336 if (j > 0 && manifestRevs[j-1] > manifestRevisionIndex) { |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
337 needsSort = true; |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
338 } |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
339 j++; |
326
d42a45a2c9d6
Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
324
diff
changeset
|
340 } |
d42a45a2c9d6
Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
324
diff
changeset
|
341 } |
d42a45a2c9d6
Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
324
diff
changeset
|
342 if (needsSort) { |
390
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
343 Arrays.sort(manifestRevs, 0, j); |
326
d42a45a2c9d6
Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
324
diff
changeset
|
344 } |
390
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
345 if (j == manifestRevs.length) { |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
346 return manifestRevs; |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
347 } else { |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
348 int[] rv = new int[j]; |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
349 //Arrays.copyOfRange |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
350 System.arraycopy(manifestRevs, 0, rv, 0, j); |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
351 return rv; |
6952d9ce97f1
Handle missing manifest revision case (brought up with Issue 23), do my best to report missing manifests when walking few manifest revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
385
diff
changeset
|
352 } |
326
d42a45a2c9d6
Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
324
diff
changeset
|
353 } |
d42a45a2c9d6
Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
324
diff
changeset
|
354 |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
355 @Callback |
19
40532cdc92fc
Inspector (visitor) for manifest
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
16
diff
changeset
|
356 public interface Inspector { |
222
373e07cd3991
Due to discrepancy in manifest and changelor indexes, wrong manifest revisions got cached and compared
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
220
diff
changeset
|
357 boolean begin(int mainfestRevision, Nodeid nid, int changelogRevision); |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
358 /** |
415
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
359 * @param nid file revision |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
360 * @param fname file name |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
361 * @param flags one of {@link HgManifest.Flags} constants, not <code>null</code> |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
362 * @return <code>true</code> to continue iteration, <code>false</code> to stop |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
363 */ |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
364 boolean next(Nodeid nid, Path fname, Flags flags); |
424
6437d261048a
Deprecated code removed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
423
diff
changeset
|
365 boolean end(int manifestRevision); |
267
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
366 } |
424
6437d261048a
Deprecated code removed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
423
diff
changeset
|
367 |
268
c5980f287cc4
Use StringProxy when parsing manifest to minimize number of useless conversions and array instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
267
diff
changeset
|
368 /** |
c5980f287cc4
Use StringProxy when parsing manifest to minimize number of useless conversions and array instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
267
diff
changeset
|
369 * When Pool uses Strings directly, |
c5980f287cc4
Use StringProxy when parsing manifest to minimize number of useless conversions and array instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
267
diff
changeset
|
370 * ManifestParser creates new String instance with new char[] value, and does byte->char conversion. |
c5980f287cc4
Use StringProxy when parsing manifest to minimize number of useless conversions and array instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
267
diff
changeset
|
371 * For cpython repo, walk(0..10k), there are over 16 million filenames, of them only 3020 unique. |
c5980f287cc4
Use StringProxy when parsing manifest to minimize number of useless conversions and array instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
267
diff
changeset
|
372 * This means there are 15.9 million useless char[] instances and byte->char conversions |
c5980f287cc4
Use StringProxy when parsing manifest to minimize number of useless conversions and array instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
267
diff
changeset
|
373 * |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
374 * When String (Path) is wrapped into {@link PathProxy}, there's extra overhead of byte[] representation |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
375 * of the String, but these are only for unique Strings (Paths) (3020 in the example above). Besides, I save |
268
c5980f287cc4
Use StringProxy when parsing manifest to minimize number of useless conversions and array instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
267
diff
changeset
|
376 * useless char[] and byte->char conversions. |
c5980f287cc4
Use StringProxy when parsing manifest to minimize number of useless conversions and array instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
267
diff
changeset
|
377 */ |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
378 private static class PathProxy { |
267
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
379 private byte[] data; |
268
c5980f287cc4
Use StringProxy when parsing manifest to minimize number of useless conversions and array instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
267
diff
changeset
|
380 private int start; |
c5980f287cc4
Use StringProxy when parsing manifest to minimize number of useless conversions and array instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
267
diff
changeset
|
381 private final int hash, length; |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
382 private Path result; |
412
63c5a9d7ca3f
Follow-up for Issue 29: unify path translation for manifest and dirstate
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
383 private final EncodingHelper encHelper; |
267
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
384 |
412
63c5a9d7ca3f
Follow-up for Issue 29: unify path translation for manifest and dirstate
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
385 public PathProxy(byte[] data, int start, int length, EncodingHelper eh) { |
267
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
386 this.data = data; |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
387 this.start = start; |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
388 this.length = length; |
412
63c5a9d7ca3f
Follow-up for Issue 29: unify path translation for manifest and dirstate
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
389 this.encHelper = eh; |
267
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
390 |
268
c5980f287cc4
Use StringProxy when parsing manifest to minimize number of useless conversions and array instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
267
diff
changeset
|
391 // copy from String.hashCode(). In fact, not necessarily match result of String(data).hashCode |
c5980f287cc4
Use StringProxy when parsing manifest to minimize number of useless conversions and array instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
267
diff
changeset
|
392 // just need some nice algorithm here |
267
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
393 int h = 0; |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
394 byte[] d = data; |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
395 for (int i = 0, off = start, len = length; i < len; i++) { |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
396 h = 31 * h + d[off++]; |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
397 } |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
398 hash = h; |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
399 } |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
400 |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
401 @Override |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
402 public boolean equals(Object obj) { |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
403 if (false == obj instanceof PathProxy) { |
267
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
404 return false; |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
405 } |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
406 PathProxy o = (PathProxy) obj; |
267
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
407 if (o.result != null && result != null) { |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
408 return result.equals(o.result); |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
409 } |
268
c5980f287cc4
Use StringProxy when parsing manifest to minimize number of useless conversions and array instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
267
diff
changeset
|
410 if (o.length != length || o.hash != hash) { |
267
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
411 return false; |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
412 } |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
413 for (int i = 0, x = o.start, y = start; i < length; i++) { |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
414 if (o.data[x++] != data[y++]) { |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
415 return false; |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
416 } |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
417 } |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
418 return true; |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
419 } |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
420 @Override |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
421 public int hashCode() { |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
422 return hash; |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
423 } |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
424 |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
425 public Path freeze() { |
267
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
426 if (result == null) { |
412
63c5a9d7ca3f
Follow-up for Issue 29: unify path translation for manifest and dirstate
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
427 result = Path.create(encHelper.fromManifest(data, start, length)); |
268
c5980f287cc4
Use StringProxy when parsing manifest to minimize number of useless conversions and array instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
267
diff
changeset
|
428 // release reference to bigger data array, make a copy of relevant part only |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
429 // use original bytes, not those from String above to avoid cache misses due to different encodings |
268
c5980f287cc4
Use StringProxy when parsing manifest to minimize number of useless conversions and array instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
267
diff
changeset
|
430 byte[] d = new byte[length]; |
c5980f287cc4
Use StringProxy when parsing manifest to minimize number of useless conversions and array instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
267
diff
changeset
|
431 System.arraycopy(data, start, d, 0, length); |
c5980f287cc4
Use StringProxy when parsing manifest to minimize number of useless conversions and array instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
267
diff
changeset
|
432 data = d; |
c5980f287cc4
Use StringProxy when parsing manifest to minimize number of useless conversions and array instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
267
diff
changeset
|
433 start = 0; |
267
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
434 } |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
435 return result; |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
436 } |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
437 } |
196
e2115da4cf6a
Pool objects to avoid memory polution with duplicates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
438 |
312
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
439 private static class ManifestParser implements RevlogStream.Inspector, Lifecycle { |
196
e2115da4cf6a
Pool objects to avoid memory polution with duplicates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
440 private final Inspector inspector; |
431
12f668401613
FIXMEs: awkward API refactored, what need to be internal got hidden; public aspects got captured in slim interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
426
diff
changeset
|
441 private IdentityPool<Nodeid> nodeidPool, thisRevPool; |
12f668401613
FIXMEs: awkward API refactored, what need to be internal got hidden; public aspects got captured in slim interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
426
diff
changeset
|
442 private final IdentityPool<PathProxy> fnamePool; |
266
0a2f445de774
Improve manifest parsing: reduce number of arrays instantiated for Nodeid
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
264
diff
changeset
|
443 private byte[] nodeidLookupBuffer = new byte[20]; // get reassigned each time new Nodeid is added to pool |
312
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
444 private final ProgressSupport progressHelper; |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
445 private IterateControlMediator iterateControl; |
412
63c5a9d7ca3f
Follow-up for Issue 29: unify path translation for manifest and dirstate
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
446 private final EncodingHelper encHelper; |
262
3dcd3dd90c77
Improve manifest parsing: decode bytes to chars once, minimize arraycopy on String instantiation, keep set of file revisions from previous manifest only
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
257
diff
changeset
|
447 |
412
63c5a9d7ca3f
Follow-up for Issue 29: unify path translation for manifest and dirstate
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
448 public ManifestParser(Inspector delegate, EncodingHelper eh) { |
196
e2115da4cf6a
Pool objects to avoid memory polution with duplicates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
449 assert delegate != null; |
e2115da4cf6a
Pool objects to avoid memory polution with duplicates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
450 inspector = delegate; |
412
63c5a9d7ca3f
Follow-up for Issue 29: unify path translation for manifest and dirstate
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
451 encHelper = eh; |
431
12f668401613
FIXMEs: awkward API refactored, what need to be internal got hidden; public aspects got captured in slim interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
426
diff
changeset
|
452 nodeidPool = new IdentityPool<Nodeid>(); |
12f668401613
FIXMEs: awkward API refactored, what need to be internal got hidden; public aspects got captured in slim interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
426
diff
changeset
|
453 fnamePool = new IdentityPool<PathProxy>(); |
12f668401613
FIXMEs: awkward API refactored, what need to be internal got hidden; public aspects got captured in slim interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
426
diff
changeset
|
454 thisRevPool = new IdentityPool<Nodeid>(); |
312
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
455 progressHelper = ProgressSupport.Factory.get(delegate); |
196
e2115da4cf6a
Pool objects to avoid memory polution with duplicates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
456 } |
268
c5980f287cc4
Use StringProxy when parsing manifest to minimize number of useless conversions and array instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
267
diff
changeset
|
457 |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
458 public void next(int revisionNumber, int actualLen, int baseRevision, int linkRevision, int parent1Revision, int parent2Revision, byte[] nodeid, DataAccess da) { |
196
e2115da4cf6a
Pool objects to avoid memory polution with duplicates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
459 try { |
312
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
460 if (!inspector.begin(revisionNumber, new Nodeid(nodeid, true), linkRevision)) { |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
461 iterateControl.stop(); |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
462 return; |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
463 } |
372
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
464 if (!da.isEmpty()) { |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
465 // although unlikely, manifest entry may be empty, when all files have been deleted from the repository |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
466 Path fname = null; |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
467 Flags flags = null; |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
468 Nodeid nid = null; |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
469 int i; |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
470 byte[] data = da.byteArray(); |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
471 for (i = 0; i < actualLen; i++) { |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
472 int x = i; |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
473 for( ; data[i] != '\n' && i < actualLen; i++) { |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
474 if (fname == null && data[i] == 0) { |
412
63c5a9d7ca3f
Follow-up for Issue 29: unify path translation for manifest and dirstate
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
475 PathProxy px = fnamePool.unify(new PathProxy(data, x, i - x, encHelper)); |
372
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
476 // if (cached = fnamePool.unify(px))== px then cacheMiss, else cacheHit |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
477 // cpython 0..10k: hits: 15 989 152, misses: 3020 |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
478 fname = px.freeze(); |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
479 x = i+1; |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
480 } |
196
e2115da4cf6a
Pool objects to avoid memory polution with duplicates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
481 } |
372
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
482 if (i < actualLen) { |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
483 assert data[i] == '\n'; |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
484 int nodeidLen = i - x < 40 ? i-x : 40; // if > 40, there are flags |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
485 DigestHelper.ascii2bin(data, x, nodeidLen, nodeidLookupBuffer); // ignore return value as it's unlikely to have NULL in manifest |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
486 nid = new Nodeid(nodeidLookupBuffer, false); // this Nodeid is for pool lookup only, mock object |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
487 Nodeid cached = nodeidPool.unify(nid); |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
488 if (cached == nid) { |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
489 // buffer now belongs to the cached nodeid |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
490 nodeidLookupBuffer = new byte[20]; |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
491 } else { |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
492 nid = cached; // use existing version, discard the lookup object |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
493 } // for cpython 0..10k, cache hits are 15 973 301, vs 18871 misses. |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
494 thisRevPool.record(nid); // memorize revision for the next iteration. |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
495 if (nodeidLen + x < i) { |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
496 // 'x' and 'l' for executable bits and symlinks? |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
497 // hg --debug manifest shows 644 for each regular file in my repo |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
498 // for cpython 0..10k, there are 4361062 flag checks, and there's only 1 unique flag |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
499 flags = Flags.parse(data, x + nodeidLen, i-x-nodeidLen); |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
500 } else { |
415
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
501 flags = Flags.RegularFile; |
372
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
502 } |
424
6437d261048a
Deprecated code removed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
423
diff
changeset
|
503 boolean good2go = inspector.next(nid, fname, flags); |
372
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
504 if (!good2go) { |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
505 iterateControl.stop(); |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
506 return; |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
507 } |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
508 } |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
509 nid = null; |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
510 fname = null; |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
511 flags = null; |
196
e2115da4cf6a
Pool objects to avoid memory polution with duplicates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
512 } |
e2115da4cf6a
Pool objects to avoid memory polution with duplicates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
513 } |
312
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
514 if (!inspector.end(revisionNumber)) { |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
515 iterateControl.stop(); |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
516 return; |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
517 } |
262
3dcd3dd90c77
Improve manifest parsing: decode bytes to chars once, minimize arraycopy on String instantiation, keep set of file revisions from previous manifest only
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
257
diff
changeset
|
518 // |
3dcd3dd90c77
Improve manifest parsing: decode bytes to chars once, minimize arraycopy on String instantiation, keep set of file revisions from previous manifest only
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
257
diff
changeset
|
519 // keep only actual file revisions, found at this version |
3dcd3dd90c77
Improve manifest parsing: decode bytes to chars once, minimize arraycopy on String instantiation, keep set of file revisions from previous manifest only
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
257
diff
changeset
|
520 // (next manifest is likely to refer to most of them, although in specific cases |
3dcd3dd90c77
Improve manifest parsing: decode bytes to chars once, minimize arraycopy on String instantiation, keep set of file revisions from previous manifest only
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
257
diff
changeset
|
521 // like commit in another branch a lot may be useless) |
3dcd3dd90c77
Improve manifest parsing: decode bytes to chars once, minimize arraycopy on String instantiation, keep set of file revisions from previous manifest only
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
257
diff
changeset
|
522 nodeidPool.clear(); |
431
12f668401613
FIXMEs: awkward API refactored, what need to be internal got hidden; public aspects got captured in slim interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
426
diff
changeset
|
523 IdentityPool<Nodeid> t = nodeidPool; |
262
3dcd3dd90c77
Improve manifest parsing: decode bytes to chars once, minimize arraycopy on String instantiation, keep set of file revisions from previous manifest only
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
257
diff
changeset
|
524 nodeidPool = thisRevPool; |
264
6bb5e7ed051a
Optimize memory usage (reduce number of objects instantiated) when pooling file names and nodeids during manifest parsing
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
262
diff
changeset
|
525 thisRevPool = t; |
313
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
526 iterateControl.checkCancelled(); |
312
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
527 progressHelper.worked(1); |
196
e2115da4cf6a
Pool objects to avoid memory polution with duplicates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
528 } catch (IOException ex) { |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
529 throw new HgInvalidControlFileException("Failed reading manifest", ex, null).setRevisionIndex(revisionNumber); |
196
e2115da4cf6a
Pool objects to avoid memory polution with duplicates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
530 } |
e2115da4cf6a
Pool objects to avoid memory polution with duplicates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
531 } |
312
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
532 |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
533 public void start(int count, Callback callback, Object token) { |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
534 CancelSupport cs = CancelSupport.Factory.get(inspector, null); |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
535 iterateControl = new IterateControlMediator(cs, callback); |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
536 progressHelper.start(count); |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
537 } |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
538 |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
539 public void finish(Object token) { |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
540 progressHelper.done(); |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
541 } |
196
e2115da4cf6a
Pool objects to avoid memory polution with duplicates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
542 } |
218
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
543 |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
544 private static class RevisionMapper implements RevlogStream.Inspector, Lifecycle { |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
545 |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
546 private final int changelogRevisionCount; |
218
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
547 private int[] changelog2manifest; |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
548 private final HgRepository repo; |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
549 |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
550 public RevisionMapper(HgRepository hgRepo) { |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
551 repo = hgRepo; |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
552 changelogRevisionCount = repo.getChangelog().getRevisionCount(); |
218
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
553 } |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
554 |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
555 /** |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
556 * Get index of manifest revision that corresponds to specified changeset |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
557 * @param changesetRevisionIndex non-negative index of changelog revision, or {@link HgRepository#TIP} |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
558 * @return index of manifest revision, or {@link HgRepository#BAD_REVISION} if changeset doesn't reference a valid manifest |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
559 * @throws HgInvalidRevisionException if method argument specifies non-existent revision index |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
560 */ |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
561 public int at(int changesetRevisionIndex) throws HgInvalidRevisionException { |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
562 if (changesetRevisionIndex == TIP) { |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
563 changesetRevisionIndex = changelogRevisionCount - 1; |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
564 } |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
565 if (changesetRevisionIndex >= changelogRevisionCount) { |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
566 throw new HgInvalidRevisionException(changesetRevisionIndex); |
257
f39fb6b3cc76
Handle revision constants correctly
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
254
diff
changeset
|
567 } |
218
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
568 if (changelog2manifest != null) { |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
569 return changelog2manifest[changesetRevisionIndex]; |
218
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
570 } |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
571 return changesetRevisionIndex; |
218
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
572 } |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
573 |
324
283b294d1079
Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
321
diff
changeset
|
574 // XXX likely can be replaced with Revlog.RevisionInspector |
218
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
575 public void next(int revisionNumber, int actualLen, int baseRevision, int linkRevision, int parent1Revision, int parent2Revision, byte[] nodeid, DataAccess data) { |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
576 if (changelog2manifest != null) { |
220
8de327242aa0
Basic information about branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
218
diff
changeset
|
577 // next assertion is not an error, rather assumption check, which is too development-related to be explicit exception - |
8de327242aa0
Basic information about branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
218
diff
changeset
|
578 // I just wonder if there are manifests that have two entries pointing to single changeset. It seems unrealistic, though - |
8de327242aa0
Basic information about branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
218
diff
changeset
|
579 // changeset records one and only one manifest nodeid |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
580 assert changelog2manifest[linkRevision] == BAD_REVISION : String.format("revision:%d, link:%d, already linked to revision:%d", revisionNumber, linkRevision, changelog2manifest[linkRevision]); |
218
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
581 changelog2manifest[linkRevision] = revisionNumber; |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
582 } else { |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
583 if (revisionNumber != linkRevision) { |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
584 changelog2manifest = new int[changelogRevisionCount]; |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
585 Arrays.fill(changelog2manifest, BAD_REVISION); |
218
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
586 for (int i = 0; i < revisionNumber; changelog2manifest[i] = i, i++) |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
587 ; |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
588 changelog2manifest[linkRevision] = revisionNumber; |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
589 } |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
590 } |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
591 } |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
592 |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
593 public void start(int count, Callback callback, Object token) { |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
594 if (count != changelogRevisionCount) { |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
595 assert count < changelogRevisionCount; // no idea what to do if manifest has more revisions than changelog |
218
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
596 // the way how manifest may contain more revisions than changelog, as I can imagine, is a result of |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
597 // some kind of an import tool (e.g. from SVN or CVS), that creates manifest and changelog independently. |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
598 // Note, it's pure guess, I didn't see such repository yet (although the way manifest revisions |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
599 // in cpython repo are numbered makes me think aforementioned way) |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
600 changelog2manifest = new int[changelogRevisionCount]; |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
601 Arrays.fill(changelog2manifest, BAD_REVISION); |
218
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
602 } |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
603 } |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
604 |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
605 public void finish(Object token) { |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
606 if (changelog2manifest == null) { |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
607 return; |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
608 } |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
609 // I assume there'd be not too many revisions we don't know manifest of |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
610 ArrayList<Integer> undefinedChangelogRevision = new ArrayList<Integer>(); |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
611 for (int i = 0; i < changelog2manifest.length; i++) { |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
612 if (changelog2manifest[i] == BAD_REVISION) { |
218
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
613 undefinedChangelogRevision.add(i); |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
614 } |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
615 } |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
616 for (int u : undefinedChangelogRevision) { |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
617 Nodeid manifest = repo.getChangelog().range(u, u).get(0).manifest(); |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
618 // TODO calculate those missing effectively (e.g. cache and sort nodeids to speed lookup |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
619 // right away in the #next (may refactor ParentWalker's sequential and sorted into dedicated helper and reuse here) |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
620 if (manifest.isNull()) { |
456
909306e412e2
Refactor LogFacility and SessionContext, better API for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
431
diff
changeset
|
621 repo.getContext().getLog().dump(getClass(), Severity.Warn, "Changeset %d has no associated manifest entry", u); |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
622 // keep -1 in the changelog2manifest map. |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
623 } else { |
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
624 changelog2manifest[u] = repo.getManifest().getRevisionIndex(manifest); |
354
5f9073eabf06
Propagate errors with exceptions up to a end client
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
326
diff
changeset
|
625 } |
218
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
626 } |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
627 } |
047b1dec7a04
Issue 7: Correctly handle manifest and changelog with different number of (or non-matching) revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
196
diff
changeset
|
628 } |
415
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
629 |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
630 /** |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
631 * Look up specified file in possibly multiple manifest revisions, collect file revision and flags. |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
632 */ |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
633 private static class FileLookupInspector implements RevlogStream.Inspector { |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
634 |
426
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
635 private final Path filename; |
415
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
636 private final byte[] filenameAsBytes; |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
637 private final IntMap<Nodeid> csetIndex2FileRev; |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
638 private final IntMap<Flags> csetIndex2Flags; |
426
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
639 private final Inspector delegate; |
415
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
640 |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
641 public FileLookupInspector(EncodingHelper eh, Path fileToLookUp, IntMap<Nodeid> csetIndex2FileRevMap, IntMap<Flags> csetIndex2FlagsMap) { |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
642 assert fileToLookUp != null; |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
643 // need at least one map for the inspector to make any sense |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
644 assert csetIndex2FileRevMap != null || csetIndex2FlagsMap != null; |
426
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
645 filename = fileToLookUp; |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
646 filenameAsBytes = eh.toManifest(fileToLookUp.toString()); |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
647 delegate = null; |
415
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
648 csetIndex2FileRev = csetIndex2FileRevMap; |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
649 csetIndex2Flags = csetIndex2FlagsMap; |
426
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
650 } |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
651 |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
652 public FileLookupInspector(EncodingHelper eh, Path fileToLookUp, Inspector delegateInspector) { |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
653 assert fileToLookUp != null; |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
654 assert delegateInspector != null; |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
655 filename = fileToLookUp; |
415
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
656 filenameAsBytes = eh.toManifest(fileToLookUp.toString()); |
426
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
657 delegate = delegateInspector; |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
658 csetIndex2FileRev = null; |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
659 csetIndex2Flags = null; |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
660 } |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
661 |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
662 void walk(int manifestRevIndex, RevlogStream content) { |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
663 content.iterate(manifestRevIndex, manifestRevIndex, true, this); |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
664 } |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
665 |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
666 void walk(int[] manifestRevIndexes, RevlogStream content) { |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
667 content.iterate(manifestRevIndexes, true, this); |
415
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
668 } |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
669 |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
670 public void next(int revisionNumber, int actualLen, int baseRevision, int linkRevision, int parent1Revision, int parent2Revision, byte[] nodeid, DataAccess data) { |
415
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
671 ByteArrayOutputStream bos = new ByteArrayOutputStream(); |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
672 try { |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
673 byte b; |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
674 while (!data.isEmpty() && (b = data.readByte()) != '\n') { |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
675 if (b != 0) { |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
676 bos.write(b); |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
677 } else { |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
678 byte[] byteArray = bos.toByteArray(); |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
679 bos.reset(); |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
680 if (Arrays.equals(filenameAsBytes, byteArray)) { |
426
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
681 Nodeid fileRev = null; |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
682 Flags flags = null; |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
683 if (csetIndex2FileRev != null || delegate != null) { |
415
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
684 byte[] nid = new byte[40]; |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
685 data.readBytes(nid, 0, 40); |
426
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
686 fileRev = Nodeid.fromAscii(nid, 0, 40); |
415
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
687 } else { |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
688 data.skip(40); |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
689 } |
426
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
690 if (csetIndex2Flags != null || delegate != null) { |
415
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
691 while (!data.isEmpty() && (b = data.readByte()) != '\n') { |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
692 bos.write(b); |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
693 } |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
694 if (bos.size() == 0) { |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
695 flags = Flags.RegularFile; |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
696 } else { |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
697 flags = Flags.parse(bos.toByteArray(), 0, bos.size()); |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
698 } |
426
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
699 |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
700 } |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
701 if (delegate != null) { |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
702 assert flags != null; |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
703 assert fileRev != null; |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
704 delegate.begin(revisionNumber, Nodeid.fromBinary(nodeid, 0), linkRevision); |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
705 delegate.next(fileRev, filename, flags); |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
706 delegate.end(revisionNumber); |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
707 |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
708 } else { |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
709 if (csetIndex2FileRev != null) { |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
710 csetIndex2FileRev.put(linkRevision, fileRev); |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
711 } |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
712 if (csetIndex2Flags != null) { |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
713 csetIndex2Flags.put(linkRevision, flags); |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
714 } |
415
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
715 } |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
716 break; |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
717 } else { |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
718 data.skip(40); |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
719 } |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
720 // else skip to the end of line |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
721 while (!data.isEmpty() && (b = data.readByte()) != '\n') |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
722 ; |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
723 } |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
724 } |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
725 } catch (IOException ex) { |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
421
diff
changeset
|
726 throw new HgInvalidControlFileException("Failed reading manifest", ex, null); |
415
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
727 } |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
728 } |
ee8264d80747
Explicit constant for regular file flags, access to flags for a given file revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
414
diff
changeset
|
729 } |
2
08db726a0fb7
Shaping out low-level Hg structures
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
730 } |