Changeset 17896 in josm for trunk/src/org


Ignore:
Timestamp:
2021-05-17T19:44:04+02:00 (3 years ago)
Author:
simon04
Message:

see #17177 - IWaySegment: encapsulate fields

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

Legend:

Unmodified
Added
Removed

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

    r17188 r17896  
    108108            for (WaySegment ws : wss) {
    109109                // Maybe cleaner to pass a "isSelected" predicate to getNearestWaySegments, but this is less invasive.
    110                 if (restrictToSelectedWays && !ws.way.isSelected()) {
     110                if (restrictToSelectedWays && !ws.getWay().isSelected()) {
    111111                    continue;
    112112                }
    … …  
    135135                    // only use the closest WaySegment of each way and ignore those that already contain the node
    136136                    if (!ws.getFirstNode().equals(node) && !ws.getSecondNode().equals(node)
    137                             && !seenWays.contains(ws.way)) {
     137                            && !seenWays.contains(ws.getWay())) {
    138138                        if (usedDist == null)
    139139                            usedDist = entry.getKey();
    140                         MultiMap<Integer, Node> innerMap = data.get(ws.way);
     140                        MultiMap<Integer, Node> innerMap = data.get(ws.getWay());
    141141                        if (innerMap == null) {
    142142                            innerMap = new MultiMap<>();
    143                             data.put(ws.way, innerMap);
     143                            data.put(ws.getWay(), innerMap);
    144144                        }
    145                         innerMap.put(ws.lowerIndex, node);
    146                         seenWays.add(ws.way);
     145                        innerMap.put(ws.getLowerIndex(), node);
     146                        seenWays.add(ws.getWay());
    147147                    }
    148148                }

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

    r16661 r17896  
    418418            return DeleteCommand.deleteWaySegment(parameters.nearestSegment);
    419419        case way:
    420             return DeleteCommand.delete(Collections.singleton(parameters.nearestSegment.way), false, silent);
     420            return DeleteCommand.delete(Collections.singleton(parameters.nearestSegment.getWay()), false, silent);
    421421        case way_with_nodes:
    422             return DeleteCommand.delete(Collections.singleton(parameters.nearestSegment.way), true, silent);
     422            return DeleteCommand.delete(Collections.singleton(parameters.nearestSegment.getWay()), true, silent);
    423423        case way_with_references:
    424             return DeleteCommand.deleteWithReferences(Collections.singleton(parameters.nearestSegment.way), true);
     424            return DeleteCommand.deleteWithReferences(Collections.singleton(parameters.nearestSegment.getWay()), true);
    425425        default:
    426426            return null;

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

    r17666 r17896  
    694694        for (WaySegment ws : wss) {
    695695            List<Integer> is;
    696             if (insertPoints.containsKey(ws.way)) {
    697                 is = insertPoints.get(ws.way);
     696            if (insertPoints.containsKey(ws.getWay())) {
     697                is = insertPoints.get(ws.getWay());
    698698            } else {
    699699                is = new ArrayList<>();
    700                 insertPoints.put(ws.way, is);
    701             }
    702 
    703             is.add(ws.lowerIndex);
     700                insertPoints.put(ws.getWay(), is);
     701            }
     702
     703            is.add(ws.getLowerIndex());
    704704        }
    705705
    … …  
    859859            List<WaySegment> wss = mv.getNearestWaySegments(mousePos, OsmPrimitive::isSelectable);
    860860            for (WaySegment ws : wss) {
    861                 mouseOnExistingWays.add(ws.way);
     861                mouseOnExistingWays.add(ws.getWay());
    862862            }
    863863        }

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

    r17461 r17896  
    432432                mode = Mode.create_new;
    433433                // create a new segment and then select and extrude the new segment
    434                 getLayerManager().getEditDataSet().setSelected(selectedSegment.way);
     434                getLayerManager().getEditDataSet().setSelected(selectedSegment.getWay());
    435435                alwaysCreateNodes = true;
    436436            } else {
    437437                mode = Mode.extrude;
    438                 getLayerManager().getEditDataSet().setSelected(selectedSegment.way);
     438                getLayerManager().getEditDataSet().setSelected(selectedSegment.getWay());
    439439                alwaysCreateNodes = shift;
    440440            }
    … …  
    591591            EastNorth b = ws.getSecondNode().getEastNorth();
    592592            n.setEastNorth(Geometry.closestPointToSegment(a, b, n.getEastNorth()));
    593             Way wnew = new Way(ws.way);
    594             wnew.addNode(ws.lowerIndex+1, n);
    595             DataSet ds = ws.way.getDataSet();
     593            Way wnew = new Way(ws.getWay());
     594            wnew.addNode(ws.getLowerIndex() +1, n);
     595            DataSet ds = ws.getWay().getDataSet();
    596596            UndoRedoHandler.getInstance().add(new SequenceCommand(tr("Add a new node to an existing way"),
    597                     new AddCommand(ds, n), new ChangeNodesCommand(ds, ws.way, wnew.getNodes())));
     597                    new AddCommand(ds, n), new ChangeNodesCommand(ds, ws.getWay(), wnew.getNodes())));
    598598            wnew.setNodes(null); // see #19885
    599599
    … …  
    641641        // create extrusion
    642642        Collection<Command> cmds = new LinkedList<>();
    643         Way wnew = new Way(selectedSegment.way);
     643        Way wnew = new Way(selectedSegment.getWay());
    644644        boolean wayWasModified = false;
    645645        boolean wayWasSingleSegment = wnew.getNodesCount() == 2;
    646         int insertionPoint = selectedSegment.lowerIndex + 1;
     646        int insertionPoint = selectedSegment.getUpperIndex();
    647647
    648648        //find if the new points overlap existing segments (in case of 90 degree angles)
    649         Node prevNode = getPreviousNode(selectedSegment.lowerIndex);
     649        Node prevNode = getPreviousNode(selectedSegment.getLowerIndex());
    650650        boolean nodeOverlapsSegment = prevNode != null && Geometry.segmentsParallel(initialN1en, prevNode.getEastNorth(), initialN1en, newN1en);
    651651        // segmentAngleZero marks subset of nodeOverlapsSegment.
    652652        // nodeOverlapsSegment is true if angle between segments is 0 or PI, segmentAngleZero only if angle is 0
    653653        boolean segmentAngleZero = prevNode != null && Math.abs(Geometry.getCornerAngle(prevNode.getEastNorth(), initialN1en, newN1en)) < 1e-5;
    654         boolean hasOtherWays = hasNodeOtherWays(selectedSegment.getFirstNode(), selectedSegment.way);
     654        boolean hasOtherWays = hasNodeOtherWays(selectedSegment.getFirstNode(), selectedSegment.getWay());
    655655        List<Node> changedNodes = new ArrayList<>();
    656656        if (nodeOverlapsSegment && !alwaysCreateNodes && !hasOtherWays) {
    … …  
    679679
    680680        //find if the new points overlap existing segments (in case of 90 degree angles)
    681         Node nextNode = getNextNode(selectedSegment.lowerIndex + 1);
     681        Node nextNode = getNextNode(selectedSegment.getUpperIndex());
    682682        nodeOverlapsSegment = nextNode != null && Geometry.segmentsParallel(initialN2en, nextNode.getEastNorth(), initialN2en, newN2en);
    683683        segmentAngleZero = nextNode != null && Math.abs(Geometry.getCornerAngle(nextNode.getEastNorth(), initialN2en, newN2en)) < 1e-5;
    684         hasOtherWays = hasNodeOtherWays(selectedSegment.getSecondNode(), selectedSegment.way);
     684        hasOtherWays = hasNodeOtherWays(selectedSegment.getSecondNode(), selectedSegment.getWay());
    685685
    686686        if (nodeOverlapsSegment && !alwaysCreateNodes && !hasOtherWays) {
    … …  
    714714        if (wayWasModified) {
    715715            // we only need to change the way if its node list was really modified
    716             cmds.add(new ChangeNodesCommand(selectedSegment.way, wnew.getNodes()));
     716            cmds.add(new ChangeNodesCommand(selectedSegment.getWay(), wnew.getNodes()));
    717717        }
    718718        wnew.setNodes(null); // see #19885
    … …  
    824824
    825825        //add directions parallel to neighbor segments
    826         Node prevNode = getPreviousNode(selectedSegment.lowerIndex);
     826        Node prevNode = getPreviousNode(selectedSegment.getLowerIndex());
    827827        if (prevNode != null) {
    828828            EastNorth en = prevNode.getEastNorth();
    … …  
    833833        }
    834834
    835         Node nextNode = getNextNode(selectedSegment.lowerIndex + 1);
     835        Node nextNode = getNextNode(selectedSegment.getUpperIndex());
    836836        if (nextNode != null) {
    837837            EastNorth en = nextNode.getEastNorth();
    … …  
    871871     */
    872872    private boolean checkDualAlignConditions() {
    873         Node prevNode = getPreviousNode(selectedSegment.lowerIndex);
    874         Node nextNode = getNextNode(selectedSegment.lowerIndex + 1);
     873        Node prevNode = getPreviousNode(selectedSegment.getLowerIndex());
     874        Node nextNode = getNextNode(selectedSegment.getUpperIndex());
    875875        if (prevNode == null || nextNode == null) {
    876876            return false;
    … …  
    906906
    907907        // set neighboring segments
    908         Node prevNode = getPreviousNode(selectedSegment.lowerIndex);
     908        Node prevNode = getPreviousNode(selectedSegment.getLowerIndex());
    909909        if (prevNode != null) {
    910910            EastNorth prevNodeEn = prevNode.getEastNorth();
    … …  
    915915        }
    916916
    917         Node nextNode = getNextNode(selectedSegment.lowerIndex + 1);
     917        Node nextNode = getNextNode(selectedSegment.getUpperIndex());
    918918        if (nextNode != null) {
    919919            EastNorth nextNodeEn = nextNode.getEastNorth();
    … …  
    975975        if (index > 0)
    976976            return index - 1;
    977         else if (selectedSegment.way.isClosed())
    978             return selectedSegment.way.getNodesCount() - 2;
     977        else if (selectedSegment.getWay().isClosed())
     978            return selectedSegment.getWay().getNodesCount() - 2;
    979979        else
    980980            return -1;
    … …  
    989989        int indexPrev = getPreviousNodeIndex(index);
    990990        if (indexPrev >= 0)
    991             return selectedSegment.way.getNode(indexPrev);
     991            return selectedSegment.getWay().getNode(indexPrev);
    992992        else
    993993            return null;
    … …  
    10001000     */
    10011001    private int getNextNodeIndex(int index) {
    1002         int count = selectedSegment.way.getNodesCount();
     1002        int count = selectedSegment.getWay().getNodesCount();
    10031003        if (index < count - 1)
    10041004            return index + 1;
    1005         else if (selectedSegment.way.isClosed())
     1005        else if (selectedSegment.getWay().isClosed())
    10061006            return 1;
    10071007        else
    … …  
    10171017        int indexNext = getNextNodeIndex(index);
    10181018        if (indexNext >= 0)
    1019             return selectedSegment.way.getNode(indexNext);
     1019            return selectedSegment.getWay().getNode(indexNext);
    10201020        else
    10211021            return null;

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

    r17440 r17896  
    463463                // Adding the node to all segments found
    464464                for (WaySegment virtualSegment : virtualSegments) {
    465                     Way w = virtualSegment.way;
     465                    Way w = virtualSegment.getWay();
    466466                    List<Node> modNodes = w.getNodes();
    467                     modNodes.add(virtualSegment.lowerIndex + 1, virtualNode);
     467                    modNodes.add(virtualSegment.getUpperIndex(), virtualNode);
    468468                    virtualCmds.add(new ChangeNodesCommand(w, modNodes));
    469469                }

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

    r17157 r17896  
    508508        sourceWays.removeIf(w -> w.isIncomplete() || w.isEmpty());
    509509
    510         if (!sourceWays.contains(referenceSegment.way)) {
     510        if (!sourceWays.contains(referenceSegment.getWay())) {
    511511            clearSourceWays();
    512             addSourceWay(referenceSegment.way);
     512            addSourceWay(referenceSegment.getWay());
    513513        }
    514514
    … …  
    517517            int i = 0;
    518518            for (Way w : sourceWays) {
    519                 if (w == referenceSegment.way) {
     519                if (w == referenceSegment.getWay()) {
    520520                    referenceWayIndex = i;
    521521                    break;

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

    r17666 r17896  
    12151215
    12161216                for (WaySegment ws : mv.getNearestWaySegments(p, mv.isSelectablePredicate)) {
    1217                     Way w = ws.way;
    1218 
    1219                     wnp.a = w.getNode(ws.lowerIndex);
    1220                     wnp.b = w.getNode(ws.lowerIndex + 1);
     1217                    Way w = ws.getWay();
     1218
     1219                    wnp.a = w.getNode(ws.getLowerIndex());
     1220                    wnp.b = w.getNode(ws.getUpperIndex());
    12211221                    MapViewPoint p1 = mv.getState().getPointFor(wnp.a);
    12221222                    MapViewPoint p2 = mv.getState().getPointFor(wnp.b);
    … …  
    12571257            virtualCmds.add(new AddCommand(ds, virtualNode));
    12581258            for (WaySegment virtualWay : virtualWays) {
    1259                 Way w = virtualWay.way;
     1259                Way w = virtualWay.getWay();
    12601260                List<Node> modNodes = w.getNodes();
    1261                 modNodes.add(virtualWay.lowerIndex + 1, virtualNode);
     1261                modNodes.add(virtualWay.getUpperIndex(), virtualNode);
    12621262                virtualCmds.add(new ChangeNodesCommand(ds, w, modNodes));
    12631263            }

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

    r17205 r17896  
    479479     */
    480480    public static Command deleteWaySegment(WaySegment ws) {
    481         if (ws.way.getNodesCount() < 3)
    482             return delete(Collections.singleton(ws.way), false);
    483 
    484         if (ws.way.isClosed()) {
     481        if (ws.getWay().getNodesCount() < 3)
     482            return delete(Collections.singleton(ws.getWay()), false);
     483
     484        if (ws.getWay().isClosed()) {
    485485            // If the way is circular (first and last nodes are the same), the way shouldn't be splitted
    486486
    487487            List<Node> n = new ArrayList<>();
    488488
    489             n.addAll(ws.way.getNodes().subList(ws.lowerIndex + 1, ws.way.getNodesCount() - 1));
    490             n.addAll(ws.way.getNodes().subList(0, ws.lowerIndex + 1));
    491 
    492             return new ChangeNodesCommand(ws.way, n);
     489            n.addAll(ws.getWay().getNodes().subList(ws.getUpperIndex(), ws.getWay().getNodesCount() - 1));
     490            n.addAll(ws.getWay().getNodes().subList(0, ws.getUpperIndex()));
     491
     492            return new ChangeNodesCommand(ws.getWay(), n);
    493493        }
    494494
    … …  
    496496        List<Node> n2 = new ArrayList<>();
    497497
    498         n1.addAll(ws.way.getNodes().subList(0, ws.lowerIndex + 1));
    499         n2.addAll(ws.way.getNodes().subList(ws.lowerIndex + 1, ws.way.getNodesCount()));
     498        n1.addAll(ws.getWay().getNodes().subList(0, ws.getUpperIndex()));
     499        n2.addAll(ws.getWay().getNodes().subList(ws.getUpperIndex(), ws.getWay().getNodesCount()));
    500500
    501501        if (n1.size() < 2) {
    502             return new ChangeNodesCommand(ws.way, n2);
     502            return new ChangeNodesCommand(ws.getWay(), n2);
    503503        } else if (n2.size() < 2) {
    504             return new ChangeNodesCommand(ws.way, n1);
     504            return new ChangeNodesCommand(ws.getWay(), n1);
    505505        } else {
    506             return SplitWayCommand.splitWay(ws.way, Arrays.asList(n1, n2), Collections.<OsmPrimitive>emptyList());
     506            return SplitWayCommand.splitWay(ws.getWay(), Arrays.asList(n1, n2), Collections.<OsmPrimitive>emptyList());
    507507        }
    508508    }

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

    r17867 r17896  
    1919public class IWaySegment<N extends INode, W extends IWay<N>> implements Comparable<IWaySegment<N, W>> {
    2020
     21    private final W way;
     22    private final int lowerIndex;
     23
    2124    /**
    2225     * The way.
    2326     */
    24     public final W way;
     27    public W getWay() {
     28        return way;
     29    }
    2530
    2631    /**
    27      * The index of one of the 2 nodes in the way.  The other node has the
    28      * index <code>lowerIndex + 1</code>.
     32     * The index of the first of the 2 nodes in the way.
     33     * @see #getUpperIndex()
     34     * @see #getFirstNode()
    2935     */
    30     public final int lowerIndex;
     36    public int getLowerIndex() {
     37        return lowerIndex;
     38    }
     39
     40    /**
     41     * The index of the second of the 2 nodes in the way.
     42     * @see #getLowerIndex()
     43     * @see #getSecondNode()
     44     */
     45    public int getUpperIndex() {
     46        return lowerIndex;
     47    }
    3148
    3249    /**
    … …  
    4966     */
    5067    public N getFirstNode() {
    51         return way.getNode(lowerIndex);
     68        return way.getNode(getLowerIndex());
    5269    }
    5370
    … …  
    5774     */
    5875    public N getSecondNode() {
    59         return way.getNode(lowerIndex + 1);
     76        return way.getNode(getUpperIndex());
    6077    }
    6178

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

    r17862 r17896  
    100100    @Override
    101101    public String toString() {
    102         return "WaySegment [way=" + way.getUniqueId() + ", lowerIndex=" + lowerIndex + ']';
     102        return "WaySegment [way=" + getWay().getUniqueId() + ", lowerIndex=" + getLowerIndex() + ']';
    103103    }
    104104}

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

    r17333 r17896  
    149149            path = new GeneralPath();
    150150            for (WaySegment wseg: data.getHighlightedVirtualNodes()) {
    151                 if (wseg.way.isUsable() && !wseg.way.isDisabled()) {
     151                if (wseg.getWay().isUsable() && !wseg.getWay().isDisabled()) {
    152152                    Way tmpWay = wseg.toWay();
    153153                    visitVirtual(path, tmpWay);

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

    r17862 r17896  
    12911291            MapViewPath highlightSegs = null;
    12921292            for (WaySegment ws : highlightWaySegments) {
    1293                 if (ws.way != way || ws.lowerIndex < offset) {
     1293                if (ws.getWay() != way || ws.getLowerIndex() < offset) {
    12941294                    continue;
    12951295                }

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

    r17447 r17896  
    366366
    367367                    if (!es1.intersects(es2)
    368                             || (!findSelfCrossingOnly && ignoreWaySegmentCombination(es1.way, es2.way))) {
     368                            || (!findSelfCrossingOnly && ignoreWaySegmentCombination(es1.getWay(), es2.getWay()))) {
    369369                        continue;
    370370                    }
    371371
    372372                    prims = new ArrayList<>();
    373                     prims.add(es1.way);
    374                     if (es1.way != es2.way)
    375                         prims.add(es2.way);
     373                    prims.add(es1.getWay());
     374                    if (es1.getWay() != es2.getWay())
     375                        prims.add(es2.getWay());
    376376                    if ((highlight = seenWays.get(prims)) == null) {
    377377                        highlight = new ArrayList<>();
    … …  
    379379                        highlight.add(es2);
    380380
    381                         final MessageHelper message = createMessage(es1.way, es2.way);
     381                        final MessageHelper message = createMessage(es1.getWay(), es2.getWay());
    382382                        errors.add(TestError.builder(this, Severity.WARNING, message.code)
    383383                                .message(message.message)
    … …  
    437437
    438438                    List<WaySegment> highlight;
    439                     if (es2.way == w // reported by CrossingWays.SelfIntersection
     439                    if (es2.getWay() == w // reported by CrossingWays.SelfIntersection
    440440                            || (findSharedWaySegments && !es1.isSimilar(es2))
    441441                            || (!findSharedWaySegments && !es1.intersects(es2)))
    442442                        continue;
    443443
    444                     List<Way> prims = Arrays.asList(es1.way, es2.way);
     444                    List<Way> prims = Arrays.asList(es1.getWay(), es2.getWay());
    445445                    if ((highlight = crossingWays.get(prims)) == null) {
    446446                        highlight = new ArrayList<>();

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

    r17761 r17896  
    107107            errors.add(TestError.builder(this, Severity.WARNING, LONG_SEGMENT)
    108108                    .message(tr("Long segments"), marktr("Very long segment of {0} kilometers"), length.intValue())
    109                     .primitives(waySegment.way)
     109                    .primitives(waySegment.getWay())
    110110                    .highlightWaySegments(Collections.singleton(waySegment))
    111111                    .build());

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

    r17786 r17896  
    107107                for (WaySegment ws : duplicated) {
    108108                    // order in set is important
    109                     grouped.computeIfAbsent(OsmUtils.getLayer(ws.way), k -> new LinkedHashSet<>()).add(ws);
     109                    grouped.computeIfAbsent(OsmUtils.getLayer(ws.getWay()), k -> new LinkedHashSet<>()).add(ws);
    110110                }
    111111                grouped.values().forEach(group -> analyseOverlaps(group, seenWays));
    … …  
    122122            return;
    123123
    124         List<Way> currentWays = duplicated.stream().map(ws -> ws.way).collect(Collectors.toList());
     124        List<Way> currentWays = duplicated.stream().map(ws -> ws.getWay()).collect(Collectors.toList());
    125125        Collection<WaySegment> highlight;
    126126        if ((highlight = seenWays.get(currentWays)) != null) {
    … …  
    134134            int numAreas = 0;
    135135            for (WaySegment ws : duplicated) {
    136                 boolean isArea = ws.way.concernsArea();
    137                 if (ws.way.hasKey(HIGHWAY)) {
     136                boolean isArea = ws.getWay().concernsArea();
     137                if (ws.getWay().hasKey(HIGHWAY)) {
    138138                    if (!isArea) {
    139139                        countHighway++;
    140140                    }
    141                 } else if (ws.way.hasKey(RAILWAY)) {
     141                } else if (ws.getWay().hasKey(RAILWAY)) {
    142142                    if (!isArea) {
    143143                        countRailway++;
    144144                    }
    145                 } else if (ws.way.hasKey(WATERWAY)) {
     145                } else if (ws.getWay().hasKey(WATERWAY)) {
    146146                    if (!isArea) {
    147147                        countWaterway++;
    148148                    }
    149149                } else {
    150                     if (ws.way.getInterestingTags().isEmpty() && parentMultipolygonConcernsArea(ws.way))
     150                    if (ws.getWay().getInterestingTags().isEmpty() && parentMultipolygonConcernsArea(ws.getWay()))
    151151                        isArea = true;
    152                     if (!isArea && isOtherLinear(ws.way)) {
     152                    if (!isArea && isOtherLinear(ws.getWay())) {
    153153                        countOther++;
    154154                    }

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

    r17841 r17896  
    12591259            // makes the order of nearestList dependent on current selection state
    12601260            for (WaySegment ws : wss) {
    1261                 (ws.way.isSelected() ? nearestList : unselected).add(ws);
     1261                (ws.getWay().isSelected() ? nearestList : unselected).add(ws);
    12621262            }
    12631263            nearestList.addAll(unselected);
    … …  
    13071307                    wayseg = ws;
    13081308                }
    1309                 if (ntsel == null && ws.way.isSelected()) {
     1309                if (ntsel == null && ws.getWay().isSelected()) {
    13101310                    ntsel = ws;
    13111311                }
    … …  
    13421342                    wayseg = ws;
    13431343                }
    1344                 if (useSelected && ws.way.isSelected()) {
     1344                if (useSelected && ws.getWay().isSelected()) {
    13451345                    return ws;
    13461346                }
    … …  
    13501350                        return ws;
    13511351                    }
    1352                     Collection<OsmPrimitive> wayRefs = ws.way.getReferrers();
     1352                    Collection<OsmPrimitive> wayRefs = ws.getWay().getReferrers();
    13531353                    // prefer member of the given relations
    13541354                    for (OsmPrimitive ref: preferredRefs) {
    … …  
    13921392        List<Way> nearestList = getNearestWaySegmentsImpl(p, predicate).values().stream()
    13931393                .flatMap(Collection::stream)
    1394                 .filter(ws -> wset.add(ws.way))
    1395                 .map(ws -> ws.way)
     1394                .filter(ws -> wset.add(ws.getWay()))
     1395                .map(ws -> ws.getWay())
    13961396                .collect(Collectors.toList());
    13971397        if (ignore != null) {
    … …  
    14281428    public final Way getNearestWay(Point p, Predicate<OsmPrimitive> predicate) {
    14291429        WaySegment nearestWaySeg = getNearestWaySegment(p, predicate);
    1430         return (nearestWaySeg == null) ? null : nearestWaySeg.way;
     1430        return (nearestWaySeg == null) ? null : nearestWaySeg.getWay();
    14311431    }
    14321432
    … …  
    15461546        if (ws == null) return osm;
    15471547
    1548         if ((ws.way.isSelected() && useSelected) || osm == null) {
     1548        if ((ws.getWay().isSelected() && useSelected) || osm == null) {
    15491549            // either (no _selected_ nearest node found, if desired) or no nearest node was found
    1550             osm = ws.way;
     1550            osm = ws.getWay();
    15511551        } else {
    15521552            int maxWaySegLenSq = 3*PROP_SNAP_DISTANCE.get();
    … …  
    15601560            if (wp1.distanceSq(wp2) < maxWaySegLenSq &&
    15611561                    p.distanceSq(project(0.5, wp1, wp2)) < p.distanceSq(getPoint2D((Node) osm))) {
    1562                 osm = ws.way;
     1562                osm = ws.getWay();
    15631563            }
    15641564        }
    … …  
    16031603        List<OsmPrimitive> nearestList = getNearestWaySegmentsImpl(p, predicate).values().stream()
    16041604                .flatMap(Collection::stream)
    1605                 .filter(ws -> wset.add(ws.way))
    1606                 .map(ws -> ws.way)
     1605                .filter(ws -> wset.add(ws.getWay()))
     1606                .map(ws -> ws.getWay())
    16071607                .collect(Collectors.toList());
    16081608

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

    r17261 r17896  
    562562        @Override
    563563        public void visit(WaySegment ws) {
    564             if (ws.lowerIndex < 0 || ws.lowerIndex + 1 >= ws.way.getNodesCount())
     564            if (ws.getLowerIndex() < 0 || ws.getUpperIndex() >= ws.getWay().getNodesCount())
    565565                return;
    566566            visit(ws.getFirstNode());

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

    r15586 r17896  
    207207    @Override
    208208    public void visit(WaySegment ws) {
    209         if (ws.lowerIndex < 0 || ws.lowerIndex + 1 >= ws.way.getNodesCount())
     209        if (ws.getLowerIndex() < 0 || ws.getUpperIndex() >= ws.getWay().getNodesCount())
    210210            return;
    211211        drawSegment(ws.getFirstNode(), ws.getSecondNode(), color);
Note: See TracChangeset for help on using the changeset viewer.