1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
|
/*
* Copyright 2000-2014 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.intellij.openapi.vcs.versionBrowser;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.util.*;
import com.intellij.util.text.SyncDateFormat;
import org.jdom.Element;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.text.DateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
public class ChangeBrowserSettings implements JDOMExternalizable {
public interface Filter {
boolean accepts(CommittedChangeList change);
}
public static final String HEAD = "HEAD";
public static final SyncDateFormat DATE_FORMAT = new SyncDateFormat(DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG));
private static final Logger LOG = Logger.getInstance(ChangeBrowserSettings.class);
public boolean USE_DATE_BEFORE_FILTER = false;
public boolean USE_DATE_AFTER_FILTER = false;
public boolean USE_CHANGE_BEFORE_FILTER = false;
public boolean USE_CHANGE_AFTER_FILTER = false;
public String DATE_BEFORE = "";
public String DATE_AFTER = "";
public String CHANGE_BEFORE = "";
public String CHANGE_AFTER = "";
public boolean USE_USER_FILTER = false;
public String USER = "";
public boolean STOP_ON_COPY = false;
public void readExternal(Element element) throws InvalidDataException {
DefaultJDOMExternalizer.readExternal(this, element);
}
public void writeExternal(Element element) throws WriteExternalException {
DefaultJDOMExternalizer.writeExternal(this, element);
}
@Nullable
private static Date parseDate(@Nullable String dateStr) {
if (dateStr == null || dateStr.isEmpty()) return null;
try {
return DATE_FORMAT.parse(dateStr);
}
catch (Exception e) {
LOG.warn(e);
return null;
}
}
public void setDateBefore(@Nullable Date value) {
DATE_BEFORE = value == null ? null : DATE_FORMAT.format(value);
}
@Nullable
public Date getDateBefore() {
return parseDate(DATE_BEFORE);
}
@Nullable
public Date getDateAfter() {
return parseDate(DATE_AFTER);
}
@Nullable
public Long getChangeBeforeFilter() {
if (USE_CHANGE_BEFORE_FILTER && CHANGE_BEFORE.length() > 0) {
if (HEAD.equals(CHANGE_BEFORE)) return null;
return Long.parseLong(CHANGE_BEFORE);
}
return null;
}
@Nullable
public Date getDateBeforeFilter() {
return USE_DATE_BEFORE_FILTER ? parseDate(DATE_BEFORE) : null;
}
@Nullable
public Long getChangeAfterFilter() {
if (USE_CHANGE_AFTER_FILTER && CHANGE_AFTER.length() > 0) {
return Long.parseLong(CHANGE_AFTER);
}
return null;
}
@Nullable
public Date getDateAfterFilter() {
return USE_DATE_AFTER_FILTER ? parseDate(DATE_AFTER) : null;
}
public void setDateAfter(@Nullable Date value) {
DATE_AFTER = value == null ? null : DATE_FORMAT.format(value);
}
@NotNull
protected List<Filter> createFilters() {
final ArrayList<Filter> result = new ArrayList<Filter>();
addDateFilter(USE_DATE_BEFORE_FILTER, getDateBefore(), result, true);
addDateFilter(USE_DATE_AFTER_FILTER, getDateAfter(), result, false);
if (USE_CHANGE_BEFORE_FILTER) {
try {
final long numBefore = Long.parseLong(CHANGE_BEFORE);
result.add(new Filter() {
public boolean accepts(CommittedChangeList change) {
return change.getNumber() <= numBefore;
}
});
}
catch (NumberFormatException e) {
//ignore
LOG.info(e);
}
}
if (USE_CHANGE_AFTER_FILTER) {
try {
final long numAfter = Long.parseLong(CHANGE_AFTER);
result.add(new Filter() {
public boolean accepts(CommittedChangeList change) {
return change.getNumber() >= numAfter;
}
});
}
catch (NumberFormatException e) {
//ignore
LOG.info(e);
}
}
if (USE_USER_FILTER) {
result.add(new Filter() {
public boolean accepts(CommittedChangeList change) {
return Comparing.equal(change.getCommitterName(), USER, false);
}
});
}
return result;
}
private static void addDateFilter(final boolean useFilter, final Date date, final ArrayList<Filter> result, final boolean before) {
if (useFilter) {
assert date != null;
result.add(new Filter() {
public boolean accepts(CommittedChangeList change) {
final Date changeDate = change.getCommitDate();
if (changeDate == null) return false;
return before ? changeDate.before(date) : changeDate.after(date);
}
});
}
}
@NotNull
public Filter createFilter() {
final List<Filter> filters = createFilters();
return new Filter() {
public boolean accepts(CommittedChangeList change) {
for (Filter filter : filters) {
if (!filter.accepts(change)) return false;
}
return true;
}
};
}
public void filterChanges(@NotNull List<? extends CommittedChangeList> changeListInfos) {
Filter filter = createFilter();
for (Iterator<? extends CommittedChangeList> iterator = changeListInfos.iterator(); iterator.hasNext();) {
CommittedChangeList changeListInfo = iterator.next();
if (!filter.accepts(changeListInfo)) {
iterator.remove();
}
}
}
@Nullable
public String getUserFilter() {
return USE_USER_FILTER ? USER : null;
}
public boolean isAnyFilterSpecified() {
return USE_CHANGE_AFTER_FILTER || USE_CHANGE_BEFORE_FILTER || USE_DATE_AFTER_FILTER || USE_DATE_BEFORE_FILTER ||
isNonDateFilterSpecified();
}
public boolean isNonDateFilterSpecified() {
return USE_USER_FILTER;
}
}
|
