Changeset 2204 in josm for trunk

Timestamp:

2009-09-27T18:15:34+02:00 (15 years ago)

Author:

jttt

Message:

Save way nodes as array instead of ArrayList to save memory

File:

• trunk/src/org/openstreetmap/josm/data/osm/Way.java (modified) (16 diffs)

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

@@ -2 +2 @@
 package org.openstreetmap.josm.data.osm;
 
+import static org.openstreetmap.josm.tools.I18n.tr;
+
 import java.util.ArrayList;
-
 import java.util.Arrays;
 import java.util.Collection;
@@ -11 +12 @@
 import org.openstreetmap.josm.tools.CopyList;
 import org.openstreetmap.josm.tools.Pair;
-import static org.openstreetmap.josm.tools.I18n.tr;
 
 /**
@@ -24 +24 @@
      *
      */
-    private final List<Node> nodes = new ArrayList<Node>();
+    private Node[] nodes = new Node[0];
 
     /**
@@ -34 +34 @@
      */
     public List<Node> getNodes() {
-        return new CopyList<Node>(nodes.toArray(new Node[nodes.size()]));
-    }
-
-    /**
+        return new CopyList<Node>(nodes);
+    }
+
+    /**
+     * Set new list of nodes to way. This method is preferred to multiple calls to addNode/removeNode
+     * and similar methods because nodes are internally saved as array which means lower memory overhead
+     * but also slower modifying operations.
      * @param nodes New way nodes. Can be null, in that case all way nodes are removed
      * @since 1862
      */
     public void setNodes(List<Node> nodes) {
-        this.nodes.clear();
-        if (nodes != null) {
-            this.nodes.addAll(nodes);
+        if (nodes == null) {
+            this.nodes = new Node[0];
+        } else {
+            this.nodes = nodes.toArray(new Node[nodes.size()]);
         }
         clearCached();
@@ -51 +55 @@
     /**
      * Replies the number of nodes in this ways.
-     * 
+     *
      * @return the number of nodes in this ways.
      * @since 1862
      */
     public int getNodesCount() {
-        return nodes.size();
+        return nodes.length;
     }
 
     /**
      * Replies the node at position <code>index</code>.
-     * 
+     *
      * @param index the position
      * @return  the node at position <code>index</code>
@@ -69 +73 @@
      */
     public Node getNode(int index) {
-        return nodes.get(index);
+        return nodes[index];
     }
 
@@ -75 +79 @@
      * Replies true if this way contains the node <code>node</code>, false
      * otherwise. Replies false if  <code>node</code> is null.
-     * 
+     *
      * @param node the node. May be null.
      * @return true if this way contains the node <code>node</code>, false
@@ -83 +87 @@
     public boolean containsNode(Node node) {
         if (node == null) return false;
-        return nodes.contains(node);
+        for (int i=0; i<nodes.length; i++) {
+            if (nodes[i].equals(node)) {
+                return true;
+            }
+        }
+        return false;
     }
 
@@ -122 +131 @@
     /**
      * Creates a new way with id 0.
-     * 
+     *
      */
     public Way(){
@@ -130 +139 @@
     /**
      * Create an identical clone of the argument (including the id).
-     * 
+     *
      * @param original  the original way. Must not be null.
      */
@@ -141 +150 @@
      * Creates a new way for the given id. If the id > 0, the way is marked
      * as incomplete.
-     * 
+     *
      * @param id the id. > 0 required
      * @throws IllegalArgumentException thrown if id < 0
@@ -151 +160 @@
     @Override public void cloneFrom(OsmPrimitive osm) {
         super.cloneFrom(osm);
-        nodes.clear();
-        nodes.addAll(((Way)osm).nodes);
+        Way otherWay = (Way)osm;
+        nodes = new Node[otherWay.nodes.length];
+        System.arraycopy(otherWay.nodes, 0, nodes, 0, otherWay.nodes.length);
     }
 
     @Override public String toString() {
         if (incomplete) return "{Way id="+getId()+" version="+getVersion()+" (incomplete)}";
-        return "{Way id="+getId()+" version="+getVersion()+" nodes="+Arrays.toString(nodes.toArray())+"}";
+        return "{Way id="+getId()+" version="+getVersion()+" nodes="+Arrays.toString(nodes)+"}";
     }
 
@@ -180 +190 @@
         boolean closed = (lastNode() == n && firstNode() == n);
         int i;
-        while ((i = nodes.indexOf(n)) >= 0) {
-            nodes.remove(i);
-        }
-        i = nodes.size();
+        List<Node> copy = getNodes();
+        while ((i = copy.indexOf(n)) >= 0) {
+            copy.remove(i);
+        }
+        i = copy.size();
         if (closed && i > 2) {
             addNode(firstNode());
-        } else if (i >= 2 && i <= 3 && nodes.get(0) == nodes.get(i-1)) {
-            nodes.remove(i-1);
-        }
+        } else if (i >= 2 && i <= 3 && copy.get(0) == copy.get(i-1)) {
+            copy.remove(i-1);
+        }
+        setNodes(copy);
     }
 
@@ -202 +214 @@
     /**
      * Adds a node to the end of the list of nodes. Ignored, if n is null.
-     * 
+     *
      * @param n the node. Ignored, if null.
      * @throws IllegalStateException thrown, if this way is marked as incomplete. We can't add a node
@@ -211 +223 @@
         if (incomplete)
             throw new IllegalStateException(tr("Cannot add node {0} to incomplete way {1}.", n.getId(), getId()));
-        if (incomplete) return;
         clearCached();
-        nodes.add(n);
+        Node[] newNodes = new Node[nodes.length + 1];
+        System.arraycopy(nodes, 0, newNodes, 0, nodes.length);
+        newNodes[nodes.length] = n;
+        nodes = newNodes;
     }
 
     /**
      * Adds a node at position offs.
-     * 
+     *
      * @param int offs the offset
      * @param n the node. Ignored, if null.
@@ -230 +244 @@
             throw new IllegalStateException(tr("Cannot add node {0} to incomplete way {1}.", n.getId(), getId()));
         clearCached();
-        nodes.add(offs, n);
+        Node[] newNodes = new Node[nodes.length + 1];
+        System.arraycopy(nodes, 0, newNodes, 0, offs);
+        System.arraycopy(nodes, offs, newNodes, offs + 1, nodes.length - offs);
+        newNodes[offs] = n;
+        nodes = newNodes;
     }
 
     public boolean isClosed() {
         if (incomplete) return false;
-        return nodes.size() >= 3 && lastNode() == firstNode();
+        return nodes.length >= 3 && lastNode() == firstNode();
     }
 
     public Node lastNode() {
-        if (incomplete || nodes.size() == 0) return null;
-        return nodes.get(nodes.size()-1);
+        if (incomplete || nodes.length == 0) return null;
+        return nodes[nodes.length-1];
     }
 
     public Node firstNode() {
-        if (incomplete || nodes.size() == 0) return null;
-        return nodes.get(0);
+        if (incomplete || nodes.length == 0) return null;
+        return nodes[0];
     }
 
     public boolean isFirstLastNode(Node n) {
-        if (incomplete || nodes.size() == 0) return false;
+        if (incomplete || nodes.length == 0) return false;
         return n == firstNode() || n == lastNode();
     }