Changeset 17896 in josm for trunk/src

Timestamp:

2021-05-17T19:44:04+02:00 (4 years ago)

Author:

simon04

Message:

see #17177 - IWaySegment: encapsulate fields

Location:

trunk/src/org/openstreetmap/josm

Files:

• actions/JoinNodeWayAction.java (modified) (2 diffs)
• actions/mapmode/DeleteAction.java (modified) (1 diff)
• actions/mapmode/DrawAction.java (modified) (2 diffs)
• actions/mapmode/ExtrudeAction.java (modified) (14 diffs)
• actions/mapmode/ImproveWayAccuracyAction.java (modified) (1 diff)
• actions/mapmode/ParallelWayAction.java (modified) (2 diffs)
• actions/mapmode/SelectAction.java (modified) (2 diffs)
• command/DeleteCommand.java (modified) (2 diffs)
• data/osm/IWaySegment.java (modified) (3 diffs)
• data/osm/WaySegment.java (modified) (1 diff)
• data/osm/visitor/paint/AbstractMapRenderer.java (modified) (1 diff)
• data/osm/visitor/paint/StyledMapRenderer.java (modified) (1 diff)
• data/validation/tests/CrossingWays.java (modified) (3 diffs)
• data/validation/tests/LongSegment.java (modified) (1 diff)
• data/validation/tests/OverlappingWays.java (modified) (3 diffs)
• gui/NavigatableComponent.java (modified) (9 diffs)
• gui/dialogs/ValidatorDialog.java (modified) (1 diff)
• gui/layer/validation/PaintVisitor.java (modified) (1 diff)

trunk/src/org/openstreetmap/josm/actions/JoinNodeWayAction.java

@@ -108 +108 @@
             for (WaySegment ws : wss) {
                 // Maybe cleaner to pass a "isSelected" predicate to getNearestWaySegments, but this is less invasive.
-                if (restrictToSelectedWays && !ws.way.isSelected()) {
+                if (restrictToSelectedWays && !ws.getWay().isSelected()) {
                     continue;
                 }
@@ -135 +135 @@
                     // only use the closest WaySegment of each way and ignore those that already contain the node
                     if (!ws.getFirstNode().equals(node) && !ws.getSecondNode().equals(node)
-                            && !seenWays.contains(ws.way)) {
+                            && !seenWays.contains(ws.getWay())) {
                         if (usedDist == null)
                             usedDist = entry.getKey();
-                        MultiMap<Integer, Node> innerMap = data.get(ws.way);
+                        MultiMap<Integer, Node> innerMap = data.get(ws.getWay());
                         if (innerMap == null) {
                             innerMap = new MultiMap<>();
-                            data.put(ws.way, innerMap);
+                            data.put(ws.getWay(), innerMap);
                         }
-                        innerMap.put(ws.lowerIndex, node);
-                        seenWays.add(ws.way);
+                        innerMap.put(ws.getLowerIndex(), node);
+                        seenWays.add(ws.getWay());
                     }
                 }

trunk/src/org/openstreetmap/josm/actions/mapmode/DeleteAction.java

@@ -418 +418 @@
             return DeleteCommand.deleteWaySegment(parameters.nearestSegment);
         case way:
-            return DeleteCommand.delete(Collections.singleton(parameters.nearestSegment.way), false, silent);
+            return DeleteCommand.delete(Collections.singleton(parameters.nearestSegment.getWay()), false, silent);
         case way_with_nodes:
-            return DeleteCommand.delete(Collections.singleton(parameters.nearestSegment.way), true, silent);
+            return DeleteCommand.delete(Collections.singleton(parameters.nearestSegment.getWay()), true, silent);
         case way_with_references:
-            return DeleteCommand.deleteWithReferences(Collections.singleton(parameters.nearestSegment.way), true);
+            return DeleteCommand.deleteWithReferences(Collections.singleton(parameters.nearestSegment.getWay()), true);
         default:
             return null;

trunk/src/org/openstreetmap/josm/actions/mapmode/DrawAction.java

@@ -694 +694 @@
         for (WaySegment ws : wss) {
             List<Integer> is;
-            if (insertPoints.containsKey(ws.way)) {
-                is = insertPoints.get(ws.way);
+            if (insertPoints.containsKey(ws.getWay())) {
+                is = insertPoints.get(ws.getWay());
             } else {
                 is = new ArrayList<>();
-                insertPoints.put(ws.way, is);
-            }
-
-            is.add(ws.lowerIndex);
+                insertPoints.put(ws.getWay(), is);
+            }
+
+            is.add(ws.getLowerIndex());
         }
 
@@ -859 +859 @@
             List<WaySegment> wss = mv.getNearestWaySegments(mousePos, OsmPrimitive::isSelectable);
             for (WaySegment ws : wss) {
-                mouseOnExistingWays.add(ws.way);
+                mouseOnExistingWays.add(ws.getWay());
             }
         }

trunk/src/org/openstreetmap/josm/actions/mapmode/ExtrudeAction.java

@@ -432 +432 @@
                 mode = Mode.create_new;
                 // create a new segment and then select and extrude the new segment
-                getLayerManager().getEditDataSet().setSelected(selectedSegment.way);
+                getLayerManager().getEditDataSet().setSelected(selectedSegment.getWay());
                 alwaysCreateNodes = true;
             } else {
                 mode = Mode.extrude;
-                getLayerManager().getEditDataSet().setSelected(selectedSegment.way);
+                getLayerManager().getEditDataSet().setSelected(selectedSegment.getWay());
                 alwaysCreateNodes = shift;
             }
@@ -591 +591 @@
             EastNorth b = ws.getSecondNode().getEastNorth();
             n.setEastNorth(Geometry.closestPointToSegment(a, b, n.getEastNorth()));
-            Way wnew = new Way(ws.way);
-            wnew.addNode(ws.lowerIndex+1, n);
-            DataSet ds = ws.way.getDataSet();
+            Way wnew = new Way(ws.getWay());
+            wnew.addNode(ws.getLowerIndex() +1, n);
+            DataSet ds = ws.getWay().getDataSet();
             UndoRedoHandler.getInstance().add(new SequenceCommand(tr("Add a new node to an existing way"),
-                    new AddCommand(ds, n), new ChangeNodesCommand(ds, ws.way, wnew.getNodes())));
+                    new AddCommand(ds, n), new ChangeNodesCommand(ds, ws.getWay(), wnew.getNodes())));
             wnew.setNodes(null); // see #19885
 
@@ -641 +641 @@
         // create extrusion
         Collection<Command> cmds = new LinkedList<>();
-        Way wnew = new Way(selectedSegment.way);
+        Way wnew = new Way(selectedSegment.getWay());
         boolean wayWasModified = false;
         boolean wayWasSingleSegment = wnew.getNodesCount() == 2;
-        int insertionPoint = selectedSegment.lowerIndex + 1;
+        int insertionPoint = selectedSegment.getUpperIndex();
 
         //find if the new points overlap existing segments (in case of 90 degree angles)
-        Node prevNode = getPreviousNode(selectedSegment.lowerIndex);
+        Node prevNode = getPreviousNode(selectedSegment.getLowerIndex());
         boolean nodeOverlapsSegment = prevNode != null && Geometry.segmentsParallel(initialN1en, prevNode.getEastNorth(), initialN1en, newN1en);
         // segmentAngleZero marks subset of nodeOverlapsSegment.
         // nodeOverlapsSegment is true if angle between segments is 0 or PI, segmentAngleZero only if angle is 0
         boolean segmentAngleZero = prevNode != null && Math.abs(Geometry.getCornerAngle(prevNode.getEastNorth(), initialN1en, newN1en)) < 1e-5;
-        boolean hasOtherWays = hasNodeOtherWays(selectedSegment.getFirstNode(), selectedSegment.way);
+        boolean hasOtherWays = hasNodeOtherWays(selectedSegment.getFirstNode(), selectedSegment.getWay());
         List<Node> changedNodes = new ArrayList<>();
         if (nodeOverlapsSegment && !alwaysCreateNodes && !hasOtherWays) {
@@ -679 +679 @@
 
         //find if the new points overlap existing segments (in case of 90 degree angles)
-        Node nextNode = getNextNode(selectedSegment.lowerIndex + 1);
+        Node nextNode = getNextNode(selectedSegment.getUpperIndex());
         nodeOverlapsSegment = nextNode != null && Geometry.segmentsParallel(initialN2en, nextNode.getEastNorth(), initialN2en, newN2en);
         segmentAngleZero = nextNode != null && Math.abs(Geometry.getCornerAngle(nextNode.getEastNorth(), initialN2en, newN2en)) < 1e-5;
-        hasOtherWays = hasNodeOtherWays(selectedSegment.getSecondNode(), selectedSegment.way);
+        hasOtherWays = hasNodeOtherWays(selectedSegment.getSecondNode(), selectedSegment.getWay());
 
         if (nodeOverlapsSegment && !alwaysCreateNodes && !hasOtherWays) {
@@ -714 +714 @@
         if (wayWasModified) {
             // we only need to change the way if its node list was really modified
-            cmds.add(new ChangeNodesCommand(selectedSegment.way, wnew.getNodes()));
+            cmds.add(new ChangeNodesCommand(selectedSegment.getWay(), wnew.getNodes()));
         }
         wnew.setNodes(null); // see #19885
@@ -824 +824 @@
 
         //add directions parallel to neighbor segments
-        Node prevNode = getPreviousNode(selectedSegment.lowerIndex);
+        Node prevNode = getPreviousNode(selectedSegment.getLowerIndex());
         if (prevNode != null) {
             EastNorth en = prevNode.getEastNorth();
@@ -833 +833 @@
         }
 
-        Node nextNode = getNextNode(selectedSegment.lowerIndex + 1);
+        Node nextNode = getNextNode(selectedSegment.getUpperIndex());
         if (nextNode != null) {
             EastNorth en = nextNode.getEastNorth();
@@ -871 +871 @@
      */
     private boolean checkDualAlignConditions() {
-        Node prevNode = getPreviousNode(selectedSegment.lowerIndex);
-        Node nextNode = getNextNode(selectedSegment.lowerIndex + 1);
+        Node prevNode = getPreviousNode(selectedSegment.getLowerIndex());
+        Node nextNode = getNextNode(selectedSegment.getUpperIndex());
         if (prevNode == null || nextNode == null) {
             return false;
@@ -906 +906 @@
 
         // set neighboring segments
-        Node prevNode = getPreviousNode(selectedSegment.lowerIndex);
+        Node prevNode = getPreviousNode(selectedSegment.getLowerIndex());
         if (prevNode != null) {
             EastNorth prevNodeEn = prevNode.getEastNorth();
@@ -915 +915 @@
         }
 
-        Node nextNode = getNextNode(selectedSegment.lowerIndex + 1);
+        Node nextNode = getNextNode(selectedSegment.getUpperIndex());
         if (nextNode != null) {
             EastNorth nextNodeEn = nextNode.getEastNorth();
@@ -975 +975 @@
         if (index > 0)
             return index - 1;
-        else if (selectedSegment.way.isClosed())
-            return selectedSegment.way.getNodesCount() - 2;
+        else if (selectedSegment.getWay().isClosed())
+            return selectedSegment.getWay().getNodesCount() - 2;
         else
             return -1;
@@ -989 +989 @@
         int indexPrev = getPreviousNodeIndex(index);
         if (indexPrev >= 0)
-            return selectedSegment.way.getNode(indexPrev);
+            return selectedSegment.getWay().getNode(indexPrev);
         else
             return null;
@@ -1000 +1000 @@
      */
     private int getNextNodeIndex(int index) {
-        int count = selectedSegment.way.getNodesCount();
+        int count = selectedSegment.getWay().getNodesCount();
         if (index < count - 1)
             return index + 1;
-        else if (selectedSegment.way.isClosed())
+        else if (selectedSegment.getWay().isClosed())
             return 1;
         else
@@ -1017 +1017 @@
         int indexNext = getNextNodeIndex(index);
         if (indexNext >= 0)
-            return selectedSegment.way.getNode(indexNext);
+            return selectedSegment.getWay().getNode(indexNext);
         else
             return null;

trunk/src/org/openstreetmap/josm/actions/mapmode/ImproveWayAccuracyAction.java

@@ -463 +463 @@
                 // Adding the node to all segments found
                 for (WaySegment virtualSegment : virtualSegments) {
-                    Way w = virtualSegment.way;
+                    Way w = virtualSegment.getWay();
                     List<Node> modNodes = w.getNodes();
-                    modNodes.add(virtualSegment.lowerIndex + 1, virtualNode);
+                    modNodes.add(virtualSegment.getUpperIndex(), virtualNode);
                     virtualCmds.add(new ChangeNodesCommand(w, modNodes));
                 }

trunk/src/org/openstreetmap/josm/actions/mapmode/ParallelWayAction.java

@@ -508 +508 @@
         sourceWays.removeIf(w -> w.isIncomplete() || w.isEmpty());
 
-        if (!sourceWays.contains(referenceSegment.way)) {
+        if (!sourceWays.contains(referenceSegment.getWay())) {
             clearSourceWays();
-            addSourceWay(referenceSegment.way);
+            addSourceWay(referenceSegment.getWay());
         }
 
@@ -517 +517 @@
             int i = 0;
             for (Way w : sourceWays) {
-                if (w == referenceSegment.way) {
+                if (w == referenceSegment.getWay()) {
                     referenceWayIndex = i;
                     break;

trunk/src/org/openstreetmap/josm/actions/mapmode/SelectAction.java

@@ -1215 +1215 @@
 
                 for (WaySegment ws : mv.getNearestWaySegments(p, mv.isSelectablePredicate)) {
-                    Way w = ws.way;
-
-                    wnp.a = w.getNode(ws.lowerIndex);
-                    wnp.b = w.getNode(ws.lowerIndex + 1);
+                    Way w = ws.getWay();
+
+                    wnp.a = w.getNode(ws.getLowerIndex());
+                    wnp.b = w.getNode(ws.getUpperIndex());
                     MapViewPoint p1 = mv.getState().getPointFor(wnp.a);
                     MapViewPoint p2 = mv.getState().getPointFor(wnp.b);
@@ -1257 +1257 @@
             virtualCmds.add(new AddCommand(ds, virtualNode));
             for (WaySegment virtualWay : virtualWays) {
-                Way w = virtualWay.way;
+                Way w = virtualWay.getWay();
                 List<Node> modNodes = w.getNodes();
-                modNodes.add(virtualWay.lowerIndex + 1, virtualNode);
+                modNodes.add(virtualWay.getUpperIndex(), virtualNode);
                 virtualCmds.add(new ChangeNodesCommand(ds, w, modNodes));
             }

trunk/src/org/openstreetmap/josm/command/DeleteCommand.java

@@ -479 +479 @@
      */
     public static Command deleteWaySegment(WaySegment ws) {
-        if (ws.way.getNodesCount() < 3)
-            return delete(Collections.singleton(ws.way), false);
-
-        if (ws.way.isClosed()) {
+        if (ws.getWay().getNodesCount() < 3)
+            return delete(Collections.singleton(ws.getWay()), false);
+
+        if (ws.getWay().isClosed()) {
             // If the way is circular (first and last nodes are the same), the way shouldn't be splitted
 
             List<Node> n = new ArrayList<>();
 
-            n.addAll(ws.way.getNodes().subList(ws.lowerIndex + 1, ws.way.getNodesCount() - 1));
-            n.addAll(ws.way.getNodes().subList(0, ws.lowerIndex + 1));
-
-            return new ChangeNodesCommand(ws.way, n);
+            n.addAll(ws.getWay().getNodes().subList(ws.getUpperIndex(), ws.getWay().getNodesCount() - 1));
+            n.addAll(ws.getWay().getNodes().subList(0, ws.getUpperIndex()));
+
+            return new ChangeNodesCommand(ws.getWay(), n);
         }
 
@@ -496 +496 @@
         List<Node> n2 = new ArrayList<>();
 
-        n1.addAll(ws.way.getNodes().subList(0, ws.lowerIndex + 1));
-        n2.addAll(ws.way.getNodes().subList(ws.lowerIndex + 1, ws.way.getNodesCount()));
+        n1.addAll(ws.getWay().getNodes().subList(0, ws.getUpperIndex()));
+        n2.addAll(ws.getWay().getNodes().subList(ws.getUpperIndex(), ws.getWay().getNodesCount()));
 
         if (n1.size() < 2) {
-            return new ChangeNodesCommand(ws.way, n2);
+            return new ChangeNodesCommand(ws.getWay(), n2);
         } else if (n2.size() < 2) {
-            return new ChangeNodesCommand(ws.way, n1);
+            return new ChangeNodesCommand(ws.getWay(), n1);
         } else {
-            return SplitWayCommand.splitWay(ws.way, Arrays.asList(n1, n2), Collections.<OsmPrimitive>emptyList());
+            return SplitWayCommand.splitWay(ws.getWay(), Arrays.asList(n1, n2), Collections.<OsmPrimitive>emptyList());
         }
     }

trunk/src/org/openstreetmap/josm/data/osm/IWaySegment.java

@@ -19 +19 @@
 public class IWaySegment<N extends INode, W extends IWay<N>> implements Comparable<IWaySegment<N, W>> {
 
+    private final W way;
+    private final int lowerIndex;
+
     /**
      * The way.
      */
-    public final W way;
+    public W getWay() {
+        return way;
+    }
 
     /**
-     * The index of one of the 2 nodes in the way.  The other node has the
-     * index <code>lowerIndex + 1</code>.
+     * The index of the first of the 2 nodes in the way.
+     * @see #getUpperIndex()
+     * @see #getFirstNode()
      */
-    public final int lowerIndex;
+    public int getLowerIndex() {
+        return lowerIndex;
+    }
+
+    /**
+     * The index of the second of the 2 nodes in the way.
+     * @see #getLowerIndex()
+     * @see #getSecondNode()
+     */
+    public int getUpperIndex() {
+        return lowerIndex;
+    }
 
     /**
@@ -49 +66 @@
      */
     public N getFirstNode() {
-        return way.getNode(lowerIndex);
+        return way.getNode(getLowerIndex());
     }
 
@@ -57 +74 @@
      */
     public N getSecondNode() {
-        return way.getNode(lowerIndex + 1);
+        return way.getNode(getUpperIndex());
     }
 

trunk/src/org/openstreetmap/josm/data/osm/WaySegment.java

@@ -100 +100 @@
     @Override
     public String toString() {
-        return "WaySegment [way=" + way.getUniqueId() + ", lowerIndex=" + lowerIndex + ']';
+        return "WaySegment [way=" + getWay().getUniqueId() + ", lowerIndex=" + getLowerIndex() + ']';
     }
 }

trunk/src/org/openstreetmap/josm/data/osm/visitor/paint/AbstractMapRenderer.java

@@ -149 +149 @@
             path = new GeneralPath();
             for (WaySegment wseg: data.getHighlightedVirtualNodes()) {
-                if (wseg.way.isUsable() && !wseg.way.isDisabled()) {
+                if (wseg.getWay().isUsable() && !wseg.getWay().isDisabled()) {
                     Way tmpWay = wseg.toWay();
                     visitVirtual(path, tmpWay);

trunk/src/org/openstreetmap/josm/data/osm/visitor/paint/StyledMapRenderer.java

@@ -1291 +1291 @@
             MapViewPath highlightSegs = null;
             for (WaySegment ws : highlightWaySegments) {
-                if (ws.way != way || ws.lowerIndex < offset) {
+                if (ws.getWay() != way || ws.getLowerIndex() < offset) {
                     continue;
                 }

trunk/src/org/openstreetmap/josm/data/validation/tests/CrossingWays.java

@@ -366 +366 @@
 
                     if (!es1.intersects(es2)
-                            || (!findSelfCrossingOnly && ignoreWaySegmentCombination(es1.way, es2.way))) {
+                            || (!findSelfCrossingOnly && ignoreWaySegmentCombination(es1.getWay(), es2.getWay()))) {
                         continue;
                     }
 
                     prims = new ArrayList<>();
-                    prims.add(es1.way);
-                    if (es1.way != es2.way)
-                        prims.add(es2.way);
+                    prims.add(es1.getWay());
+                    if (es1.getWay() != es2.getWay())
+                        prims.add(es2.getWay());
                     if ((highlight = seenWays.get(prims)) == null) {
                         highlight = new ArrayList<>();
@@ -379 +379 @@
                         highlight.add(es2);
 
-                        final MessageHelper message = createMessage(es1.way, es2.way);
+                        final MessageHelper message = createMessage(es1.getWay(), es2.getWay());
                         errors.add(TestError.builder(this, Severity.WARNING, message.code)
                                 .message(message.message)
@@ -437 +437 @@
 
                     List<WaySegment> highlight;
-                    if (es2.way == w // reported by CrossingWays.SelfIntersection
+                    if (es2.getWay() == w // reported by CrossingWays.SelfIntersection
                             || (findSharedWaySegments && !es1.isSimilar(es2))
                             || (!findSharedWaySegments && !es1.intersects(es2)))
                         continue;
 
-                    List<Way> prims = Arrays.asList(es1.way, es2.way);
+                    List<Way> prims = Arrays.asList(es1.getWay(), es2.getWay());
                     if ((highlight = crossingWays.get(prims)) == null) {
                         highlight = new ArrayList<>();

trunk/src/org/openstreetmap/josm/data/validation/tests/LongSegment.java

@@ -107 +107 @@
             errors.add(TestError.builder(this, Severity.WARNING, LONG_SEGMENT)
                     .message(tr("Long segments"), marktr("Very long segment of {0} kilometers"), length.intValue())
-                    .primitives(waySegment.way)
+                    .primitives(waySegment.getWay())
                     .highlightWaySegments(Collections.singleton(waySegment))
                     .build());

trunk/src/org/openstreetmap/josm/data/validation/tests/OverlappingWays.java

@@ -107 +107 @@
                 for (WaySegment ws : duplicated) {
                     // order in set is important
-                    grouped.computeIfAbsent(OsmUtils.getLayer(ws.way), k -> new LinkedHashSet<>()).add(ws);
+                    grouped.computeIfAbsent(OsmUtils.getLayer(ws.getWay()), k -> new LinkedHashSet<>()).add(ws);
                 }
                 grouped.values().forEach(group -> analyseOverlaps(group, seenWays));
@@ -122 +122 @@
             return;
 
-        List<Way> currentWays = duplicated.stream().map(ws -> ws.way).collect(Collectors.toList());
+        List<Way> currentWays = duplicated.stream().map(ws -> ws.getWay()).collect(Collectors.toList());
         Collection<WaySegment> highlight;
         if ((highlight = seenWays.get(currentWays)) != null) {
@@ -134 +134 @@
             int numAreas = 0;
             for (WaySegment ws : duplicated) {
-                boolean isArea = ws.way.concernsArea();
-                if (ws.way.hasKey(HIGHWAY)) {
+                boolean isArea = ws.getWay().concernsArea();
+                if (ws.getWay().hasKey(HIGHWAY)) {
                     if (!isArea) {
                         countHighway++;
                     }
-                } else if (ws.way.hasKey(RAILWAY)) {
+                } else if (ws.getWay().hasKey(RAILWAY)) {
                     if (!isArea) {
                         countRailway++;
                     }
-                } else if (ws.way.hasKey(WATERWAY)) {
+                } else if (ws.getWay().hasKey(WATERWAY)) {
                     if (!isArea) {
                         countWaterway++;
                     }
                 } else {
-                    if (ws.way.getInterestingTags().isEmpty() && parentMultipolygonConcernsArea(ws.way))
+                    if (ws.getWay().getInterestingTags().isEmpty() && parentMultipolygonConcernsArea(ws.getWay()))
                         isArea = true;
-                    if (!isArea && isOtherLinear(ws.way)) {
+                    if (!isArea && isOtherLinear(ws.getWay())) {
                         countOther++;
                     }

trunk/src/org/openstreetmap/josm/gui/NavigatableComponent.java

@@ -1259 +1259 @@
             // makes the order of nearestList dependent on current selection state
             for (WaySegment ws : wss) {
-                (ws.way.isSelected() ? nearestList : unselected).add(ws);
+                (ws.getWay().isSelected() ? nearestList : unselected).add(ws);
             }
             nearestList.addAll(unselected);
@@ -1307 +1307 @@
                     wayseg = ws;
                 }
-                if (ntsel == null && ws.way.isSelected()) {
+                if (ntsel == null && ws.getWay().isSelected()) {
                     ntsel = ws;
                 }
@@ -1342 +1342 @@
                     wayseg = ws;
                 }
-                if (useSelected && ws.way.isSelected()) {
+                if (useSelected && ws.getWay().isSelected()) {
                     return ws;
                 }
@@ -1350 +1350 @@
                         return ws;
                     }
-                    Collection<OsmPrimitive> wayRefs = ws.way.getReferrers();
+                    Collection<OsmPrimitive> wayRefs = ws.getWay().getReferrers();
                     // prefer member of the given relations
                     for (OsmPrimitive ref: preferredRefs) {
@@ -1392 +1392 @@
         List<Way> nearestList = getNearestWaySegmentsImpl(p, predicate).values().stream()
                 .flatMap(Collection::stream)
-                .filter(ws -> wset.add(ws.way))
-                .map(ws -> ws.way)
+                .filter(ws -> wset.add(ws.getWay()))
+                .map(ws -> ws.getWay())
                 .collect(Collectors.toList());
         if (ignore != null) {
@@ -1428 +1428 @@
     public final Way getNearestWay(Point p, Predicate<OsmPrimitive> predicate) {
         WaySegment nearestWaySeg = getNearestWaySegment(p, predicate);
-        return (nearestWaySeg == null) ? null : nearestWaySeg.way;
+        return (nearestWaySeg == null) ? null : nearestWaySeg.getWay();
     }
 
@@ -1546 +1546 @@
         if (ws == null) return osm;
 
-        if ((ws.way.isSelected() && useSelected) || osm == null) {
+        if ((ws.getWay().isSelected() && useSelected) || osm == null) {
             // either (no _selected_ nearest node found, if desired) or no nearest node was found
-            osm = ws.way;
+            osm = ws.getWay();
         } else {
             int maxWaySegLenSq = 3*PROP_SNAP_DISTANCE.get();
@@ -1560 +1560 @@
             if (wp1.distanceSq(wp2) < maxWaySegLenSq &&
                     p.distanceSq(project(0.5, wp1, wp2)) < p.distanceSq(getPoint2D((Node) osm))) {
-                osm = ws.way;
+                osm = ws.getWay();
             }
         }
@@ -1603 +1603 @@
         List<OsmPrimitive> nearestList = getNearestWaySegmentsImpl(p, predicate).values().stream()
                 .flatMap(Collection::stream)
-                .filter(ws -> wset.add(ws.way))
-                .map(ws -> ws.way)
+                .filter(ws -> wset.add(ws.getWay()))
+                .map(ws -> ws.getWay())
                 .collect(Collectors.toList());
 

trunk/src/org/openstreetmap/josm/gui/dialogs/ValidatorDialog.java

@@ -562 +562 @@
         @Override
         public void visit(WaySegment ws) {
-            if (ws.lowerIndex < 0 || ws.lowerIndex + 1 >= ws.way.getNodesCount())
+            if (ws.getLowerIndex() < 0 || ws.getUpperIndex() >= ws.getWay().getNodesCount())
                 return;
             visit(ws.getFirstNode());

trunk/src/org/openstreetmap/josm/gui/layer/validation/PaintVisitor.java

@@ -207 +207 @@
     @Override
     public void visit(WaySegment ws) {
-        if (ws.lowerIndex < 0 || ws.lowerIndex + 1 >= ws.way.getNodesCount())
+        if (ws.getLowerIndex() < 0 || ws.getUpperIndex() >= ws.getWay().getNodesCount())
             return;
         drawSegment(ws.getFirstNode(), ws.getSecondNode(), color);