Mercurial > hg4j
annotate src/org/tmatesoft/hg/repo/HgManifest.java @ 638:2f1cd1c26de5 smartgit-4.5
AIOOBE in HgManifest.RevisionMapper: provide more details about exception context. Create lock file atomically. Picked from changeset 8a5cdcb27b8f
author | Artem Tikhomirov <tikhomirov.artem@gmail.com> |
---|---|
date | Fri, 07 Jun 2013 13:21:20 +0200 |
parents | 47dfa0ec7e35 |
children | 5d8798772cca |
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 /* |
537
5a455624be4f
Update javadoc for HgManifest.Inspector and fix erroneous internal API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
2 * Copyright (c) 2010-2013 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 |
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
|
23 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
|
24 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
|
25 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
|
26 |
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
|
27 import org.tmatesoft.hg.core.HgChangesetFileSneaker; |
74
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
28
diff
changeset
|
28 import org.tmatesoft.hg.core.Nodeid; |
574
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
571
diff
changeset
|
29 import org.tmatesoft.hg.internal.ByteVector; |
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; |
574
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
571
diff
changeset
|
34 import org.tmatesoft.hg.internal.IdentityPool; |
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
|
35 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
|
36 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
|
37 import org.tmatesoft.hg.internal.Lifecycle; |
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; |
574
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
571
diff
changeset
|
40 import org.tmatesoft.hg.util.LogFacility.Severity; |
232
b7347daa50e3
Allow to cat a file with changeset revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
222
diff
changeset
|
41 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
|
42 import org.tmatesoft.hg.util.ProgressSupport; |
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; |
574
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
571
diff
changeset
|
54 private final EncodingHelper encodingHelper; |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
571
diff
changeset
|
55 private final Path.Source pathFactory; |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
56 |
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
|
57 /** |
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 * 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
|
59 */ |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
60 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
|
61 /** |
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 * 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
|
63 */ |
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 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
|
65 /** |
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 * 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
|
67 */ |
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 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
|
69 /** |
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 * 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
|
71 */ |
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
|
72 RegularFile; |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
73 |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
74 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
|
75 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
|
76 return Exec; |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
77 } |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
78 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
|
79 return Link; |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
80 } |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
81 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
|
82 return RegularFile; |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
83 } |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
84 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
|
85 } |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
86 |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
87 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
|
88 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
|
89 return RegularFile; |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
90 } |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
91 if (length == 1) { |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
92 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
|
93 return Exec; |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
94 } |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
95 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
|
96 return Link; |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
97 } |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
98 // FALL THROUGH |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
99 } |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
100 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
|
101 } |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
102 |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
103 String nativeString() { |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
104 if (this == Exec) { |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
105 return "x"; |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
106 } |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
107 if (this == Link) { |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
108 return "l"; |
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
109 } |
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
|
110 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
|
111 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
|
112 } |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
113 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
|
114 } |
574
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
571
diff
changeset
|
115 |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
571
diff
changeset
|
116 public int fsMode() { |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
571
diff
changeset
|
117 if (this == Exec) { |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
571
diff
changeset
|
118 return 0755; |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
571
diff
changeset
|
119 } |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
571
diff
changeset
|
120 return 0644; |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
571
diff
changeset
|
121 } |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
122 } |
2
08db726a0fb7
Shaping out low-level Hg structures
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
123 |
412
63c5a9d7ca3f
Follow-up for Issue 29: unify path translation for manifest and dirstate
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
124 /*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
|
125 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
|
126 encodingHelper = eh; |
574
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
571
diff
changeset
|
127 pathFactory = hgRepo.getSessionContext().getPathFactory(); |
13
df8c67f3006a
Basic manifest parsing to analyze what's in there
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
2
diff
changeset
|
128 } |
df8c67f3006a
Basic manifest parsing to analyze what's in there
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
2
diff
changeset
|
129 |
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
|
130 /** |
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
|
131 * 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
|
132 * 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
|
133 * 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
|
134 * <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
|
135 * 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
|
136 * 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
|
137 * 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
|
138 * </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
|
139 * 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
|
140 * 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
|
141 * |
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 * <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
|
143 * 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
|
144 * 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
|
145 * <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
|
146 * <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
|
147 * (<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
|
148 * 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
|
149 * 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
|
150 * 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
|
151 * <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
|
152 * 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
|
153 * 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
|
154 * 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
|
155 * </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
|
156 * 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
|
157 * <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
|
158 * |
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
|
159 * @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
|
160 * @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
|
161 * @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
|
162 * @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
|
163 * @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
|
164 * @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
|
165 */ |
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 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
|
167 if (inspector == null) { |
e2115da4cf6a
Pool objects to avoid memory polution with duplicates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
168 throw new IllegalArgumentException(); |
e2115da4cf6a
Pool objects to avoid memory polution with duplicates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
169 } |
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
|
170 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
|
171 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
|
172 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
|
173 manifestFirst = fromChangelog(csetFirst+i); |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
174 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
|
175 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
|
176 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
|
177 } |
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 i++; |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
179 } while (manifestFirst == BAD_REVISION && csetFirst+i <= csetLast); |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
180 if (manifestFirst == BAD_REVISION) { |
490
b3c16d1aede0
Refactoring: move HgRepository's implementation aspects to Internals (which is now its imlementation counterpart and primary repository class to be used by other parts of the library)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
456
diff
changeset
|
181 getRepo().getSessionContext().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
|
182 // 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
|
183 // 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
|
184 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
|
185 } |
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
|
186 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
|
187 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
|
188 manifestLast = fromChangelog(csetLast-i); |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
189 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
|
190 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
|
191 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
|
192 } |
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 i++; |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
194 } while (manifestLast == BAD_REVISION && csetLast-i >= csetFirst); |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
195 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
|
196 // 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
|
197 // 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
|
198 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
|
199 } |
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
|
200 if (manifestLast < manifestFirst) { |
300
650b45d290b1
Share range check code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
285
diff
changeset
|
201 // 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
|
202 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
|
203 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
|
204 manifestFirst = x; |
300
650b45d290b1
Share range check code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
285
diff
changeset
|
205 } |
571
e4ee4bf4c7d0
Let session context control creation of Path instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
550
diff
changeset
|
206 content.iterate(manifestFirst, manifestLast, true, new ManifestParser(inspector)); |
19
40532cdc92fc
Inspector (visitor) for manifest
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
16
diff
changeset
|
207 } |
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
|
208 |
254
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
232
diff
changeset
|
209 /** |
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
|
210 * "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
|
211 * <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
|
212 * 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
|
213 * 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
|
214 * 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
|
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 * @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
|
217 * @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
|
218 * @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
|
219 * @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
|
220 */ |
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
|
221 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
|
222 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
|
223 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
|
224 } |
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
|
225 int[] manifestRevs = toManifestRevisionIndexes(revisionIndexes, inspector); |
571
e4ee4bf4c7d0
Let session context control creation of Path instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
550
diff
changeset
|
226 content.iterate(manifestRevs, true, new ManifestParser(inspector)); |
254
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
232
diff
changeset
|
227 } |
a620f0663a37
Collect tags for a file - improve performance of 'sparse' manifest reads
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
232
diff
changeset
|
228 |
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
|
229 // |
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
|
230 /** |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
231 * 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
|
232 * 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
|
233 * @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
|
234 * @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
|
235 * @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
|
236 */ |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
237 /*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
|
238 if (HgInternals.wrongRevisionIndex(changesetRevisionIndex)) { |
425
48f993aa2f41
FIXMEs: exceptions, javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
424
diff
changeset
|
239 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
|
240 } |
368
8107b95f4280
Update Javadoc with 'revision index'
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
367
diff
changeset
|
241 if (changesetRevisionIndex == HgRepository.WORKING_COPY || changesetRevisionIndex == HgRepository.BAD_REVISION) { |
425
48f993aa2f41
FIXMEs: exceptions, javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
424
diff
changeset
|
242 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
|
243 } |
f39fb6b3cc76
Handle revision constants correctly
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
254
diff
changeset
|
244 // 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
|
245 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
|
246 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
|
247 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
|
248 } |
368
8107b95f4280
Update Javadoc with 'revision index'
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
367
diff
changeset
|
249 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
|
250 } |
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
|
251 |
232
b7347daa50e3
Allow to cat a file with changeset revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
222
diff
changeset
|
252 /** |
b7347daa50e3
Allow to cat a file with changeset revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
222
diff
changeset
|
253 * 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
|
254 * <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
|
255 * <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
|
256 * |
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
|
257 * @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
|
258 * @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
|
259 * @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
|
260 * @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
|
261 * @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
|
262 * @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
|
263 */ |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
264 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
|
265 // 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
|
266 // 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
|
267 // both file revision and changeset revision index. But there's no easy way to go from changesetRevisionIndex to |
547
66fc86e8c0dd
#getFileRevision() shall accept TIP as an argument
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
537
diff
changeset
|
268 // file revision (the task this method solves), except for HgFileInformer |
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
|
269 // I feel methods dealing with changeset indexes shall be more exposed in HgChangelog and HgManifest API. |
547
66fc86e8c0dd
#getFileRevision() shall accept TIP as an argument
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
537
diff
changeset
|
270 // TODO need tests (e.g. pass TIP here to see resMap.get(-1) doesn't fail) |
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 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
|
272 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
|
273 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
|
274 } |
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 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
|
276 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
|
277 parser.walk(manifestRevIndex, content); |
550
c1478cc31f45
Regression: expect file to be missing in a manifest
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
547
diff
changeset
|
278 assert resMap.size() <= 1; // size() == 0 if file wasn't found |
547
66fc86e8c0dd
#getFileRevision() shall accept TIP as an argument
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
537
diff
changeset
|
279 // can't use changelogRevisionIndex as key - it might have been TIP |
550
c1478cc31f45
Regression: expect file to be missing in a manifest
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
547
diff
changeset
|
280 return resMap.size() == 0 ? null : resMap.get(resMap.firstKey()); |
326
d42a45a2c9d6
Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
324
diff
changeset
|
281 } |
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
|
282 |
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 /** |
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 * 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
|
285 * 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
|
286 * 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
|
287 * |
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 * <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
|
289 * 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
|
290 * 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
|
291 * |
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 * @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
|
293 * @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
|
294 * @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
|
295 * @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
|
296 * @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
|
297 */ |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
298 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
|
299 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
|
300 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
|
301 } |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
302 // 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
|
303 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
|
304 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
|
305 parser.walk(manifestRevIndexes, content); |
232
b7347daa50e3
Allow to cat a file with changeset revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
222
diff
changeset
|
306 } |
326
d42a45a2c9d6
Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
324
diff
changeset
|
307 |
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
|
308 /** |
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
|
309 * 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
|
310 * |
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
|
311 * @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
|
312 * @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
|
313 * @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
|
314 * @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
|
315 * @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
|
316 */ |
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
|
317 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
|
318 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
|
319 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
|
320 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
|
321 parser.walk(manifestRevIdx, content); |
550
c1478cc31f45
Regression: expect file to be missing in a manifest
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
547
diff
changeset
|
322 assert resMap.size() <= 1; // size() == 0 if not found |
547
66fc86e8c0dd
#getFileRevision() shall accept TIP as an argument
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
537
diff
changeset
|
323 // can't use changesetRevIndex as key - it might have been TIP |
550
c1478cc31f45
Regression: expect file to be missing in a manifest
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
547
diff
changeset
|
324 return resMap.size() == 0 ? null : resMap.get(resMap.firstKey()); |
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
|
325 } |
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
|
326 |
326
d42a45a2c9d6
Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
324
diff
changeset
|
327 |
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
|
328 /** |
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 * @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
|
330 * @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
|
331 * @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
|
332 * @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
|
333 * @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
|
334 */ |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
335 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
|
336 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
|
337 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
|
338 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
|
339 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
|
340 final int manifestRevisionIndex = fromChangelog(changelogRevisionIndexes[i]); |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
341 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
|
342 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
|
343 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
|
344 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
|
345 } |
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 // 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
|
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 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
|
349 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
|
350 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
|
351 } |
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 j++; |
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 } |
d42a45a2c9d6
Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
324
diff
changeset
|
355 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
|
356 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
|
357 } |
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
|
358 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
|
359 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
|
360 } 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
|
361 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
|
362 //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
|
363 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
|
364 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
|
365 } |
326
d42a45a2c9d6
Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
324
diff
changeset
|
366 } |
d42a45a2c9d6
Alternative tag collection approach for a file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
324
diff
changeset
|
367 |
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
|
368 @Callback |
19
40532cdc92fc
Inspector (visitor) for manifest
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
16
diff
changeset
|
369 public interface Inspector { |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
370 /** |
537
5a455624be4f
Update javadoc for HgManifest.Inspector and fix erroneous internal API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
371 * Denotes entering specific manifest revision, separate entries are |
5a455624be4f
Update javadoc for HgManifest.Inspector and fix erroneous internal API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
372 * reported with subsequence {@link #next(Nodeid, Path, Flags)} calls. |
5a455624be4f
Update javadoc for HgManifest.Inspector and fix erroneous internal API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
373 * |
583
47dfa0ec7e35
Effective revlog patching
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
574
diff
changeset
|
374 * @param manifestRevisionIndex local revision index of the inspected revision |
537
5a455624be4f
Update javadoc for HgManifest.Inspector and fix erroneous internal API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
375 * @param manifestRevision revision of the manifest we're about to iterate through |
5a455624be4f
Update javadoc for HgManifest.Inspector and fix erroneous internal API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
376 * @param changelogRevisionIndex local revision index of changelog this manifest points to |
5a455624be4f
Update javadoc for HgManifest.Inspector and fix erroneous internal API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
377 * @return <code>true</code> to continue iteration, <code>false</code> to stop |
5a455624be4f
Update javadoc for HgManifest.Inspector and fix erroneous internal API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
378 */ |
583
47dfa0ec7e35
Effective revlog patching
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
574
diff
changeset
|
379 boolean begin(int manifestRevisionIndex, Nodeid manifestRevision, int changelogRevisionIndex); |
537
5a455624be4f
Update javadoc for HgManifest.Inspector and fix erroneous internal API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
380 |
5a455624be4f
Update javadoc for HgManifest.Inspector and fix erroneous internal API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
381 |
5a455624be4f
Update javadoc for HgManifest.Inspector and fix erroneous internal API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
382 /** |
5a455624be4f
Update javadoc for HgManifest.Inspector and fix erroneous internal API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
383 * Reports each manifest entry |
5a455624be4f
Update javadoc for HgManifest.Inspector and fix erroneous internal API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
384 * |
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
|
385 * @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
|
386 * @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
|
387 * @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
|
388 * @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
|
389 */ |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
390 boolean next(Nodeid nid, Path fname, Flags flags); |
537
5a455624be4f
Update javadoc for HgManifest.Inspector and fix erroneous internal API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
391 |
5a455624be4f
Update javadoc for HgManifest.Inspector and fix erroneous internal API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
392 /** |
5a455624be4f
Update javadoc for HgManifest.Inspector and fix erroneous internal API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
393 * Denotes leaving specific manifest revision, after all entries were reported using {@link #next(Nodeid, Path, Flags)} |
5a455624be4f
Update javadoc for HgManifest.Inspector and fix erroneous internal API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
394 * |
5a455624be4f
Update javadoc for HgManifest.Inspector and fix erroneous internal API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
395 * @param manifestRevisionIndex indicates manifest revision, corresponds to opening {@link #begin(int, Nodeid, int)} |
5a455624be4f
Update javadoc for HgManifest.Inspector and fix erroneous internal API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
396 * @return <code>true</code> to continue iteration, <code>false</code> to stop |
5a455624be4f
Update javadoc for HgManifest.Inspector and fix erroneous internal API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
397 */ |
5a455624be4f
Update javadoc for HgManifest.Inspector and fix erroneous internal API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
398 boolean end(int manifestRevisionIndex); |
267
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
399 } |
424
6437d261048a
Deprecated code removed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
423
diff
changeset
|
400 |
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
|
401 /** |
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
|
402 * 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
|
403 * 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
|
404 * 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
|
405 * 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
|
406 * |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
407 * 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
|
408 * 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
|
409 * 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
|
410 */ |
571
e4ee4bf4c7d0
Let session context control creation of Path instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
550
diff
changeset
|
411 private final 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
|
412 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
|
413 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
|
414 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
|
415 private Path result; |
267
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
416 |
571
e4ee4bf4c7d0
Let session context control creation of Path instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
550
diff
changeset
|
417 public PathProxy(byte[] data, int start, int length) { |
267
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
418 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
|
419 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
|
420 this.length = length; |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
421 |
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
|
422 // 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
|
423 // 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
|
424 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
|
425 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
|
426 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
|
427 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
|
428 } |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
429 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
|
430 } |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
431 |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
432 @Override |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
433 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
|
434 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
|
435 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
|
436 } |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
437 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
|
438 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
|
439 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
|
440 } |
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
|
441 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
|
442 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
|
443 } |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
444 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
|
445 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
|
446 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
|
447 } |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
448 } |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
449 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
|
450 } |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
451 @Override |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
452 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
|
453 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
|
454 } |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
455 |
285
6dbbc53fc46d
Use Path instead of plain String for manifest file names
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
268
diff
changeset
|
456 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
|
457 if (result == null) { |
574
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
571
diff
changeset
|
458 Path.Source pf = HgManifest.this.pathFactory; |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
571
diff
changeset
|
459 result = pf.path(HgManifest.this.encodingHelper.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
|
460 // 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
|
461 // 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
|
462 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
|
463 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
|
464 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
|
465 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
|
466 } |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
467 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
|
468 } |
ec921ef0628e
Revert manifest parser changes - no single string and back to HashMap Pool
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
266
diff
changeset
|
469 } |
196
e2115da4cf6a
Pool objects to avoid memory polution with duplicates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
470 |
571
e4ee4bf4c7d0
Let session context control creation of Path instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
550
diff
changeset
|
471 private 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
|
472 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
|
473 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
|
474 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
|
475 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
|
476 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
|
477 private IterateControlMediator iterateControl; |
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
|
478 |
571
e4ee4bf4c7d0
Let session context control creation of Path instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
550
diff
changeset
|
479 public ManifestParser(Inspector delegate) { |
196
e2115da4cf6a
Pool objects to avoid memory polution with duplicates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
480 assert delegate != null; |
e2115da4cf6a
Pool objects to avoid memory polution with duplicates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
481 inspector = delegate; |
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
|
482 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
|
483 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
|
484 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
|
485 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
|
486 } |
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
|
487 |
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
|
488 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
|
489 try { |
312
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
490 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
|
491 iterateControl.stop(); |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
492 return; |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
493 } |
372
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
494 if (!da.isEmpty()) { |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
495 // 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
|
496 Path fname = null; |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
497 Flags flags = null; |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
498 Nodeid nid = null; |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
499 int i; |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
500 byte[] data = da.byteArray(); |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
501 for (i = 0; i < actualLen; i++) { |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
502 int x = i; |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
503 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
|
504 if (fname == null && data[i] == 0) { |
571
e4ee4bf4c7d0
Let session context control creation of Path instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
550
diff
changeset
|
505 PathProxy px = fnamePool.unify(new PathProxy(data, x, i - x)); |
372
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
506 // 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
|
507 // 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
|
508 fname = px.freeze(); |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
509 x = i+1; |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
510 } |
196
e2115da4cf6a
Pool objects to avoid memory polution with duplicates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
511 } |
372
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
512 if (i < actualLen) { |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
513 assert data[i] == '\n'; |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
514 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
|
515 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
|
516 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
|
517 Nodeid cached = nodeidPool.unify(nid); |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
518 if (cached == nid) { |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
519 // 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
|
520 nodeidLookupBuffer = new byte[20]; |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
521 } else { |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
522 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
|
523 } // 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
|
524 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
|
525 if (nodeidLen + x < i) { |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
526 // '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
|
527 // 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
|
528 // 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
|
529 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
|
530 } 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
|
531 flags = Flags.RegularFile; |
372
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
532 } |
424
6437d261048a
Deprecated code removed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
423
diff
changeset
|
533 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
|
534 if (!good2go) { |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
535 iterateControl.stop(); |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
536 return; |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
537 } |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
538 } |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
539 nid = null; |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
540 fname = null; |
155c1893bda4
Issue 22: UnsupportedOperationException on empty manifest entry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
368
diff
changeset
|
541 flags = null; |
196
e2115da4cf6a
Pool objects to avoid memory polution with duplicates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
542 } |
e2115da4cf6a
Pool objects to avoid memory polution with duplicates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
543 } |
312
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
544 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
|
545 iterateControl.stop(); |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
546 return; |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
547 } |
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
|
548 // |
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
|
549 // 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
|
550 // (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
|
551 // 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
|
552 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
|
553 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
|
554 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
|
555 thisRevPool = t; |
313
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
556 iterateControl.checkCancelled(); |
312
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
557 progressHelper.worked(1); |
196
e2115da4cf6a
Pool objects to avoid memory polution with duplicates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
558 } 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
|
559 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
|
560 } |
e2115da4cf6a
Pool objects to avoid memory polution with duplicates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
561 } |
312
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
562 |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
563 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
|
564 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
|
565 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
|
566 progressHelper.start(count); |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
567 } |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
568 |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
569 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
|
570 progressHelper.done(); |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
304
diff
changeset
|
571 } |
196
e2115da4cf6a
Pool objects to avoid memory polution with duplicates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
157
diff
changeset
|
572 } |
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
|
573 |
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
|
574 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
|
575 |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
576 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
|
577 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
|
578 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
|
579 |
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
|
580 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
|
581 repo = hgRepo; |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
582 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
|
583 } |
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
|
584 |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
585 /** |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
586 * 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
|
587 * @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
|
588 * @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
|
589 * @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
|
590 */ |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
591 public int at(int changesetRevisionIndex) throws HgInvalidRevisionException { |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
592 if (changesetRevisionIndex == TIP) { |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
593 changesetRevisionIndex = changelogRevisionCount - 1; |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
594 } |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
595 if (changesetRevisionIndex >= changelogRevisionCount) { |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
596 throw new HgInvalidRevisionException(changesetRevisionIndex); |
257
f39fb6b3cc76
Handle revision constants correctly
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
254
diff
changeset
|
597 } |
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
|
598 if (changelog2manifest != null) { |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
599 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
|
600 } |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
601 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
|
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 |
324
283b294d1079
Explore alternatives to access file-changelog combined history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
321
diff
changeset
|
604 // XXX likely can be replaced with Revlog.RevisionInspector |
638
2f1cd1c26de5
AIOOBE in HgManifest.RevisionMapper: provide more details about exception context. Create lock file atomically. Picked from changeset 8a5cdcb27b8f
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
583
diff
changeset
|
605 public void next(int revisionNumber, int actualLen, int baseRevision, int linkRevision, int parent1Revision, int parent2Revision, byte[] nodeid, DataAccess data) throws HgInvalidRevisionException { |
2f1cd1c26de5
AIOOBE in HgManifest.RevisionMapper: provide more details about exception context. Create lock file atomically. Picked from changeset 8a5cdcb27b8f
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
583
diff
changeset
|
606 if (linkRevision >= changelogRevisionCount) { |
2f1cd1c26de5
AIOOBE in HgManifest.RevisionMapper: provide more details about exception context. Create lock file atomically. Picked from changeset 8a5cdcb27b8f
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
583
diff
changeset
|
607 String storeLock = repo.getStoreLock().readLockInfo(); |
2f1cd1c26de5
AIOOBE in HgManifest.RevisionMapper: provide more details about exception context. Create lock file atomically. Picked from changeset 8a5cdcb27b8f
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
583
diff
changeset
|
608 String message = String.format("Manifest revision %d references changeset %d, which is beyond known scope [0..%d). Lock: %s", revisionNumber, linkRevision, changelogRevisionCount, storeLock); |
2f1cd1c26de5
AIOOBE in HgManifest.RevisionMapper: provide more details about exception context. Create lock file atomically. Picked from changeset 8a5cdcb27b8f
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
583
diff
changeset
|
609 throw new HgInvalidRevisionException(message, null, linkRevision); |
2f1cd1c26de5
AIOOBE in HgManifest.RevisionMapper: provide more details about exception context. Create lock file atomically. Picked from changeset 8a5cdcb27b8f
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
583
diff
changeset
|
610 } |
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
|
611 if (changelog2manifest != null) { |
220
8de327242aa0
Basic information about branches
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
218
diff
changeset
|
612 // 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
|
613 // 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
|
614 // 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
|
615 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
|
616 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
|
617 } 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
|
618 if (revisionNumber != linkRevision) { |
403
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
619 changelog2manifest = new int[changelogRevisionCount]; |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
620 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
|
621 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
|
622 ; |
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
|
623 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
|
624 } |
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
|
625 } |
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 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
|
629 if (count != changelogRevisionCount) { |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
630 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
|
631 // 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
|
632 // 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
|
633 // 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
|
634 // 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
|
635 changelog2manifest = new int[changelogRevisionCount]; |
2747b0723867
FIXMEs: work on exceptions and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
390
diff
changeset
|
636 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
|
637 } |
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
|
638 } |
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
|
639 |
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
|
640 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
|
641 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
|
642 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
|
643 } |
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
|
644 // 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
|
645 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
|
646 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
|
647 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
|
648 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
|
649 } |
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
|
650 } |
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
|
651 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
|
652 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
|
653 // 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
|
654 // 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
|
655 if (manifest.isNull()) { |
490
b3c16d1aede0
Refactoring: move HgRepository's implementation aspects to Internals (which is now its imlementation counterpart and primary repository class to be used by other parts of the library)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
456
diff
changeset
|
656 repo.getSessionContext().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
|
657 // 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
|
658 } 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
|
659 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
|
660 } |
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
|
661 } |
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
|
662 } |
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
|
663 } |
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
|
664 |
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
|
665 /** |
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
|
666 * 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
|
667 */ |
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 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
|
669 |
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
|
670 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
|
671 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
|
672 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
|
673 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
|
674 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
|
675 |
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 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
|
677 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
|
678 // 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
|
679 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
|
680 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
|
681 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
|
682 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
|
683 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
|
684 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
|
685 } |
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 |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
687 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
|
688 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
|
689 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
|
690 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
|
691 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
|
692 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
|
693 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
|
694 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
|
695 } |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
696 |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
697 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
|
698 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
|
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 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
|
702 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
|
703 } |
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
|
704 |
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
|
705 public void next(int revisionNumber, int actualLen, int baseRevision, int linkRevision, int parent1Revision, int parent2Revision, byte[] nodeid, DataAccess data) { |
574
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
571
diff
changeset
|
706 ByteVector byteVector = new ByteVector(256, 128); // allocate for long paths right away |
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
|
707 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
|
708 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
|
709 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
|
710 if (b != 0) { |
574
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
571
diff
changeset
|
711 byteVector.add(b); |
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
|
712 } else { |
574
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
571
diff
changeset
|
713 if (byteVector.equalsTo(filenameAsBytes)) { |
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
|
714 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
|
715 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
|
716 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
|
717 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
|
718 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
|
719 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
|
720 } 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
|
721 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
|
722 } |
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
|
723 if (csetIndex2Flags != null || delegate != null) { |
574
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
571
diff
changeset
|
724 byteVector.clear(); |
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
|
725 while (!data.isEmpty() && (b = data.readByte()) != '\n') { |
574
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
571
diff
changeset
|
726 byteVector.add(b); |
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 } |
574
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
571
diff
changeset
|
728 if (byteVector.size() == 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
|
729 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
|
730 } else { |
574
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
571
diff
changeset
|
731 flags = Flags.parse(byteVector.toByteArray(), 0, byteVector.size()); |
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
|
732 } |
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
|
733 } |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
734 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
|
735 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
|
736 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
|
737 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
|
738 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
|
739 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
|
740 |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
741 } 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
|
742 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
|
743 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
|
744 } |
063b0663495a
HgManifest#getFileRevisions refactored into #walkFileRevisions to match pattern throught rest of the library
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
425
diff
changeset
|
745 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
|
746 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
|
747 } |
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
|
748 } |
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
|
749 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
|
750 } 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
|
751 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
|
752 } |
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
|
753 // 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
|
754 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
|
755 ; |
574
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
571
diff
changeset
|
756 |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
571
diff
changeset
|
757 byteVector.clear(); |
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
|
758 } |
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
|
759 } |
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
|
760 } 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
|
761 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
|
762 } |
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
|
763 } |
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
|
764 } |
2
08db726a0fb7
Shaping out low-level Hg structures
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
765 } |