Changeset 10590 in josm for trunk


Ignore:
Timestamp:
2016-07-22T23:20:40+02:00 (4 years ago)
Author:
Don-vip
Message:

see #11390, fix #13191 - Documentation and migration to java 8 of preset code (patch by michael2402) - gsoc-core

Location:
trunk/src/org/openstreetmap/josm
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/data/osm/DataSet.java

    r10346 r10590  
    313313    private final QuadBuckets<Node> nodes = new QuadBuckets<>();
    314314
    315     private <T extends OsmPrimitive> Collection<T> getPrimitives(Predicate<? super OsmPrimitive> predicate) {
     315    /**
     316     * Gets a filtered collection of primitives matching the given predicate.
     317     * @param <T> The primitive type.
     318     * @param predicate The predicate to match
     319     * @return The list of primtives.
     320     * @since 10590
     321     */
     322    public <T extends OsmPrimitive> Collection<T> getPrimitives(java.util.function.Predicate<? super OsmPrimitive> predicate) {
    316323        return new SubclassFilteredCollection<>(allPrimitives, predicate);
    317324    }
  • trunk/src/org/openstreetmap/josm/gui/tagging/presets/TaggingPreset.java

    r10446 r10590  
    8686    public static final String PRESET_ICON_ERROR_MSG_PREFIX = "Could not get presets icon ";
    8787
     88    /**
     89     * The preset group this preset belongs to.
     90     */
    8891    public TaggingPresetMenu group;
     92
     93    /**
     94     * The name of the tagging preset.
     95     * @see #getRawName()
     96     */
    8997    public String name;
     98    /**
     99     * The icon name that was used for this preset.
     100     */
    90101    public String iconName;
    91102    public String name_context;
     103    /**
     104     * A cache for the local name. Should never be accessed directly.
     105     * @see #getLocaleName()
     106     */
    92107    public String locale_name;
    93108    public boolean preset_name_label;
     
    128143    }
    129144
     145    /**
     146     * Gets the localized version of the name
     147     * @return The name that should be displayed to the user.
     148     */
    130149    public String getLocaleName() {
    131150        if (locale_name == null) {
     
    189208            public void finished(final ImageResource result) {
    190209                if (result != null) {
    191                     GuiHelper.runInEDT(new Runnable() {
    192                         @Override
    193                         public void run() {
    194                             result.attachImageIcon(TaggingPreset.this);
    195                         }
    196                     });
     210                    GuiHelper.runInEDT(() -> result.attachImageIcon(TaggingPreset.this));
    197211                } else {
    198212                    Main.warn(TaggingPreset.this + ": " + PRESET_ICON_ERROR_MSG_PREFIX + iconName);
     
    386400                members.add(rm);
    387401            }
    388             SwingUtilities.invokeLater(new Runnable() {
    389                 @Override
    390                 public void run() {
    391                     RelationEditor.getEditor(Main.getLayerManager().getEditLayer(), r, members).setVisible(true);
    392                 }
    393             });
     402            SwingUtilities.invokeLater(() -> RelationEditor.getEditor(Main.getLayerManager().getEditLayer(), r, members).setVisible(true));
    394403        }
    395404        ds.setSelected(ds.getSelected()); // force update
  • trunk/src/org/openstreetmap/josm/gui/tagging/presets/TaggingPresetHandler.java

    r8863 r10590  
    88import org.openstreetmap.josm.data.osm.Tag;
    99
     10/**
     11 * This interface needs to be implemented in order to display a tagging preset. It allows the preset dialog to query the primitives it should
     12 * be displayed for and modify them.
     13 */
    1014public interface TaggingPresetHandler {
     15    /**
     16     * Gets the selection the preset should be applied to.
     17     * @return A collection of primitives.
     18     */
    1119    Collection<OsmPrimitive> getSelection();
    1220
     21    /**
     22     * Update the given tags on the selection.
     23     * @param tags The tags to update.
     24     */
    1325    void updateTags(List<Tag> tags);
    1426}
  • trunk/src/org/openstreetmap/josm/gui/tagging/presets/TaggingPresetListener.java

    r8863 r10590  
    55 * Notification of tagging presets events.
    66 * @since 7100
     7 * @see TaggingPresets#addListener(TaggingPresetListener)
    78 */
     9@FunctionalInterface
    810public interface TaggingPresetListener {
    911
  • trunk/src/org/openstreetmap/josm/gui/tagging/presets/TaggingPresetReader.java

    r10378 r10590  
    4444import org.openstreetmap.josm.io.UTFInputStreamReader;
    4545import org.openstreetmap.josm.tools.Predicates;
    46 import org.openstreetmap.josm.tools.Utils;
    4746import org.openstreetmap.josm.tools.XmlObjectParser;
    4847import org.xml.sax.SAXException;
     
    227226                    if (all.contains(tp)) {
    228227                        lastmenuOriginal = tp;
    229                         tp = (TaggingPresetMenu) Utils.filter(all, Predicates.<TaggingPreset>equalTo(tp)).iterator().next();
     228                        tp = (TaggingPresetMenu) all.stream().filter(Predicates.equalTo(tp)).findFirst().get();
    230229                        lastmenuOriginal.group = null;
    231230                    } else {
  • trunk/src/org/openstreetmap/josm/gui/tagging/presets/TaggingPresetSearchDialog.java

    r9422 r10590  
    55
    66import java.awt.event.ActionEvent;
    7 import java.awt.event.ActionListener;
    87
    98import org.openstreetmap.josm.Main;
     
    3736        setContent(selector, false);
    3837        DataSet.addSelectionListener(selector);
    39         selector.setDblClickListener(new ActionListener() {
    40             @Override
    41             public void actionPerformed(ActionEvent e) {
    42                 buttonAction(0, null);
    43             }
    44         });
     38        selector.setDblClickListener(e -> buttonAction(0, null));
    4539    }
    4640
  • trunk/src/org/openstreetmap/josm/gui/tagging/presets/TaggingPresetSearchPrimitiveDialog.java

    r10453 r10590  
    55
    66import java.awt.event.ActionEvent;
    7 import java.awt.event.ActionListener;
    87import java.awt.event.KeyEvent;
    98import java.util.HashSet;
     
    1514import org.openstreetmap.josm.gui.ExtendedDialog;
    1615import org.openstreetmap.josm.tools.Shortcut;
    17 import org.openstreetmap.josm.tools.Utils;
    1816
    1917/**
     
    7169        selector = new TaggingPresetSelector(false, false);
    7270        setContent(selector, false);
    73         selector.setDblClickListener(new ActionListener() {
    74             @Override
    75             public void actionPerformed(ActionEvent e) {
    76                 buttonAction(0, null);
    77             }
    78         });
     71        selector.setDblClickListener(e -> buttonAction(0, null));
    7972    }
    8073
     
    9386            TaggingPreset preset = selector.getSelectedPresetAndUpdateClassification();
    9487            if (preset != null) {
    95                 final Set<OsmPrimitive> matching = new HashSet<>(Utils.filter(Main.getLayerManager().getEditDataSet().allPrimitives(), preset));
     88
     89                final Set<OsmPrimitive> matching = new HashSet<>(Main.getLayerManager().getEditDataSet().getPrimitives(preset));
    9690                Main.getLayerManager().getEditDataSet().setSelected(matching);
    9791            }
  • trunk/src/org/openstreetmap/josm/gui/tagging/presets/TaggingPresetSelector.java

    r10446 r10590  
    88import java.awt.Dimension;
    99import java.awt.event.ActionEvent;
    10 import java.awt.event.ItemEvent;
    11 import java.awt.event.ItemListener;
    1210import java.util.ArrayList;
    1311import java.util.Collection;
     
    4745import org.openstreetmap.josm.gui.widgets.PopupMenuLauncher;
    4846import org.openstreetmap.josm.gui.widgets.SearchTextResultListPanel;
    49 import org.openstreetmap.josm.tools.Predicate;
    5047import org.openstreetmap.josm.tools.Utils;
    5148
     
    189186            ckOnlyApplicable.setText(tr("Show only applicable to selection"));
    190187            pnChecks.add(ckOnlyApplicable);
    191             ckOnlyApplicable.addItemListener(new ItemListener() {
    192                 @Override
    193                 public void itemStateChanged(ItemEvent e) {
    194                     filterItems();
    195                 }
    196             });
     188            ckOnlyApplicable.addItemListener(e -> filterItems());
    197189        } else {
    198190            ckOnlyApplicable = null;
     
    203195            ckSearchInTags.setText(tr("Search in tags"));
    204196            ckSearchInTags.setSelected(SEARCH_IN_TAGS.get());
    205             ckSearchInTags.addItemListener(new ItemListener() {
    206                 @Override
    207                 public void itemStateChanged(ItemEvent e) {
    208                     filterItems();
    209                 }
    210             });
     197            ckSearchInTags.addItemListener(e -> filterItems());
    211198            pnChecks.add(ckSearchInTags);
    212199        } else {
     
    247234
    248235        final TaggingPreset oldPreset = getSelectedPreset();
    249         lsResultModel.setItems(Utils.transform(result, new Utils.Function<PresetClassification, TaggingPreset>() {
    250             @Override
    251             public TaggingPreset apply(PresetClassification x) {
    252                 return x.preset;
    253             }
    254         }));
     236        lsResultModel.setItems(Utils.transform(result, x -> x.preset));
    255237        final TaggingPreset newPreset = getSelectedPreset();
    256238        if (!Objects.equals(oldPreset, newPreset)) {
     
    299281                    if (!suitable && preset.types.contains(TaggingPresetType.RELATION)
    300282                            && preset.roles != null && !preset.roles.roles.isEmpty()) {
    301                         final Predicate<Role> memberExpressionMatchesOnePrimitive = new Predicate<Role>() {
    302                             @Override
    303                             public boolean evaluate(Role object) {
    304                                 return object.memberExpression != null
    305                                         && Utils.exists(selectedPrimitives, object.memberExpression);
    306                             }
    307                         };
    308                         suitable = Utils.exists(preset.roles.roles, memberExpressionMatchesOnePrimitive);
     283                        suitable = preset.roles.roles.stream().anyMatch(
     284                                object -> object.memberExpression != null && Utils.exists(selectedPrimitives, object.memberExpression));
    309285                        // keep the preset to allow the creation of new relations
    310286                    }
  • trunk/src/org/openstreetmap/josm/gui/tagging/presets/TaggingPresets.java

    r9266 r10590  
    1515import org.openstreetmap.josm.gui.MenuScroller;
    1616import org.openstreetmap.josm.gui.tagging.ac.AutoCompletionManager;
    17 import org.openstreetmap.josm.tools.Predicate;
    18 import org.openstreetmap.josm.tools.Utils;
     17import org.openstreetmap.josm.tools.SubclassFilteredCollection;
    1918
    2019/**
     
    108107    public static Collection<TaggingPreset> getMatchingPresets(final Collection<TaggingPresetType> t,
    109108                                                               final Map<String, String> tags, final boolean onlyShowable) {
    110         return Utils.filter(getTaggingPresets(), new Predicate<TaggingPreset>() {
    111             @Override
    112             public boolean evaluate(TaggingPreset object) {
    113                 return object.matches(t, tags, onlyShowable);
    114             }
    115         });
     109        return SubclassFilteredCollection.filter(getTaggingPresets(), preset -> preset.matches(t, tags, onlyShowable));
    116110    }
    117111
     
    125119     */
    126120    public static Collection<TaggingPreset> getMatchingPresets(final OsmPrimitive primitive) {
    127         return Utils.filter(getTaggingPresets(), new Predicate<TaggingPreset>() {
    128             @Override
    129             public boolean evaluate(TaggingPreset object) {
    130                 return object.evaluate(primitive);
    131             }
    132         });
     121        return SubclassFilteredCollection.filter(getTaggingPresets(), preset -> preset.evaluate(primitive));
    133122    }
    134123
  • trunk/src/org/openstreetmap/josm/gui/tagging/presets/items/ComboMultiSelect.java

    r10420 r10590  
    2121import java.util.Set;
    2222import java.util.TreeSet;
     23import java.util.stream.Collectors;
    2324
    2425import javax.swing.ImageIcon;
     
    365366    public Collection<String> getDisplayValues() {
    366367        initListEntries();
    367         return Utils.transform(lhm.values(), new Utils.Function<PresetListEntry, String>() {
    368             @Override
    369             public String apply(PresetListEntry x) {
    370                 return x.getDisplayValue(true);
    371             }
    372         });
     368        return lhm.values().stream().map(x -> x.getDisplayValue(true)).collect(Collectors.toList());
    373369    }
    374370
    375371    @Override
    376372    public boolean addToPanel(JPanel p, Collection<OsmPrimitive> sel, boolean presetInitiallyMatches) {
    377 
    378373        initListEntries();
    379374
  • trunk/src/org/openstreetmap/josm/gui/tagging/presets/items/KeyedItem.java

    r9665 r10590  
    88import java.util.HashMap;
    99import java.util.Map;
     10import java.util.NoSuchElementException;
    1011import java.util.SortedSet;
    1112import java.util.TreeSet;
     
    9293    }
    9394
     95    /**
     96     * Usage information on a
     97     */
    9498    protected static class Usage {
    95         public SortedSet<String> values; // NOSONAR
     99        /**
     100         * A set of values that were used for this key.
     101         */
     102        public final SortedSet<String> values = new TreeSet<>();; // NOSONAR
    96103        private boolean hadKeys;
    97104        private boolean hadEmpty;
    98105
     106        /**
     107         * Check if there is exactly one value for this key.
     108         * @return <code>true</code> if there was exactly one value.
     109         */
    99110        public boolean hasUniqueValue() {
    100111            return values.size() == 1 && !hadEmpty;
    101112        }
    102113
     114        /**
     115         * Check if this key was not used in any primitive
     116         * @return <code>true</code> if it was unused.
     117         */
    103118        public boolean unused() {
    104119            return values.isEmpty();
    105120        }
    106121
     122        /**
     123         * Get the first value available.
     124         * @return The first value
     125         * @throws NoSuchElementException if there is no such value.
     126         */
    107127        public String getFirst() {
    108128            return values.first();
    109129        }
    110130
     131        /**
     132         * Check if we encountered any primitive that had any keys
     133         * @return <code>true</code> if any of the primtives had any tags.
     134         */
    111135        public boolean hadKeys() {
    112136            return hadKeys;
     
    116140    protected static Usage determineTextUsage(Collection<OsmPrimitive> sel, String key) {
    117141        Usage returnValue = new Usage();
    118         returnValue.values = new TreeSet<>();
    119142        for (OsmPrimitive s : sel) {
    120143            String v = s.get(key);
     
    132155
    133156    protected static Usage determineBooleanUsage(Collection<OsmPrimitive> sel, String key) {
    134 
    135157        Usage returnValue = new Usage();
    136         returnValue.values = new TreeSet<>();
    137158        for (OsmPrimitive s : sel) {
    138159            String booleanValue = OsmUtils.getNamedOsmBoolean(s.get(key));
  • trunk/src/org/openstreetmap/josm/gui/tagging/presets/items/PresetLink.java

    r9665 r10590  
    66import java.util.Collection;
    77import java.util.List;
     8import java.util.Optional;
    89
    910import javax.swing.JLabel;
     
    1718import org.openstreetmap.josm.gui.tagging.presets.TaggingPresets;
    1819import org.openstreetmap.josm.tools.GBC;
    19 import org.openstreetmap.josm.tools.Predicate;
    20 import org.openstreetmap.josm.tools.Utils;
    2120
    2221/**
     
    3231    public boolean addToPanel(JPanel p, Collection<OsmPrimitive> sel, boolean presetInitiallyMatches) {
    3332        final String presetName = preset_name;
    34         final TaggingPreset t = Utils.filter(TaggingPresets.getTaggingPresets(), new Predicate<TaggingPreset>() {
    35             @Override
    36             public boolean evaluate(TaggingPreset object) {
    37                 return presetName.equals(object.name);
    38             }
    39         }).iterator().next();
    40         if (t == null)
     33        Optional<TaggingPreset> found = TaggingPresets.getTaggingPresets().stream().filter(preset -> presetName.equals(preset.name)).findFirst();
     34        if (!found.isPresent())
    4135            return false;
     36        TaggingPreset t = found.get();
    4237        JLabel lbl = new TaggingPresetLabel(t);
    4338        lbl.addMouseListener(new MouseAdapter() {
  • trunk/src/org/openstreetmap/josm/gui/tagging/presets/items/Text.java

    r10378 r10590  
    77import java.awt.GridBagLayout;
    88import java.awt.Insets;
    9 import java.awt.event.ActionEvent;
    10 import java.awt.event.ActionListener;
    119import java.text.NumberFormat;
    1210import java.text.ParseException;
     
    143141                    final int buttonvalue = (NumberFormat.getIntegerInstance().parse(ai.replace("+", ""))).intValue();
    144142                    if (auto_increment_selected == buttonvalue) aibutton.setSelected(true);
    145                     aibutton.addActionListener(new ActionListener() {
    146                         @Override
    147                         public void actionPerformed(ActionEvent e) {
    148                             auto_increment_selected = buttonvalue;
    149                         }
    150                     });
     143                    aibutton.addActionListener(e -> auto_increment_selected = buttonvalue);
    151144                    pnl.add(aibutton, GBC.std());
    152145                } catch (ParseException x) {
     
    167160            releasebutton.setMargin(new Insets(0, 0, 0, 0));
    168161            releasebutton.setFocusable(false);
    169             releasebutton.addActionListener(new ActionListener() {
    170                 @Override
    171                 public void actionPerformed(ActionEvent e) {
    172                     auto_increment_selected = 0;
    173                     clearbutton.setSelected(true);
    174                 }
     162            releasebutton.addActionListener(e -> {
     163                auto_increment_selected = 0;
     164                clearbutton.setSelected(true);
    175165            });
    176166            saveHorizontalSpace(releasebutton);
Note: See TracChangeset for help on using the changeset viewer.