Mercurial > hg4j
annotate src/org/tmatesoft/hg/internal/KeywordFilter.java @ 713:661e77dc88ba tip
Mac support: respect Mac alternatives of command-line arguments for common unix tools
author | Artem Tikhomirov <tikhomirov.artem@gmail.com> |
---|---|
date | Sun, 03 Aug 2014 18:09:00 +0200 |
parents | a62079bc422b |
children |
rev | line source |
---|---|
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
1 /* |
710
cf200271439a
KeywordFilter: 'IllegalStateException: need buffer of at least...' during status op for a small file
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
490
diff
changeset
|
2 * Copyright (c) 2011-2013 TMate Software Ltd |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
3 * |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
4 * This program is free software; you can redistribute it and/or modify |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
5 * it under the terms of the GNU General Public License as published by |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
6 * the Free Software Foundation; version 2 of the License. |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
7 * |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
8 * This program is distributed in the hope that it will be useful, |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
11 * GNU General Public License for more details. |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
12 * |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
13 * For information on how to redistribute this software under |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
14 * the terms of a license other than GNU General Public License |
130
7567f4a42fe5
Correct contact address
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
129
diff
changeset
|
15 * contact TMate Software at support@hg4j.com |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
16 */ |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
17 package org.tmatesoft.hg.internal; |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
18 |
456
909306e412e2
Refactor LogFacility and SessionContext, better API for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
423
diff
changeset
|
19 import static org.tmatesoft.hg.util.LogFacility.Severity.Error; |
909306e412e2
Refactor LogFacility and SessionContext, better API for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
423
diff
changeset
|
20 |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
21 import java.nio.ByteBuffer; |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
22 import java.util.ArrayList; |
354
5f9073eabf06
Propagate errors with exceptions up to a end client
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
331
diff
changeset
|
23 import java.util.Date; |
711
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
24 import java.util.Map; |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
25 import java.util.TreeMap; |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
26 |
354
5f9073eabf06
Propagate errors with exceptions up to a end client
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
331
diff
changeset
|
27 import org.tmatesoft.hg.core.Nodeid; |
154
ba2bf656f00f
Changeset => RawChangeset
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
28 import org.tmatesoft.hg.repo.HgChangelog.RawChangeset; |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
29 import org.tmatesoft.hg.repo.HgRepository; |
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:
418
diff
changeset
|
30 import org.tmatesoft.hg.repo.HgRuntimeException; |
331
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
154
diff
changeset
|
31 import org.tmatesoft.hg.util.Pair; |
133
4a948ec83980
core.Path to util.Path as it's not Hg repo dependant
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
130
diff
changeset
|
32 import org.tmatesoft.hg.util.Path; |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
33 |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
34 /** |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
35 * |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
36 * @author Artem Tikhomirov |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
37 * @author TMate Software Ltd. |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
38 */ |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
39 public class KeywordFilter implements Filter { |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
40 private final HgRepository repo; |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
41 private final boolean isExpanding; |
711
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
42 private final Map<String,String> keywords; |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
43 private final Path path; |
154
ba2bf656f00f
Changeset => RawChangeset
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
44 private RawChangeset latestFileCset; |
711
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
45 private final ByteVector unprocessedBuffer; |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
46 |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
47 /** |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
48 * |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
49 * @param hgRepo |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
50 * @param path |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
51 * @param expand <code>true</code> to expand keywords, <code>false</code> to shrink |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
52 */ |
711
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
53 private KeywordFilter(HgRepository hgRepo, Path p, Map<String, String> kw, boolean expand) { |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
54 repo = hgRepo; |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
55 path = p; |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
56 isExpanding = expand; |
711
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
57 keywords = kw; |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
58 unprocessedBuffer = expand ? new ByteVector(0, 0) : new ByteVector(120, 50); |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
59 } |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
60 |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
61 /** |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
62 * @param src buffer ready to be read |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
63 * @return buffer ready to be read and original buffer's position modified to reflect consumed bytes. IOW, if source buffer |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
64 * on return has remaining bytes, they are assumed not-read (not processed) and next chunk passed to filter is supposed to |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
65 * start with them |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
66 */ |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
67 public ByteBuffer filter(ByteBuffer src) { |
711
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
68 // when unprocessedBuffer is empty, we are looking for first $ in the input, |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
69 // when we've already got anything unprocessed, newline is of interest, too |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
70 int kwBreak = indexOf(src, '$', src.position(), !unprocessedBuffer.isEmpty()); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
71 ByteBuffer outBuffer = null; |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
72 while (kwBreak != -1) { |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
73 if (unprocessedBuffer.isEmpty()) { |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
74 // both expand and collapse cases |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
75 assert src.get(kwBreak) == '$'; |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
76 |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
77 int end = indexOf(src, '$', kwBreak+1, true); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
78 if (end == -1) { |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
79 for (int i = kwBreak; i < src.limit(); i++) { |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
80 unprocessedBuffer.add(src.get(i)); |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
81 } |
711
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
82 src.limit(kwBreak); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
83 kwBreak = -1; |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
84 // src up to kwBreak is left and returned either with outBuffer or alone |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
85 } else if (src.get(end) == '$') { |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
86 StringBuilder sb = new StringBuilder(end - kwBreak); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
87 for (int i = kwBreak+1; i < end; i++) { |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
88 if (src.get(i) == ':' || src.get(i) == ' ') { |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
89 break; |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
90 } |
711
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
91 sb.append((char) src.get(i)); |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
92 } |
711
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
93 final String keyword = sb.toString(); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
94 if (knownKeyword(keyword)) { |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
95 // copy src up to kw, including starting $keyword |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
96 outBuffer = append(outBuffer, src, kwBreak - src.position() + 1+keyword.length()); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
97 // replace kwStart..end with new content |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
98 outBuffer = ensureCapacityFor(outBuffer, (isExpanding ? 200 : 1)); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
99 if (isExpanding) { |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
100 outBuffer.put((byte) ':'); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
101 outBuffer.put((byte) ' '); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
102 outBuffer = expandKeywordValue(keyword, outBuffer); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
103 outBuffer.put((byte) ' '); |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
104 } |
711
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
105 outBuffer.put((byte) '$'); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
106 // src is consumed up to end |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
107 src.position(end+1); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
108 kwBreak = indexOf(src, '$', end+1, false); |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
109 } else { |
711
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
110 // no (or unknown) keyword, try with '$' at src[end] |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
111 kwBreak = end; |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
112 } |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
113 } else { |
711
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
114 // newline, ignore keyword start |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
115 kwBreak = indexOf(src, '$', end+1, false); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
116 } |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
117 } else { |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
118 // we've got smth unprocessed, and we've matched either $ or NL |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
119 // the only chance to get here is when src is in the very start |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
120 if (src.get(kwBreak) == '$') { |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
121 // closed tag |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
122 for (int i = src.position(); i <= kwBreak; i++) { |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
123 // consume src: going to handle its [position*()..kwBreak] as part of unprocessedBuffer |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
124 unprocessedBuffer.add(src.get()); |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
125 } |
711
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
126 StringBuilder sb = new StringBuilder(unprocessedBuffer.size()); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
127 assert unprocessedBuffer.get(0) == '$'; |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
128 for (int i = 1; i < unprocessedBuffer.size(); i++) { |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
129 char ch = (char) unprocessedBuffer.get(i); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
130 if (ch == ':' || ch == ' ') { |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
131 break; |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
132 } |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
133 sb.append(ch); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
134 } |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
135 final String keyword = sb.toString(); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
136 if (knownKeyword(keyword)) { |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
137 outBuffer = ensureCapacityFor(outBuffer, keyword.length() + (isExpanding ? 200 : 2)); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
138 outBuffer.put((byte) '$'); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
139 outBuffer.put(keyword.getBytes()); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
140 if (isExpanding) { |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
141 outBuffer.put((byte) ':'); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
142 outBuffer.put((byte) ' '); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
143 outBuffer = expandKeywordValue(keyword, outBuffer); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
144 outBuffer.put((byte) ' '); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
145 } |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
146 outBuffer.put((byte) '$'); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
147 } else { |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
148 outBuffer = append(outBuffer, unprocessedBuffer.toByteArray()); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
149 } |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
150 // src part is consumed already, do nothing here, look for next possible kw |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
151 kwBreak = indexOf(src, '$', kwBreak+1, false); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
152 } else { |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
153 // newline => tag without close |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
154 outBuffer = append(outBuffer, unprocessedBuffer.toByteArray()); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
155 kwBreak = indexOf(src, '$', kwBreak+1, false); |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
156 } |
711
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
157 unprocessedBuffer.clear(); |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
158 } |
711
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
159 } while (kwBreak != -1); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
160 if (outBuffer == null) { |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
161 return src; |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
162 } |
711
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
163 outBuffer = ensureCapacityFor(outBuffer, src.remaining()); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
164 outBuffer.put(src); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
165 outBuffer.flip(); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
166 return outBuffer; |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
167 } |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
168 private boolean knownKeyword(String kw) { |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
169 return keywords.containsKey(kw); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
170 } |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
171 |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
172 private static ByteBuffer append(ByteBuffer out, byte[] data) { |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
173 out = ensureCapacityFor(out, data.length); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
174 out.put(data); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
175 return out; |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
176 } |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
177 private static ByteBuffer append(ByteBuffer out, ByteBuffer in, int count) { |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
178 out = ensureCapacityFor(out, count); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
179 while (count-- > 0) { |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
180 out.put(in.get()); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
181 } |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
182 return out; |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
183 } |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
184 private static ByteBuffer ensureCapacityFor(ByteBuffer out, int exansion) { |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
185 if (out == null || out.remaining() < exansion) { |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
186 ByteBuffer newOut = ByteBuffer.allocate(out == null ? exansion*2 : out.capacity() + exansion); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
187 if (out != null) { |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
188 out.flip(); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
189 newOut.put(out); |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
190 } |
711
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
191 return newOut; |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
192 } |
711
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
193 return out; |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
194 } |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
195 |
711
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
196 private ByteBuffer expandKeywordValue(String keyword, ByteBuffer rv) { |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
197 byte[] toInject; |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
198 if ("Id".equals(keyword)) { |
711
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
199 toInject = identityString().getBytes(); |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
200 } else if ("Revision".equals(keyword)) { |
711
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
201 toInject = revision().getBytes(); |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
202 } else if ("Author".equals(keyword)) { |
711
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
203 toInject = username().getBytes(); |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
204 } else if ("Date".equals(keyword)) { |
711
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
205 toInject = date().getBytes(); |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
206 } else { |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
207 throw new IllegalStateException(String.format("Keyword %s is not yet supported", keyword)); |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
208 } |
711
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
209 rv = ensureCapacityFor(rv, toInject.length); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
210 rv.put(toInject); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
211 return rv; |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
212 } |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
213 |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
214 // copies part of the src buffer, [from..to). doesn't modify src position |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
112
diff
changeset
|
215 static void copySlice(ByteBuffer src, int from, int to, ByteBuffer dst) { |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
216 if (to > src.limit()) { |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
217 throw new IllegalArgumentException("Bad right boundary"); |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
218 } |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
219 if (dst.remaining() < to - from) { |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
220 throw new IllegalArgumentException("Not enough room in the destination buffer"); |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
221 } |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
222 for (int i = from; i < to; i++) { |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
223 dst.put(src.get(i)); |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
224 } |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
225 } |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
226 |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
227 private static int indexOf(ByteBuffer b, char ch, int from, boolean newlineBreaks) { |
113
67ae317408c9
Filter implementation for newline translation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
112
diff
changeset
|
228 for (int i = from; i < b.limit(); i++) { |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
229 byte c = b.get(i); |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
230 if (ch == c) { |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
231 return i; |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
232 } |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
233 if (newlineBreaks && (c == '\n' || c == '\r')) { |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
234 return i; |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
235 } |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
236 } |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
237 return -1; |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
238 } |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
239 |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
240 private String identityString() { |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
241 return String.format("%s,v %s %s %s", path, revision(), date(), username()); |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
242 } |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
243 |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
244 private String revision() { |
354
5f9073eabf06
Propagate errors with exceptions up to a end client
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
331
diff
changeset
|
245 try { |
418
528b6780a8bd
A bit of FIXME cleanup (mostly degraded to TODO post 1.0), comments and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
367
diff
changeset
|
246 // TODO post-1.0 Either add cset's nodeid into Changeset class or use own inspector |
528b6780a8bd
A bit of FIXME cleanup (mostly degraded to TODO post 1.0), comments and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
367
diff
changeset
|
247 // when accessing changelog, see below, #getChangeset |
367
2fadf8695f8a
Use 'revision index' instead of the vague 'local revision number' concept in the API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
354
diff
changeset
|
248 int csetRev = repo.getFileNode(path).getChangesetRevisionIndex(HgRepository.TIP); |
354
5f9073eabf06
Propagate errors with exceptions up to a end client
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
331
diff
changeset
|
249 return repo.getChangelog().getRevision(csetRev).shortNotation(); |
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:
418
diff
changeset
|
250 } catch (HgRuntimeException ex) { |
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
|
251 repo.getSessionContext().getLog().dump(getClass(), Error, ex, null); |
354
5f9073eabf06
Propagate errors with exceptions up to a end client
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
331
diff
changeset
|
252 return Nodeid.NULL.shortNotation(); // XXX perhaps, might return anything better? Not sure how hg approaches this. |
5f9073eabf06
Propagate errors with exceptions up to a end client
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
331
diff
changeset
|
253 } |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
254 } |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
255 |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
256 private String username() { |
354
5f9073eabf06
Propagate errors with exceptions up to a end client
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
331
diff
changeset
|
257 try { |
5f9073eabf06
Propagate errors with exceptions up to a end client
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
331
diff
changeset
|
258 return getChangeset().user(); |
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:
418
diff
changeset
|
259 } catch (HgRuntimeException ex) { |
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
|
260 repo.getSessionContext().getLog().dump(getClass(), Error, ex, null); |
354
5f9073eabf06
Propagate errors with exceptions up to a end client
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
331
diff
changeset
|
261 return ""; |
5f9073eabf06
Propagate errors with exceptions up to a end client
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
331
diff
changeset
|
262 } |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
263 } |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
264 |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
265 private String date() { |
354
5f9073eabf06
Propagate errors with exceptions up to a end client
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
331
diff
changeset
|
266 Date d; |
5f9073eabf06
Propagate errors with exceptions up to a end client
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
331
diff
changeset
|
267 try { |
5f9073eabf06
Propagate errors with exceptions up to a end client
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
331
diff
changeset
|
268 d = getChangeset().date(); |
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:
418
diff
changeset
|
269 } catch (HgRuntimeException ex) { |
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
|
270 repo.getSessionContext().getLog().dump(getClass(), Error, ex, null); |
354
5f9073eabf06
Propagate errors with exceptions up to a end client
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
331
diff
changeset
|
271 d = new Date(0l); |
5f9073eabf06
Propagate errors with exceptions up to a end client
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
331
diff
changeset
|
272 } |
5f9073eabf06
Propagate errors with exceptions up to a end client
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
331
diff
changeset
|
273 return String.format("%tY/%<tm/%<td %<tH:%<tM:%<tS", d); |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
274 } |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
275 |
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:
418
diff
changeset
|
276 private RawChangeset getChangeset() throws HgRuntimeException { |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
277 if (latestFileCset == null) { |
418
528b6780a8bd
A bit of FIXME cleanup (mostly degraded to TODO post 1.0), comments and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
367
diff
changeset
|
278 // TODO post-1.0 Use of TIP is likely incorrect in cases when working copy is not based |
528b6780a8bd
A bit of FIXME cleanup (mostly degraded to TODO post 1.0), comments and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
367
diff
changeset
|
279 // on latest revision. Perhaps, a constant like HgRepository.DIRSTATE_PARENT may come handy |
528b6780a8bd
A bit of FIXME cleanup (mostly degraded to TODO post 1.0), comments and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
367
diff
changeset
|
280 // Besides, it's reasonable to pass own inspector instead of implicit use of RawCsetCollector |
528b6780a8bd
A bit of FIXME cleanup (mostly degraded to TODO post 1.0), comments and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
367
diff
changeset
|
281 // to get changeset nodeid/index right away. Also check ChangelogHelper if may be of any use |
367
2fadf8695f8a
Use 'revision index' instead of the vague 'local revision number' concept in the API
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
354
diff
changeset
|
282 int csetRev = repo.getFileNode(path).getChangesetRevisionIndex(HgRepository.TIP); |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
283 latestFileCset = repo.getChangelog().range(csetRev, csetRev).get(0); |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
284 } |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
285 return latestFileCset; |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
286 } |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
287 |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
288 public static class Factory implements Filter.Factory { |
711
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
289 private final Map<String,String> keywords; |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
290 private HgRepository repo; |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
291 private Path.Matcher matcher; |
711
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
292 |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
293 public Factory() { |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
294 keywords = new TreeMap<String,String>(); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
295 keywords.put("Id", "Id"); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
296 keywords.put("Revision", "Revision"); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
297 keywords.put("Author", "Author"); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
298 keywords.put("Date", "Date"); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
299 keywords.put("LastChangedRevision", "LastChangedRevision"); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
300 keywords.put("LastChangedBy", "LastChangedBy"); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
301 keywords.put("LastChangedDate", "LastChangedDate"); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
302 keywords.put("Source", "Source"); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
303 keywords.put("Header", "Header"); |
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
304 } |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
305 |
331
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
154
diff
changeset
|
306 public void initialize(HgRepository hgRepo) { |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
307 repo = hgRepo; |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
308 ArrayList<String> patterns = new ArrayList<String>(); |
331
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
154
diff
changeset
|
309 for (Pair<String,String> e : hgRepo.getConfiguration().getSection("keyword")) { |
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
154
diff
changeset
|
310 if (!"ignore".equalsIgnoreCase(e.second())) { |
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
154
diff
changeset
|
311 patterns.add(e.first()); |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
312 } |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
313 } |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
314 matcher = new PathGlobMatcher(patterns.toArray(new String[patterns.size()])); |
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:
418
diff
changeset
|
315 // TODO post-1.0 read and respect keyword patterns from [keywordmaps] |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
316 } |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
317 |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
318 public Filter create(Path path, Options opts) { |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
319 if (matcher.accept(path)) { |
711
a62079bc422b
Keyword filtering that doesn't depend on input buffer size and the way input lines got split between filter() calls. KewordFilter got state to keep processed suspicious ...$ lines
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
710
diff
changeset
|
320 return new KeywordFilter(repo, path, keywords, opts.getDirection() == Filter.Direction.FromRepo); |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
321 } |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
322 return null; |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
323 } |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
324 } |
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
325 |
114
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
326 // |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
327 // public static void main(String[] args) throws Exception { |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
328 // FileInputStream fis = new FileInputStream(new File("/temp/kwoutput.txt")); |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
329 // FileOutputStream fos = new FileOutputStream(new File("/temp/kwoutput2.txt")); |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
330 // ByteBuffer b = ByteBuffer.allocate(256); |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
331 // KeywordFilter kwFilter = new KeywordFilter(false); |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
332 // while (fis.getChannel().read(b) != -1) { |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
333 // b.flip(); // get ready to be read |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
334 // ByteBuffer f = kwFilter.filter(b); |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
335 // fos.getChannel().write(f); // XXX in fact, f may not be fully consumed |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
336 // if (b.hasRemaining()) { |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
337 // b.compact(); |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
338 // } else { |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
339 // b.clear(); |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
340 // } |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
341 // } |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
342 // fis.close(); |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
343 // fos.flush(); |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
344 // fos.close(); |
46291ec605a0
Filters to read and initialize according to configuration files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
113
diff
changeset
|
345 // } |
112
d488c7638b87
Prototype Filter support with keyword filter as a playground
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
346 } |