Changeset 1910 in josm


Ignore:
Timestamp:
2009-08-05T08:19:02+02:00 (10 years ago)
Author:
jttt
Message:

Way refactoring - finish replacing Way.nodes with the new api

Location:
trunk
Files:
18 edited

Legend:

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

    r1862 r1910  
    66import java.awt.event.ActionEvent;
    77import java.awt.event.KeyEvent;
     8import java.util.ArrayList;
    89import java.util.Collection;
    910import java.util.LinkedList;
     
    134135
    135136            // build a way for the circle
    136             Way wayToAdd;
    137             if (existingWay == null) {
    138                 wayToAdd = new Way();
    139             } else {
    140                 // re-use existing way if it was selected
    141                 wayToAdd = new Way(existingWay);
    142                 wayToAdd.nodes.clear();
    143             }
     137            List<Node> wayToAdd = new ArrayList<Node>();
    144138
    145139            for (int i = 1; i <= numberOfNodesInCircle; i++) {
     
    148142                // insert existing nodes if they fit before this new node (999 means "already added this node")
    149143                if ((a1 < 999) && (a1 > a - 1E-9) && (a1 < a + 1E-9)) {
    150                     wayToAdd.nodes.add(n1);
     144                    wayToAdd.add(n1);
    151145                    a1 = 999;
    152146                }
    153147                else if ((a2 < 999) && (a2 > a - 1E-9) && (a2 < a + 1E-9)) {
    154                     wayToAdd.nodes.add(n2);
     148                    wayToAdd.add(n2);
    155149                    a2 = 999;
    156150                }
     
    160154                    double y = yc + r*Math.sin(a);
    161155                    Node n = new Node(Main.proj.eastNorth2latlon(new EastNorth(x,y)));
    162                     wayToAdd.nodes.add(n);
     156                    wayToAdd.add(n);
    163157                    cmds.add(new AddCommand(n));
    164158                }
    165159            }
    166             wayToAdd.nodes.add(wayToAdd.nodes.get(0)); // close the circle
     160            wayToAdd.add(wayToAdd.get(0)); // close the circle
    167161            if (existingWay == null) {
    168                 cmds.add(new AddCommand(wayToAdd));
     162                Way newWay = new Way();
     163                newWay.setNodes(wayToAdd);
     164                cmds.add(new AddCommand(newWay));
    169165            } else {
    170                 cmds.add(new ChangeCommand(existingWay, wayToAdd));
     166                Way newWay = new Way(existingWay);
     167                newWay.setNodes(wayToAdd);
     168                cmds.add(new ChangeCommand(existingWay, newWay));
    171169            }
    172170
     
    229227
    230228            // build a way for the circle
    231             Way wayToAdd;
    232             if (existingWay == null) {
    233                 wayToAdd = new Way();
    234             } else {
    235                 // re-use existing way if it was selected
    236                 wayToAdd = new Way(existingWay);
    237                 wayToAdd.nodes.clear();
    238             }
     229            List<Node> wayToAdd = new ArrayList<Node>();
    239230            for (int i = 1; i <= numberOfNodesInCircle; i++) {
    240231                double a = 2*Math.PI*(1.0 - i/(double)numberOfNodesInCircle); // "1-" to get it clock-wise
    241232                // insert existing nodes if they fit before this new node (999 means "already added this node")
    242233                if (a1 < 999 && a1 > a) {
    243                     wayToAdd.nodes.add(n1);
     234                    wayToAdd.add(n1);
    244235                    a1 = 999;
    245236                }
    246237                if (a2 < 999 && a2 > a) {
    247                     wayToAdd.nodes.add(n2);
     238                    wayToAdd.add(n2);
    248239                    a2 = 999;
    249240                }
    250241                if (a3 < 999 && a3 > a) {
    251                     wayToAdd.nodes.add(n3);
     242                    wayToAdd.add(n3);
    252243                    a3 = 999;
    253244                }
     
    256247                double y = yc + r*Math.sin(a);
    257248                Node n = new Node(Main.proj.eastNorth2latlon(new EastNorth(x,y)));
    258                 wayToAdd.nodes.add(n);
     249                wayToAdd.add(n);
    259250                cmds.add(new AddCommand(n));
    260251            }
    261             wayToAdd.nodes.add(wayToAdd.nodes.get(0)); // close the circle
     252            wayToAdd.add(wayToAdd.get(0)); // close the circle
    262253            if (existingWay == null) {
    263                 cmds.add(new AddCommand(wayToAdd));
     254                Way newWay = new Way();
     255                newWay.setNodes(wayToAdd);
     256                cmds.add(new AddCommand(newWay));
    264257            } else {
    265                 cmds.add(new ChangeCommand(existingWay, wayToAdd));
     258                Way newWay = new Way(existingWay);
     259                newWay.setNodes(wayToAdd);
     260                cmds.add(new ChangeCommand(existingWay, newWay));
    266261            }
    267262
  • trunk/src/org/openstreetmap/josm/actions/JoinNodeWayAction.java

    r1862 r1910  
    5959        for (Map.Entry<Way, List<Integer>> insertPoint : insertPoints.entrySet()) {
    6060            Way w = insertPoint.getKey();
    61             Way wnew = new Way(w);
     61            List<Node> nodesToAdd = new ArrayList<Node>();
    6262            List<Integer> is = insertPoint.getValue();
    6363            pruneSuccsAndReverse(is);
    6464            for (int i : is) {
    65                 wnew.nodes.add(i+1, node);
     65                nodesToAdd.add(i+1, node);
    6666            }
     67            Way wnew = new Way(w);
     68            wnew.setNodes(nodesToAdd);
    6769            cmds.add(new ChangeCommand(w, wnew));
    6870        }
  • trunk/src/org/openstreetmap/josm/command/PurgePrimitivesCommand.java

    r1898 r1910  
    186186                Way w = (Way)pair.getParent();
    187187                System.out.println(tr("removing reference from way {0}",w.id));
    188                 w.nodes.remove(primitive);
     188                List<Node> wayNodes = w.getNodes();
     189                wayNodes.remove(primitive);
     190                w.setNodes(wayNodes);
    189191                // if a way ends up with less than two node we
    190192                // remember it on the "hive"
  • trunk/src/org/openstreetmap/josm/command/WayNodesConflictResolverCommand.java

    r1766 r1910  
    3737
    3838    /**
    39      * 
     39     *
    4040     * @param my my may
    4141     * @param their their way
     
    6868        // nodes
    6969        //
    70         conflict.getMy().nodes.clear();
    71         for (int i=0; i<mergedNodeList.size();i++) {
    72             Node n = mergedNodeList.get(i);
    73             conflict.getMy().nodes.add(n);
     70        for (Node n:mergedNodeList) {
    7471            if (! getLayer().data.nodes.contains(n)) {
    7572                logger.warning(tr("Main dataset does not include node {0}", n.toString()));
    7673            }
    7774        }
     75        conflict.getMy().setNodes(mergedNodeList);
    7876        rememberConflict(conflict);
    7977        return true;
  • trunk/src/org/openstreetmap/josm/data/osm/DataSet.java

    r1899 r1910  
    372372
    373373    protected void deleteWay(Way way) {
    374         way.nodes.clear();
     374        way.setNodes(null);
    375375        way.delete(true);
    376376    }
     
    383383    public void unlinkNodeFromWays(Node node) {
    384384        for (Way way: ways) {
    385             if (way.nodes.contains(node)) {
    386                 way.nodes.remove(node);
    387                 if (way.nodes.size() < 2) {
     385            List<Node> nodes = way.getNodes();
     386            if (nodes.remove(node)) {
     387                if (nodes.size() < 2) {
    388388                    deleteWay(way);
     389                } else {
     390                    way.setNodes(nodes);
    389391                }
    390392            }
  • trunk/src/org/openstreetmap/josm/data/osm/Way.java

    r1900 r1910  
    2424    /**
    2525     * All way nodes in this way
    26      * 
     26     *
    2727     * @deprecated This public field will become private or protected in the future.
    2828     *  Use the new public API instead.
     
    4343
    4444    /**
    45      * @param nodes
     45     * @param nodes New way nodes. Can be null, in that case all way nodes are removed
    4646     * @since 1862
    4747     */
    4848    public void setNodes(List<Node> nodes) {
    4949        this.nodes.clear();
    50         this.nodes.addAll(nodes);
     50        if (nodes != null) {
     51            this.nodes.addAll(nodes);
     52        }
     53        clearCached();
    5154    }
    5255
  • trunk/src/org/openstreetmap/josm/data/osm/visitor/MergeSourceBuildingVisitor.java

    r1898 r1910  
    136136            return;
    137137        Way clone = new Way(w);
    138         clone.nodes.clear();
     138        clone.setNodes(null);
    139139        clone.incomplete = true;
    140140        mappedPrimitives.put(w, clone);
  • trunk/src/org/openstreetmap/josm/gui/SelectionManager.java

    r1898 r1910  
    289289                        continue;
    290290                if (alt) {
    291                     for (Node n : w.nodes) {
     291                    for (Node n : w.getNodes()) {
    292292                        if (!n.incomplete && r.contains(nc.getPoint(n))) {
    293293                            selection.add(w);
     
    297297                } else {
    298298                    boolean allIn = true;
    299                     for (Node n : w.nodes) {
     299                    for (Node n : w.getNodes()) {
    300300                        if (!n.incomplete && !r.contains(nc.getPoint(n))) {
    301301                            allIn = false;
  • trunk/src/org/openstreetmap/josm/gui/layer/GpxLayer.java

    r1890 r1910  
    710710            for (GpxTrack trk : data.tracks) {
    711711                for (Collection<WayPoint> segment : trk.trackSegs) {
    712                     Way w = new Way();
     712                    List<Node> nodes = new ArrayList<Node>();
    713713                    for (WayPoint p : segment) {
    714714                        Node n = new Node(p.getCoor());
     
    718718                        }
    719719                        ds.nodes.add(n);
    720                         w.nodes.add(n);
    721                     }
     720                        nodes.add(n);
     721                    }
     722                    Way w = new Way();
     723                    w.setNodes(nodes);
    722724                    ds.ways.add(w);
    723725                }
     
    741743    /**
    742744     * Action that issues a series of download requests to the API, following the GPX track.
    743      * 
     745     *
    744746     * @author fred
    745747     */
     
    842844             * can only download rectangles, so the following is an attempt at finding a number of
    843845             * rectangles to download.
    844              * 
     846             *
    845847             * The idea is simply: Start out with the full bounding box. If it is too large, then
    846848             * split it in half and repeat recursively for each half until you arrive at something
     
    11411143     * Makes a WayPoint at the projection of point P onto the track providing P is less than
    11421144     * tolerance away from the track
    1143      * 
     1145     *
    11441146     * @param P : the point to determine the projection for
    11451147     * @param tolerance : must be no further than this from the track
     
    11511153         * assume the coordinates of P are xp,yp, and those of a section of track between two
    11521154         * trackpoints are R=xr,yr and S=xs,ys. Let N be the projected point.
    1153          * 
     1155         *
    11541156         * The equation of RS is Ax + By + C = 0 where A = ys - yr B = xr - xs C = - Axr - Byr
    1155          * 
     1157         *
    11561158         * Also, note that the distance RS^2 is A^2 + B^2
    1157          * 
     1159         *
    11581160         * If RS^2 == 0.0 ignore the degenerate section of track
    1159          * 
     1161         *
    11601162         * PN^2 = (Axp + Byp + C)^2 / RS^2 that is the distance from P to the line
    1161          * 
     1163         *
    11621164         * so if PN^2 is less than PNmin^2 (initialized to tolerance) we can reject the line;
    11631165         * otherwise... determine if the projected poijnt lies within the bounds of the line: PR^2 -
    11641166         * PN^2 <= RS^2 and PS^2 - PN^2 <= RS^2
    1165          * 
     1167         *
    11661168         * where PR^2 = (xp - xr)^2 + (yp-yr)^2 and PS^2 = (xp - xs)^2 + (yp-ys)^2
    1167          * 
     1169         *
    11681170         * If so, calculate N as xn = xr + (RN/RS) B yn = y1 + (RN/RS) A
    1169          * 
     1171         *
    11701172         * where RN = sqrt(PR^2 - PN^2)
    11711173         */
  • trunk/src/org/openstreetmap/josm/gui/layer/RawGpsLayer.java

    r1890 r1910  
    1414import java.awt.event.ActionListener;
    1515import java.io.File;
     16import java.util.ArrayList;
    1617import java.util.Collection;
     18import java.util.List;
    1719
    1820import javax.swing.AbstractAction;
     
    7375            DataSet ds = new DataSet();
    7476            for (Collection<GpsPoint> c : data) {
    75                 Way w = new Way();
     77                List<Node> nodes = new ArrayList<Node>();
    7678                for (GpsPoint p : c) {
    7779                    Node n = new Node(p.latlon);
    7880                    ds.nodes.add(n);
    79                     w.nodes.add(n);
    80                 }
     81                    nodes.add(n);
     82                }
     83                Way w = new Way();
     84                w.setNodes(nodes);
    8185                ds.ways.add(w);
    8286            }
  • trunk/src/org/openstreetmap/josm/io/OsmReader.java

    r1899 r1910  
    1212import java.util.HashMap;
    1313import java.util.LinkedList;
     14import java.util.List;
    1415import java.util.Map;
    1516import java.util.Map.Entry;
     
    330331            Way w = new Way(e.getKey().id);
    331332            boolean incomplete = false;
     333            List<Node> wayNodes = new ArrayList<Node>();
    332334            for (long id : e.getValue()) {
    333335                Node n = findNode(id);
     
    337339                    incomplete = true;
    338340                }
    339                 w.nodes.add(n);
    340             }
     341                wayNodes.add(n);
     342            }
     343            w.setNodes(wayNodes);
    341344            if (incomplete) {
    342                 logger.warning(tr("marked way {0} with {1} nodes incomplete because at least one node was missing in the loaded data and is therefore incomplete too", e.getKey().id, w.nodes.size()));
     345                logger.warning(tr("marked way {0} with {1} nodes incomplete because at least one node was missing in the " +
     346                                "loaded data and is therefore incomplete too", e.getKey().id, w.getNodesCount()));
    343347                e.getKey().copyTo(w);
    344348                w.incomplete = true;
  • trunk/test/functional/org/openstreetmap/josm/gui/conflict/nodes/NodeListMergerTest.java

    r1707 r1910  
    1717        Way w1 = new Way();
    1818        Node n1;
    19         w1.nodes.add(n1 = new Node(1));
     19        w1.addNode(n1 = new Node(1));
    2020        for (int i=0; i < 20; i++) {
    2121            n1.put("key" + i, "value" + i);
     
    2626        }
    2727        n1.put("note", note);
    28         w1.nodes.add(new Node(2));
    29         w1.nodes.add(new Node(3));
     28        w1.addNode(new Node(2));
     29        w1.addNode(new Node(3));
    3030
    3131        Way w2 = new Way();
    32         w2.nodes.add(new Node(4));
    33         w2.nodes.add(new Node(5));
    34         w2.nodes.add(new Node(6));
     32        w2.addNode(new Node(4));
     33        w2.addNode(new Node(5));
     34        w2.addNode(new Node(6));
    3535
    3636        nodeListMerger.populate(w1, w2);
     
    4141        Way w1 = new Way();
    4242        for (int i = 0; i < 100; i++) {
    43             w1.nodes.add(new Node(i));
     43            w1.addNode(new Node(i));
    4444        }
    4545
    4646        Way w2 = new Way();
    4747        for (int i = 1; i < 200; i+=2) {
    48             w2.nodes.add(new Node(i));
     48            w2.addNode(new Node(i));
    4949        }
    5050        nodeListMerger.populate(w1, w2);
  • trunk/test/functional/org/openstreetmap/josm/gui/dialogs/ConflictResolutionDialogTest.java

    r1707 r1910  
    1010
    1111    private ConflictResolutionDialog dialog;
    12    
     12
    1313    protected void build() {
    1414        setSize(100,100);
    1515        dialog = new ConflictResolutionDialog(this);
    1616        dialog.setSize(600,600);
    17        
    18        
     17
     18
    1919    }
    2020    protected void populate() {
    2121        Way w1 = new Way(1);
    22           w1.nodes.add(new Node(10));
    23           w1.nodes.add(new Node(11));
    24        
     22          w1.addNode(new Node(10));
     23          w1.addNode(new Node(11));
     24
    2525        Way w2 = new Way(1);
    26           w2.nodes.add(new Node(10));
    27           w2.nodes.add(new Node(11));
    28    
     26          w2.addNode(new Node(10));
     27          w2.addNode(new Node(11));
     28
    2929       dialog.getConflictResolver().populate(w1, w2);
    3030    }
    31    
     31
    3232    public void showDialog() {
    3333        dialog.setVisible(true);
    3434    }
    35    
     35
    3636    public ConflictResolutionDialogTest() {
    3737        build();
    3838    }
    39    
     39
    4040    static public void main(String args[]) {
    4141        ConflictResolutionDialogTest test = new ConflictResolutionDialogTest();
  • trunk/test/functional/org/openstreetmap/josm/io/MultiFetchServerObjectReaderTest.java

    r1898 r1910  
    7676                int idx = (start + j) % numNodes;
    7777                Node n = nodes.get(idx);
    78                 w.nodes.add(n);
     78                w.addNode(n);
    7979            }
    8080            w.put("name", "way-"+i);
  • trunk/test/functional/org/openstreetmap/josm/io/OsmServerBackreferenceReaderTest.java

    r1898 r1910  
    7474            w.incomplete = false;
    7575            for (int j = 0; j < 10;j++) {
    76                 w.nodes.add(lookupNode(ds, i+j));
     76                w.addNode(lookupNode(ds, i+j));
    7777            }
    7878            w.put("name", "way-"+i);
  • trunk/test/unit/org/openstreetmap/josm/data/osm/visitor/MergeSourceBuildingVisitorTest.java

    r1890 r1910  
    22package org.openstreetmap.josm.data.osm.visitor;
    33
     4import static org.junit.Assert.assertEquals;
     5import static org.junit.Assert.assertNotNull;
     6import static org.junit.Assert.assertNull;
     7import static org.junit.Assert.assertTrue;
     8
    49import java.util.Collection;
    510
    6 import org.junit.Ignore;
    711import org.junit.Test;
    812import org.openstreetmap.josm.data.coor.LatLon;
     
    1317import org.openstreetmap.josm.data.osm.RelationMember;
    1418import org.openstreetmap.josm.data.osm.Way;
    15 
    16 import static org.junit.Assert.*;
    1719
    1820public class MergeSourceBuildingVisitorTest {
     
    6971        Node n2 = new Node(2);
    7072        Way w1 = new Way(3);
    71         w1.nodes.add(n1);
    72         w1.nodes.add(n2);
     73        w1.addNode(n1);
     74        w1.addNode(n2);
    7375        source.nodes.add(n1);
    7476        source.nodes.add(n2);
     
    101103        Node n2 = new Node(2);
    102104        Way w1 = new Way(3);
    103         w1.nodes.add(n1);
    104         w1.nodes.add(n2);
     105        w1.addNode(n1);
     106        w1.addNode(n2);
    105107        source.nodes.add(n1);
    106108        source.nodes.add(n2);
     
    154156        Way w30 = new Way(30);
    155157        Node n21;
    156         w30.nodes.add(n21 = new Node(21));
     158        w30.addNode(n21 = new Node(21));
    157159        Node n22;
    158         w30.nodes.add(n22 = new Node(22));
     160        w30.addNode(n22 = new Node(22));
    159161        r1.members.add(new RelationMember("way-30",w30));
    160162        Relation r40 = new Relation(40);
     
    181183        Way w = (Way)hull.getPrimitiveById(30);
    182184        assertNotNull(w);
    183         assertEquals(2, w.nodes.size());
     185        assertEquals(2, w.getNodesCount());
    184186        Node n = (Node)hull.getPrimitiveById(21);
    185187        assertNotNull(n);
    186         assertTrue(w.nodes.contains(n));
     188        assertTrue(w.getNodes().contains(n));
    187189
    188190        n = (Node)hull.getPrimitiveById(22);
    189191        assertNotNull(n);
    190         assertTrue(w.nodes.contains(n));
     192        assertTrue(w.getNodes().contains(n));
    191193
    192194        Relation r = (Relation)hull.getPrimitiveById(40);
     
    212214        Way w30 = new Way(30);
    213215        Node n21;
    214         w30.nodes.add(n21 = new Node(21));
     216        w30.addNode(n21 = new Node(21));
    215217        Node n22;
    216         w30.nodes.add(n22 = new Node(22));
     218        w30.addNode(n22 = new Node(22));
    217219        r1.members.add(new RelationMember("way-30",w30));
    218220        Relation r40 = new Relation(40);
     
    274276        w30.put("name", "w30");
    275277        Node n21;
    276         w30.nodes.add(n21 = new Node(new LatLon(21.0,21.0)));
     278        w30.addNode(n21 = new Node(new LatLon(21.0,21.0)));
    277279        n21.put("name","n21");
    278280        Node n22;
    279         w30.nodes.add(n22 = new Node(new LatLon(22.0,22.0)));
     281        w30.addNode(n22 = new Node(new LatLon(22.0,22.0)));
    280282        n22.put("name","n22");
    281283        r1.members.add(new RelationMember("way-30",w30));
     
    304306        Way w = (Way)lookupByName(hull.ways, "w30");
    305307        assertNotNull(w);
    306         assertEquals(2, w.nodes.size());
     308        assertEquals(2, w.getNodesCount());
    307309
    308310        Node n = (Node)lookupByName(hull.nodes, "n21");
    309311        assertNotNull(n);
    310         assertTrue(w.nodes.contains(n));
     312        assertTrue(w.getNodes().contains(n));
    311313
    312314        n = (Node)lookupByName(hull.nodes, "n22");
    313315        assertNotNull(n);
    314         assertTrue(w.nodes.contains(n));
     316        assertTrue(w.getNodes().contains(n));
    315317
    316318        Relation r = (Relation)lookupByName(hull.relations, "r40");
  • trunk/test/unit/org/openstreetmap/josm/data/osm/visitor/MergeVisitorTest.java

    r1813 r1910  
    489489        myWay.version = 1;
    490490        myWay.put("key1", "value1");
    491         myWay.nodes.add(n1);
    492         myWay.nodes.add(n2);
     491        myWay.addNode(n1);
     492        myWay.addNode(n2);
    493493        my.addPrimitive(myWay);
    494494
     
    511511        theirWay.put("key1", "value1");
    512512        theirWay.put("key2", "value2");
    513         theirWay.nodes.add(n3);
    514         theirWay.nodes.add(n4);
     513        theirWay.addNode(n3);
     514        theirWay.addNode(n4);
    515515        their.addPrimitive(theirWay);
    516516
     
    525525        assertEquals(3,merged.id);
    526526        assertEquals(2,merged.version);
    527         assertEquals(2,merged.nodes.size());
    528         assertEquals(1,merged.nodes.get(0).id);
    529         assertEquals(2,merged.nodes.get(1).id);
     527        assertEquals(2,merged.getNodesCount());
     528        assertEquals(1,merged.getNode(0).id);
     529        assertEquals(2,merged.getNode(1).id);
    530530
    531531    }
     
    557557        myWay.id = 3;
    558558        myWay.version = 1;
    559         myWay.nodes.add(n1);
    560         myWay.nodes.add(n2);
     559        myWay.addNode(n1);
     560        myWay.addNode(n2);
    561561        my.addPrimitive(myWay);
    562562
     
    586586        theirWay.id = 3;
    587587        theirWay.version = 2;
    588         theirWay.nodes.add(n3);
    589         theirWay.nodes.add(n5); // insert a node
    590         theirWay.nodes.add(n4); // this one is updated
     588        theirWay.addNode(n3);
     589        theirWay.addNode(n5); // insert a node
     590        theirWay.addNode(n4); // this one is updated
    591591        their.addPrimitive(theirWay);
    592592
     
    599599        assertEquals(3,merged.id);
    600600        assertEquals(2,merged.version);
    601         assertEquals(3,merged.nodes.size());
    602         assertEquals(1,merged.nodes.get(0).id);
    603         assertEquals(4,merged.nodes.get(1).id);
    604         assertEquals(2,merged.nodes.get(2).id);
    605         assertEquals("value1",merged.nodes.get(2).get("key1"));
     601        assertEquals(3,merged.getNodesCount());
     602        assertEquals(1,merged.getNode(0).id);
     603        assertEquals(4,merged.getNode(1).id);
     604        assertEquals(2,merged.getNode(2).id);
     605        assertEquals("value1",merged.getNode(2).get("key1"));
    606606    }
    607607
     
    631631        myWay.id = 3;
    632632        myWay.version = 1;
    633         myWay.nodes.add(n1);
    634         myWay.nodes.add(n2);
     633        myWay.addNode(n1);
     634        myWay.addNode(n2);
    635635        myWay.modified = true;
    636636        myWay.put("key1", "value1");
     
    662662        theirWay.id = 3;
    663663        theirWay.version = 2;
    664         theirWay.nodes.add(n3);
    665         theirWay.nodes.add(n5); // insert a node
    666         theirWay.nodes.add(n4); // this one is updated
     664        theirWay.addNode(n3);
     665        theirWay.addNode(n5); // insert a node
     666        theirWay.addNode(n4); // this one is updated
    667667        their.addPrimitive(theirWay);
    668668
     
    675675        assertEquals(3,merged.id);
    676676        assertEquals(1,merged.version);
    677         assertEquals(2,merged.nodes.size());
    678         assertEquals(1,merged.nodes.get(0).id);
    679         assertEquals(2,merged.nodes.get(1).id);
     677        assertEquals(2,merged.getNodesCount());
     678        assertEquals(1,merged.getNode(0).id);
     679        assertEquals(2,merged.getNode(1).id);
    680680        assertEquals("value1",merged.get("key1"));
    681681    }
     
    707707        myWay.id = 3;
    708708        myWay.version = 1;
    709         myWay.nodes.add(n1);
    710         myWay.nodes.add(n2);
     709        myWay.addNode(n1);
     710        myWay.addNode(n2);
    711711        my.addPrimitive(myWay);
    712712
     
    757757        myWay.id = 0;
    758758        myWay.version = -1;
    759         myWay.nodes.add(n1);
    760         myWay.nodes.add(n2);
     759        myWay.addNode(n1);
     760        myWay.addNode(n2);
    761761        my.addPrimitive(myWay);
    762762
     
    777777        theirWay.id = 0;
    778778        theirWay.version = -1;
    779         theirWay.nodes.add(n3);
    780         theirWay.nodes.add(n4);
     779        theirWay.addNode(n3);
     780        theirWay.addNode(n4);
    781781        theirWay.user = User.get("their");
    782782        theirWay.user.uid = "1111";
     
    819819        myWay.id = 0;
    820820        myWay.version = -1;
    821         myWay.nodes.add(n1);
    822         myWay.nodes.add(n2);
     821        myWay.addNode(n1);
     822        myWay.addNode(n2);
    823823        my.addPrimitive(myWay);
    824824
     
    839839        theirWay.id = 0;
    840840        theirWay.version = -1;
    841         theirWay.nodes.add(n3);
    842         theirWay.nodes.add(n4);
     841        theirWay.addNode(n3);
     842        theirWay.addNode(n4);
    843843        theirWay.user = User.get("their");
    844844        theirWay.user.uid = "1111";
     
    899899        theirWay.id = 4;
    900900        theirWay.version = 1;
    901         theirWay.nodes.add(n3);
    902         theirWay.nodes.add(n4);
    903         theirWay.nodes.add(n5);
     901        theirWay.addNode(n3);
     902        theirWay.addNode(n4);
     903        theirWay.addNode(n5);
    904904        theirWay.user = User.get("their");
    905905        theirWay.user.uid = "1111";
     
    913913
    914914        Way myWay = (Way)my.getPrimitiveById(4);
    915         assertEquals(2, myWay.nodes.size());
     915        assertEquals(2, myWay.getNodesCount());
    916916
    917917        Node n = (Node)my.getPrimitiveById(1);
  • trunk/test/unit/org/openstreetmap/josm/gui/conflict/nodes/NodeListMergeModelTest.java

    r1650 r1910  
    6464
    6565        Way myWay = new Way(1);
    66         myWay.nodes.add(new Node(2));
    67         myWay.nodes.add(new Node(3));
     66        myWay.addNode(new Node(2));
     67        myWay.addNode(new Node(3));
    6868        Way theirWay = new Way(1);
    6969
     
    8888
    8989        Way myWay = new Way(1);
    90         myWay.nodes.add(new Node(2));
    91         myWay.nodes.add(new Node(3));
     90        myWay.addNode(new Node(2));
     91        myWay.addNode(new Node(3));
    9292        Way theirWay = new Way(1);
    9393
     
    119119
    120120        Way myWay = new Way(1);
    121         myWay.nodes.add(new Node(2));
    122         myWay.nodes.add(new Node(3));
     121        myWay.addNode(new Node(2));
     122        myWay.addNode(new Node(3));
    123123        Way theirWay = new Way(1);
    124124
     
    145145
    146146        Way myWay = new Way(1);
    147         myWay.nodes.add(new Node(2));
    148         myWay.nodes.add(new Node(3));
    149         myWay.nodes.add(new Node(4));
     147        myWay.addNode(new Node(2));
     148        myWay.addNode(new Node(3));
     149        myWay.addNode(new Node(4));
    150150        Way theirWay = new Way(1);
    151151
     
    173173
    174174        Way myWay = new Way(1);
    175         myWay.nodes.add(new Node(2));
    176         myWay.nodes.add(new Node(3));
     175        myWay.addNode(new Node(2));
     176        myWay.addNode(new Node(3));
    177177        Way theirWay = new Way(1);
    178178
     
    194194
    195195        Way myWay = new Way(1);
    196         myWay.nodes.add(new Node(2));
    197         myWay.nodes.add(new Node(3));
     196        myWay.addNode(new Node(2));
     197        myWay.addNode(new Node(3));
    198198        Way theirWay = new Way(1);
    199199
     
    220220
    221221        Way myWay = new Way(1);
    222         myWay.nodes.add(new Node(2));
    223         myWay.nodes.add(new Node(3));
     222        myWay.addNode(new Node(2));
     223        myWay.addNode(new Node(3));
    224224        Way theirWay = new Way(1);
    225225
     
    247247
    248248        Way myWay = new Way(1);
    249         myWay.nodes.add(new Node(2));
    250         myWay.nodes.add(new Node(3));
    251         myWay.nodes.add(new Node(4));
     249        myWay.addNode(new Node(2));
     250        myWay.addNode(new Node(3));
     251        myWay.addNode(new Node(4));
    252252        Way theirWay = new Way(1);
    253253
     
    279279
    280280        Way myWay = new Way(1);
    281         myWay.nodes.add(new Node(1));
    282         myWay.nodes.add(new Node(2));
     281        myWay.addNode(new Node(1));
     282        myWay.addNode(new Node(2));
    283283        Way theirWay = new Way(1);
    284284
     
    307307
    308308        Way myWay = new Way(1);
    309         myWay.nodes.add(new Node(1));
    310         myWay.nodes.add(new Node(2));
     309        myWay.addNode(new Node(1));
     310        myWay.addNode(new Node(2));
    311311        Way theirWay = new Way(1);
    312312
     
    335335
    336336        Way myWay = new Way(1);
    337         myWay.nodes.add(new Node(1));
    338         myWay.nodes.add(new Node(2));
     337        myWay.addNode(new Node(1));
     338        myWay.addNode(new Node(2));
    339339        Way theirWay = new Way(1);
    340340
     
    368368
    369369        Way myWay = new Way(1);
    370         myWay.nodes.add(new Node(1));
    371         myWay.nodes.add(new Node(2));
     370        myWay.addNode(new Node(1));
     371        myWay.addNode(new Node(2));
    372372        Way theirWay = new Way(1);
    373373
     
    396396
    397397        Way myWay = new Way(1);
    398         myWay.nodes.add(new Node(1));
    399         myWay.nodes.add(new Node(2));
    400         myWay.nodes.add(new Node(3));
     398        myWay.addNode(new Node(1));
     399        myWay.addNode(new Node(2));
     400        myWay.addNode(new Node(3));
    401401        Way theirWay = new Way(1);
    402402
     
    426426
    427427        Way myWay = new Way(1);
    428         myWay.nodes.add(new Node(1));
    429         myWay.nodes.add(new Node(2));
    430         myWay.nodes.add(new Node(3));
     428        myWay.addNode(new Node(1));
     429        myWay.addNode(new Node(2));
     430        myWay.addNode(new Node(3));
    431431        Way theirWay = new Way(1);
    432432
     
    455455
    456456        Way myWay = new Way(1);
    457         myWay.nodes.add(new Node(1));
    458         myWay.nodes.add(new Node(2));
     457        myWay.addNode(new Node(1));
     458        myWay.addNode(new Node(2));
    459459        Way theirWay = new Way(1);
    460460
     
    488488
    489489        Way myWay = new Way(1);
    490         myWay.nodes.add(new Node(1));
    491         myWay.nodes.add(new Node(2));
     490        myWay.addNode(new Node(1));
     491        myWay.addNode(new Node(2));
    492492        Way theirWay = new Way(1);
    493493
     
    514514
    515515        Way myWay = new Way(1);
    516         myWay.nodes.add(new Node(1));
    517         myWay.nodes.add(new Node(2));
     516        myWay.addNode(new Node(1));
     517        myWay.addNode(new Node(2));
    518518        Way theirWay = new Way(1);
    519519
     
    544544
    545545        Way myWay = new Way(1);
    546         myWay.nodes.add(new Node(1));
    547         myWay.nodes.add(new Node(2));
     546        myWay.addNode(new Node(1));
     547        myWay.addNode(new Node(2));
    548548        Way theirWay = new Way(1);
    549549
     
    577577
    578578        Way myWay = new Way(1);
    579         myWay.nodes.add(new Node(1));
    580         myWay.nodes.add(new Node(2));
     579        myWay.addNode(new Node(1));
     580        myWay.addNode(new Node(2));
    581581        Way theirWay = new Way(1);
    582582
     
    603603
    604604        Way myWay = new Way(1);
    605         myWay.nodes.add(new Node(1));
    606         myWay.nodes.add(new Node(2));
     605        myWay.addNode(new Node(1));
     606        myWay.addNode(new Node(2));
    607607        Way theirWay = new Way(1);
    608608
     
    633633
    634634        Way myWay = new Way(1);
    635         myWay.nodes.add(new Node(1));
    636         myWay.nodes.add(new Node(2));
     635        myWay.addNode(new Node(1));
     636        myWay.addNode(new Node(2));
    637637        Way theirWay = new Way(1);
    638638
Note: See TracChangeset for help on using the changeset viewer.