Ignore:
Timestamp:
2024-04-22T20:59:26+02:00 (6 weeks ago)
Author:
taylor.smock
Message:

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

Also, document why various ErrorProne checks were originally disabled and fix
generic SonarLint issues.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/org/openstreetmap/josm/actions/JoinAreasAction.java

    r19048 r19050  
    210210
    211211        public List<Node> getNodes() {
    212             final var nodes = new ArrayList<Node>();
     212            List<Node> nodes = new ArrayList<>();
    213213            for (WayInPolygon way : this.ways) {
    214214                //do not add the last node as it will be repeated in the next way
    215215                if (way.insideToTheRight) {
    216                     for (var pos = 0; pos < way.way.getNodesCount() - 1; pos++) {
     216                    for (int pos = 0; pos < way.way.getNodesCount() - 1; pos++) {
    217217                        nodes.add(way.way.getNode(pos));
    218218                    }
    … …  
    343343         */
    344344        private static double getAngle(Node n1, Node n2, Node n3) {
    345             final var en1 = n1.getEastNorth();
    346             final var en2 = n2.getEastNorth();
    347             final var en3 = n3.getEastNorth();
     345            EastNorth en1 = n1.getEastNorth();
     346            EastNorth en2 = n2.getEastNorth();
     347            EastNorth en3 = n3.getEastNorth();
    348348            double angle = Math.atan2(en3.getY() - en1.getY(), en3.getX() - en1.getX()) -
    349349                    Math.atan2(en2.getY() - en1.getY(), en2.getX() - en1.getX());
    … …  
    362362         */
    363363        public WayInPolygon walk() {
    364             final var headNode = getHeadNode();
    365             final var prevNode = getPrevNode();
     364            Node headNode = getHeadNode();
     365            Node prevNode = getPrevNode();
    366366
    367367            double headAngle = Math.atan2(headNode.getEastNorth().east() - prevNode.getEastNorth().east(),
    … …  
    371371            //find best next way
    372372            WayInPolygon bestWay = null;
    373             var bestWayReverse = false;
     373            boolean bestWayReverse = false;
    374374
    375375            for (WayInPolygon way : availableWays) {
    … …  
    418418         */
    419419        public WayInPolygon leftComingWay() {
    420             final var headNode = getHeadNode();
    421             final var prevNode = getPrevNode();
     420            Node headNode = getHeadNode();
     421            Node prevNode = getPrevNode();
    422422
    423423            WayInPolygon mostLeft = null; // most left way connected to head node
    424             var comingToHead = false; // true if candidate come to head node
     424            boolean comingToHead = false; // true if candidate come to head node
    425425            double angle = 2*Math.PI;
    426426
    … …  
    649649        }
    650650
    651         var hasChanges = false;
    652 
    653         final var allStartingWays = new ArrayList<Way>();
    654         final var innerStartingWays = new ArrayList<Way>();
    655         final var outerStartingWays = new ArrayList<Way>();
     651        boolean hasChanges = false;
     652
     653        List<Way> allStartingWays = new ArrayList<>();
     654        List<Way> innerStartingWays = new ArrayList<>();
     655        List<Way> outerStartingWays = new ArrayList<>();
    656656
    657657        for (Multipolygon area : areas) {
    … …  
    721721        if (discardedWays.stream().anyMatch(w -> !w.isNew())) {
    722722            for (AssembledPolygon ring : boundaries) {
    723                 for (var k = 0; k < ring.ways.size(); k++) {
     723                for (int k = 0; k < ring.ways.size(); k++) {
    724724                    WayInPolygon ringWay = ring.ways.get(k);
    725725                    Way older = keepOlder(ringWay.way, oldestWayMap, discardedWays);
    726726
    727727                    if (ringWay.way != older) {
    728                         final var repl = new WayInPolygon(older, ringWay.insideToTheRight);
     728                        WayInPolygon repl = new WayInPolygon(older, ringWay.insideToTheRight);
    729729                        ring.ways.set(k, repl);
    730730                    }
    … …  
    769769        // Delete the discarded inner ways
    770770        if (!discardedWays.isEmpty()) {
    771             final var deleteCmd = DeleteCommand.delete(discardedWays, true);
     771            Command deleteCmd = DeleteCommand.delete(discardedWays, true);
    772772            if (deleteCmd != null) {
    773773                cmds.add(deleteCmd);
    … …  
    796796    private Way keepOlder(Way way, Map<Node, Way> oldestWayMap, List<Way> discardedWays) {
    797797        Way oldest = null;
    798         for (var n : way.getNodes()) {
    799             final var orig = oldestWayMap .get(n);
     798        for (Node n : way.getNodes()) {
     799            Way orig = oldestWayMap .get(n);
    800800            if (orig != null && (oldest == null || oldest.getUniqueId() > orig.getUniqueId())
    801801                    && discardedWays.contains(orig)) {
    … …  
    830830        }
    831831
    832         final var wayTags = TagCollection.unionOfAllPrimitives(ways);
     832        TagCollection wayTags = TagCollection.unionOfAllPrimitives(ways);
    833833        try {
    834834            cmds.addAll(CombinePrimitiveResolverDialog.launchIfNecessary(wayTags, ways, ways));
    … …  
    847847     */
    848848    private boolean removeDuplicateNodes(List<Way> ways) {
    849         final var nodeMap = new TreeMap<Node, Node>(new NodePositionComparator());
    850         var totalWaysModified = 0;
     849        Map<Node, Node> nodeMap = new TreeMap<>(new NodePositionComparator());
     850        int totalWaysModified = 0;
    851851
    852852        for (Way way : ways) {
    … …  
    855855            }
    856856
    857             final var newNodes = new ArrayList<Node>();
     857            List<Node> newNodes = new ArrayList<>();
    858858            Node prevNode = null;
    859             var modifyWay = false;
     859            boolean modifyWay = false;
    860860
    861861            for (Node node : way.getNodes()) {
    862                 var representator = nodeMap.get(node);
     862                Node representator = nodeMap.get(node);
    863863                if (representator == null) {
    864864                    //new node
    … …  
    923923        cmds.clear();
    924924        if (addUndoRedo && !executedCmds.isEmpty()) {
    925             final var ur = UndoRedoHandler.getInstance();
     925            UndoRedoHandler ur = UndoRedoHandler.getInstance();
    926926            if (executedCmds.size() == 1) {
    927927                ur.add(executedCmds.getFirst(), false);
    … …  
    945945        Map<Way, Way> nextWayMap = new HashMap<>();
    946946
    947         for (var pos = 0; pos < parts.size(); pos++) {
     947        for (int pos = 0; pos < parts.size(); pos++) {
    948948
    949949            if (!parts.get(pos).lastNode().equals(parts.get((pos + 1) % parts.size()).firstNode()))
    … …  
    956956        Way topWay = null;
    957957        Node topNode = null;
    958         var topIndex = 0;
     958        int topIndex = 0;
    959959        double minY = Double.POSITIVE_INFINITY;
    960960
    961961        for (Way way : parts) {
    962             for (var pos = 0; pos < way.getNodesCount(); pos++) {
    963                 final var node = way.getNode(pos);
     962            for (int pos = 0; pos < way.getNodesCount(); pos++) {
     963                Node node = way.getNode(pos);
    964964
    965965                if (node.getEastNorth().getY() < minY) {
    … …  
    996996            for (Way way : parts) {
    997997                if (way.firstNode().equals(headNode)) {
    998                     final var nextNode = way.getNode(1);
     998                    Node nextNode = way.getNode(1);
    999999
    10001000                    if (topWay == null || !Geometry.isToTheRightSideOfLine(prevNode, headNode, bestWayNextNode, nextNode)) {
    … …  
    10081008                if (way.lastNode().equals(headNode)) {
    10091009                    //end adjacent to headNode
    1010                     final var nextNode = way.getNode(way.getNodesCount() - 2);
     1010                    Node nextNode = way.getNode(way.getNodesCount() - 2);
    10111011
    10121012                    if (topWay == null || !Geometry.isToTheRightSideOfLine(prevNode, headNode, bestWayNextNode, nextNode)) {
    … …  
    10201020        } else {
    10211021            //node is inside way - pick the clockwise going end.
    1022             final var prev = topWay.getNode(topIndex - 1);
    1023             final var next = topWay.getNode(topIndex + 1);
     1022            Node prev = topWay.getNode(topIndex - 1);
     1023            Node next = topWay.getNode(topIndex + 1);
    10241024
    10251025            //there will be no parallel segments in the middle of way, so all fine.
    … …  
    10271027        }
    10281028
    1029         var curWay = topWay;
     1029        Way curWay = topWay;
    10301030        boolean curWayInsideToTheRight = wayClockwise ^ isInner;
    10311031        List<WayInPolygon> result = new ArrayList<>();
    … …  
    10351035
    10361036            //add cur way
    1037             final var resultWay = new WayInPolygon(curWay, curWayInsideToTheRight);
     1037            WayInPolygon resultWay = new WayInPolygon(curWay, curWayInsideToTheRight);
    10381038            result.add(resultWay);
    10391039
    10401040            //process next way
    1041             final var nextWay = nextWayMap.get(curWay);
    1042             final var prevNode = curWay.getNode(curWay.getNodesCount() - 2);
    1043             final var headNode = curWay.lastNode();
    1044             final var nextNode = nextWay.getNode(1);
     1041            Way nextWay = nextWayMap.get(curWay);
     1042            Node prevNode = curWay.getNode(curWay.getNodesCount() - 2);
     1043            Node headNode = curWay.lastNode();
     1044            Node nextNode = nextWay.getNode(1);
    10451045
    10461046            if (nextWay == topWay) {
    … …  
    10681068            //                       |
    10691069
    1070             var intersectionCount = 0;
     1070            int intersectionCount = 0;
    10711071
    10721072            for (Way wayA : parts) {
    … …  
    10781078                if (wayA.lastNode().equals(headNode)) {
    10791079
    1080                     final var wayB = nextWayMap.get(wayA);
     1080                    Way wayB = nextWayMap.get(wayA);
    10811081
    10821082                    //test if wayA is opposite wayB relative to curWay and nextWay
    10831083
    1084                     final var wayANode = wayA.getNode(wayA.getNodesCount() - 2);
    1085                     final var wayBNode = wayB.getNode(1);
     1084                    Node wayANode = wayA.getNode(wayA.getNodesCount() - 2);
     1085                    Node wayBNode = wayB.getNode(1);
    10861086
    10871087                    boolean wayAToTheRight = Geometry.isToTheRightSideOfLine(prevNode, headNode, nextNode, wayANode);
    … …  
    11171117     */
    11181118    private static void revertDuplicateTwoNodeWays(List<WayInPolygon> parts) {
    1119         for (var i = 0; i < parts.size(); i++) {
     1119        for (int i = 0; i < parts.size(); i++) {
    11201120            WayInPolygon w1 = parts.get(i);
    11211121            if (w1.way.getNodesCount() != 2)
    … …  
    11411141    private List<Way> splitWayOnNodes(Way way, Set<Node> nodes, Map<Node, Way> oldestWayMap) {
    11421142
    1143         final var result = new ArrayList<Way>();
     1143        List<Way> result = new ArrayList<>();
    11441144        List<List<Node>> chunks = buildNodeChunks(way, nodes);
    11451145
    11461146        if (chunks.size() > 1) {
    1147             final var split = SplitWayCommand.splitWay(way, chunks,
     1147            SplitWayCommand split = SplitWayCommand.splitWay(way, chunks,
    11481148                    Collections.emptyList(), SplitWayCommand.Strategy.keepFirstChunk());
    11491149
    … …  
    11591159                if (!way.isNew() && result.size() > 1) {
    11601160                    for (Way part : result) {
    1161                         final var n = part.firstNode();
    1162                         final var old = oldestWayMap.get(n);
     1161                        Node n = part.firstNode();
     1162                        Way old = oldestWayMap.get(n);
    11631163                        if (old == null || old.getUniqueId() > way.getUniqueId()) {
    11641164                            oldestWayMap.put(n, way);
    … …  
    12311231
    12321232        //TODO: bad performance for deep nestings...
    1233         final var result = new ArrayList<PolygonLevel>();
     1233        List<PolygonLevel> result = new ArrayList<>();
    12341234
    12351235        for (AssembledPolygon outerWay : boundaryWays) {
    12361236
    1237             var outerGood = true;
    1238             final var innerCandidates = new ArrayList<AssembledPolygon>();
     1237            boolean outerGood = true;
     1238            List<AssembledPolygon> innerCandidates = new ArrayList<>();
    12391239
    12401240            for (AssembledPolygon innerWay : boundaryWays) {
    … …  
    12561256
    12571257            //add new outer polygon
    1258             final var pol = new AssembledMultipolygon(outerWay);
    1259             final var polLev = new PolygonLevel(pol, level);
     1258            AssembledMultipolygon pol = new AssembledMultipolygon(outerWay);
     1259            PolygonLevel polLev = new PolygonLevel(pol, level);
    12601260
    12611261            //process inner ways
    … …  
    12881288        // This seems to appear when is apply over invalid way like #9911 test-case
    12891289        // Remove all of these way to make the next work.
    1290         final var cleanMultigonWays = new ArrayList<WayInPolygon>();
     1290        List<WayInPolygon> cleanMultigonWays = new ArrayList<>();
    12911291        for (WayInPolygon way: multigonWays) {
    12921292            if (way.way.getNodesCount() != 2 || !way.way.isClosed())
    12931293                cleanMultigonWays.add(way);
    12941294        }
    1295         final var traverser = new WayTraverser(cleanMultigonWays);
    1296         final var result = new ArrayList<AssembledPolygon>();
     1295        WayTraverser traverser = new WayTraverser(cleanMultigonWays);
     1296        List<AssembledPolygon> result = new ArrayList<>();
    12971297
    12981298        WayInPolygon startWay;
    12991299        while ((startWay = traverser.startNewWay()) != null) {
    1300             final var path = new ArrayList<WayInPolygon>();
    1301             final var startWays = new ArrayList<WayInPolygon>();
     1300            List<WayInPolygon> path = new ArrayList<>();
     1301            List<WayInPolygon> startWays = new ArrayList<>();
    13021302            path.add(startWay);
    13031303            while (true) {
    … …  
    13181318                if (path.get(0) == nextWay) {
    13191319                    // path is closed -> stop here
    1320                     final var ring = new AssembledPolygon(path);
     1320                    AssembledPolygon ring = new AssembledPolygon(path);
    13211321                    if (ring.getNodes().size() <= 2) {
    13221322                        // Invalid ring (2 nodes) -> remove
    … …  
    13571357     */
    13581358    public static List<AssembledPolygon> fixTouchingPolygons(List<AssembledPolygon> polygons) {
    1359         final var newPolygons = new ArrayList<AssembledPolygon>();
     1359        List<AssembledPolygon> newPolygons = new ArrayList<>();
    13601360
    13611361        for (AssembledPolygon ring : polygons) {
    13621362            ring.reverse();
    1363             final var traverser = new WayTraverser(ring.ways);
     1363            WayTraverser traverser = new WayTraverser(ring.ways);
    13641364            WayInPolygon startWay;
    13651365
    13661366            while ((startWay = traverser.startNewWay()) != null) {
    1367                 final var simpleRingWays = new ArrayList<WayInPolygon>();
     1367                List<WayInPolygon> simpleRingWays = new ArrayList<>();
    13681368                simpleRingWays.add(startWay);
    13691369                WayInPolygon nextWay;
    … …  
    13741374                }
    13751375                traverser.removeWays(simpleRingWays);
    1376                 final var simpleRing = new AssembledPolygon(simpleRingWays);
     1376                AssembledPolygon simpleRing = new AssembledPolygon(simpleRingWays);
    13771377                simpleRing.reverse();
    13781378                newPolygons.add(simpleRing);
    … …  
    14111411     */
    14121412    private Multipolygon joinPolygon(AssembledMultipolygon polygon) throws UserCancelException {
    1413         final var result = new Multipolygon(joinWays(polygon.outerWay.ways));
     1413        Multipolygon result = new Multipolygon(joinWays(polygon.outerWay.ways));
    14141414
    14151415        for (AssembledPolygon pol : polygon.innerWays) {
    … …  
    14291429
    14301430        //leave original orientation, if all paths are reverse.
    1431         var allReverse = true;
     1431        boolean allReverse = true;
    14321432        for (WayInPolygon way : ways) {
    14331433            allReverse &= !way.insideToTheRight;
    … …  
    14401440        }
    14411441
    1442         final var joinedWay = joinOrientedWays(ways);
     1442        Way joinedWay = joinOrientedWays(ways);
    14431443
    14441444        //should not happen
    … …  
    14621462        // the user about this.
    14631463
    1464         final var actionWays = new ArrayList<Way>(ways.size());
    1465         var oldestPos = 0;
     1464        List<Way> actionWays = new ArrayList<>(ways.size());
     1465        int oldestPos = 0;
    14661466        Way oldest = ways.get(0).way;
    14671467        for (WayInPolygon way : ways) {
    … …  
    15111511            }
    15121512
    1513             var hasKnownOuter = false;
     1513            boolean hasKnownOuter = false;
    15141514            outerWays.clear();
    15151515            innerWays.clear();
    … …  
    15381538            }
    15391539
    1540             final var outerWay = outerWays.get(0);
     1540            Way outerWay = outerWays.get(0);
    15411541
    15421542            //retain only selected inner ways
    … …  
    15881588            processedInnerWays.addAll(innerWays);
    15891589
    1590             final var pol = new Multipolygon(outerWay);
     1590            Multipolygon pol = new Multipolygon(outerWay);
    15911591            pol.innerWays.addAll(innerWays);
    15921592
    … …  
    16151615        OsmDataLayer layer = getLayerManager().getEditLayer();
    16161616        // Create new multipolygon relation and add all inner ways to it
    1617         final var newRel = new Relation();
     1617        Relation newRel = new Relation();
    16181618        newRel.put("type", "multipolygon");
    16191619        for (Way w : inner) {
    … …  
    16501650
    16511651                cmds.add(new ChangeMembersCommand(r, members));
    1652                 final var saverel = new RelationRole(r, rm.getRole());
     1652                RelationRole saverel = new RelationRole(r, rm.getRole());
    16531653                if (!result.contains(saverel)) {
    16541654                    result.add(saverel);
    … …  
    17011701        default:
    17021702            // Create a new relation with all previous members and (Way)outer as outer.
    1703             final var newRel = new Relation();
     1703            Relation newRel = new Relation();
    17041704            for (RelationRole r : multiouters) {
    17051705                // Add members
Note: See TracChangeset for help on using the changeset viewer.