Changeset 1910 in josm


Ignore:
Timestamp:
Aug 5, 2009 8:19:02 AM (4 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.