Mercurial > hg4j

annotate src/org/tmatesoft/hg/internal/KeywordFilter.java @ 711:a62079bc422b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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
author Artem Tikhomirov <tikhomirov.artem@gmail.com>
date Fri, 11 Oct 2013 21:35:41 +0200
parents cf200271439a
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 }