Changeset 12865 in josm


Ignore:
Timestamp:
2017-09-15T01:20:41+02:00 (18 months ago)
Author:
Don-vip
Message:

see #11390 - SonarQube - squid:S3824 - "Map.get" and value test should be replaced with single method call

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

Legend:

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

    r12673 r12865  
    282282
    283283        public Set<Relation> getChildren(Relation relation) {
    284             Set<Relation> p = children.get(relation);
    285             if (p == null) {
    286                 p = new HashSet<>();
    287                 children.put(relation, p);
    288             }
    289             return p;
     284            return children.computeIfAbsent(relation, k -> new HashSet<>());
    290285        }
    291286
  • trunk/src/org/openstreetmap/josm/data/Preferences.java

    r12857 r12865  
    4747import org.openstreetmap.josm.data.preferences.ColorProperty;
    4848import org.openstreetmap.josm.data.preferences.DoubleProperty;
    49 import org.openstreetmap.josm.spi.preferences.IPreferences;
    5049import org.openstreetmap.josm.data.preferences.IntegerProperty;
    5150import org.openstreetmap.josm.data.preferences.ListListSetting;
     
    6362import org.openstreetmap.josm.spi.preferences.AbstractPreferences;
    6463import org.openstreetmap.josm.spi.preferences.IBaseDirectories;
     64import org.openstreetmap.josm.spi.preferences.IPreferences;
    6565import org.openstreetmap.josm.tools.CheckParameterUtil;
    6666import org.openstreetmap.josm.tools.ColorHelper;
     
    282282
    283283    private ListenerList<PreferenceChangedListener> listenersForKey(String key) {
    284         ListenerList<PreferenceChangedListener> keyListener = keyListeners.get(key);
    285         if (keyListener == null) {
    286             keyListener = ListenerList.create();
    287             keyListeners.put(key, keyListener);
    288         }
    289         return keyListener;
     284        return keyListeners.computeIfAbsent(key, k -> ListenerList.create());
    290285    }
    291286
  • trunk/src/org/openstreetmap/josm/data/cache/CacheEntryAttributes.java

    r12620 r12865  
    8989     */
    9090    private long getLongAttr(String key) {
    91         String val = attrs.get(key);
    92         if (val == null) {
    93             attrs.put(key, "0");
    94             return 0;
    95         }
    9691        try {
    97             return Long.parseLong(val);
     92            return Long.parseLong(attrs.computeIfAbsent(key, k -> "0"));
    9893        } catch (NumberFormatException e) {
    9994            attrs.put(key, "0");
  • trunk/src/org/openstreetmap/josm/data/cache/HostLimitQueue.java

    r12620 r12865  
    159159        if (limit == null) {
    160160            synchronized (hostSemaphores) {
    161                 limit = hostSemaphores.get(host);
    162                 if (limit == null) {
    163                     limit = new Semaphore(hostLimit);
    164                     hostSemaphores.put(host, limit);
    165                 }
     161                limit = hostSemaphores.computeIfAbsent(host, k -> new Semaphore(hostLimit));
    166162            }
    167163        }
  • trunk/src/org/openstreetmap/josm/data/imagery/TMSCachedTileLoaderJob.java

    r12765 r12865  
    6868            String deduplicationKey = getCacheKey();
    6969            synchronized (inProgress) {
    70                 Set<TileLoaderListener> newListeners = inProgress.get(deduplicationKey);
    71                 if (newListeners == null) {
    72                     newListeners = new HashSet<>();
    73                     inProgress.put(deduplicationKey, newListeners);
    74                 }
    75                 newListeners.add(listener);
     70                inProgress.computeIfAbsent(deduplicationKey, k -> new HashSet<>()).add(listener);
    7671            }
    7772        }
  • trunk/src/org/openstreetmap/josm/data/osm/User.java

    r12537 r12865  
    7474        }
    7575
    76         Long ouid = uid;
    77         User user = userMap.get(ouid);
    78         if (user == null) {
    79             user = new User(uid, name);
    80             userMap.put(ouid, user);
    81         }
     76        User user = userMap.computeIfAbsent(uid, k -> new User(uid, name));
    8277        if (name != null) user.addName(name);
    8378
  • trunk/src/org/openstreetmap/josm/data/osm/history/HistoryDataSet.java

    r12636 r12865  
    125125    public void put(HistoryOsmPrimitive primitive) {
    126126        PrimitiveId id = new SimplePrimitiveId(primitive.getId(), primitive.getType());
    127         if (data.get(id) == null) {
    128             data.put(id, new ArrayList<HistoryOsmPrimitive>());
    129         }
    130         data.get(id).add(primitive);
     127        data.computeIfAbsent(id, k-> new ArrayList<>()).add(primitive);
    131128        fireHistoryUpdated(id);
    132129    }
  • trunk/src/org/openstreetmap/josm/data/validation/tests/CrossingWays.java

    r12620 r12865  
    315315     */
    316316    public static List<List<WaySegment>> getSegments(Map<Point2D, List<WaySegment>> cellSegments, EastNorth n1, EastNorth n2) {
    317 
    318317        List<List<WaySegment>> cells = new ArrayList<>();
    319318        for (Point2D cell : ValUtil.getSegmentCells(n1, n2, OsmValidator.getGridDetail())) {
    320             List<WaySegment> segments = cellSegments.get(cell);
    321             if (segments == null) {
    322                 segments = new ArrayList<>();
    323                 cellSegments.put(cell, segments);
    324             }
    325             cells.add(segments);
     319            cells.add(cellSegments.computeIfAbsent(cell, k -> new ArrayList<>()));
    326320        }
    327321        return cells;
  • trunk/src/org/openstreetmap/josm/data/validation/tests/RelationChecker.java

    r12006 r12865  
    129129        Map<String, RoleInfo> map = new HashMap<>();
    130130        for (RelationMember m : n.getMembers()) {
    131             String role = m.getRole();
    132             RoleInfo ri = map.get(role);
    133             if (ri == null) {
    134                 ri = new RoleInfo();
    135                 map.put(role, ri);
    136             }
    137             ri.total++;
     131            map.computeIfAbsent(m.getRole(), k -> new RoleInfo()).total++;
    138132        }
    139133        return map;
  • trunk/src/org/openstreetmap/josm/data/validation/util/ValUtil.java

    r11852 r12865  
    5656        cell = new Point2D.Double(x0, y0);
    5757        cellNodes.add(cell);
    58         List<Way> ways = cellWays.get(cell);
    59         if (ways == null) {
    60             ways = new ArrayList<>();
    61             cellWays.put(cell, ways);
    62         }
    63         cells.add(ways);
     58        cells.add(cellWays.computeIfAbsent(cell, k -> new ArrayList<>()));
    6459
    6560        // End of the way
     
    6762        if (!cellNodes.contains(cell)) {
    6863            cellNodes.add(cell);
    69             ways = cellWays.get(cell);
    70             if (ways == null) {
    71                 ways = new ArrayList<>();
    72                 cellWays.put(cell, ways);
    73             }
    74             cells.add(ways);
     64            cells.add(cellWays.computeIfAbsent(cell, k -> new ArrayList<>()));
    7565        }
    7666
     
    8777        if (!cellNodes.contains(cell)) {
    8878            cellNodes.add(cell);
    89             ways = cellWays.get(cell);
    90             if (ways == null) {
    91                 ways = new ArrayList<>();
    92                 cellWays.put(cell, ways);
    93             }
    94             cells.add(ways);
     79            cells.add(cellWays.computeIfAbsent(cell, k -> new ArrayList<>()));
    9580        }
    9681
     
    9984        if (!cellNodes.contains(cell)) {
    10085            cellNodes.add(cell);
    101             ways = cellWays.get(cell);
    102             if (ways == null) {
    103                 ways = new ArrayList<>();
    104                 cellWays.put(cell, ways);
    105             }
    106             cells.add(ways);
     86            cells.add(cellWays.computeIfAbsent(cell, k -> new ArrayList<>()));
    10787        }
    10888        return cells;
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/sort/RelationNodeMap.java

    r10043 r12865  
    108108
    109109    private void addPair(Node n, int i) {
    110         Set<Integer> ts = map.nodes.get(n);
    111         if (ts == null) {
    112             ts = new TreeSet<>();
    113             map.nodes.put(n, ts);
    114         }
    115         ts.add(i);
    116 
    117         Set<Node> ts2 = map.ways.get(i);
    118         if (ts2 == null) {
    119             ts2 = new TreeSet<>();
    120             map.ways.put(i, ts2);
    121         }
    122         ts2.add(n);
     110        map.nodes.computeIfAbsent(n, k -> new TreeSet<>()).add(i);
     111        map.ways.computeIfAbsent(i, k -> new TreeSet<>()).add(n);
    123112    }
    124113
    125114    private void addNodeWayMap(Node n, int i) {
    126         Set<Integer> ts = onewayMap.nodes.get(n);
    127         if (ts == null) {
    128             ts = new TreeSet<>();
    129             onewayMap.nodes.put(n, ts);
    130         }
    131         ts.add(i);
     115        onewayMap.nodes.computeIfAbsent(n, k -> new TreeSet<>()).add(i);
    132116    }
    133117
    134118    private void addWayNodeMap(Node n, int i) {
    135         Set<Node> ts2 = onewayMap.ways.get(i);
    136         if (ts2 == null) {
    137             ts2 = new TreeSet<>();
    138             onewayMap.ways.put(i, ts2);
    139         }
    140         ts2.add(n);
     119        onewayMap.ways.computeIfAbsent(i, k -> new TreeSet<>()).add(n);
    141120    }
    142121
    143122    private void addNodeWayMapReverse(Node n, int i) {
    144         Set<Integer> ts = onewayReverseMap.nodes.get(n);
    145         if (ts == null) {
    146             ts = new TreeSet<>();
    147             onewayReverseMap.nodes.put(n, ts);
    148         }
    149         ts.add(i);
     123        onewayReverseMap.nodes.computeIfAbsent(n, k -> new TreeSet<>()).add(i);
    150124    }
    151125
    152126    private void addWayNodeMapReverse(Node n, int i) {
    153         Set<Node> ts2 = onewayReverseMap.ways.get(i);
    154         if (ts2 == null) {
    155             ts2 = new TreeSet<>();
    156             onewayReverseMap.ways.put(i, ts2);
    157         }
    158         ts2.add(n);
     127        onewayReverseMap.ways.computeIfAbsent(i, k -> new TreeSet<>()).add(n);
    159128    }
    160129
    161130    private void addRemainingForward(Node n, int i) {
    162         Set<Node> ts2 = remainingOneway.get(i);
    163         if (ts2 == null) {
    164             ts2 = new TreeSet<>();
    165             remainingOneway.put(i, ts2);
    166         }
    167         ts2.add(n);
     131        remainingOneway.computeIfAbsent(i, k -> new TreeSet<>()).add(n);
    168132    }
    169133
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/sort/RelationSorter.java

    r12663 r12865  
    151151            for (AdditionalSorter sorter : ADDITIONAL_SORTERS) {
    152152                if (sorter.acceptsMember(m)) {
    153                     List<RelationMember> list;
    154                     list = customMap.get(sorter);
    155                     if (list == null) {
    156                         list = new LinkedList<>();
    157                         customMap.put(sorter, list);
    158                     }
    159                     list.add(m);
    160                     wasAdded = true;
     153                    wasAdded = customMap.computeIfAbsent(sorter, k -> new LinkedList<>()).add(m);
    161154                    break;
    162155                }
  • trunk/src/org/openstreetmap/josm/gui/tagging/ac/AutoCompletionManager.java

    r12859 r12865  
    506506    }
    507507
    508     private static void registerListeners(AutoCompletionManager autoCompletionManager) {
    509         autoCompletionManager.ds.addDataSetListener(autoCompletionManager);
     508    private AutoCompletionManager registerListeners() {
     509        ds.addDataSetListener(this);
    510510        MainApplication.getLayerManager().addLayerChangeListener(new LayerChangeListener() {
    511511            @Override
    512512            public void layerRemoving(LayerRemoveEvent e) {
    513513                if (e.getRemovedLayer() instanceof OsmDataLayer
    514                         && ((OsmDataLayer) e.getRemovedLayer()).data == autoCompletionManager.ds) {
    515                     INSTANCES.remove(autoCompletionManager.ds);
    516                     autoCompletionManager.ds.removeDataSetListener(autoCompletionManager);
     514                        && ((OsmDataLayer) e.getRemovedLayer()).data == ds) {
     515                    INSTANCES.remove(ds);
     516                    ds.removeDataSetListener(AutoCompletionManager.this);
    517517                    MainApplication.getLayerManager().removeLayerChangeListener(this);
    518518                }
     
    529529            }
    530530        });
     531        return this;
    531532    }
    532533
     
    538539     */
    539540    public static AutoCompletionManager of(DataSet dataSet) {
    540         AutoCompletionManager result = INSTANCES.get(dataSet);
    541         if (result == null) {
    542             result = new AutoCompletionManager(dataSet);
    543             INSTANCES.put(dataSet, result);
    544             registerListeners(result);
    545         }
    546         return result;
     541        return INSTANCES.computeIfAbsent(dataSet, ds -> new AutoCompletionManager(ds).registerListeners());
    547542    }
    548543}
  • trunk/src/org/openstreetmap/josm/tools/ImageProvider.java

    r12856 r12865  
    13221322
    13231323        synchronized (ROTATE_CACHE) {
    1324             Map<Long, Image> cacheByAngle = ROTATE_CACHE.get(img);
    1325             if (cacheByAngle == null) {
    1326                 cacheByAngle = new HashMap<>();
    1327                 ROTATE_CACHE.put(img, cacheByAngle);
    1328             }
    1329 
     1324            Map<Long, Image> cacheByAngle = ROTATE_CACHE.computeIfAbsent(img, k -> new HashMap<>());
    13301325            Image rotatedImg = cacheByAngle.get(originalAngle);
    13311326
  • trunk/src/org/openstreetmap/josm/tools/ImageWarp.java

    r12798 r12865  
    9191
    9292        private Point2D getValue(int xIdx, int yIdx) {
    93             Map<Integer, Point2D> row = getRow(yIdx);
    94             Point2D val = row.get(xIdx);
    95             if (val == null) {
    96                 val = trfm.transform(new Point2D.Double(xIdx * stride, yIdx * stride));
    97                 row.put(xIdx, val);
    98             }
    99             return val;
     93            return getRow(yIdx).computeIfAbsent(xIdx, k -> trfm.transform(new Point2D.Double(xIdx * stride, yIdx * stride)));
    10094        }
    10195
  • trunk/src/org/openstreetmap/josm/tools/MultiMap.java

    r9790 r12865  
    6666     */
    6767    public void put(A key, B value) {
    68         Set<B> vals = map.get(key);
    69         if (vals == null) {
    70             vals = new LinkedHashSet<>();
    71             map.put(key, vals);
    72         }
    73         vals.add(value);
     68        map.computeIfAbsent(key, k -> new LinkedHashSet<>()).add(value);
    7469    }
    7570
     
    9590     */
    9691    public void putAll(A key, Collection<B> values) {
    97         Set<B> vals = map.get(key);
    98         if (vals == null) {
    99             vals = new LinkedHashSet<>(values);
    100             map.put(key, vals);
    101         }
    102         vals.addAll(values);
     92        map.computeIfAbsent(key, k -> new LinkedHashSet<>(values)).addAll(values);
    10393    }
    10494
Note: See TracChangeset for help on using the changeset viewer.