source: josm/trunk/src/org/openstreetmap/josm/gui/history/HistoryBrowserModel.java@ 13202

Last change on this file since 13202 was 13202, checked in by Don-vip, 6 years ago

update to PMD 6.0.0
  • Property svn:eol-style set to native
File size: 26.2 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.gui.history;
3
4import static org.openstreetmap.josm.tools.I18n.tr;
5
6import java.util.HashSet;
7import java.util.Set;
8
9import javax.swing.JTable;
10import javax.swing.table.TableModel;
11
12import org.openstreetmap.josm.Main;
13import org.openstreetmap.josm.data.UserIdentityManager;
14import org.openstreetmap.josm.data.osm.Node;
15import org.openstreetmap.josm.data.osm.OsmPrimitive;
16import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
17import org.openstreetmap.josm.data.osm.Relation;
18import org.openstreetmap.josm.data.osm.RelationMember;
19import org.openstreetmap.josm.data.osm.RelationMemberData;
20import org.openstreetmap.josm.data.osm.User;
21import org.openstreetmap.josm.data.osm.UserInfo;
22import org.openstreetmap.josm.data.osm.Way;
23import org.openstreetmap.josm.data.osm.event.AbstractDatasetChangedEvent;
24import org.openstreetmap.josm.data.osm.event.DataChangedEvent;
25import org.openstreetmap.josm.data.osm.event.DataSetListener;
26import org.openstreetmap.josm.data.osm.event.NodeMovedEvent;
27import org.openstreetmap.josm.data.osm.event.PrimitivesAddedEvent;
28import org.openstreetmap.josm.data.osm.event.PrimitivesRemovedEvent;
29import org.openstreetmap.josm.data.osm.event.RelationMembersChangedEvent;
30import org.openstreetmap.josm.data.osm.event.TagsChangedEvent;
31import org.openstreetmap.josm.data.osm.event.WayNodesChangedEvent;
32import org.openstreetmap.josm.data.osm.history.History;
33import org.openstreetmap.josm.data.osm.history.HistoryNode;
34import org.openstreetmap.josm.data.osm.history.HistoryOsmPrimitive;
35import org.openstreetmap.josm.data.osm.history.HistoryRelation;
36import org.openstreetmap.josm.data.osm.history.HistoryWay;
37import org.openstreetmap.josm.data.osm.visitor.OsmPrimitiveVisitor;
38import org.openstreetmap.josm.gui.MainApplication;
39import org.openstreetmap.josm.gui.layer.Layer;
40import org.openstreetmap.josm.gui.layer.MainLayerManager.ActiveLayerChangeEvent;
41import org.openstreetmap.josm.gui.layer.MainLayerManager.ActiveLayerChangeListener;
42import org.openstreetmap.josm.gui.layer.OsmDataLayer;
43import org.openstreetmap.josm.gui.util.ChangeNotifier;
44import org.openstreetmap.josm.tools.CheckParameterUtil;
45import org.openstreetmap.josm.tools.Logging;
46
47/**
48 * This is the model used by the history browser.
49 *
50 * The model state consists of the following elements:
51 * <ul>
52 * <li>the {@link History} of a specific {@link OsmPrimitive}</li>
53 * <li>a dedicated version in this {@link History} called the {@link PointInTimeType#REFERENCE_POINT_IN_TIME}</li>
54 * <li>another version in this {@link History} called the {@link PointInTimeType#CURRENT_POINT_IN_TIME}</li>
55 * </ul>
56 * {@link HistoryBrowser} always compares the {@link PointInTimeType#REFERENCE_POINT_IN_TIME} with the
57 * {@link PointInTimeType#CURRENT_POINT_IN_TIME}.
58
59 * This model provides various {@link TableModel}s for {@link JTable}s used in {@link HistoryBrowser}, for
60 * instance:
61 * <ul>
62 * <li>{@link #getTagTableModel(PointInTimeType)} replies a {@link TableModel} for the tags of either of
63 * the two selected versions</li>
64 * <li>{@link #getNodeListTableModel(PointInTimeType)} replies a {@link TableModel} for the list of nodes of
65 * the two selected versions (if the current history provides information about a {@link Way}</li>
66 * <li> {@link #getRelationMemberTableModel(PointInTimeType)} replies a {@link TableModel} for the list of relation
67 * members of the two selected versions (if the current history provides information about a {@link Relation}</li>
68 * </ul>
69 *
70 * @see HistoryBrowser
71 */
72public class HistoryBrowserModel extends ChangeNotifier implements ActiveLayerChangeListener, DataSetListener {
73 /** the history of an OsmPrimitive */
74 private History history;
75 private HistoryOsmPrimitive reference;
76 private HistoryOsmPrimitive current;
77 /**
78 * latest isn't a reference of history. It's a clone of the currently edited
79 * {@link OsmPrimitive} in the current edit layer.
80 */
81 private HistoryOsmPrimitive latest;
82
83 private final VersionTableModel versionTableModel;
84 private final TagTableModel currentTagTableModel;
85 private final TagTableModel referenceTagTableModel;
86 private final DiffTableModel currentRelationMemberTableModel;
87 private final DiffTableModel referenceRelationMemberTableModel;
88 private final DiffTableModel referenceNodeListTableModel;
89 private final DiffTableModel currentNodeListTableModel;
90
91 /**
92 * constructor
93 */
94 public HistoryBrowserModel() {
95 versionTableModel = new VersionTableModel(this);
96 currentTagTableModel = new TagTableModel(this, PointInTimeType.CURRENT_POINT_IN_TIME);
97 referenceTagTableModel = new TagTableModel(this, PointInTimeType.REFERENCE_POINT_IN_TIME);
98 referenceNodeListTableModel = new DiffTableModel();
99 currentNodeListTableModel = new DiffTableModel();
100 currentRelationMemberTableModel = new DiffTableModel();
101 referenceRelationMemberTableModel = new DiffTableModel();
102
103 if (Main.main != null) {
104 OsmDataLayer editLayer = MainApplication.getLayerManager().getEditLayer();
105 if (editLayer != null) {
106 editLayer.data.addDataSetListener(this);
107 }
108 }
109 MainApplication.getLayerManager().addActiveLayerChangeListener(this);
110 }
111
112 /**
113 * Creates a new history browser model for a given history.
114 *
115 * @param history the history. Must not be null.
116 * @throws IllegalArgumentException if history is null
117 */
118 public HistoryBrowserModel(History history) {
119 this();
120 CheckParameterUtil.ensureParameterNotNull(history, "history");
121 setHistory(history);
122 }
123
124 /**
125 * replies the history managed by this model
126 * @return the history
127 */
128 public History getHistory() {
129 return history;
130 }
131
132 private boolean canShowAsLatest(OsmPrimitive primitive) {
133 if (primitive == null)
134 return false;
135 if (primitive.isNew() || !primitive.isUsable())
136 return false;
137
138 //try creating a history primitive. if that fails, the primitive cannot be used.
139 try {
140 HistoryOsmPrimitive.forOsmPrimitive(primitive);
141 } catch (IllegalArgumentException ign) {
142 Logging.trace(ign);
143 return false;
144 }
145
146 if (history == null)
147 return false;
148 // only show latest of the same version if it is modified
149 if (history.getByVersion(primitive.getVersion()) != null)
150 return primitive.isModified();
151
152 // if latest version from history is higher than a non existing primitive version,
153 // that means this version has been redacted and the primitive cannot be used.
154 return history.getLatest().getVersion() <= primitive.getVersion();
155
156 // latest has a higher version than one of the primitives
157 // in the history (probably because the history got out of sync
158 // with uploaded data) -> show the primitive as latest
159 }
160
161 /**
162 * sets the history to be managed by this model
163 *
164 * @param history the history
165 *
166 */
167 public void setHistory(History history) {
168 this.history = history;
169 if (history.getNumVersions() > 0) {
170 HistoryOsmPrimitive newLatest = null;
171 OsmDataLayer editLayer = MainApplication.getLayerManager().getEditLayer();
172 if (editLayer != null) {
173 OsmPrimitive p = editLayer.data.getPrimitiveById(history.getId(), history.getType());
174 if (canShowAsLatest(p)) {
175 newLatest = new HistoryPrimitiveBuilder().build(p);
176 }
177 }
178 if (newLatest == null) {
179 current = history.getLatest();
180 int prevIndex = history.getNumVersions() - 2;
181 reference = prevIndex < 0 ? history.getEarliest() : history.get(prevIndex);
182 } else {
183 reference = history.getLatest();
184 current = newLatest;
185 }
186 setLatest(newLatest);
187 }
188 initTagTableModels();
189 fireModelChange();
190 }
191
192 private void fireModelChange() {
193 initNodeListTableModels();
194 initMemberListTableModels();
195 fireStateChanged();
196 versionTableModel.fireTableDataChanged();
197 }
198
199 /**
200 * Replies the table model to be used in a {@link JTable} which
201 * shows the list of versions in this history.
202 *
203 * @return the table model
204 */
205 public VersionTableModel getVersionTableModel() {
206 return versionTableModel;
207 }
208
209 private void initTagTableModels() {
210 currentTagTableModel.initKeyList();
211 referenceTagTableModel.initKeyList();
212 }
213
214 /**
215 * Should be called everytime either reference of current changes to update the diff.
216 * TODO: Maybe rename to reflect this? eg. updateNodeListTableModels
217 */
218 private void initNodeListTableModels() {
219 if (current == null || current.getType() != OsmPrimitiveType.WAY
220 || reference == null || reference.getType() != OsmPrimitiveType.WAY)
221 return;
222 TwoColumnDiff diff = new TwoColumnDiff(
223 ((HistoryWay) reference).getNodes().toArray(),
224 ((HistoryWay) current).getNodes().toArray());
225 referenceNodeListTableModel.setRows(diff.referenceDiff, diff.referenceReversed);
226 currentNodeListTableModel.setRows(diff.currentDiff, false);
227 }
228
229 private void initMemberListTableModels() {
230 if (current == null || current.getType() != OsmPrimitiveType.RELATION
231 || reference == null || reference.getType() != OsmPrimitiveType.RELATION)
232 return;
233 TwoColumnDiff diff = new TwoColumnDiff(
234 ((HistoryRelation) reference).getMembers().toArray(),
235 ((HistoryRelation) current).getMembers().toArray());
236 referenceRelationMemberTableModel.setRows(diff.referenceDiff, diff.referenceReversed);
237 currentRelationMemberTableModel.setRows(diff.currentDiff, false);
238 }
239
240 /**
241 * Replies the tag table model for the respective point in time.
242 *
243 * @param pointInTimeType the type of the point in time (must not be null)
244 * @return the tag table model
245 * @throws IllegalArgumentException if pointInTimeType is null
246 */
247 public TagTableModel getTagTableModel(PointInTimeType pointInTimeType) {
248 CheckParameterUtil.ensureParameterNotNull(pointInTimeType, "pointInTimeType");
249 if (pointInTimeType.equals(PointInTimeType.CURRENT_POINT_IN_TIME))
250 return currentTagTableModel;
251 else // REFERENCE_POINT_IN_TIME
252 return referenceTagTableModel;
253 }
254
255 /**
256 * Replies the node list table model for the respective point in time.
257 *
258 * @param pointInTimeType the type of the point in time (must not be null)
259 * @return the node list table model
260 * @throws IllegalArgumentException if pointInTimeType is null
261 */
262 public DiffTableModel getNodeListTableModel(PointInTimeType pointInTimeType) {
263 CheckParameterUtil.ensureParameterNotNull(pointInTimeType, "pointInTimeType");
264 if (pointInTimeType.equals(PointInTimeType.CURRENT_POINT_IN_TIME))
265 return currentNodeListTableModel;
266 else // REFERENCE_POINT_IN_TIME
267 return referenceNodeListTableModel;
268 }
269
270 /**
271 * Replies the relation member table model for the respective point in time.
272 *
273 * @param pointInTimeType the type of the point in time (must not be null)
274 * @return the relation member table model
275 * @throws IllegalArgumentException if pointInTimeType is null
276 */
277 public DiffTableModel getRelationMemberTableModel(PointInTimeType pointInTimeType) {
278 CheckParameterUtil.ensureParameterNotNull(pointInTimeType, "pointInTimeType");
279 if (pointInTimeType.equals(PointInTimeType.CURRENT_POINT_IN_TIME))
280 return currentRelationMemberTableModel;
281 else // REFERENCE_POINT_IN_TIME
282 return referenceRelationMemberTableModel;
283 }
284
285 /**
286 * Sets the {@link HistoryOsmPrimitive} which plays the role of a reference point
287 * in time (see {@link PointInTimeType}).
288 *
289 * @param reference the reference history primitive. Must not be null.
290 * @throws IllegalArgumentException if reference is null
291 * @throws IllegalStateException if this model isn't a assigned a history yet
292 * @throws IllegalArgumentException if reference isn't an history primitive for the history managed by this mode
293 *
294 * @see #setHistory(History)
295 * @see PointInTimeType
296 */
297 public void setReferencePointInTime(HistoryOsmPrimitive reference) {
298 CheckParameterUtil.ensureParameterNotNull(reference, "reference");
299 if (history == null)
300 throw new IllegalStateException(tr("History not initialized yet. Failed to set reference primitive."));
301 if (reference.getId() != history.getId())
302 throw new IllegalArgumentException(
303 tr("Failed to set reference. Reference ID {0} does not match history ID {1}.", reference.getId(), history.getId()));
304 if (history.getByVersion(reference.getVersion()) == null)
305 throw new IllegalArgumentException(
306 tr("Failed to set reference. Reference version {0} not available in history.", reference.getVersion()));
307
308 this.reference = reference;
309 initTagTableModels();
310 initNodeListTableModels();
311 initMemberListTableModels();
312 fireStateChanged();
313 }
314
315 /**
316 * Sets the {@link HistoryOsmPrimitive} which plays the role of the current point
317 * in time (see {@link PointInTimeType}).
318 *
319 * @param current the reference history primitive. Must not be {@code null}.
320 * @throws IllegalArgumentException if reference is {@code null}
321 * @throws IllegalStateException if this model isn't a assigned a history yet
322 * @throws IllegalArgumentException if reference isn't an history primitive for the history managed by this mode
323 *
324 * @see #setHistory(History)
325 * @see PointInTimeType
326 */
327 public void setCurrentPointInTime(HistoryOsmPrimitive current) {
328 CheckParameterUtil.ensureParameterNotNull(current, "current");
329 if (history == null)
330 throw new IllegalStateException(tr("History not initialized yet. Failed to set current primitive."));
331 if (current.getId() != history.getId())
332 throw new IllegalArgumentException(
333 tr("Failed to set reference. Reference ID {0} does not match history ID {1}.", current.getId(), history.getId()));
334 if (history.getByVersion(current.getVersion()) == null)
335 throw new IllegalArgumentException(
336 tr("Failed to set current primitive. Current version {0} not available in history.", current.getVersion()));
337 this.current = current;
338 initTagTableModels();
339 initNodeListTableModels();
340 initMemberListTableModels();
341 fireStateChanged();
342 }
343
344 /**
345 * Replies the history OSM primitive for the {@link PointInTimeType#CURRENT_POINT_IN_TIME}
346 *
347 * @return the history OSM primitive for the {@link PointInTimeType#CURRENT_POINT_IN_TIME} (may be null)
348 */
349 public HistoryOsmPrimitive getCurrentPointInTime() {
350 return getPointInTime(PointInTimeType.CURRENT_POINT_IN_TIME);
351 }
352
353 /**
354 * Replies the history OSM primitive for the {@link PointInTimeType#REFERENCE_POINT_IN_TIME}
355 *
356 * @return the history OSM primitive for the {@link PointInTimeType#REFERENCE_POINT_IN_TIME} (may be null)
357 */
358 public HistoryOsmPrimitive getReferencePointInTime() {
359 return getPointInTime(PointInTimeType.REFERENCE_POINT_IN_TIME);
360 }
361
362 /**
363 * replies the history OSM primitive for a given point in time
364 *
365 * @param type the type of the point in time (must not be null)
366 * @return the respective primitive. Can be null.
367 * @throws IllegalArgumentException if type is null
368 */
369 public HistoryOsmPrimitive getPointInTime(PointInTimeType type) {
370 CheckParameterUtil.ensureParameterNotNull(type, "type");
371 if (type.equals(PointInTimeType.CURRENT_POINT_IN_TIME))
372 return current;
373 else if (type.equals(PointInTimeType.REFERENCE_POINT_IN_TIME))
374 return reference;
375
376 // should not happen
377 return null;
378 }
379
380 /**
381 * Returns true if <code>primitive</code> is the latest primitive
382 * representing the version currently edited in the current data layer.
383 *
384 * @param primitive the primitive to check
385 * @return true if <code>primitive</code> is the latest primitive
386 */
387 public boolean isLatest(HistoryOsmPrimitive primitive) {
388 return primitive != null && primitive == latest;
389 }
390
391 /**
392 * Sets the reference point in time to the given row.
393 * @param row row number
394 */
395 public void setReferencePointInTime(int row) {
396 if (history == null)
397 return;
398 if (row == history.getNumVersions()) {
399 if (latest != null) {
400 setReferencePointInTime(latest);
401 }
402 return;
403 }
404 if (row < 0 || row > history.getNumVersions())
405 return;
406 setReferencePointInTime(history.get(row));
407 }
408
409 /**
410 * Sets the current point in time to the given row.
411 * @param row row number
412 */
413 public void setCurrentPointInTime(int row) {
414 if (history == null)
415 return;
416 if (row == history.getNumVersions()) {
417 if (latest != null) {
418 setCurrentPointInTime(latest);
419 }
420 return;
421 }
422 if (row < 0 || row > history.getNumVersions())
423 return;
424 setCurrentPointInTime(history.get(row));
425 }
426
427 /**
428 * Determines if the given row is the reference point in time.
429 * @param row row number
430 * @return {@code true} if the given row is the reference point in time
431 */
432 public boolean isReferencePointInTime(int row) {
433 if (history == null)
434 return false;
435 if (row == history.getNumVersions())
436 return latest == reference;
437 if (row < 0 || row > history.getNumVersions())
438 return false;
439 return history.get(row) == reference;
440 }
441
442 /**
443 * Determines if the given row is the current point in time.
444 * @param row row number
445 * @return {@code true} if the given row is the current point in time
446 */
447 public boolean isCurrentPointInTime(int row) {
448 if (history == null)
449 return false;
450 if (row == history.getNumVersions())
451 return latest == current;
452 if (row < 0 || row > history.getNumVersions())
453 return false;
454 return history.get(row) == current;
455 }
456
457 /**
458 * Returns the {@code HistoryPrimitive} at the given row.
459 * @param row row number
460 * @return the {@code HistoryPrimitive} at the given row
461 */
462 public HistoryOsmPrimitive getPrimitive(int row) {
463 if (history == null)
464 return null;
465 return isLatest(row) ? latest : history.get(row);
466 }
467
468 /**
469 * Determines if the given row is the latest.
470 * @param row row number
471 * @return {@code true} if the given row is the latest
472 */
473 public boolean isLatest(int row) {
474 return row >= history.getNumVersions();
475 }
476
477 /**
478 * Returns the latest {@code HistoryOsmPrimitive}.
479 * @return the latest {@code HistoryOsmPrimitive}
480 * @since 11646
481 */
482 public HistoryOsmPrimitive getLatest() {
483 return latest;
484 }
485
486 /**
487 * Returns the key set (union of current and reference point in type key sets).
488 * @return the key set (union of current and reference point in type key sets)
489 * @since 11647
490 */
491 public Set<String> getKeySet() {
492 Set<String> keySet = new HashSet<>();
493 if (current != null) {
494 keySet.addAll(current.getTags().keySet());
495 }
496 if (reference != null) {
497 keySet.addAll(reference.getTags().keySet());
498 }
499 return keySet;
500 }
501
502 /**
503 * Sets the latest {@code HistoryOsmPrimitive}.
504 * @param latest the latest {@code HistoryOsmPrimitive}
505 */
506 protected void setLatest(HistoryOsmPrimitive latest) {
507 if (latest == null) {
508 if (this.current == this.latest) {
509 this.current = history != null ? history.getLatest() : null;
510 }
511 if (this.reference == this.latest) {
512 this.reference = history != null ? history.getLatest() : null;
513 }
514 this.latest = null;
515 } else {
516 if (this.current == this.latest) {
517 this.current = latest;
518 }
519 if (this.reference == this.latest) {
520 this.reference = latest;
521 }
522 this.latest = latest;
523 }
524 fireModelChange();
525 }
526
527 /**
528 * Removes this model as listener for data change and layer change events.
529 *
530 */
531 public void unlinkAsListener() {
532 OsmDataLayer editLayer = MainApplication.getLayerManager().getEditLayer();
533 if (editLayer != null) {
534 editLayer.data.removeDataSetListener(this);
535 }
536 MainApplication.getLayerManager().removeActiveLayerChangeListener(this);
537 }
538
539 /* ---------------------------------------------------------------------- */
540 /* DataSetListener */
541 /* ---------------------------------------------------------------------- */
542 @Override
543 public void nodeMoved(NodeMovedEvent event) {
544 Node node = event.getNode();
545 if (!node.isNew() && node.getId() == history.getId()) {
546 setLatest(new HistoryPrimitiveBuilder().build(node));
547 }
548 }
549
550 @Override
551 public void primitivesAdded(PrimitivesAddedEvent event) {
552 for (OsmPrimitive p: event.getPrimitives()) {
553 if (canShowAsLatest(p)) {
554 setLatest(new HistoryPrimitiveBuilder().build(p));
555 }
556 }
557 }
558
559 @Override
560 public void primitivesRemoved(PrimitivesRemovedEvent event) {
561 for (OsmPrimitive p: event.getPrimitives()) {
562 if (!p.isNew() && p.getId() == history.getId()) {
563 setLatest(null);
564 }
565 }
566 }
567
568 @Override
569 public void relationMembersChanged(RelationMembersChangedEvent event) {
570 Relation r = event.getRelation();
571 if (!r.isNew() && r.getId() == history.getId()) {
572 setLatest(new HistoryPrimitiveBuilder().build(r));
573 }
574 }
575
576 @Override
577 public void tagsChanged(TagsChangedEvent event) {
578 OsmPrimitive prim = event.getPrimitive();
579 if (!prim.isNew() && prim.getId() == history.getId()) {
580 setLatest(new HistoryPrimitiveBuilder().build(prim));
581 }
582 }
583
584 @Override
585 public void wayNodesChanged(WayNodesChangedEvent event) {
586 Way way = event.getChangedWay();
587 if (!way.isNew() && way.getId() == history.getId()) {
588 setLatest(new HistoryPrimitiveBuilder().build(way));
589 }
590 }
591
592 @Override
593 public void dataChanged(DataChangedEvent event) {
594 if (history == null)
595 return;
596 OsmPrimitive primitive = event.getDataset().getPrimitiveById(history.getId(), history.getType());
597 HistoryOsmPrimitive newLatest;
598 if (canShowAsLatest(primitive)) {
599 newLatest = new HistoryPrimitiveBuilder().build(primitive);
600 } else {
601 newLatest = null;
602 }
603 setLatest(newLatest);
604 fireModelChange();
605 }
606
607 @Override
608 public void otherDatasetChange(AbstractDatasetChangedEvent event) {
609 // Irrelevant
610 }
611
612 /* ---------------------------------------------------------------------- */
613 /* ActiveLayerChangeListener */
614 /* ---------------------------------------------------------------------- */
615 @Override
616 public void activeOrEditLayerChanged(ActiveLayerChangeEvent e) {
617 Layer oldLayer = e.getPreviousActiveLayer();
618 if (oldLayer instanceof OsmDataLayer) {
619 OsmDataLayer l = (OsmDataLayer) oldLayer;
620 l.data.removeDataSetListener(this);
621 }
622 Layer newLayer = e.getSource().getActiveLayer();
623 if (!(newLayer instanceof OsmDataLayer)) {
624 latest = null;
625 fireModelChange();
626 return;
627 }
628 OsmDataLayer l = (OsmDataLayer) newLayer;
629 l.data.addDataSetListener(this);
630 OsmPrimitive primitive = history != null ? l.data.getPrimitiveById(history.getId(), history.getType()) : null;
631 HistoryOsmPrimitive newLatest;
632 if (canShowAsLatest(primitive)) {
633 newLatest = new HistoryPrimitiveBuilder().build(primitive);
634 } else {
635 newLatest = null;
636 }
637 setLatest(newLatest);
638 fireModelChange();
639 }
640
641 /**
642 * Creates a {@link HistoryOsmPrimitive} from a {@link OsmPrimitive}
643 *
644 */
645 static class HistoryPrimitiveBuilder implements OsmPrimitiveVisitor {
646 private HistoryOsmPrimitive clone;
647
648 @Override
649 public void visit(Node n) {
650 clone = new HistoryNode(n.getId(), n.getVersion(), n.isVisible(), getCurrentUser(), 0, null, n.getCoor(), false);
651 clone.setTags(n.getKeys());
652 }
653
654 @Override
655 public void visit(Relation r) {
656 clone = new HistoryRelation(r.getId(), r.getVersion(), r.isVisible(), getCurrentUser(), 0, null, false);
657 clone.setTags(r.getKeys());
658 HistoryRelation hr = (HistoryRelation) clone;
659 for (RelationMember rm : r.getMembers()) {
660 hr.addMember(new RelationMemberData(rm.getRole(), rm.getType(), rm.getUniqueId()));
661 }
662 }
663
664 @Override
665 public void visit(Way w) {
666 clone = new HistoryWay(w.getId(), w.getVersion(), w.isVisible(), getCurrentUser(), 0, null, false);
667 clone.setTags(w.getKeys());
668 for (Node n: w.getNodes()) {
669 ((HistoryWay) clone).addNode(n.getUniqueId());
670 }
671 }
672
673 private static User getCurrentUser() {
674 UserInfo info = UserIdentityManager.getInstance().getUserInfo();
675 return info == null ? User.getAnonymous() : User.createOsmUser(info.getId(), info.getDisplayName());
676 }
677
678 HistoryOsmPrimitive build(OsmPrimitive primitive) {
679 primitive.accept(this);
680 return clone;
681 }
682 }
683
684}
Note: See TracBrowser for help on using the repository browser.