Changeset 1862 in josm


Ignore:
Timestamp:
2009-07-27T21:09:44+02:00 (15 years ago)
Author:
jttt
Message:

Way refactoring - added method that will in future replace public field nodes

Location:
trunk/src/org/openstreetmap/josm
Files:
1 added
24 edited

Legend:

Unmodified
Added
Removed

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

    r1847 r1862  
    113113            // distance between two nodes.
    114114            if (nodes.size() > 0) {
    115                 if (nodes.size() == 1 && way.nodes.contains(nodes.get(0))) {
     115                if (nodes.size() == 1 && way.getNodes().contains(nodes.get(0))) {
    116116                    regular = true;
    117117                } else {
    118118
    119                     center = nodes.get(way.nodes.contains(nodes.get(0)) ? 1 : 0).getEastNorth();
     119                    center = nodes.get(way.getNodes().contains(nodes.get(0)) ? 1 : 0).getEastNorth();
    120120                    if (nodes.size() == 2) {
    121121                        radius = distance(nodes.get(0).getEastNorth(), nodes.get(1).getEastNorth());
    … …  
    125125            }
    126126
    127             for (Node n : way.nodes) {
     127            for (Node n : way.getNodes()) {
    128128                if (!nodes.contains(n)) {
    129129                    nodes.add(n);

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

    r1847 r1862  
    5656            for (OsmPrimitive osm : sel)
    5757                if (osm instanceof Way) {
    58                     nodes.addAll(((Way)osm).nodes);
    59                     itnodes.addAll(((Way)osm).nodes);
     58                    nodes.addAll(((Way)osm).getNodes());
     59                    itnodes.addAll(((Way)osm).getNodes());
    6060                }
    6161        }

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

    r1847 r1862  
    104104
    105105            if (osmPrimitive instanceof Way &&
    106                     ((Way)osmPrimitive).nodes.size() > maxNodes) {
     106                    ((Way)osmPrimitive).getNodesCount() > maxNodes) {
    107107                OptionPaneUtil.showMessageDialog(
    108108                        Main.parent,
    109109                        tr("{0} nodes in way {1} exceed the max. allowed number of nodes {2}",
    110                                 ((Way)osmPrimitive).nodes.size(),
     110                                ((Way)osmPrimitive).getNodesCount(),
    111111                                Long.toString(osmPrimitive.id),
    112112                                maxNodes

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

    r1847 r1862  
    144144        List<Node> nodeList = null;
    145145        Object firstTry = actuallyCombineWays(selectedWays, false);
    146         if (firstTry instanceof List) {
     146        if (firstTry instanceof List<?>) {
    147147            nodeList = (List<Node>) firstTry;
    148148        } else {
    149149            Object secondTry = actuallyCombineWays(selectedWays, true);
    150             if (secondTry instanceof List) {
     150            if (secondTry instanceof List<?>) {
    151151                int option = new ExtendedDialog(Main.parent,
    152152                        tr("Change directions?"),
    … …  
    182182        Way newWay = new Way(modifyWay);
    183183
    184         newWay.nodes.clear();
    185         newWay.nodes.addAll(nodeList);
     184        newWay.setNodes(nodeList);
    186185
    187186        // display conflict dialog

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

    r1847 r1862  
    8181                Way wnew = new Way();
    8282                wnew.cloneFrom(w);
    83                 wnew.nodes.clear();
    8483                List<Node> nodes = new ArrayList<Node>();
    85                 for (Node n : w.nodes) {
     84                for (Node n : w.getNodes()) {
    8685                    if (! map.containsKey(n)) {
    8786                        n.visit(this);
    … …  
    8988                    nodes.add((Node)map.get(n));
    9089                }
    91                 wnew.nodes.addAll(nodes);
     90                wnew.setNodes(nodes);
    9291                pasteBuffer.addPrimitive(wnew);
    9392            }

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

    r1847 r1862  
    9999                if (osm instanceof Way) {
    100100                    existingWay = ((Way)osm);
    101                     for (Node n : ((Way)osm).nodes)
     101                    for (Node n : ((Way)osm).getNodes())
    102102                    {
    103103                        if(!nodes.contains(n)) {

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

    r1847 r1862  
    5454            for (OsmPrimitive osm : sel)
    5555                if (osm instanceof Way) {
    56                     nodes.addAll(((Way)osm).nodes);
    57                     itnodes.addAll(((Way)osm).nodes);
     56                    nodes.addAll(((Way)osm).getNodes());
     57                    itnodes.addAll(((Way)osm).getNodes());
    5858                }
    5959        }

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

    r1820 r1862  
    5050            }
    5151
    52             if (ws.way.nodes.get(ws.lowerIndex) != node
    53                     && ws.way.nodes.get(ws.lowerIndex+1) != node) {
     52            if (ws.way.getNode(ws.lowerIndex) != node
     53                    && ws.way.getNode(ws.lowerIndex+1) != node) {
    5454                is.add(ws.lowerIndex);
    5555            }

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

    r1857 r1862  
    217217
    218218        for (Way w : getCurrentDataSet().ways) {
    219             if (w.deleted || w.incomplete || w.nodes.size() < 1) {
     219            if (w.deleted || w.incomplete || w.getNodesCount() < 1) {
    220220                continue;
    221221            }
    … …  
    225225                    continue;
    226226                }
    227                 if (w.nodes.contains(sn)) {
     227                if (w.getNodes().contains(sn)) {
    228228                    modify = true;
    229229                }
    … …  
    235235            ArrayList<Node> nn = new ArrayList<Node>();
    236236            Node lastNode = null;
    237             for (int i = 0; i < w.nodes.size(); i++) {
    238                 Node pushNode = w.nodes.get(i);
     237            for (Node pushNode: w.getNodes()) {
    239238                if (allNodes.contains(pushNode)) {
    240239                    pushNode = dest;
    … …  
    262261            } else {
    263262                Way newWay = new Way(w);
    264                 newWay.nodes.clear();
    265                 newWay.nodes.addAll(nn);
     263                newWay.setNodes(nn);
    266264                cmds.add(new ChangeCommand(w, newWay));
    267265            }

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

    r1857 r1862  
    4545                nodes.add((Node)osm);
    4646            } else if (osm instanceof Way) {
    47                 nodes.addAll(((Way)osm).nodes);
     47                nodes.addAll(((Way)osm).getNodes());
    4848            }
    4949        }

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

    r1857 r1862  
    8383            // Check if every way is made of at least four segments and closed
    8484            Way way = (Way)osm;
    85             if ((way.nodes.size() < 5) || (!way.nodes.get(0).equals(way.nodes.get(way.nodes.size() - 1)))) {
     85            if ((way.getNodesCount() < 5) || !way.isClosed()) {
    8686                OptionPaneUtil.showMessageDialog(
    8787                        Main.parent,

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

    r1844 r1862  
    8181            /* make sure we reference the new nodes corresponding to the old ones */
    8282            List<Node> nodes = new ArrayList<Node>();
    83             for (Node n : w.nodes) {
     83            for (Node n : w.getNodes()) {
    8484                nodes.add((Node)map.get(n));
    8585            }
    86             wnew.nodes.clear();
    87             wnew.nodes.addAll(nodes);
     86            wnew.setNodes(nodes);
    8887            map.put(w, wnew);
    8988        }

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

    r1847 r1862  
    99import java.util.Collections;
    1010import java.util.LinkedList;
     11import java.util.List;
    1112
    1213import javax.swing.JOptionPane;
    … …  
    1920import org.openstreetmap.josm.corrector.UserCancelException;
    2021import org.openstreetmap.josm.data.osm.DataSet;
     22import org.openstreetmap.josm.data.osm.Node;
    2123import org.openstreetmap.josm.data.osm.OsmPrimitive;
    2224import org.openstreetmap.josm.data.osm.Way;
    … …  
    5860        for (Way w : sel) {
    5961            Way wnew = new Way(w);
    60             Collections.reverse(wnew.nodes);
     62            List<Node> nodesCopy = wnew.getNodes();
     63            Collections.reverse(nodesCopy);
     64            wnew.setNodes(nodesCopy);
    6165            if (Main.pref.getBoolean("tag-correction.reverse-way", true)) {
    6266                try

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

    r1857 r1862  
    106106                        continue;
    107107                    }
    108                     int last = w.nodes.size()-1;
     108                    int last = w.getNodesCount()-1;
    109109                    if(last <= 0) {
    110110                        continue; // zero or one node ways
    111111                    }
    112                     Boolean circular = w.nodes.get(0).equals(w.nodes.get(last));
     112                    boolean circular = w.isClosed();
    113113                    int i = 0;
    114                     for (Node wn : w.nodes) {
     114                    for (Node wn : w.getNodes()) {
    115115                        if ((circular || (i > 0 && i < last)) && n.equals(wn)) {
    116116                            Integer old = wayOccurenceCounter.get(w);
    … …  
    159159
    160160            HashSet<Node> nds = new HashSet<Node>(selectedNodes);
    161             for (Node n : selectedWay.nodes) {
     161            for (Node n : selectedWay.getNodes()) {
    162162                nds.remove(n);
    163163            }
    … …  
    211211        wayChunks.add(currentWayChunk);
    212212
    213         Iterator<Node> it = selectedWay.nodes.iterator();
     213        Iterator<Node> it = selectedWay.getNodes().iterator();
    214214        while (it.hasNext()) {
    215215            Node currentNode = it.next();
    … …  
    273273        // First, change the original way
    274274        Way changedWay = new Way(selectedWay);
    275         changedWay.nodes.clear();
    276         changedWay.nodes.addAll(chunkIt.next());
     275        changedWay.setNodes(chunkIt.next());
    277276        commandList.add(new ChangeCommand(selectedWay, changedWay));
    278277        newSelection.add(selectedWay);

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

    r1857 r1862  
    6767            int count = 0;
    6868            for (Way w : getCurrentDataSet().ways) {
    69                 if (w.deleted || w.incomplete || w.nodes.size() < 1) {
     69                if (w.deleted || w.incomplete || w.getNodesCount() < 1) {
    7070                    continue;
    7171                }
    72                 if (!w.nodes.contains(selectedNode)) {
     72                if (!w.getNodes().contains(selectedNode)) {
    7373                    continue;
    7474                }
    … …  
    9292                int count = 0;
    9393                for (Way w : getCurrentDataSet().ways) {
    94                     if (w.deleted || w.incomplete || w.nodes.size() < 1) {
     94                    if (w.deleted || w.incomplete || w.getNodesCount() < 1) {
    9595                        continue;
    9696                    }
    97                     if (!w.nodes.contains(n)) {
     97                    if (!w.getNodes().contains(n)) {
    9898                        continue;
    9999                    }
    … …  
    191191        boolean isPartOfWay = false;
    192192        for(Way w : getCurrentDataSet().ways) {
    193             if(w.nodes.contains(n)) {
     193            if(w.getNodes().contains(n)) {
    194194                isPartOfWay = true;
    195195                break;
    … …  
    232232                selectedNode = (Node) p;
    233233                if (size == 1 || selectedWay != null)
    234                     return size == 1 || selectedWay.nodes.contains(selectedNode);
     234                    return size == 1 || selectedWay.getNodes().contains(selectedNode);
    235235            } else if (p instanceof Way) {
    236236                selectedWay = (Way) p;
    237237                if (size == 2 && selectedNode != null)
    238                     return selectedWay.nodes.contains(selectedNode);
     238                    return selectedWay.getNodes().contains(selectedNode);
    239239            }
    240240        }
    … …  
    276276            if (p instanceof Node) {
    277277                Node n = (Node) p;
    278                 if (!selectedWay.nodes.contains(n))
     278                if (!selectedWay.getNodes().contains(n))
    279279                    return false;
    280280                selectedNodes.add(n);
    … …  
    283283
    284284        if (selectedNodes.size() < 1) {
    285             selectedNodes.addAll(selectedWay.nodes);
     285            selectedNodes.addAll(selectedWay.getNodes());
    286286        }
    287287
    … …  
    298298    private Way modifyWay(Node originalNode, Way w, List<Command> cmds, List<Node> newNodes) {
    299299        ArrayList<Node> nn = new ArrayList<Node>();
    300         for (Node pushNode : w.nodes) {
     300        for (Node pushNode : w.getNodes()) {
    301301            if (originalNode == pushNode) {
    302302                // clone the node for all other ways
    … …  
    309309        }
    310310        Way newWay = new Way(w);
    311         newWay.nodes.clear();
    312         newWay.nodes.addAll(nn);
     311        newWay.setNodes(nn);
    313312
    314313        return newWay;
    … …  
    370369            // modify all ways containing the nodes
    371370            for (Way w : getCurrentDataSet().ways) {
    372                 if (w.deleted || w.incomplete || w.nodes.size() < 1) {
     371                if (w.deleted || w.incomplete || w.getNodesCount() < 1) {
    373372                    continue;
    374373                }
    375                 if (!w.nodes.contains(selectedNode)) {
     374                if (!w.getNodes().contains(selectedNode)) {
    376375                    continue;
    377376                }

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

    r1847 r1862  
    6565    /**
    6666     * Replies true if we are currently running on OSX
    67      * 
     67     *
    6868     * @return true if we are currently running on OSX
    6969     */
    … …  
    306306                {
    307307                    Way w = (Way)osm;
    308                     Point p1 = c.getPoint(w.nodes.get(nearestWS.lowerIndex));
    309                     Point p2 = c.getPoint(w.nodes.get(nearestWS.lowerIndex+1));
     308                    Point p1 = c.getPoint(w.getNode(nearestWS.lowerIndex));
     309                    Point p2 = c.getPoint(w.getNode(nearestWS.lowerIndex+1));
    310310                    if(SimplePaintVisitor.isLargeSegment(p1, p2, Main.pref.getInteger("mappaint.node.virtual-space", 70)))
    311311                    {
    … …  
    317317                            // virtual node at the same spot will be joined which is likely unwanted
    318318                            if(virtualWayNode != null) {
    319                                 if(  !w.nodes.get(nearestWS.lowerIndex+1).equals(virtualWayNode)
    320                                         && !w.nodes.get(nearestWS.lowerIndex  ).equals(virtualWayNode)) {
     319                                if(  !w.getNode(nearestWS.lowerIndex+1).equals(virtualWayNode)
     320                                        && !w.getNode(nearestWS.lowerIndex).equals(virtualWayNode)) {
    321321                                    continue;
    322322                                }
    323323                            } else {
    324                                 virtualWayNode = w.nodes.get(nearestWS.lowerIndex+1);
     324                                virtualWayNode = w.getNode(nearestWS.lowerIndex+1);
    325325                            }
    326326
    … …  
    459459                    {
    460460                        s.add(osm);
    461                         s.addAll(((Way)osm).nodes);
     461                        s.addAll(((Way)osm).getNodes());
    462462                    }
    463463                    if(s.size() > max)

  • trunk/src/org/openstreetmap/josm/actions/search/SearchCompiler.java

    r1843 r1862  
    375375        public NodeCount(int count) {this.count = count;}
    376376        @Override public boolean match(OsmPrimitive osm) {
    377             return osm instanceof Way && ((Way) osm).nodes.size() == count;
     377            return osm instanceof Way && ((Way) osm).getNodesCount() == count;
    378378        }
    379379        @Override public String toString() {return "nodes="+count;}
    … …  
    394394        @Override public boolean match(OsmPrimitive osm) {
    395395            if(!(osm instanceof Way)) return false;
    396             int size = ((Way)osm).nodes.size();
     396            int size = ((Way)osm).getNodesCount();
    397397            return (size >= minCount) && (size <= maxCount);
    398398        }
    … …  
    441441
    442442            if (osm instanceof Way) {
    443                 for (Node n : ((Way)osm).nodes) {
     443                for (Node n : ((Way)osm).getNodes()) {
    444444                    isParent |= child.match(n);
    445445                }

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

    r1814 r1862  
    2121import org.openstreetmap.josm.data.osm.RelationMember;
    2222import org.openstreetmap.josm.data.osm.Way;
    23 import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    2423import org.openstreetmap.josm.tools.ImageProvider;
    2524
    … …  
    2827 * layer and disconnects any references from {@see Way}s or {@see Relation}s
    2928 * to this primitive.
    30  * 
     29 *
    3130 * This command is necessary if a local {@see OsmPrimitive} has been deleted on
    3231 * the server by another user and if the local user decides to delete his version
    3332 * too. If he only deleted it "logically" JOSM would try to delete it on the server
    3433 * which would result in an non resolvable conflict.
    35  * 
     34 *
    3635 */
    3736public class PurgePrimitivesCommand extends ConflictResolveCommand{
    … …  
    4443     * because a {@see Relation} refers to any other {@see OsmPrimitive}
    4544     * via a relation member.
    46      * 
     45     *
    4746     */
    4847    static class OsmParentChildPair {
    … …  
    10099     * as child and given set of parents. We don't use {@see CollectBackReferencesVisitor}
    101100     * because it seems quite inefficient.
    102      * 
     101     *
    103102     * @param parents  the set of potential parents
    104103     * @param child the child
    … …  
    110109            if (parent instanceof Way) {
    111110                Way w = (Way)parent;
    112                 for (OsmPrimitive node : w.nodes) {
     111                for (OsmPrimitive node : w.getNodes()) {
    113112                    if (node == child) {
    114113                        OsmParentChildPair pair = new OsmParentChildPair(parent, node);
    … …  
    170169    /**
    171170     * Purges an {@see OsmPrimitive} <code>toPurge</code> from a {@see DataSet}.
    172      * 
     171     *
    173172     * @param toPurge the primitive to purge
    174173     * @param ds  the dataset to purge from
    175174     * @param hive the hive of {@see OsmPrimitive}s we remember other {@see OsmPrimitive}
    176175     * we have to purge because we purge <code>toPurge</code>.
    177      * 
     176     *
    178177     */
    179178    protected void purge(OsmPrimitive toPurge, DataSet ds, ArrayList<OsmPrimitive> hive) {

  • trunk/src/org/openstreetmap/josm/corrector/ReverseWayTagCorrector.java

    r1814 r1862  
    7676        ArrayList<OsmPrimitive> primitives = new ArrayList<OsmPrimitive>();
    7777        primitives.add(way);
    78         primitives.addAll(way.nodes);
     78        primitives.addAll(way.getNodes());
    7979
    8080        for (OsmPrimitive primitive : primitives) {

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

    r1762 r1862  
    44import static org.openstreetmap.josm.tools.I18n.tr;
    55import static org.openstreetmap.josm.tools.I18n.trn;
    6 
    7 import java.util.HashSet;
    86
    97import java.util.ArrayList;
    108import java.util.Arrays;
    119import java.util.Collection;
     10import java.util.HashSet;
    1211import java.util.List;
    1312
    1413import org.openstreetmap.josm.data.osm.visitor.Visitor;
     14import org.openstreetmap.josm.tools.CopyList;
    1515import org.openstreetmap.josm.tools.Pair;
    1616
    … …  
    2626     */
    2727    public final List<Node> nodes = new ArrayList<Node>();
     28
     29    /**
     30     *
     31     * You can modify returned list but changes will not be propagated back
     32     * to the Way. Use {@link #setNodes(List)} to update this way
     33     * @return Nodes composing the way
     34     * @since 1862
     35     */
     36    public List<Node> getNodes() {
     37        return new CopyList<Node>(nodes.toArray(new Node[nodes.size()]));
     38    }
     39
     40    /**
     41     * @param nodes
     42     * @since 1862
     43     */
     44    public void setNodes(List<Node> nodes) {
     45        this.nodes.clear();
     46        this.nodes.addAll(nodes);
     47    }
     48
     49    /**
     50     *
     51     * @return
     52     * @since 1862
     53     */
     54    public int getNodesCount() {
     55        return nodes.size();
     56    }
     57
     58    /**
     59     *
     60     * @param index
     61     * @return
     62     * @since 1862
     63     */
     64    public Node getNode(int index) {
     65        return nodes.get(index);
     66    }
    2867
    2968    /* mappaint data */

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

    r1523 r1862  
    66
    77import org.openstreetmap.josm.data.osm.DataSet;
     8import org.openstreetmap.josm.data.osm.Node;
     9import org.openstreetmap.josm.data.osm.OsmPrimitive;
    810import org.openstreetmap.josm.data.osm.Relation;
    911import org.openstreetmap.josm.data.osm.RelationMember;
    10 import org.openstreetmap.josm.data.osm.Node;
    11 import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1212import org.openstreetmap.josm.data.osm.Way;
    1313
    … …  
    4747        for (Way w : ds.ways) {
    4848            if (w.deleted || w.incomplete) continue;
    49             for (Node n2 : w.nodes) {
     49            for (Node n2 : w.getNodes()) {
    5050                if (n == n2) {
    5151                    data.add(w);

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

    r1843 r1862  
    2121import java.util.Iterator;
    2222import java.util.LinkedList;
     23import java.util.List;
    2324
    2425import javax.swing.ImageIcon;
    … …  
    162163     */
    163164    public void visit(Way w) {
    164         if(w.nodes.size() < 2)
     165        if(w.getNodesCount() < 2)
    165166        {
    166167            w.mappaintVisibleCode = viewid;
    … …  
    174175        double maxy = -10000;
    175176
    176         for (Node n : w.nodes)
     177        for (Node n : w.getNodes())
    177178        {
    178179            if(n.getEastNorth().east() > maxx) maxx = n.getEastNorth().east();
    … …  
    293294                {
    294295                    lastN = null;
    295                     for(Node n : w.nodes)
     296                    for(Node n : w.getNodes())
    296297                    {
    297298                        if(lastN != null)
    … …  
    308309        /* draw the way */
    309310        lastN = null;
    310         Iterator<Node> it = w.nodes.iterator();
     311        Iterator<Node> it = w.getNodes().iterator();
    311312        while (it.hasNext())
    312313        {
    … …  
    326327                {
    327328                    lastN = null;
    328                     for(Node n : w.nodes)
     329                    for(Node n : w.getNodes())
    329330                    {
    330331                        if(lastN != null)
    … …  
    365366            Way w = null;
    366367            Boolean selected = false;
    367             ArrayList<Node> n = null;
     368            List<Node> n = null;
    368369            Boolean joined = true;
    369370            while(joined && left != 0)
    … …  
    380381                        {
    381382                            int mode = 0;
    382                             int cl = c.nodes.size()-1;
     383                            int cl = c.getNodesCount()-1;
    383384                            int nl;
    384385                            if(n == null)
    385386                            {
    386                                 nl = w.nodes.size()-1;
    387                                 if(w.nodes.get(nl) == c.nodes.get(0)) mode = 21;
    388                                 else if(w.nodes.get(nl) == c.nodes.get(cl)) mode = 22;
    389                                 else if(w.nodes.get(0) == c.nodes.get(0)) mode = 11;
    390                                 else if(w.nodes.get(0) == c.nodes.get(cl)) mode = 12;
     387                                nl = w.getNodesCount()-1;
     388                                if(w.getNode(nl) == c.getNode(0)) mode = 21;
     389                                else if(w.getNode(nl) == c.getNode(cl)) mode = 22;
     390                                else if(w.getNode(0) == c.getNode(0)) mode = 11;
     391                                else if(w.getNode(0) == c.getNode(cl)) mode = 12;
    391392                            }
    392393                            else
    393394                            {
    394395                                nl = n.size()-1;
    395                                 if(n.get(nl) == c.nodes.get(0)) mode = 21;
    396                                 else if(n.get(0) == c.nodes.get(cl)) mode = 12;
    397                                 else if(n.get(0) == c.nodes.get(0)) mode = 11;
    398                                 else if(n.get(nl) == c.nodes.get(cl)) mode = 22;
     396                                if(n.get(nl) == c.getNode(0)) mode = 21;
     397                                else if(n.get(0) == c.getNode(cl)) mode = 12;
     398                                else if(n.get(0) == c.getNode(0)) mode = 11;
     399                                else if(n.get(nl) == c.getNode(cl)) mode = 22;
    399400                            }
    400401                            if(mode != 0)
    … …  
    404405                                if(c.selected) selected = true;
    405406                                --left;
    406                                 if(n == null) n = new ArrayList<Node>(w.nodes);
     407                                if(n == null) n = w.getNodes();
    407408                                n.remove((mode == 21 || mode == 22) ? nl : 0);
    408409                                if(mode == 21)
    409                                     n.addAll(c.nodes);
     410                                    n.addAll(c.getNodes());
    410411                                else if(mode == 12)
    411                                     n.addAll(0, c.nodes);
     412                                    n.addAll(0, c.getNodes());
    412413                                else if(mode == 22)
    413414                                {
    414                                     for(Node node : c.nodes)
     415                                    for(Node node : c.getNodes())
    415416                                        n.add(nl, node);
    416417                                }
    417418                                else /* mode == 11 */
    418419                                {
    419                                     for(Node node : c.nodes)
     420                                    for(Node node : c.getNodes())
    420421                                        n.add(0, node);
    421422                                }
    … …  
    551552                {
    552553                    Way w = (Way) m.member;
    553                     if(w.nodes.size() < 2)
     554                    if(w.getNodesCount() < 2)
    554555                    {
    555556                        r.putError(tr("Way ''{0}'' with less than two points.",
    … …  
    640641        if(fromWay.firstNode() == via) {
    641642            //System.out.println("From way heading away from via");
    642             fromNode = fromWay.nodes.get(1);
     643            fromNode = fromWay.getNode(1);
    643644        } else {
    644645            //System.out.println("From way heading towards via");
    645             fromNode = fromWay.nodes.get(fromWay.nodes.size()-2);
     646            fromNode = fromWay.getNode(fromWay.nodes.size()-2);
    646647        }
    647648
    … …  
    796797                {
    797798                    Way w = (Way) m.member;
    798                     if(w.nodes.size() < 2)
     799                    if(w.getNodesCount() < 2)
    799800                    {
    800801                        r.putError(tr("Way ''{0}'' with less than two points.",
    … …  
    881882                    {
    882883                        way = w;
    883                         for (Node n : w.nodes)
     884                        for (Node n : w.getNodes())
    884885                        {
    885886                            p = nc.getPoint(n);
    … …  
    10591060        Polygon polygon = new Polygon();
    10601061
    1061         for (Node n : w.nodes)
     1062        for (Node n : w.getNodes())
    10621063        {
    10631064            Point p = nc.getPoint(n);

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

    r1753 r1862  
    77import java.util.HashMap;
    88import java.util.LinkedList;
     9import java.util.List;
    910import java.util.Map;
    1011import java.util.logging.Logger;
    … …  
    5152    /**
    5253     * constructor
    53      * 
     54     *
    5455     * The visitor will merge <code>theirDataSet</code> onto <code>myDataSet</code>
    55      * 
     56     *
    5657     * @param myDataSet  dataset with my primitives
    5758     * @param theirDataSet dataset with their primitives.
    … …  
    7677    /**
    7778     * Merges a primitive <code>other</code> of type <P> onto my primitives.
    78      * 
     79     *
    7980     * If other.id != 0 it tries to merge it with an corresponding primitive from
    8081     * my dataset with the same id. If this is not possible a conflict is remembered
    8182     * in {@see #conflicts}.
    82      * 
     83     *
    8384     * If other.id == 0 it tries to find a primitive in my dataset with id == 0 which
    8485     * is semantically equal. If it finds one it merges its technical attributes onto
    8586     * my primitive.
    86      * 
     87     *
    8788     * @param <P>  the type of the other primitive
    8889     * @param other  the other primitive
    … …  
    171172    private void fixWay(Way w) {
    172173        boolean replacedSomething = false;
    173         LinkedList<Node> newNodes = new LinkedList<Node>();
    174         for (Node myNode : w.nodes) {
     174        List<Node> newNodes = new LinkedList<Node>();
     175        for (Node myNode : w.getNodes()) {
    175176            Node mergedNode = (Node) merged.get(myNode);
    176177            if (mergedNode != null) {
    … …  
    184185        }
    185186        if (replacedSomething) {
    186             w.nodes.clear();
    187             w.nodes.addAll(newNodes);
     187            w.setNodes(newNodes);
    188188        }
    189189    }
    … …  
    310310     * Runs the merge operation. Successfully merged {@see OsmPrimitive}s are in
    311311     * {@see #getMyDataSet()}.
    312      * 
     312     *
    313313     * See {@see #getConflicts()} for a map of conflicts after the merge operation.
    314314     */
    … …  
    322322    /**
    323323     * replies my dataset
    324      * 
     324     *
    325325     * @return
    326326     */
    … …  
    332332    /**
    333333     * replies the map of conflicts
    334      * 
     334     *
    335335     * @return the map of conflicts
    336336     */

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

    r1725 r1862  
    2020import org.openstreetmap.josm.Main;
    2121import org.openstreetmap.josm.data.osm.DataSet;
    22 import org.openstreetmap.josm.data.osm.RelationMember;
    2322import org.openstreetmap.josm.data.osm.Node;
    2423import org.openstreetmap.josm.data.osm.OsmPrimitive;
    2524import org.openstreetmap.josm.data.osm.Relation;
     25import org.openstreetmap.josm.data.osm.RelationMember;
    2626import org.openstreetmap.josm.data.osm.Way;
    2727import org.openstreetmap.josm.gui.NavigatableComponent;
    … …  
    269269
    270270    public void visitVirtual(Way w) {
    271         Iterator<Node> it = w.nodes.iterator();
     271        Iterator<Node> it = w.getNodes().iterator();
    272272        if (it.hasNext()) {
    273273            Point lastP = nc.getPoint(it.next());
    … …  
    294294     */
    295295    public void visit(Way w) {
    296         if (w.incomplete || w.nodes.size() < 2)
     296        if (w.incomplete || w.getNodesCount() < 2)
    297297            return;
    298298
    … …  
    361361
    362362                boolean first = true;
    363                 for (Node n : ((Way) m.member).nodes) {
     363                for (Node n : ((Way) m.member).getNodes()) {
    364364                    if (n.incomplete || n.deleted) continue;
    365365                    Point p = nc.getPoint(n);
Note: See TracChangeset for help on using the changeset viewer.