001// License: GPL. For details, see LICENSE file.
002package org.openstreetmap.josm.gui.conflict.pair;
003
004import static org.openstreetmap.josm.gui.conflict.pair.ComparePairType.MY_WITH_MERGED;
005import static org.openstreetmap.josm.gui.conflict.pair.ComparePairType.MY_WITH_THEIR;
006import static org.openstreetmap.josm.gui.conflict.pair.ComparePairType.THEIR_WITH_MERGED;
007import static org.openstreetmap.josm.gui.conflict.pair.ListRole.MERGED_ENTRIES;
008import static org.openstreetmap.josm.gui.conflict.pair.ListRole.MY_ENTRIES;
009import static org.openstreetmap.josm.gui.conflict.pair.ListRole.THEIR_ENTRIES;
010import static org.openstreetmap.josm.tools.I18n.tr;
011
012import java.beans.PropertyChangeEvent;
013import java.beans.PropertyChangeListener;
014import java.util.ArrayList;
015import java.util.Arrays;
016import java.util.EnumMap;
017import java.util.HashSet;
018import java.util.List;
019import java.util.Map;
020import java.util.Set;
021import java.util.stream.Collectors;
022import java.util.stream.IntStream;
023
024import javax.swing.DefaultListSelectionModel;
025import javax.swing.JOptionPane;
026import javax.swing.JTable;
027import javax.swing.ListSelectionModel;
028import javax.swing.table.DefaultTableModel;
029import javax.swing.table.TableModel;
030
031import org.openstreetmap.josm.command.conflict.ConflictResolveCommand;
032import org.openstreetmap.josm.data.conflict.Conflict;
033import org.openstreetmap.josm.data.osm.DataSet;
034import org.openstreetmap.josm.data.osm.OsmPrimitive;
035import org.openstreetmap.josm.data.osm.PrimitiveId;
036import org.openstreetmap.josm.data.osm.RelationMember;
037import org.openstreetmap.josm.gui.HelpAwareOptionPane;
038import org.openstreetmap.josm.gui.MainApplication;
039import org.openstreetmap.josm.gui.help.HelpUtil;
040import org.openstreetmap.josm.gui.util.ChangeNotifier;
041import org.openstreetmap.josm.gui.util.TableHelper;
042import org.openstreetmap.josm.gui.widgets.JosmComboBoxModel;
043import org.openstreetmap.josm.gui.widgets.OsmPrimitivesTableModel;
044import org.openstreetmap.josm.tools.CheckParameterUtil;
045import org.openstreetmap.josm.tools.Logging;
046import org.openstreetmap.josm.tools.Utils;
047
048/**
049 * ListMergeModel is a model for interactively comparing and merging two list of entries
050 * of type T. It maintains three lists of entries of type T:
051 * <ol>
052 *   <li>the list of <em>my</em> entries</li>
053 *   <li>the list of <em>their</em> entries</li>
054 *   <li>the list of <em>merged</em> entries</li>
055 * </ol>
056 *
057 * A ListMergeModel is a factory for three {@link TableModel}s and three {@link ListSelectionModel}s:
058 * <ol>
059 *   <li>the table model and the list selection for for a  {@link JTable} which shows my entries.
060 *    See {@link #getMyTableModel()} and {@link AbstractListMergeModel#getMySelectionModel()}</li>
061 *   <li>dito for their entries and merged entries</li>
062 * </ol>
063 *
064 * A ListMergeModel can be ''frozen''. If it's frozen, it doesn't accept additional merge
065 * decisions. {@link PropertyChangeListener}s can register for property value changes of
066 * {@link #FROZEN_PROP}.
067 * <p>
068 * ListMergeModel is an abstract class. Three methods have to be implemented by subclasses:
069 * <ul>
070 *   <li>{@link AbstractListMergeModel#cloneEntryForMergedList} - clones an entry of type T</li>
071 *   <li>{@link AbstractListMergeModel#isEqualEntry} - checks whether two entries are equals </li>
072 *   <li>{@link AbstractListMergeModel#setValueAt(DefaultTableModel, Object, int, int)} - handles values edited in
073 *     a JTable, dispatched from {@link TableModel#setValueAt(Object, int, int)} </li>
074 * </ul>
075 * A ListMergeModel is used in combination with a {@link AbstractListMerger}.
076 *
077 * @param <T> the type of the list entries
078 * @param <C> the type of conflict resolution command
079 * @see AbstractListMerger
080 * @see PairTable For the table displaying this model
081 */
082public abstract class AbstractListMergeModel<T extends PrimitiveId, C extends ConflictResolveCommand> extends ChangeNotifier {
083    /**
084     * The property name to listen for frozen changes.
085     * @see #setFrozen(boolean)
086     * @see #isFrozen()
087     */
088    public static final String FROZEN_PROP = AbstractListMergeModel.class.getName() + ".frozen";
089
090    private static final int MAX_DELETED_PRIMITIVE_IN_DIALOG = 5;
091
092    protected Map<ListRole, ArrayList<T>> entries;
093
094    protected EntriesTableModel myEntriesTableModel;
095    protected EntriesTableModel theirEntriesTableModel;
096    protected EntriesTableModel mergedEntriesTableModel;
097
098    protected EntriesSelectionModel myEntriesSelectionModel;
099    protected EntriesSelectionModel theirEntriesSelectionModel;
100    protected EntriesSelectionModel mergedEntriesSelectionModel;
101
102    private final Set<PropertyChangeListener> listeners;
103    private boolean isFrozen;
104    private final ComparePairListModel comparePairListModel;
105
106    private DataSet myDataset;
107    private Map<PrimitiveId, PrimitiveId> mergedMap;
108
109    /**
110     * Creates a clone of an entry of type T suitable to be included in the
111     * list of merged entries
112     *
113     * @param entry the entry
114     * @return the cloned entry
115     */
116    protected abstract T cloneEntryForMergedList(T entry);
117
118    /**
119     * checks whether two entries are equal. This is not necessarily the same as
120     * e1.equals(e2).
121     *
122     * @param e1  the first entry
123     * @param e2  the second entry
124     * @return true, if the entries are equal, false otherwise.
125     */
126    public abstract boolean isEqualEntry(T e1, T e2);
127
128    /**
129     * Handles method dispatches from {@link TableModel#setValueAt(Object, int, int)}.
130     *
131     * @param model the table model
132     * @param value  the value to be set
133     * @param row  the row index
134     * @param col the column index
135     *
136     * @see TableModel#setValueAt(Object, int, int)
137     */
138    protected abstract void setValueAt(DefaultTableModel model, Object value, int row, int col);
139
140    /**
141     * Replies primitive from my dataset referenced by entry
142     * @param entry entry
143     * @return Primitive from my dataset referenced by entry
144     */
145    public OsmPrimitive getMyPrimitive(T entry) {
146        return getMyPrimitiveById(entry);
147    }
148
149    public final OsmPrimitive getMyPrimitiveById(PrimitiveId entry) {
150        OsmPrimitive result = myDataset.getPrimitiveById(entry);
151        if (result == null && mergedMap != null) {
152            PrimitiveId id = mergedMap.get(entry);
153            if (id == null && entry instanceof OsmPrimitive) {
154                id = mergedMap.get(((OsmPrimitive) entry).getPrimitiveId());
155            }
156            if (id != null) {
157                result = myDataset.getPrimitiveById(id);
158            }
159        }
160        return result;
161    }
162
163    protected void buildMyEntriesTableModel() {
164        myEntriesTableModel = new EntriesTableModel(MY_ENTRIES);
165    }
166
167    protected void buildTheirEntriesTableModel() {
168        theirEntriesTableModel = new EntriesTableModel(THEIR_ENTRIES);
169    }
170
171    protected void buildMergedEntriesTableModel() {
172        mergedEntriesTableModel = new EntriesTableModel(MERGED_ENTRIES);
173    }
174
175    protected List<T> getMergedEntries() {
176        return entries.get(MERGED_ENTRIES);
177    }
178
179    protected List<T> getMyEntries() {
180        return entries.get(MY_ENTRIES);
181    }
182
183    protected List<T> getTheirEntries() {
184        return entries.get(THEIR_ENTRIES);
185    }
186
187    public int getMyEntriesSize() {
188        return getMyEntries().size();
189    }
190
191    public int getMergedEntriesSize() {
192        return getMergedEntries().size();
193    }
194
195    public int getTheirEntriesSize() {
196        return getTheirEntries().size();
197    }
198
199    /**
200     * Constructs a new {@code ListMergeModel}.
201     */
202    protected AbstractListMergeModel() {
203        entries = new EnumMap<>(ListRole.class);
204        for (ListRole role : ListRole.values()) {
205            entries.put(role, new ArrayList<>());
206        }
207
208        buildMyEntriesTableModel();
209        buildTheirEntriesTableModel();
210        buildMergedEntriesTableModel();
211
212        myEntriesSelectionModel = new EntriesSelectionModel(entries.get(MY_ENTRIES));
213        theirEntriesSelectionModel = new EntriesSelectionModel(entries.get(THEIR_ENTRIES));
214        mergedEntriesSelectionModel = new EntriesSelectionModel(entries.get(MERGED_ENTRIES));
215
216        listeners = new HashSet<>();
217        comparePairListModel = new ComparePairListModel();
218
219        setFrozen(true);
220    }
221
222    public void addPropertyChangeListener(PropertyChangeListener listener) {
223        synchronized (listeners) {
224            if (listener != null) {
225                listeners.add(listener);
226            }
227        }
228    }
229
230    public void removePropertyChangeListener(PropertyChangeListener listener) {
231        synchronized (listeners) {
232            if (listener != null) {
233                listeners.remove(listener);
234            }
235        }
236    }
237
238    protected void fireFrozenChanged(boolean oldValue, boolean newValue) {
239        synchronized (listeners) {
240            PropertyChangeEvent evt = new PropertyChangeEvent(this, FROZEN_PROP, oldValue, newValue);
241            listeners.forEach(listener -> listener.propertyChange(evt));
242        }
243    }
244
245    /**
246     * Sets the frozen status for this model.
247     * @param isFrozen <code>true</code> if it should be frozen.
248     */
249    public final void setFrozen(boolean isFrozen) {
250        boolean oldValue = this.isFrozen;
251        this.isFrozen = isFrozen;
252        fireFrozenChanged(oldValue, this.isFrozen);
253    }
254
255    /**
256     * Check if the model is frozen.
257     * @return The current frozen state.
258     */
259    public final boolean isFrozen() {
260        return isFrozen;
261    }
262
263    public OsmPrimitivesTableModel getMyTableModel() {
264        return myEntriesTableModel;
265    }
266
267    public OsmPrimitivesTableModel getTheirTableModel() {
268        return theirEntriesTableModel;
269    }
270
271    public OsmPrimitivesTableModel getMergedTableModel() {
272        return mergedEntriesTableModel;
273    }
274
275    public EntriesSelectionModel getMySelectionModel() {
276        return myEntriesSelectionModel;
277    }
278
279    public EntriesSelectionModel getTheirSelectionModel() {
280        return theirEntriesSelectionModel;
281    }
282
283    public EntriesSelectionModel getMergedSelectionModel() {
284        return mergedEntriesSelectionModel;
285    }
286
287    protected void fireModelDataChanged() {
288        myEntriesTableModel.fireTableDataChanged();
289        theirEntriesTableModel.fireTableDataChanged();
290        mergedEntriesTableModel.fireTableDataChanged();
291        fireStateChanged();
292    }
293
294    protected void copyToTop(ListRole role, int... rows) {
295        copy(role, rows, 0);
296        mergedEntriesSelectionModel.setSelectionInterval(0, rows.length -1);
297    }
298
299    /**
300     * Copies the nodes given by indices in rows from the list of my nodes to the
301     * list of merged nodes. Inserts the nodes at the top of the list of merged
302     * nodes.
303     *
304     * @param rows the indices
305     */
306    public void copyMyToTop(int... rows) {
307        copyToTop(MY_ENTRIES, rows);
308    }
309
310    /**
311     * Copies the nodes given by indices in rows from the list of their nodes to the
312     * list of merged nodes. Inserts the nodes at the top of the list of merged
313     * nodes.
314     *
315     * @param rows the indices
316     */
317    public void copyTheirToTop(int... rows) {
318        copyToTop(THEIR_ENTRIES, rows);
319    }
320
321    /**
322     * Copies the nodes given by indices in rows from the list of  nodes in source to the
323     * list of merged nodes. Inserts the nodes at the end of the list of merged
324     * nodes.
325     *
326     * @param source the list of nodes to copy from
327     * @param rows the indices
328     */
329
330    public void copyToEnd(ListRole source, int... rows) {
331        copy(source, rows, getMergedEntriesSize());
332        mergedEntriesSelectionModel.setSelectionInterval(getMergedEntriesSize()-rows.length, getMergedEntriesSize() -1);
333
334    }
335
336    /**
337     * Copies the nodes given by indices in rows from the list of my nodes to the
338     * list of merged nodes. Inserts the nodes at the end of the list of merged
339     * nodes.
340     *
341     * @param rows the indices
342     */
343    public void copyMyToEnd(int... rows) {
344        copyToEnd(MY_ENTRIES, rows);
345    }
346
347    /**
348     * Copies the nodes given by indices in rows from the list of their nodes to the
349     * list of merged nodes. Inserts the nodes at the end of the list of merged
350     * nodes.
351     *
352     * @param rows the indices
353     */
354    public void copyTheirToEnd(int... rows) {
355        copyToEnd(THEIR_ENTRIES, rows);
356    }
357
358    /**
359     * Clear the merged list.
360     */
361    public void clearMerged() {
362        getMergedEntries().clear();
363        fireModelDataChanged();
364    }
365
366    protected final void initPopulate(OsmPrimitive my, OsmPrimitive their, Map<PrimitiveId, PrimitiveId> mergedMap) {
367        CheckParameterUtil.ensureParameterNotNull(my, "my");
368        CheckParameterUtil.ensureParameterNotNull(their, "their");
369        this.myDataset = my.getDataSet();
370        this.mergedMap = mergedMap;
371        getMergedEntries().clear();
372        getMyEntries().clear();
373        getTheirEntries().clear();
374    }
375
376    protected void alertCopyFailedForDeletedPrimitives(List<PrimitiveId> deletedIds) {
377        List<String> items = deletedIds.stream().limit(MAX_DELETED_PRIMITIVE_IN_DIALOG).map(Object::toString).collect(Collectors.toList());
378        if (deletedIds.size() > MAX_DELETED_PRIMITIVE_IN_DIALOG) {
379            items.add(tr("{0} more...", deletedIds.size() - MAX_DELETED_PRIMITIVE_IN_DIALOG));
380        }
381        String sb = "<html>" +
382                tr("The following objects could not be copied to the target object<br>because they are deleted in the target dataset:") +
383                Utils.joinAsHtmlUnorderedList(items) +
384                "</html>";
385        HelpAwareOptionPane.showOptionDialog(
386                MainApplication.getMainFrame(),
387                sb,
388                tr("Merging deleted objects failed"),
389                JOptionPane.WARNING_MESSAGE,
390                HelpUtil.ht("/Dialog/Conflict#MergingDeletedPrimitivesFailed")
391        );
392    }
393
394    private void copy(ListRole sourceRole, int[] rows, int position) {
395        if (position < 0 || position > getMergedEntriesSize())
396            throw new IllegalArgumentException("Position must be between 0 and "+getMergedEntriesSize()+" but is "+position);
397        List<T> newItems = new ArrayList<>(rows.length);
398        List<T> source = entries.get(sourceRole);
399        List<PrimitiveId> deletedIds = new ArrayList<>();
400        for (int row: rows) {
401            T entry = source.get(row);
402            OsmPrimitive primitive = getMyPrimitive(entry);
403            if (primitive != null) {
404                if (!primitive.isDeleted()) {
405                    T clone = cloneEntryForMergedList(entry);
406                    newItems.add(clone);
407                } else {
408                    deletedIds.add(primitive.getPrimitiveId());
409                }
410            }
411        }
412        getMergedEntries().addAll(position, newItems);
413        fireModelDataChanged();
414        if (!deletedIds.isEmpty()) {
415            alertCopyFailedForDeletedPrimitives(deletedIds);
416        }
417    }
418
419    /**
420     * Copies over all values from the given side to the merged table..
421     * @param source The source side to copy from.
422     */
423    public void copyAll(ListRole source) {
424        getMergedEntries().clear();
425
426        int[] rows = IntStream.range(0, entries.get(source).size()).toArray();
427        copy(source, rows, 0);
428    }
429
430    /**
431     * Copies the nodes given by indices in rows from the list of  nodes <code>source</code> to the
432     * list of merged nodes. Inserts the nodes before row given by current.
433     *
434     * @param source the list of nodes to copy from
435     * @param rows the indices
436     * @param current the row index before which the nodes are inserted
437     * @throws IllegalArgumentException if current &lt; 0 or &gt;= #nodes in list of merged nodes
438     */
439    protected void copyBeforeCurrent(ListRole source, int[] rows, int current) {
440        copy(source, rows, current);
441        mergedEntriesSelectionModel.setSelectionInterval(current, current + rows.length-1);
442    }
443
444    /**
445     * Copies the nodes given by indices in rows from the list of my nodes to the
446     * list of merged nodes. Inserts the nodes before row given by current.
447     *
448     * @param rows the indices
449     * @param current the row index before which the nodes are inserted
450     * @throws IllegalArgumentException if current &lt; 0 or &gt;= #nodes in list of merged nodes
451     */
452    public void copyMyBeforeCurrent(int[] rows, int current) {
453        copyBeforeCurrent(MY_ENTRIES, rows, current);
454    }
455
456    /**
457     * Copies the nodes given by indices in rows from the list of their nodes to the
458     * list of merged nodes. Inserts the nodes before row given by current.
459     *
460     * @param rows the indices
461     * @param current the row index before which the nodes are inserted
462     * @throws IllegalArgumentException if current &lt; 0 or &gt;= #nodes in list of merged nodes
463     */
464    public void copyTheirBeforeCurrent(int[] rows, int current) {
465        copyBeforeCurrent(THEIR_ENTRIES, rows, current);
466    }
467
468    /**
469     * Copies the nodes given by indices in rows from the list of  nodes <code>source</code> to the
470     * list of merged nodes. Inserts the nodes after the row given by current.
471     *
472     * @param source the list of nodes to copy from
473     * @param rows the indices
474     * @param current the row index after which the nodes are inserted
475     * @throws IllegalArgumentException if current &lt; 0 or &gt;= #nodes in list of merged nodes
476     */
477    protected void copyAfterCurrent(ListRole source, int[] rows, int current) {
478        copy(source, rows, current + 1);
479        mergedEntriesSelectionModel.setSelectionInterval(current+1, current + rows.length-1);
480        fireStateChanged();
481    }
482
483    /**
484     * Copies the nodes given by indices in rows from the list of my nodes to the
485     * list of merged nodes. Inserts the nodes after the row given by current.
486     *
487     * @param rows the indices
488     * @param current the row index after which the nodes are inserted
489     * @throws IllegalArgumentException if current &lt; 0 or &gt;= #nodes in list of merged nodes
490     */
491    public void copyMyAfterCurrent(int[] rows, int current) {
492        copyAfterCurrent(MY_ENTRIES, rows, current);
493    }
494
495    /**
496     * Copies the nodes given by indices in rows from the list of my nodes to the
497     * list of merged nodes. Inserts the nodes after the row given by current.
498     *
499     * @param rows the indices
500     * @param current the row index after which the nodes are inserted
501     * @throws IllegalArgumentException if current &lt; 0 or &gt;= #nodes in list of merged nodes
502     */
503    public void copyTheirAfterCurrent(int[] rows, int current) {
504        copyAfterCurrent(THEIR_ENTRIES, rows, current);
505    }
506
507    /**
508     * Moves the nodes given by indices in rows  up by one position in the list
509     * of merged nodes.
510     *
511     * @param rows the indices
512     *
513     */
514    public void moveUpMerged(int... rows) {
515        if (rows == null || rows.length == 0)
516            return;
517        if (rows[0] == 0)
518            // can't move up
519            return;
520        List<T> mergedEntries = getMergedEntries();
521        for (int row: rows) {
522            T n = mergedEntries.get(row);
523            mergedEntries.remove(row);
524            mergedEntries.add(row -1, n);
525        }
526        fireModelDataChanged();
527        TableHelper.setSelectedIndices(mergedEntriesSelectionModel, Arrays.stream(rows).map(row -> row - 1));
528    }
529
530    /**
531     * Moves the nodes given by indices in rows down by one position in the list
532     * of merged nodes.
533     *
534     * @param rows the indices
535     */
536    public void moveDownMerged(int... rows) {
537        if (rows == null || rows.length == 0)
538            return;
539        List<T> mergedEntries = getMergedEntries();
540        if (rows[rows.length -1] == mergedEntries.size() -1)
541            // can't move down
542            return;
543        for (int i = rows.length-1; i >= 0; i--) {
544            int row = rows[i];
545            T n = mergedEntries.get(row);
546            mergedEntries.remove(row);
547            mergedEntries.add(row +1, n);
548        }
549        fireModelDataChanged();
550        TableHelper.setSelectedIndices(mergedEntriesSelectionModel, Arrays.stream(rows).map(row -> row + 1));
551    }
552
553    /**
554     * Removes the nodes given by indices in rows from the list
555     * of merged nodes.
556     *
557     * @param rows the indices
558     */
559    public void removeMerged(int... rows) {
560        if (rows == null || rows.length == 0)
561            return;
562
563        List<T> mergedEntries = getMergedEntries();
564
565        for (int i = rows.length-1; i >= 0; i--) {
566            mergedEntries.remove(rows[i]);
567        }
568        fireModelDataChanged();
569        mergedEntriesSelectionModel.clearSelection();
570    }
571
572    /**
573     * Replies true if the list of my entries and the list of their
574     * entries are equal
575     *
576     * @return true, if the lists are equal; false otherwise
577     */
578    protected boolean myAndTheirEntriesEqual() {
579        return getMyEntriesSize() == getTheirEntriesSize()
580                && IntStream.range(0, getMyEntriesSize()).allMatch(i -> isEqualEntry(getMyEntries().get(i), getTheirEntries().get(i)));
581    }
582
583    /**
584     * This an adapter between a {@link JTable} and one of the three entry lists
585     * in the role {@link ListRole} managed by the {@link AbstractListMergeModel}.
586     * <p>
587     * From the point of view of the {@link JTable} it is a {@link TableModel}.
588     *
589     * @see AbstractListMergeModel#getMyTableModel()
590     * @see AbstractListMergeModel#getTheirTableModel()
591     * @see AbstractListMergeModel#getMergedTableModel()
592     */
593    public class EntriesTableModel extends DefaultTableModel implements OsmPrimitivesTableModel {
594        private final ListRole role;
595
596        /**
597         * Create a new {@link EntriesTableModel}
598         * @param role the role
599         */
600        public EntriesTableModel(ListRole role) {
601            this.role = role;
602        }
603
604        @Override
605        public int getRowCount() {
606            int count = Math.max(getMyEntries().size(), getMergedEntries().size());
607            return Math.max(count, getTheirEntries().size());
608        }
609
610        @Override
611        public Object getValueAt(int row, int column) {
612            if (row < entries.get(role).size())
613                return entries.get(role).get(row);
614            return null;
615        }
616
617        @Override
618        public boolean isCellEditable(int row, int column) {
619            return false;
620        }
621
622        @Override
623        public void setValueAt(Object value, int row, int col) {
624            AbstractListMergeModel.this.setValueAt(this, value, row, col);
625        }
626
627        /**
628         * Returns the list merge model.
629         * @return the list merge model
630         */
631        public AbstractListMergeModel<T, C> getListMergeModel() {
632            return AbstractListMergeModel.this;
633        }
634
635        /**
636         * replies true if the {@link ListRole} of this {@link EntriesTableModel}
637         * participates in the current {@link ComparePairType}
638         *
639         * @return true, if the {@link ListRole} of this {@link EntriesTableModel}
640         * participates in the current {@link ComparePairType}
641         *
642         * @see AbstractListMergeModel.ComparePairListModel#getSelectedComparePair()
643         */
644        public boolean isParticipatingInCurrentComparePair() {
645            return getComparePairListModel()
646            .getSelectedComparePair()
647            .isParticipatingIn(role);
648        }
649
650        /**
651         * replies true if the entry at <code>row</code> is equal to the entry at the
652         * same position in the opposite list of the current {@link ComparePairType}.
653         *
654         * @param row  the row number
655         * @return true if the entry at <code>row</code> is equal to the entry at the
656         * same position in the opposite list of the current {@link ComparePairType}
657         * @throws IllegalStateException if this model is not participating in the
658         *   current  {@link ComparePairType}
659         * @see ComparePairType#getOppositeRole(ListRole)
660         * @see #getRole()
661         * @see #getOppositeEntries()
662         */
663        public boolean isSamePositionInOppositeList(int row) {
664            if (!isParticipatingInCurrentComparePair())
665                throw new IllegalStateException(tr("List in role {0} is currently not participating in a compare pair.", role.toString()));
666            if (row >= getEntries().size()) return false;
667            if (row >= getOppositeEntries().size()) return false;
668
669            T e1 = getEntries().get(row);
670            T e2 = getOppositeEntries().get(row);
671            return isEqualEntry(e1, e2);
672        }
673
674        /**
675         * replies true if the entry at the current position is present in the opposite list
676         * of the current {@link ComparePairType}.
677         *
678         * @param row the current row
679         * @return true if the entry at the current position is present in the opposite list
680         * of the current {@link ComparePairType}.
681         * @throws IllegalStateException if this model is not participating in the
682         *   current {@link ComparePairType}
683         * @see ComparePairType#getOppositeRole(ListRole)
684         * @see #getRole()
685         * @see #getOppositeEntries()
686         */
687        public boolean isIncludedInOppositeList(int row) {
688            if (!isParticipatingInCurrentComparePair())
689                throw new IllegalStateException(tr("List in role {0} is currently not participating in a compare pair.", role.toString()));
690
691            if (row >= getEntries().size()) return false;
692            T e1 = getEntries().get(row);
693            return getOppositeEntries().stream().anyMatch(e2 -> isEqualEntry(e1, e2));
694            }
695
696        protected List<T> getEntries() {
697            return entries.get(role);
698        }
699
700        /**
701         * replies the opposite list of entries with respect to the current {@link ComparePairType}
702         *
703         * @return the opposite list of entries
704         */
705        protected List<T> getOppositeEntries() {
706            ListRole opposite = getComparePairListModel().getSelectedComparePair().getOppositeRole(role);
707            return entries.get(opposite);
708        }
709
710        /**
711         * Get the role of the table.
712         * @return The role.
713         */
714        public ListRole getRole() {
715            return role;
716        }
717
718        @Override
719        public OsmPrimitive getReferredPrimitive(int idx) {
720            Object value = getValueAt(idx, 1);
721            if (value instanceof OsmPrimitive) {
722                return (OsmPrimitive) value;
723            } else if (value instanceof RelationMember) {
724                return ((RelationMember) value).getMember();
725            } else {
726                Logging.error("Unknown object type: "+value);
727                return null;
728            }
729        }
730    }
731
732    /**
733     * This is the selection model to be used in a {@link JTable} which displays
734     * an entry list managed by {@link AbstractListMergeModel}.
735     * <p>
736     * The model ensures that only rows displaying an entry in the entry list
737     * can be selected. "Empty" rows can't be selected.
738     *
739     * @see AbstractListMergeModel#getMySelectionModel()
740     * @see AbstractListMergeModel#getMergedSelectionModel()
741     * @see AbstractListMergeModel#getTheirSelectionModel()
742     *
743     */
744    protected class EntriesSelectionModel extends DefaultListSelectionModel {
745        private final transient List<T> entries;
746
747        public EntriesSelectionModel(List<T> nodes) {
748            this.entries = nodes;
749        }
750
751        @Override
752        public void addSelectionInterval(int index0, int index1) {
753            if (entries.isEmpty()) return;
754            if (index0 > entries.size() - 1) return;
755            index0 = Math.min(entries.size()-1, index0);
756            index1 = Math.min(entries.size()-1, index1);
757            super.addSelectionInterval(index0, index1);
758        }
759
760        @Override
761        public void insertIndexInterval(int index, int length, boolean before) {
762            if (entries.isEmpty()) return;
763            if (before) {
764                int newindex = Math.min(entries.size()-1, index);
765                if (newindex < index - length) return;
766                length = length - (index - newindex);
767                super.insertIndexInterval(newindex, length, before);
768            } else {
769                if (index > entries.size() -1) return;
770                length = Math.min(entries.size()-1 - index, length);
771                super.insertIndexInterval(index, length, before);
772            }
773        }
774
775        @Override
776        public void moveLeadSelectionIndex(int leadIndex) {
777            if (entries.isEmpty()) return;
778            leadIndex = Math.max(0, leadIndex);
779            leadIndex = Math.min(entries.size() - 1, leadIndex);
780            super.moveLeadSelectionIndex(leadIndex);
781        }
782
783        @Override
784        public void removeIndexInterval(int index0, int index1) {
785            if (entries.isEmpty()) return;
786            index0 = Math.max(0, index0);
787            index0 = Math.min(entries.size() - 1, index0);
788
789            index1 = Math.max(0, index1);
790            index1 = Math.min(entries.size() - 1, index1);
791            super.removeIndexInterval(index0, index1);
792        }
793
794        @Override
795        public void removeSelectionInterval(int index0, int index1) {
796            if (entries.isEmpty()) return;
797            index0 = Math.max(0, index0);
798            index0 = Math.min(entries.size() - 1, index0);
799
800            index1 = Math.max(0, index1);
801            index1 = Math.min(entries.size() - 1, index1);
802            super.removeSelectionInterval(index0, index1);
803        }
804
805        @Override
806        public void setAnchorSelectionIndex(int anchorIndex) {
807            if (entries.isEmpty()) return;
808            anchorIndex = Math.min(entries.size() - 1, anchorIndex);
809            super.setAnchorSelectionIndex(anchorIndex);
810        }
811
812        @Override
813        public void setLeadSelectionIndex(int leadIndex) {
814            if (entries.isEmpty()) return;
815            leadIndex = Math.min(entries.size() - 1, leadIndex);
816            super.setLeadSelectionIndex(leadIndex);
817        }
818
819        @Override
820        public void setSelectionInterval(int index0, int index1) {
821            if (entries.isEmpty()) return;
822            index0 = Math.max(0, index0);
823            index0 = Math.min(entries.size() - 1, index0);
824
825            index1 = Math.max(0, index1);
826            index1 = Math.min(entries.size() - 1, index1);
827
828            super.setSelectionInterval(index0, index1);
829        }
830    }
831
832    public ComparePairListModel getComparePairListModel() {
833        return this.comparePairListModel;
834    }
835
836    /**
837     * A model for {@link ComparePairType} with the enums added as options.
838     */
839    public class ComparePairListModel extends JosmComboBoxModel<ComparePairType> {
840
841        private int selectedIdx;
842        private final List<ComparePairType> compareModes;
843
844        /**
845         * Constructs a new {@code ComparePairListModel}.
846         */
847        public ComparePairListModel() {
848            this.compareModes = new ArrayList<>();
849            compareModes.add(MY_WITH_THEIR);
850            compareModes.add(MY_WITH_MERGED);
851            compareModes.add(THEIR_WITH_MERGED);
852            selectedIdx = 0;
853        }
854
855        @Override
856        public ComparePairType getElementAt(int index) {
857            if (index < compareModes.size())
858                return compareModes.get(index);
859            throw new IllegalArgumentException(tr("Unexpected value of parameter ''index''. Got {0}.", index));
860        }
861
862        @Override
863        public int getSize() {
864            return compareModes.size();
865        }
866
867        @Override
868        public Object getSelectedItem() {
869            return compareModes.get(selectedIdx);
870        }
871
872        @Override
873        public void setSelectedItem(Object anItem) {
874            int i = compareModes.indexOf(anItem);
875            if (i < 0)
876                throw new IllegalStateException(tr("Item {0} not found in list.", anItem));
877            selectedIdx = i;
878            fireModelDataChanged();
879        }
880
881        public ComparePairType getSelectedComparePair() {
882            return compareModes.get(selectedIdx);
883        }
884    }
885
886    /**
887     * Builds the command to resolve conflicts in the list.
888     *
889     * @param conflict the conflict data set
890     * @return the command
891     * @throws IllegalStateException if the merge is not yet frozen
892     */
893    public abstract C buildResolveCommand(Conflict<? extends OsmPrimitive> conflict);
894}