Changeset 1898 in josm


Ignore:
Timestamp:
2009-08-03T21:18:50+02:00 (11 years ago)
Author:
jttt
Message:

Way refactoring - rewritten another parts of code to the new nodes api

Location:
trunk
Files:
20 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/actions/OrthogonalizeAction.java

    r1862 r1898  
    1212
    1313import javax.swing.JOptionPane;
    14 import javax.swing.text.html.Option;
    1514
    1615import org.openstreetmap.josm.Main;
     
    9695            // Otherwise, two segments could be turned into same direction and intersection would fail.
    9796            // Or changes of shape would be too serious.
    98             for (int i1=0; i1 < way.nodes.size()-1; i1++) {
    99                 int i2 = (i1+1) % (way.nodes.size()-1);
    100                 int i3 = (i1+2) % (way.nodes.size()-1);
    101                 double angle1  =Math.abs(way.nodes.get(i1).getEastNorth().heading(way.nodes.get(i2).getEastNorth()));
    102                 double angle2 = Math.abs(way.nodes.get(i2).getEastNorth().heading(way.nodes.get(i3).getEastNorth()));
     97            for (int i1=0; i1 < way.getNodesCount()-1; i1++) {
     98                int i2 = (i1+1) % (way.getNodesCount()-1);
     99                int i3 = (i1+2) % (way.getNodesCount()-1);
     100                double angle1  =Math.abs(way.getNode(i1).getEastNorth().heading(way.getNode(i2).getEastNorth()));
     101                double angle2 = Math.abs(way.getNode(i2).getEastNorth().heading(way.getNode(i3).getEastNorth()));
    103102                double delta = Math.abs(angle2 - angle1);
    104103                while(delta > Math.PI) {
     
    162161
    163162            Way way = (Way)osm;
    164             int nodes = way.nodes.size();
     163            int nodes = way.getNodesCount();
    165164            int sides = nodes - 1;
    166165            // Copy necessary data into a more suitable data structure
    167166            EastNorth en[] = new EastNorth[sides];
    168167            for (int i=0; i < sides; i++) {
    169                 en[i] = new EastNorth(way.nodes.get(i).getEastNorth().east(), way.nodes.get(i).getEastNorth().north());
     168                en[i] = new EastNorth(way.getNode(i).getEastNorth().east(), way.getNode(i).getEastNorth().north());
    170169            }
    171170
     
    178177                double weights[] = new double[sides];
    179178                for (int i=0; i < sides; i++) {
    180                     headings[i] = normalize_angle(way.nodes.get(i).getEastNorth().heading(way.nodes.get(i+1).getEastNorth()));
    181                     weights[i] = way.nodes.get(i).getEastNorth().distance(way.nodes.get(i+1).getEastNorth());
     179                    headings[i] = normalize_angle(way.getNode(i).getEastNorth().heading(way.getNode(i+1).getEastNorth()));
     180                    weights[i] = way.getNode(i).getEastNorth().distance(way.getNode(i+1).getEastNorth());
    182181                }
    183182
     
    270269                        B.north() + q * (A.north() - B.north()));
    271270
    272                 Node n = way.nodes.get(i2);
     271                Node n = way.getNode(i2);
    273272
    274273                LatLon ill = Main.proj.eastNorth2latlon(intersection);
  • trunk/src/org/openstreetmap/josm/actions/SplitWayAction.java

    r1862 r1898  
    285285            }
    286286            newWays.add(wayToAdd);
    287             wayToAdd.nodes.addAll(chunkIt.next());
     287            wayToAdd.setNodes(chunkIt.next());
    288288            commandList.add(new AddCommand(wayToAdd));
    289289            //Main.debug("wayToAdd: " + wayToAdd);
  • trunk/src/org/openstreetmap/josm/actions/UpdateSelectionAction.java

    r1883 r1898  
    7272     *   the current dataset
    7373     * @exception IllegalStateException thrown if there is no current dataset
    74      * 
     74     *
    7575     */
    7676    public void updatePrimitive(long id) throws IllegalStateException{
     
    171171                } else if (primitive instanceof Way) {
    172172                    Way way = (Way)primitive;
    173                     for (Node node: way.nodes) {
     173                    for (Node node: way.getNodes()) {
    174174                        if (node.id > 0) {
    175175                            reader.append(node);
  • trunk/src/org/openstreetmap/josm/actions/mapmode/DrawAction.java

    r1858 r1898  
    391391                    for (int i : is) {
    392392                        segSet.add(
    393                                 Pair.sort(new Pair<Node,Node>(w.nodes.get(i), w.nodes.get(i+1))));
     393                                Pair.sort(new Pair<Node,Node>(w.getNode(i), w.getNode(i+1))));
    394394                    }
    395395                    for (int i : is) {
     
    478478                if(way != null) {
    479479                    int nodeCount=0;
    480                     for (Node p : way.nodes)
     480                    for (Node p : way.getNodes())
    481481                        if(p.equals(n0)) {
    482482                            nodeCount++;
     
    503503
    504504                // Connected to a node that's already in the way
    505                 if(way.nodes.contains(n)) {
     505                if(way.getNodes().contains(n)) {
    506506                    wayIsFinished = true;
    507507                    selection.clear();
     
    509509
    510510                // Add new node to way
    511                 if (way.nodes.get(way.nodes.size() - 1) == n0) {
     511                if (way.getNode(way.getNodesCount() - 1) == n0) {
    512512                    way.addNode(n);
    513513                } else {
     
    571571     */
    572572    private boolean isSelfContainedWay(Way selectedWay, Node currentNode, Node targetNode) {
    573         if(selectedWay != null && selectedWay.nodes != null) {
    574             int posn0 = selectedWay.nodes.indexOf(currentNode);
     573        if(selectedWay != null) {
     574            int posn0 = selectedWay.getNodes().indexOf(currentNode);
    575575            if( posn0 != -1 && // n0 is part of way
    576                     (posn0 >= 1                          && targetNode.equals(selectedWay.nodes.get(posn0-1))) || // previous node
    577                     (posn0 < selectedWay.nodes.size()-1) && targetNode.equals(selectedWay.nodes.get(posn0+1))) {  // next node
     576                    (posn0 >= 1                             && targetNode.equals(selectedWay.getNode(posn0-1))) || // previous node
     577                    (posn0 < selectedWay.getNodesCount()-1) && targetNode.equals(selectedWay.getNode(posn0+1))) {  // next node
    578578                getCurrentDataSet().setSelected(targetNode);
    579579                DataSet.fireSelectionChanged(getCurrentDataSet().getSelected());
     
    714714            if (selectedWay.isFirstLastNode(lastUsedNode)) {
    715715                currentBaseNode = lastUsedNode;
    716                 if (lastUsedNode == selectedWay.nodes.get(selectedWay.nodes.size()-1) && selectedWay.nodes.size() > 1) {
    717                     previousNode = selectedWay.nodes.get(selectedWay.nodes.size()-2);
     716                if (lastUsedNode == selectedWay.getNode(selectedWay.getNodesCount()-1) && selectedWay.getNodesCount() > 1) {
     717                    previousNode = selectedWay.getNode(selectedWay.getNodesCount()-2);
    718718                }
    719719            }
     
    721721            currentBaseNode = selectedNode;
    722722        } else {
    723             if (selectedNode == selectedWay.nodes.get(0) || selectedNode == selectedWay.nodes.get(selectedWay.nodes.size()-1)) {
     723            if (selectedNode == selectedWay.getNode(0) || selectedNode == selectedWay.getNode(selectedWay.getNodesCount()-1)) {
    724724                currentBaseNode = selectedNode;
    725725            }
     
    763763        Way way = null;
    764764        for (Way w : getCurrentDataSet().ways) {
    765             if (w.deleted || w.incomplete || w.nodes.size() < 1) {
     765            if (w.deleted || w.incomplete || w.getNodesCount() < 1) {
    766766                continue;
    767767            }
    768             Node firstNode = w.nodes.get(0);
    769             Node lastNode = w.nodes.get(w.nodes.size() - 1);
     768            Node firstNode = w.getNode(0);
     769            Node lastNode = w.getNode(w.getNodesCount() - 1);
    770770            if ((firstNode == n || lastNode == n) && (firstNode != lastNode)) {
    771771                if (way != null)
     
    966966        if (getCurrentDataSet() != null && getCurrentDataSet().getSelectedWays().size() > 0 && !wayIsFinished && !alt) {
    967967            Way w = (Way) getCurrentDataSet().getSelectedWays().iterator().next();
    968             for (Node m : w.nodes) {
     968            for (Node m : w.getNodes()) {
    969969                if (m.equals(mouseOnExistingNode) || mouseOnExistingWays.contains(w)) {
    970970                    rv += " " + tr("Finish drawing.");
  • trunk/src/org/openstreetmap/josm/actions/mapmode/ExtrudeAction.java

    r1814 r1898  
    2828import org.openstreetmap.josm.gui.MapFrame;
    2929import org.openstreetmap.josm.gui.MapView;
     30import org.openstreetmap.josm.gui.layer.Layer;
    3031import org.openstreetmap.josm.gui.layer.MapViewPaintable;
    31 import org.openstreetmap.josm.gui.layer.Layer;
    3232import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    3333import org.openstreetmap.josm.tools.ImageProvider;
     
    152152    public void paint(Graphics g, MapView mv) {
    153153        if (selectedSegment != null) {
    154             Node n1 = selectedSegment.way.nodes.get(selectedSegment.lowerIndex);
    155             Node n2 = selectedSegment.way.nodes.get(selectedSegment.lowerIndex + 1);
     154            Node n1 = selectedSegment.way.getNode(selectedSegment.lowerIndex);
     155            Node n2 = selectedSegment.way.getNode(selectedSegment.lowerIndex + 1);
    156156
    157157            EastNorth en1 = n1.getEastNorth();
     
    233233        if (selectedSegment == null) return;
    234234        if (mousePos.distance(initialMousePos) > 10) {
    235             Node n1 = selectedSegment.way.nodes.get(selectedSegment.lowerIndex);
    236             Node n2 = selectedSegment.way.nodes.get(selectedSegment.lowerIndex+1);
     235            Node n1 = selectedSegment.way.getNode(selectedSegment.lowerIndex);
     236            Node n2 = selectedSegment.way.getNode(selectedSegment.lowerIndex+1);
    237237            EastNorth en3 = n2.getEastNorth().add(xoff, yoff);
    238238            Node n3 = new Node(Main.proj.eastNorth2latlon(en3));
     
    242242            wnew.addNode(selectedSegment.lowerIndex+1, n3);
    243243            wnew.addNode(selectedSegment.lowerIndex+1, n4);
    244             if (wnew.nodes.size() == 4) {
     244            if (wnew.getNodesCount() == 4) {
    245245                wnew.addNode(n1);
    246246            }
  • trunk/src/org/openstreetmap/josm/command/DeleteCommand.java

    r1856 r1898  
    6767     * Constructor for a single data item. Use the collection constructor to delete multiple
    6868     * objects.
    69      * 
     69     *
    7070     * @param layer the layer context for deleting this primitive
    7171     * @param data the primitive to delete
     
    7979     * Constructor for a collection of data to be deleted in the context of
    8080     * a specific layer
    81      * 
     81     *
    8282     * @param layer the layer context for deleting these primitives
    8383     * @param data the primitives to delete
     
    137137    /**
    138138     * Delete the primitives and everything they reference.
    139      * 
     139     *
    140140     * If a node is deleted, the node and all ways and relations the node is part of are deleted as
    141141     * well.
    142      * 
     142     *
    143143     * If a way is deleted, all relations the way is member of are also deleted.
    144      * 
     144     *
    145145     * If a way is deleted, only the way and no nodes are deleted.
    146      * 
     146     *
    147147     * @param selection The list of all object to be deleted.
    148148     * @return command A command to perform the deletions, or null of there is nothing to delete.
     
    204204                continue;
    205205            }
    206             for (Node n : ((Way) osm).nodes) {
     206            for (Node n : ((Way) osm).getNodes()) {
    207207                if (n.isTagged()) {
    208208                    continue;
     
    221221    /**
    222222     * Try to delete all given primitives.
    223      * 
     223     *
    224224     * If a node is used by a way, it's removed from that way. If a node or a way is used by a
    225225     * relation, inform the user and do not delete.
    226      * 
     226     *
    227227     * If this would cause ways with less than 2 nodes to be created, delete these ways instead. If
    228228     * they are part of a relation, inform the user and do not delete.
    229      * 
     229     *
    230230     * @param layer the {@see OsmDataLayer} in whose context a primitive the primitives are deleted
    231231     * @param selection The objects to delete.
     
    279279            Way wnew = new Way(w);
    280280            wnew.removeNodes(primitivesToDelete);
    281             if (wnew.nodes.size() < 2) {
     281            if (wnew.getNodesCount() < 2) {
    282282                primitivesToDelete.add(w);
    283283
     
    347347            }
    348348            Way wnew = new Way(w);
    349             ArrayList<Node> nodesToStrip = new ArrayList<Node>();
     349            List<Node> nodesToKeep = new ArrayList<Node>();
    350350            // lookup new nodes which have been added to the set of deleted
    351351            // nodes ...
    352             for (Node n : wnew.nodes) {
    353                 if (n.id == 0 && primitivesToDelete.contains(n)) {
    354                     nodesToStrip.add(n);
     352            for (Node n : wnew.getNodes()) {
     353                if (n.id != 0 || !primitivesToDelete.contains(n)) {
     354                    nodesToKeep.add(n);
    355355                }
    356356            }
    357357            // .. and remove them from the way
    358358            //
    359             wnew.nodes.removeAll(nodesToStrip);
    360             if (!nodesToStrip.isEmpty()) {
     359            wnew.setNodes(nodesToKeep);
     360            if (nodesToKeep.size() < w.getNodesCount()) {
    361361                cmds.add(new ChangeCommand(w, wnew));
    362362            }
     
    373373        List<Node> n1 = new ArrayList<Node>(), n2 = new ArrayList<Node>();
    374374
    375         n1.addAll(ws.way.nodes.subList(0, ws.lowerIndex + 1));
    376         n2.addAll(ws.way.nodes.subList(ws.lowerIndex + 1, ws.way.nodes.size()));
     375        n1.addAll(ws.way.getNodes().subList(0, ws.lowerIndex + 1));
     376        n2.addAll(ws.way.getNodes().subList(ws.lowerIndex + 1, ws.way.getNodesCount()));
    377377
    378378        if (n1.size() < 2 && n2.size() < 2)
     
    380380
    381381        Way wnew = new Way(ws.way);
    382         wnew.nodes.clear();
    383382
    384383        if (n1.size() < 2) {
    385             wnew.nodes.addAll(n2);
     384            wnew.setNodes(n2);
    386385            return new ChangeCommand(ws.way, wnew);
    387386        } else if (n2.size() < 2) {
    388             wnew.nodes.addAll(n1);
     387            wnew.setNodes(n1);
    389388            return new ChangeCommand(ws.way, wnew);
    390389        } else {
    391390            Collection<Command> cmds = new LinkedList<Command>();
    392391
    393             wnew.nodes.addAll(n1);
     392            wnew.setNodes(n1);
    394393            cmds.add(new ChangeCommand(ws.way, wnew));
    395394
     
    398397                wnew2.keys = new HashMap<String, String>(wnew.keys);
    399398            }
    400             wnew2.nodes.addAll(n2);
     399            wnew2.setNodes(n2);
    401400            cmds.add(new AddCommand(wnew2));
    402401
     
    408407     * Check whether user is about to delete data outside of the download area. Request confirmation
    409408     * if he is.
    410      * 
     409     *
    411410     * @param layer the layer in whose context data is deleted
    412411     * @param primitivesToDelete the primitives to delete
  • trunk/src/org/openstreetmap/josm/command/PurgePrimitivesCommand.java

    r1862 r1898  
    190190                // remember it on the "hive"
    191191                //
    192                 if (w.nodes.size() < 2) {
     192                if (w.getNodesCount() < 2) {
    193193                    System.out.println(tr("Warning: Purging way {0} because number of nodes dropped below 2. Current is {1}",
    194                             w.id,w.nodes.size()));
     194                            w.id,w.getNodesCount()));
    195195                    if (!hive.contains(w)) {
    196196                        hive.add(w);
  • trunk/src/org/openstreetmap/josm/data/osm/visitor/MapPaintVisitor.java

    r1862 r1898  
    344344            int orderNumber = 0;
    345345            lastN = null;
    346             for(Node n : w.nodes)
     346            for(Node n : w.getNodes())
    347347            {
    348348                if(lastN != null)
     
    429429            {
    430430                w = new Way(w);
    431                 w.nodes.clear();
    432                 w.nodes.addAll(n);
     431                w.setNodes(n);
    433432                w.selected = selected;
    434433            }
     
    644643        } else {
    645644            //System.out.println("From way heading towards via");
    646             fromNode = fromWay.getNode(fromWay.nodes.size()-2);
     645            fromNode = fromWay.getNode(fromWay.getNodesCount()-2);
    647646        }
    648647
     
    936935                    Polygon polygon = new Polygon();
    937936
    938                     for (Node n : wInner.nodes)
     937                    for (Node n : wInner.getNodes())
    939938                    {
    940939                        Point pInner = nc.getPoint(n);
     
    943942                    if(!wInner.isClosed())
    944943                    {
    945                         Point pInner = nc.getPoint(wInner.nodes.get(0));
     944                        Point pInner = nc.getPoint(wInner.getNode(0));
    946945                        polygon.addPoint(pInner.x,pInner.y);
    947946                    }
  • trunk/src/org/openstreetmap/josm/data/osm/visitor/MergeSourceBuildingVisitor.java

    r1891 r1898  
    44import static org.openstreetmap.josm.tools.I18n.tr;
    55
     6import java.util.ArrayList;
    67import java.util.HashMap;
     8import java.util.List;
    79
    810import org.openstreetmap.josm.data.osm.DataSet;
     
    2224 * incomplete {@see OsmPrimitive}s in the "hull", if they are not themselves present in the
    2325 * original collection.
    24  * 
     26 *
    2527 */
    2628public class MergeSourceBuildingVisitor extends AbstractVisitor {
     
    3335     * the currently selected primitives in the dataset <code>selectionBase</code>,
    3436     * i.e. from {@see DataSet#getSelected()}.
    35      * 
     37     *
    3638     * @param selectionBase the dataset. Must not be null.
    3739     * @exception IllegalArgumentException thrown if selectionBase is null
    38      * 
     40     *
    3941     */
    4042    public MergeSourceBuildingVisitor(DataSet selectionBase) throws IllegalArgumentException {
     
    4850    /**
    4951     * Remebers a node in the "hull"
    50      * 
     52     *
    5153     * @param n the node
    5254     */
     
    6062    /**
    6163     * remembers a way in the hull
    62      * 
     64     *
    6365     * @param w the way
    6466     */
     
    6769            return;
    6870        Way clone = new Way(w);
    69         clone.nodes.clear();
    70         for (Node n: w.nodes) {
    71             clone.nodes.add((Node)mappedPrimitives.get(n));
    72         }
     71        List<Node> newNodes = new ArrayList<Node>();
     72        for (Node n: w.getNodes()) {
     73            newNodes.add((Node)mappedPrimitives.get(n));
     74        }
     75        clone.setNodes(newNodes);
    7376        mappedPrimitives.put(w, clone);
    7477    }
     
    7679    /**
    7780     * Remembers a relation in the hull
    78      * 
     81     *
    7982     * @param r the relation
    8083     */
     
    160163        // remember all nodes this way refers to ...
    161164        //
    162         for (Node n: w.nodes) {
     165        for (Node n: w.getNodes()) {
    163166            if (! isAlreadyRemembered(n)) {
    164167                n.visit(this);
  • trunk/src/org/openstreetmap/josm/data/osm/visitor/SimplePaintVisitor.java

    r1862 r1898  
    319319        }
    320320
    321         Iterator<Node> it = w.nodes.iterator();
     321        Iterator<Node> it = w.getNodes().iterator();
    322322        if (it.hasNext()) {
    323323            Point lastP = nc.getPoint(it.next());
  • trunk/src/org/openstreetmap/josm/gui/NavigatableComponent.java

    r1823 r1898  
    319319            Node lastN = null;
    320320            int i = -2;
    321             for (Node n : w.nodes) {
     321            for (Node n : w.getNodes()) {
    322322                i++;
    323323                if (n.deleted || n.incomplete) {
     
    437437            }
    438438            Node lastN = null;
    439             for (Node n : w.nodes) {
     439            for (Node n : w.getNodes()) {
    440440                if (n.deleted || n.incomplete) {
    441441                    continue;
  • trunk/src/org/openstreetmap/josm/gui/SelectionManager.java

    r1814 r1898  
    286286            // ways
    287287            for (Way w : nc.getCurrentDataSet().ways) {
    288                 if (w.deleted || w.nodes.isEmpty() || w.incomplete)
     288                if (w.deleted || w.getNodesCount() == 0 || w.incomplete)
    289289                        continue;
    290290                if (alt) {
  • trunk/src/org/openstreetmap/josm/gui/conflict/nodes/NodeListMergeModel.java

    r1655 r1898  
    2323     * Populates the model with the nodes in the two {@see Way}s <code>my</code> and
    2424     * <code>their</code>.
    25      * 
     25     *
    2626     * @param my  my way (i.e. the way in the local dataset)
    2727     * @param their their way (i.e. the way in the server dataset)
     
    3737        getMyEntries().clear();
    3838        getTheirEntries().clear();
    39         for (Node n : my.nodes) {
     39        for (Node n : my.getNodes()) {
    4040            getMyEntries().add(n);
    4141        }
    42         for (Node n : their.nodes) {
     42        for (Node n : their.getNodes()) {
    4343            getTheirEntries().add(n);
    4444        }
     
    5555    /**
    5656     * Builds the command to resolve conflicts in the node list of a way
    57      * 
     57     *
    5858     * @param my  my way. Must not be null.
    5959     * @param their  their way. Must not be null
  • trunk/src/org/openstreetmap/josm/gui/conflict/properties/PropertiesMergeModel.java

    r1847 r1898  
    533533
    534534        HashMap<Long,OsmPrimitive> candidates = new HashMap<Long,OsmPrimitive>();
    535         for (Node n : way.nodes) {
     535        for (Node n : way.getNodes()) {
    536536            if (n.id > 0 && ! candidates.values().contains(n)) {
    537537                candidates.put(n.id, n);
  • trunk/src/org/openstreetmap/josm/gui/dialogs/ConflictDialog.java

    r1814 r1898  
    5555 * This dialog displays the {@see ConflictCollection} of the active {@see OsmDataLayer} in a toggle
    5656 * dialog on the right of the main frame.
    57  * 
     57 *
    5858 */
    5959public final class ConflictDialog extends ToggleDialog implements LayerChangeListener, IConflictListener, SelectionChangedListener{
     
    128128    /**
    129129     * Launches a conflict resolution dialog for the first selected conflict
    130      * 
     130     *
    131131     */
    132132    private final void resolve() {
     
    180180            public void visit(Way w) {
    181181                Node lastN = null;
    182                 for (Node n : w.nodes) {
     182                for (Node n : w.getNodes()) {
    183183                    if (lastN == null) {
    184184                        lastN = n;
     
    206206    /**
    207207     * replies the conflict collection currently held by this dialog; may be null
    208      * 
     208     *
    209209     * @return the conflict collection currently held by this dialog; may be null
    210210     */
  • trunk/src/org/openstreetmap/josm/gui/layer/OsmDataLayer.java

    r1894 r1898  
    6565import org.openstreetmap.josm.tools.ImageProvider;
    6666
    67 import sun.security.action.GetLongAction;
    68 
    6967/**
    7068 * A layer holding data from a specific dataset.
     
    321319     * Cleanup the layer after save to disk. Just marks the layer as unmodified.
    322320     * Leaves the undo/redo stack unchanged.
    323      * 
     321     *
    324322     */
    325323    public void cleanupAfterSaveToDisk() {
     
    470468
    471469            ArrayList<WayPoint> trkseg = null;
    472             for (Node n : w.nodes) {
     470            for (Node n : w.getNodes()) {
    473471                if (n.incomplete || n.deleted) {
    474472                    trkseg = null;
  • trunk/src/org/openstreetmap/josm/io/MultiFetchServerObjectReader.java

    r1881 r1898  
    183183        if (way == null) return this;
    184184        if (way.id == 0) return this;
    185         for (Node node: way.nodes) {
     185        for (Node node: way.getNodes()) {
    186186            if (node.id > 0) {
    187187                remember(node.id, OsmPrimitiveType.NODE);
  • trunk/src/org/openstreetmap/josm/io/OsmWriter.java

    r1843 r1898  
    117117        } else {
    118118            out.println(">");
    119             for (Node n : w.nodes) {
     119            for (Node n : w.getNodes()) {
    120120                out.println("    <nd ref='"+getUsedId(n)+"' />");
    121121            }
  • trunk/test/functional/org/openstreetmap/josm/io/MultiFetchServerObjectReaderTest.java

    r1814 r1898  
    3333import org.openstreetmap.josm.data.projection.Mercator;
    3434import org.openstreetmap.josm.gui.progress.NullProgressMonitor;
    35 import org.openstreetmap.josm.gui.progress.PleaseWaitProgressMonitor;
    3635import org.xml.sax.SAXException;
    3736
     
    275274            Way w2 = (Way)ds.getPrimitiveById(w1.id);
    276275            assertNotNull(w2);
    277             assertEquals(w2.nodes.size(), w1.nodes.size());
     276            assertEquals(w2.getNodesCount(), w1.getNodesCount());
    278277            assertEquals(w2.get("name"),w1.get("name"));
    279278        }
     
    340339        assertFalse(reader.getMissingPrimitives().isEmpty());
    341340        assertEquals(1, reader.getMissingPrimitives().size());
    342         assertEquals(9999999, reader.getMissingPrimitives().iterator().next());
     341        assertEquals(9999999, (long)reader.getMissingPrimitives().iterator().next());
    343342    }
    344343}
  • trunk/test/functional/org/openstreetmap/josm/io/OsmServerBackreferenceReaderTest.java

    r1814 r1898  
    3232import org.openstreetmap.josm.data.projection.Mercator;
    3333import org.openstreetmap.josm.gui.progress.NullProgressMonitor;
    34 import org.openstreetmap.josm.gui.progress.PleaseWaitProgressMonitor;
    3534import org.xml.sax.SAXException;
    3635
     
    280279            assertEquals(w.id, way.id);
    281280            assertEquals(false, way.incomplete);
    282             assertEquals(10, w.nodes.size());
     281            assertEquals(10, w.getNodesCount());
    283282        }
    284283    }
     
    326325        for (Way way: referers.ways) {
    327326            Way orig = (Way)ds.getPrimitiveById(way.id);
    328             for(Node n: orig.nodes) {
     327            for(Node n: orig.getNodes()) {
    329328                expectedNodeIds.add(n.id);
    330329            }
     
    417416        HashSet<Long> ret = new HashSet<Long>();
    418417        if (way == null)return ret;
    419         for (Node n: way.nodes) {
     418        for (Node n: way.getNodes()) {
    420419            ret.add(n.id);
    421420        }
Note: See TracChangeset for help on using the changeset viewer.