source: josm/trunk/src/org/openstreetmap/josm/gui/conflict/tags/RelationMemberConflictResolverModel.java@ 19050

Last change on this file since 19050 was 19050, checked in by taylor.smock, 14 months ago

Revert most var changes from r19048, fix most new compile warnings and checkstyle issues

Also, document why various ErrorProne checks were originally disabled and fix
generic SonarLint issues.
  • Property svn:eol-style set to native
File size: 16.8 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.gui.conflict.tags;
3
4import java.beans.PropertyChangeListener;
5import java.beans.PropertyChangeSupport;
6import java.util.ArrayList;
7import java.util.Collection;
8import java.util.Collections;
9import java.util.HashSet;
10import java.util.Iterator;
11import java.util.LinkedHashMap;
12import java.util.LinkedList;
13import java.util.List;
14import java.util.Map;
15import java.util.Objects;
16import java.util.Set;
17import java.util.TreeSet;
18import java.util.stream.Collectors;
19
20import javax.swing.table.DefaultTableModel;
21
22import org.openstreetmap.josm.command.ChangeMembersCommand;
23import org.openstreetmap.josm.command.Command;
24import org.openstreetmap.josm.data.osm.Node;
25import org.openstreetmap.josm.data.osm.OsmPrimitive;
26import org.openstreetmap.josm.data.osm.Relation;
27import org.openstreetmap.josm.data.osm.RelationMember;
28import org.openstreetmap.josm.data.osm.RelationToChildReference;
29import org.openstreetmap.josm.gui.util.GuiHelper;
30
31/**
32 * This model manages a list of conflicting relation members.
33 *
34 * It can be used as {@link javax.swing.table.TableModel}.
35 */
36public class RelationMemberConflictResolverModel extends DefaultTableModel {
37 /** the property name for the number conflicts managed by this model */
38 public static final String NUM_CONFLICTS_PROP = RelationMemberConflictResolverModel.class.getName() + ".numConflicts";
39
40 /** the list of conflict decisions */
41 protected final transient List<RelationMemberConflictDecision> decisions;
42 /** the collection of relations for which we manage conflicts */
43 protected transient Collection<Relation> relations;
44 /** the collection of primitives for which we manage conflicts */
45 protected transient Collection<? extends OsmPrimitive> primitives;
46 /** the number of conflicts */
47 private int numConflicts;
48 private final PropertyChangeSupport support;
49
50 /**
51 * Replies true if each {@link MultiValueResolutionDecision} is decided.
52 *
53 * @return true if each {@link MultiValueResolutionDecision} is decided; false otherwise
54 */
55 public boolean isResolvedCompletely() {
56 return numConflicts == 0;
57 }
58
59 /**
60 * Replies the current number of conflicts
61 *
62 * @return the current number of conflicts
63 */
64 public int getNumConflicts() {
65 return numConflicts;
66 }
67
68 /**
69 * Updates the current number of conflicts from list of decisions and emits
70 * a property change event if necessary.
71 *
72 */
73 protected void updateNumConflicts() {
74 int oldValue = numConflicts;
75 numConflicts = (int) decisions.stream().filter(decision -> !decision.isDecided()).count();
76 if (numConflicts != oldValue) {
77 support.firePropertyChange(getProperty(), oldValue, numConflicts);
78 }
79 }
80
81 protected String getProperty() {
82 return NUM_CONFLICTS_PROP;
83 }
84
85 public void addPropertyChangeListener(PropertyChangeListener l) {
86 support.addPropertyChangeListener(l);
87 }
88
89 public void removePropertyChangeListener(PropertyChangeListener l) {
90 support.removePropertyChangeListener(l);
91 }
92
93 public RelationMemberConflictResolverModel() {
94 decisions = new ArrayList<>();
95 support = new PropertyChangeSupport(this);
96 }
97
98 @Override
99 public int getRowCount() {
100 return getNumDecisions();
101 }
102
103 @Override
104 public Object getValueAt(int row, int column) {
105 if (decisions == null) return null;
106
107 RelationMemberConflictDecision d = decisions.get(row);
108 switch (column) {
109 case 0: /* relation */ return d.getRelation();
110 case 1: /* pos */ return Integer.toString(d.getPos() + 1); // position in "user space" starting at 1
111 case 2: /* role */ return d.getRole();
112 case 3: /* original */ return d.getOriginalPrimitive();
113 case 4: /* decision keep */ return RelationMemberConflictDecisionType.KEEP == d.getDecision();
114 case 5: /* decision remove */ return RelationMemberConflictDecisionType.REMOVE == d.getDecision();
115 }
116 return null;
117 }
118
119 @Override
120 public void setValueAt(Object value, int row, int column) {
121 RelationMemberConflictDecision d = decisions.get(row);
122 switch (column) {
123 case 2: /* role */
124 d.setRole((String) value);
125 break;
126 case 4: /* decision keep */
127 if (Boolean.TRUE.equals(value)) {
128 d.decide(RelationMemberConflictDecisionType.KEEP);
129 refresh(false);
130 }
131 break;
132 case 5: /* decision remove */
133 if (Boolean.TRUE.equals(value)) {
134 d.decide(RelationMemberConflictDecisionType.REMOVE);
135 refresh(false);
136 }
137 break;
138 default: // Do nothing
139 }
140 fireTableDataChanged();
141 }
142
143 /**
144 * Populates the model with the members of the relation <code>relation</code>
145 * referring to <code>primitive</code>.
146 *
147 * @param relation the parent relation
148 * @param primitive the child primitive
149 */
150 protected void populate(Relation relation, OsmPrimitive primitive) {
151 for (int i = 0; i < relation.getMembersCount(); i++) {
152 if (relation.getMember(i).refersTo(primitive)) {
153 decisions.add(new RelationMemberConflictDecision(relation, i));
154 }
155 }
156 }
157
158 /**
159 * Populates the model with the relation members belonging to one of the relations in <code>relations</code>
160 * and referring to one of the primitives in <code>memberPrimitives</code>.
161 *
162 * @param relations the parent relations. Empty list assumed if null.
163 * @param memberPrimitives the child primitives. Empty list assumed if null.
164 */
165 public void populate(Collection<Relation> relations, Collection<? extends OsmPrimitive> memberPrimitives) {
166 populate(relations, memberPrimitives, true);
167 }
168
169 /**
170 * Populates the model with the relation members belonging to one of the relations in <code>relations</code>
171 * and referring to one of the primitives in <code>memberPrimitives</code>.
172 *
173 * @param relations the parent relations. Empty list assumed if null.
174 * @param memberPrimitives the child primitives. Empty list assumed if null.
175 * @param fireEvent {@code true} to call {@code fireTableDataChanged} (can be a slow operation)
176 * @since 11626
177 */
178 void populate(Collection<Relation> relations, Collection<? extends OsmPrimitive> memberPrimitives, boolean fireEvent) {
179 decisions.clear();
180 relations = relations == null ? Collections.<Relation>emptyList() : relations;
181 memberPrimitives = memberPrimitives == null ? new LinkedList<>() : memberPrimitives;
182 for (Relation r : relations) {
183 for (OsmPrimitive p: memberPrimitives) {
184 populate(r, p);
185 }
186 }
187 this.relations = relations;
188 this.primitives = memberPrimitives;
189 refresh(fireEvent);
190 }
191
192 /**
193 * Populates the model with the relation members represented as a collection of
194 * {@link RelationToChildReference}s.
195 *
196 * @param references the references. Empty list assumed if null.
197 */
198 public void populate(Collection<RelationToChildReference> references) {
199 references = references == null ? new LinkedList<>() : references;
200 decisions.clear();
201 this.relations = new HashSet<>(references.size());
202 final Collection<OsmPrimitive> newPrimitives = new HashSet<>();
203 for (RelationToChildReference reference: references) {
204 decisions.add(new RelationMemberConflictDecision(reference.getParent(), reference.getPosition()));
205 relations.add(reference.getParent());
206 newPrimitives.add(reference.getChild());
207 }
208 this.primitives = newPrimitives;
209 refresh();
210 }
211
212 /**
213 * Prepare the default decisions for the current model.
214 *
215 * Keep/delete decisions are made if every member has the same role and the members are in consecutive order within the relation.
216 * For multiple occurrences those conditions are tested stepwise for each occurrence.
217 */
218 public void prepareDefaultRelationDecisions() {
219 prepareDefaultRelationDecisions(true);
220 }
221
222 /**
223 * Prepare the default decisions for the current model.
224 *
225 * Keep/delete decisions are made if every member has the same role and the members are in consecutive order within the relation.
226 * For multiple occurrences those conditions are tested stepwise for each occurrence.
227 *
228 * @param fireEvent {@code true} to call {@code fireTableDataChanged} (can be a slow operation)
229 * @since 11626
230 */
231 void prepareDefaultRelationDecisions(boolean fireEvent) {
232 if (primitives.stream().allMatch(Node.class::isInstance)) {
233 final Collection<OsmPrimitive> primitivesInDecisions = decisions.stream()
234 .map(RelationMemberConflictDecision::getOriginalPrimitive)
235 .collect(Collectors.toSet());
236 if (primitivesInDecisions.size() == 1) {
237 for (final RelationMemberConflictDecision i : decisions) {
238 i.decide(RelationMemberConflictDecisionType.KEEP);
239 }
240 refresh();
241 return;
242 }
243 }
244
245 for (final Relation relation : relations) {
246 final Map<OsmPrimitive, List<RelationMemberConflictDecision>> decisionsByPrimitive = new LinkedHashMap<>(primitives.size(), 1);
247 for (final RelationMemberConflictDecision decision : decisions) {
248 if (decision.getRelation() == relation) {
249 final OsmPrimitive primitive = decision.getOriginalPrimitive();
250 if (!decisionsByPrimitive.containsKey(primitive)) {
251 decisionsByPrimitive.put(primitive, new ArrayList<>());
252 }
253 decisionsByPrimitive.get(primitive).add(decision);
254 }
255 }
256
257 //noinspection StatementWithEmptyBody
258 if (!decisionsByPrimitive.keySet().containsAll(primitives)) {
259 // some primitives are not part of the relation, leave undecided
260 } else {
261 final Collection<Iterator<RelationMemberConflictDecision>> iterators = decisionsByPrimitive.values().stream()
262 .map(List::iterator)
263 .collect(Collectors.toList());
264 while (iterators.stream().allMatch(Iterator::hasNext)) {
265 final List<RelationMemberConflictDecision> conflictDecisions = new ArrayList<>();
266 final Collection<String> roles = new HashSet<>();
267 final Collection<Integer> indices = new TreeSet<>();
268 for (Iterator<RelationMemberConflictDecision> it : iterators) {
269 final RelationMemberConflictDecision decision = it.next();
270 conflictDecisions.add(decision);
271 roles.add(decision.getRole());
272 indices.add(decision.getPos());
273 }
274 if (roles.size() != 1 || !isCollectionOfConsecutiveNumbers(indices)) {
275 // roles do not match or not consecutive members in relation, leave undecided
276 continue;
277 }
278 conflictDecisions.get(0).decide(RelationMemberConflictDecisionType.KEEP);
279 for (RelationMemberConflictDecision decision : conflictDecisions.subList(1, conflictDecisions.size())) {
280 decision.decide(RelationMemberConflictDecisionType.REMOVE);
281 }
282 }
283 }
284 }
285
286 refresh(fireEvent);
287 }
288
289 static boolean isCollectionOfConsecutiveNumbers(Collection<Integer> numbers) {
290 if (numbers.isEmpty()) {
291 return true;
292 }
293 final Iterator<Integer> it = numbers.iterator();
294 Integer previousValue = it.next();
295 while (it.hasNext()) {
296 final Integer i = it.next();
297 if (previousValue + 1 != i) {
298 return false;
299 }
300 previousValue = i;
301 }
302 return true;
303 }
304
305 /**
306 * Replies the decision at position <code>row</code>
307 *
308 * @param row position
309 * @return the decision at position <code>row</code>
310 */
311 public RelationMemberConflictDecision getDecision(int row) {
312 return decisions.get(row);
313 }
314
315 /**
316 * Replies the number of decisions managed by this model
317 *
318 * @return the number of decisions managed by this model
319 */
320 public int getNumDecisions() {
321 return decisions == null /* accessed via super constructor */ ? 0 : decisions.size();
322 }
323
324 /**
325 * Refreshes the model state. Invoke this method to trigger necessary change
326 * events after an update of the model data.
327 *
328 */
329 public void refresh() {
330 refresh(true);
331 }
332
333 /**
334 * Refreshes the model state. Invoke this method to trigger necessary change
335 * events after an update of the model data.
336 * @param fireEvent {@code true} to call {@code fireTableDataChanged} (can be a slow operation)
337 * @since 11626
338 */
339 void refresh(boolean fireEvent) {
340 updateNumConflicts();
341 if (fireEvent) {
342 GuiHelper.runInEDTAndWait(this::fireTableDataChanged);
343 }
344 }
345
346 /**
347 * Apply a role to all member managed by this model.
348 *
349 * @param role the role. Empty string assumed if null.
350 */
351 public void applyRole(String role) {
352 role = role == null ? "" : role;
353 for (RelationMemberConflictDecision decision : decisions) {
354 decision.setRole(role);
355 }
356 refresh();
357 }
358
359 protected RelationMemberConflictDecision getDecision(Relation relation, int pos) {
360 return decisions.stream()
361 .filter(decision -> decision.matches(relation, pos))
362 .findFirst().orElse(null);
363 }
364
365 protected Command buildResolveCommand(Relation relation, OsmPrimitive newPrimitive) {
366 List<RelationMember> modifiedMemberList = new ArrayList<>();
367 boolean isChanged = false;
368 for (int i = 0; i < relation.getMembersCount(); i++) {
369 final RelationMember member = relation.getMember(i);
370 RelationMemberConflictDecision decision = getDecision(relation, i);
371 if (decision == null) {
372 modifiedMemberList.add(member);
373 } else {
374 switch (decision.getDecision()) {
375 case KEEP:
376 final RelationMember newMember = new RelationMember(decision.getRole(), newPrimitive);
377 modifiedMemberList.add(newMember);
378 isChanged |= !member.equals(newMember);
379 break;
380 case REMOVE:
381 isChanged = true;
382 // do nothing
383 break;
384 case UNDECIDED:
385 // FIXME: this is an error
386 break;
387 }
388 }
389 }
390 return isChanged ? new ChangeMembersCommand(relation, modifiedMemberList) : null;
391 }
392
393 /**
394 * Builds a collection of commands executing the decisions made in this model.
395 *
396 * @param newPrimitive the primitive which members shall refer to
397 * @return a list of commands
398 */
399 public List<Command> buildResolutionCommands(OsmPrimitive newPrimitive) {
400 return relations.stream()
401 .map(relation -> buildResolveCommand(relation, newPrimitive))
402 .filter(Objects::nonNull)
403 .collect(Collectors.toList());
404 }
405
406 protected boolean isChanged(Relation relation, OsmPrimitive newPrimitive) {
407 for (int i = 0; i < relation.getMembersCount(); i++) {
408 RelationMemberConflictDecision decision = getDecision(relation, i);
409 if (decision == null) {
410 continue;
411 }
412 switch (decision.getDecision()) {
413 case REMOVE: return true;
414 case KEEP:
415 if (!relation.getMember(i).getRole().equals(decision.getRole()))
416 return true;
417 if (relation.getMember(i).getMember() != newPrimitive)
418 return true;
419 break;
420 case UNDECIDED:
421 // FIXME: handle error
422 }
423 }
424 return false;
425 }
426
427 /**
428 * Replies the set of relations which have to be modified according
429 * to the decisions managed by this model.
430 *
431 * @param newPrimitive the primitive which members shall refer to
432 *
433 * @return the set of relations which have to be modified according
434 * to the decisions managed by this model
435 */
436 public Set<Relation> getModifiedRelations(OsmPrimitive newPrimitive) {
437 return relations.stream()
438 .filter(relation -> isChanged(relation, newPrimitive))
439 .collect(Collectors.toSet());
440 }
441}
Note: See TracBrowser for help on using the repository browser.