Mercurial > hg4j
annotate cmdline/org/tmatesoft/hg/console/Incoming.java @ 183:9807bf8f3a9c
Do not assume second parent can be set only when first one is set
author | Artem Tikhomirov <tikhomirov.artem@gmail.com> |
---|---|
date | Wed, 13 Apr 2011 14:15:13 +0200 |
parents | f26ffe04ced0 |
children | ec1820f64d2b |
rev | line source |
---|---|
31
346b66add79d
Basic lookup for incoming changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
1 /* |
74
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
33
diff
changeset
|
2 * Copyright (c) 2011 TMate Software Ltd |
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
33
diff
changeset
|
3 * |
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
33
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:
33
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:
33
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:
33
diff
changeset
|
7 * |
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
33
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:
33
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:
33
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:
33
diff
changeset
|
11 * GNU General Public License for more details. |
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
33
diff
changeset
|
12 * |
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
33
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:
33
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:
98
diff
changeset
|
15 * contact TMate Software at support@hg4j.com |
31
346b66add79d
Basic lookup for incoming changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
16 */ |
74
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
33
diff
changeset
|
17 package org.tmatesoft.hg.console; |
31
346b66add79d
Basic lookup for incoming changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
18 |
178
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
19 import java.util.ArrayList; |
173
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
20 import java.util.Arrays; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
21 import java.util.Collections; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
22 import java.util.Comparator; |
31
346b66add79d
Basic lookup for incoming changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
23 import java.util.HashSet; |
173
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
24 import java.util.Iterator; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
25 import java.util.LinkedHashMap; |
31
346b66add79d
Basic lookup for incoming changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
26 import java.util.LinkedList; |
346b66add79d
Basic lookup for incoming changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
27 import java.util.List; |
178
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
28 import java.util.ListIterator; |
173
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
29 import java.util.Map.Entry; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
30 |
176
a8df7162ec75
Extracting complete branch using remote between call to detect incoming changes is done. Arguments reorderd in remote repo to better match Hg server ideology, not my mental convenience
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
174
diff
changeset
|
31 import org.tmatesoft.hg.core.HgException; |
74
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
33
diff
changeset
|
32 import org.tmatesoft.hg.core.Nodeid; |
181
cd3371670f0b
Refactor incoming and outgoing code to be shared with RepositoryComparator. Placeholders for in/out commands. Refactor common remote lookup code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
178
diff
changeset
|
33 import org.tmatesoft.hg.internal.RepositoryComparator; |
cd3371670f0b
Refactor incoming and outgoing code to be shared with RepositoryComparator. Placeholders for in/out commands. Refactor common remote lookup code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
178
diff
changeset
|
34 import org.tmatesoft.hg.internal.RepositoryComparator.BranchChain; |
97
ee2c750b036d
Changelog to HgChangelog
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
74
diff
changeset
|
35 import org.tmatesoft.hg.repo.HgChangelog; |
176
a8df7162ec75
Extracting complete branch using remote between call to detect incoming changes is done. Arguments reorderd in remote repo to better match Hg server ideology, not my mental convenience
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
174
diff
changeset
|
36 import org.tmatesoft.hg.repo.HgLookup; |
a8df7162ec75
Extracting complete branch using remote between call to detect incoming changes is done. Arguments reorderd in remote repo to better match Hg server ideology, not my mental convenience
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
174
diff
changeset
|
37 import org.tmatesoft.hg.repo.HgRemoteRepository; |
74
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
33
diff
changeset
|
38 import org.tmatesoft.hg.repo.HgRepository; |
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
33
diff
changeset
|
39 |
31
346b66add79d
Basic lookup for incoming changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
40 |
346b66add79d
Basic lookup for incoming changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
41 /** |
74
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
33
diff
changeset
|
42 * WORK IN PROGRESS, DO NOT USE |
173
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
43 * hg incoming counterpart |
74
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
33
diff
changeset
|
44 * |
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
33
diff
changeset
|
45 * @author Artem Tikhomirov |
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
33
diff
changeset
|
46 * @author TMate Software Ltd. |
31
346b66add79d
Basic lookup for incoming changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
47 */ |
346b66add79d
Basic lookup for incoming changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
48 public class Incoming { |
346b66add79d
Basic lookup for incoming changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
49 |
346b66add79d
Basic lookup for incoming changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
50 public static void main(String[] args) throws Exception { |
176
a8df7162ec75
Extracting complete branch using remote between call to detect incoming changes is done. Arguments reorderd in remote repo to better match Hg server ideology, not my mental convenience
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
174
diff
changeset
|
51 if (Boolean.FALSE.booleanValue()) { |
173
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
52 new SequenceConstructor().test(); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
53 return; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
54 } |
74
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
33
diff
changeset
|
55 Options cmdLineOpts = Options.parse(args); |
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
33
diff
changeset
|
56 HgRepository hgRepo = cmdLineOpts.findRepository(); |
31
346b66add79d
Basic lookup for incoming changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
57 if (hgRepo.isInvalid()) { |
346b66add79d
Basic lookup for incoming changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
58 System.err.printf("Can't find repository in: %s\n", hgRepo.getLocation()); |
346b66add79d
Basic lookup for incoming changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
59 return; |
346b66add79d
Basic lookup for incoming changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
60 } |
181
cd3371670f0b
Refactor incoming and outgoing code to be shared with RepositoryComparator. Placeholders for in/out commands. Refactor common remote lookup code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
178
diff
changeset
|
61 HgRemoteRepository hgRemote = new HgLookup().detectRemote("svnkit", hgRepo); |
cd3371670f0b
Refactor incoming and outgoing code to be shared with RepositoryComparator. Placeholders for in/out commands. Refactor common remote lookup code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
178
diff
changeset
|
62 if (hgRemote.isInvalid()) { |
cd3371670f0b
Refactor incoming and outgoing code to be shared with RepositoryComparator. Placeholders for in/out commands. Refactor common remote lookup code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
178
diff
changeset
|
63 System.err.printf("Remote repository %s is not valid", hgRemote.getLocation()); |
cd3371670f0b
Refactor incoming and outgoing code to be shared with RepositoryComparator. Placeholders for in/out commands. Refactor common remote lookup code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
178
diff
changeset
|
64 return; |
176
a8df7162ec75
Extracting complete branch using remote between call to detect incoming changes is done. Arguments reorderd in remote repo to better match Hg server ideology, not my mental convenience
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
174
diff
changeset
|
65 } |
a8df7162ec75
Extracting complete branch using remote between call to detect incoming changes is done. Arguments reorderd in remote repo to better match Hg server ideology, not my mental convenience
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
174
diff
changeset
|
66 // |
31
346b66add79d
Basic lookup for incoming changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
67 // in fact, all we need from changelog is set of all nodeids. However, since ParentWalker reuses same Nodeids, it's not too expensive |
346b66add79d
Basic lookup for incoming changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
68 // to reuse it here, XXX although later this may need to be refactored |
98
225c48d964ed
Changelog to HgChangelog, Refactoring doesn't recognize name with inner class
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
97
diff
changeset
|
69 final HgChangelog.ParentWalker pw = hgRepo.getChangelog().new ParentWalker(); |
31
346b66add79d
Basic lookup for incoming changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
70 pw.init(); |
346b66add79d
Basic lookup for incoming changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
71 // |
181
cd3371670f0b
Refactor incoming and outgoing code to be shared with RepositoryComparator. Placeholders for in/out commands. Refactor common remote lookup code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
178
diff
changeset
|
72 RepositoryComparator repoCompare = new RepositoryComparator(pw, hgRemote); |
cd3371670f0b
Refactor incoming and outgoing code to be shared with RepositoryComparator. Placeholders for in/out commands. Refactor common remote lookup code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
178
diff
changeset
|
73 repoCompare.compare(null); |
cd3371670f0b
Refactor incoming and outgoing code to be shared with RepositoryComparator. Placeholders for in/out commands. Refactor common remote lookup code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
178
diff
changeset
|
74 List<BranchChain> missingBranches0 = repoCompare.calculateMissingBranches(); |
178
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
75 for (BranchChain bc : missingBranches0) { |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
76 bc.dump(); |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
77 |
181
cd3371670f0b
Refactor incoming and outgoing code to be shared with RepositoryComparator. Placeholders for in/out commands. Refactor common remote lookup code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
178
diff
changeset
|
78 List<Nodeid> missing = visitBranches(repoCompare, bc); |
178
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
79 // Collections.reverse(missing); // useful to test output, from newer to older |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
80 for (Nodeid n : missing) { |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
81 if (pw.knownNode(n)) { |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
82 System.out.println("Erroneous to fetch:" + n); |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
83 } else { |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
84 System.out.println(n); |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
85 } |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
86 } |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
87 System.out.println("Branch done"); |
31
346b66add79d
Basic lookup for incoming changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
88 } |
178
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
89 |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
90 } |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
91 |
176
a8df7162ec75
Extracting complete branch using remote between call to detect incoming changes is done. Arguments reorderd in remote repo to better match Hg server ideology, not my mental convenience
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
174
diff
changeset
|
92 |
181
cd3371670f0b
Refactor incoming and outgoing code to be shared with RepositoryComparator. Placeholders for in/out commands. Refactor common remote lookup code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
178
diff
changeset
|
93 private static List<Nodeid> visitBranches(RepositoryComparator repoCompare, BranchChain bc) throws HgException { |
178
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
94 if (bc == null) { |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
95 return Collections.emptyList(); |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
96 } |
181
cd3371670f0b
Refactor incoming and outgoing code to be shared with RepositoryComparator. Placeholders for in/out commands. Refactor common remote lookup code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
178
diff
changeset
|
97 List<Nodeid> mine = repoCompare.completeBranch(bc.branchRoot, bc.branchHead); |
178
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
98 if (bc.isTerminal()) { |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
99 return mine; |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
100 } |
181
cd3371670f0b
Refactor incoming and outgoing code to be shared with RepositoryComparator. Placeholders for in/out commands. Refactor common remote lookup code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
178
diff
changeset
|
101 List<Nodeid> parentBranch1 = visitBranches(repoCompare, bc.p1); |
cd3371670f0b
Refactor incoming and outgoing code to be shared with RepositoryComparator. Placeholders for in/out commands. Refactor common remote lookup code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
178
diff
changeset
|
102 List<Nodeid> parentBranch2 = visitBranches(repoCompare, bc.p2); |
178
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
103 // merge |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
104 LinkedList<Nodeid> merged = new LinkedList<Nodeid>(); |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
105 ListIterator<Nodeid> i1 = parentBranch1.listIterator(), i2 = parentBranch2.listIterator(); |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
106 while (i1.hasNext() && i2.hasNext()) { |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
107 Nodeid n1 = i1.next(); |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
108 Nodeid n2 = i2.next(); |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
109 if (n1.equals(n2)) { |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
110 merged.addLast(n1); |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
111 } else { |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
112 // first different => add both, and continue adding both tails sequentially |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
113 merged.add(n2); |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
114 merged.add(n1); |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
115 break; |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
116 } |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
117 } |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
118 // copy rest of second parent branch |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
119 while (i2.hasNext()) { |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
120 merged.add(i2.next()); |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
121 } |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
122 // copy rest of first parent branch |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
123 while (i1.hasNext()) { |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
124 merged.add(i1.next()); |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
125 } |
31
346b66add79d
Basic lookup for incoming changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
126 // |
178
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
127 ArrayList<Nodeid> rv = new ArrayList<Nodeid>(mine.size() + merged.size()); |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
128 rv.addAll(merged); |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
129 rv.addAll(mine); |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
130 return rv; |
62665d8f0686
Complete logic to discover all branches missing locally. Most of wire protocol in HgRemoteRepository
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
177
diff
changeset
|
131 } |
31
346b66add79d
Basic lookup for incoming changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
132 |
346b66add79d
Basic lookup for incoming changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
133 |
173
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
134 private static class SequenceConstructor { |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
135 |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
136 private int[] between(int root, int head) { |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
137 if (head <= (root+1)) { |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
138 return new int[0]; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
139 } |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
140 System.out.printf("[%d, %d]\t\t", root, head); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
141 int size = 1 + (int) Math.floor(Math.log(head-root - 1) / Math.log(2)); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
142 int[] rv = new int[size]; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
143 for (int v = 1, i = 0; i < rv.length; i++) { |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
144 rv[i] = root + v; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
145 v = v << 1; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
146 } |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
147 System.out.println(Arrays.toString(rv)); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
148 return rv; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
149 } |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
150 |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
151 public void test() { |
176
a8df7162ec75
Extracting complete branch using remote between call to detect incoming changes is done. Arguments reorderd in remote repo to better match Hg server ideology, not my mental convenience
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
174
diff
changeset
|
152 int root = 0, head = 126; |
a8df7162ec75
Extracting complete branch using remote between call to detect incoming changes is done. Arguments reorderd in remote repo to better match Hg server ideology, not my mental convenience
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
174
diff
changeset
|
153 int[] data = between(root, head); // max number of elements to recover is 2**data.length-1, when head is exactly |
a8df7162ec75
Extracting complete branch using remote between call to detect incoming changes is done. Arguments reorderd in remote repo to better match Hg server ideology, not my mental convenience
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
174
diff
changeset
|
154 // 2**data.length element of the branch. |
a8df7162ec75
Extracting complete branch using remote between call to detect incoming changes is done. Arguments reorderd in remote repo to better match Hg server ideology, not my mental convenience
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
174
diff
changeset
|
155 // In such case, total number of elements in the branch (including head and root, would be 2**data.length+1 |
a8df7162ec75
Extracting complete branch using remote between call to detect incoming changes is done. Arguments reorderd in remote repo to better match Hg server ideology, not my mental convenience
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
174
diff
changeset
|
156 int[] finalSequence = new int[1 + (1 << data.length >>> 5)]; // div 32 - total bits to integers, +1 for possible modulus |
173
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
157 int exactNumberOfElements = -1; // exact number of meaningful bits in finalSequence |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
158 LinkedHashMap<Integer, int[]> datas = new LinkedHashMap<Integer, int[]>(); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
159 datas.put(root, data); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
160 int totalQueries = 1; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
161 HashSet<Integer> queried = new HashSet<Integer>(); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
162 int[] checkSequence = null; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
163 while(!datas.isEmpty()) { |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
164 LinkedList<int[]> toQuery = new LinkedList<int[]>(); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
165 do { |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
166 Iterator<Entry<Integer, int[]>> it = datas.entrySet().iterator(); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
167 Entry<Integer, int[]> next = it.next(); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
168 int r = next.getKey(); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
169 data = next.getValue(); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
170 it.remove(); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
171 populate(r, head, data, finalSequence); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
172 if (checkSequence != null) { |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
173 boolean match = true; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
174 // System.out.println("Try to match:"); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
175 for (int i = 0; i < checkSequence.length; i++) { |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
176 // System.out.println(i); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
177 // System.out.println("control:" + toBinaryString(checkSequence[i], ' ')); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
178 // System.out.println("present:" + toBinaryString(finalSequence[i], ' ')); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
179 if (checkSequence[i] != finalSequence[i]) { |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
180 match = false; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
181 } else { |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
182 match &= true; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
183 } |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
184 } |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
185 System.out.println(match ? "Match, on query:" + totalQueries : "Didn't match"); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
186 } |
176
a8df7162ec75
Extracting complete branch using remote between call to detect incoming changes is done. Arguments reorderd in remote repo to better match Hg server ideology, not my mental convenience
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
174
diff
changeset
|
187 if (data.length > 1) { |
a8df7162ec75
Extracting complete branch using remote between call to detect incoming changes is done. Arguments reorderd in remote repo to better match Hg server ideology, not my mental convenience
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
174
diff
changeset
|
188 /*queries for elements next to head is senseless, hence data.length check above and head-x below*/ |
173
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
189 for (int x : data) { |
176
a8df7162ec75
Extracting complete branch using remote between call to detect incoming changes is done. Arguments reorderd in remote repo to better match Hg server ideology, not my mental convenience
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
174
diff
changeset
|
190 if (!queried.contains(x) && head - x > 1) { |
173
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
191 toQuery.add(new int[] {x, head}); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
192 } |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
193 } |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
194 } |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
195 } while (!datas.isEmpty()) ; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
196 if (!toQuery.isEmpty()) { |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
197 System.out.println(); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
198 totalQueries++; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
199 } |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
200 Collections.sort(toQuery, new Comparator<int[]>() { |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
201 |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
202 public int compare(int[] o1, int[] o2) { |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
203 return o1[0] < o2[0] ? -1 : (o1[0] == o2[0] ? 0 : 1); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
204 } |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
205 }); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
206 for (int[] x : toQuery) { |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
207 if (!queried.contains(x[0])) { |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
208 queried.add(x[0]); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
209 data = between(x[0], x[1]); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
210 if (exactNumberOfElements == -1 && data.length == 1) { |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
211 exactNumberOfElements = x[0] + 1; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
212 System.out.printf("On query %d found out exact number of missing elements: %d\n", totalQueries, exactNumberOfElements); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
213 // get a bit sequence of exactNumberOfElements, 0111..110 |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
214 // to 'and' it with finalSequence later |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
215 int totalInts = (exactNumberOfElements + 2 /*heading and tailing zero bits*/) >>> 5; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
216 int trailingBits = (exactNumberOfElements + 2) & 0x1f; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
217 if (trailingBits != 0) { |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
218 totalInts++; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
219 } |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
220 checkSequence = new int[totalInts]; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
221 Arrays.fill(checkSequence, 0xffffffff); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
222 checkSequence[0] &= 0x7FFFFFFF; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
223 if (trailingBits == 0) { |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
224 checkSequence[totalInts-1] &= 0xFFFFFFFE; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
225 } else if (trailingBits == 1) { |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
226 checkSequence[totalInts-1] = 0; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
227 } else { |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
228 // trailingBits include heading and trailing zero bits |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
229 int mask = 0x80000000 >> trailingBits-2; // with sign! |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
230 checkSequence[totalInts - 1] &= mask; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
231 } |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
232 for (int e : checkSequence) { |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
233 System.out.print(toBinaryString(e, ' ')); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
234 } |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
235 System.out.println(); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
236 } |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
237 datas.put(x[0], data); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
238 } |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
239 } |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
240 } |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
241 |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
242 System.out.println("Total queries:" + totalQueries); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
243 for (int x : finalSequence) { |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
244 System.out.print(toBinaryString(x, ' ')); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
245 } |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
246 } |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
247 |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
248 private void populate(int root, int head, int[] data, int[] finalSequence) { |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
249 for (int i = 1, x = 0; root+i < head; i = i << 1, x++) { |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
250 int value = data[x]; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
251 int value_check = root+i; |
174
b1de83ffa7f8
Build shall succeed with no precompiled classes, too
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
173
diff
changeset
|
252 if (value != value_check) { |
b1de83ffa7f8
Build shall succeed with no precompiled classes, too
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
173
diff
changeset
|
253 throw new IllegalStateException(); |
b1de83ffa7f8
Build shall succeed with no precompiled classes, too
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
173
diff
changeset
|
254 } |
173
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
255 int wordIx = (root + i) >>> 5; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
256 int bitIx = (root + i) & 0x1f; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
257 finalSequence[wordIx] |= 1 << (31-bitIx); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
258 } |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
259 } |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
260 |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
261 private static String toBinaryString(int x, char byteSeparator) { |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
262 StringBuilder sb = new StringBuilder(4*8+4); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
263 sb.append(toBinaryString((byte) (x >>> 24))); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
264 sb.append(byteSeparator); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
265 sb.append(toBinaryString((byte) ((x & 0x00ff0000) >>> 16))); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
266 sb.append(byteSeparator); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
267 sb.append(toBinaryString((byte) ((x & 0x00ff00) >>> 8))); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
268 sb.append(byteSeparator); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
269 sb.append(toBinaryString((byte) (x & 0x00ff))); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
270 sb.append(byteSeparator); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
271 return sb.toString(); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
272 } |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
273 |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
274 private static String toBinaryString(byte b) { |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
275 final String nibbles = "0000000100100011010001010110011110001001101010111100110111101111"; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
276 assert nibbles.length() == 16*4; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
277 int x1 = (b >>> 4) & 0x0f, x2 = b & 0x0f; |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
278 x1 *= 4; x2 *= 4; // 4 characters per nibble |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
279 return nibbles.substring(x1, x1+4).concat(nibbles.substring(x2, x2+4)); |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
280 } |
4bf061a7c001
Test algorithm to build sequence of missing revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
171
diff
changeset
|
281 } |
31
346b66add79d
Basic lookup for incoming changes
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
282 } |