/** * Removes the given set of {@link Node nodes} from this way. Ignored, if selection is null. * * @param selection The selection of nodes to remove. Ignored, if null * @since 5408 */ public void removeNodes(Set<? extends Node> selection) { if (selection == null || isIncomplete()) return; boolean locked = writeLock(); try { boolean closed = isClosed() && selection.contains(lastNode()); List<Node> copy = new ArrayList<>(); for (Node n : nodes) { if (!selection.contains(n)) { copy.add(n); } } int i = copy.size(); if (closed && i > 2) { copy.add(copy.get(0)); } else if (i >= 2 && i <= 3 && copy.get(0) == copy.get(i - 1)) { copy.remove(i - 1); } setNodes(removeDouble(copy)); for (Node n : selection) { n.clearCachedStyle(); } } finally { writeUnlock(locked); } }
/** * 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) { boolean locked = writeLock(); try { for (Node node : this.nodes) { node.removeReferrer(this); node.clearCachedStyle(); } if (nodes == null) { this.nodes = new Node[0]; } else { this.nodes = nodes.toArray(new Node[nodes.size()]); } for (Node node : this.nodes) { node.addReferrer(this); node.clearCachedStyle(); } clearCachedStyle(); fireNodesChanged(); } finally { writeUnlock(locked); } }
/** * 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 if this way is marked as incomplete. We can't add a node to an * incomplete way * @since 1313 */ public void addNode(Node n) { if (n == null) return; boolean locked = writeLock(); try { if (isIncomplete()) throw new IllegalStateException( tr("Cannot add node {0} to incomplete way {1}.", n.getId(), getId())); clearCachedStyle(); n.addReferrer(this); nodes = Utils.addInArrayCopy(nodes, n); n.clearCachedStyle(); fireNodesChanged(); } finally { writeUnlock(locked); } }
@Override public void setDeleted(boolean deleted) { boolean locked = writeLock(); try { for (Node n : nodes) { if (deleted) { n.removeReferrer(this); } else { n.addReferrer(this); } n.clearCachedStyle(); } fireNodesChanged(); super.setDeleted(deleted); } finally { writeUnlock(locked); } }
/** * Adds a node at position offs. * * @param offs the offset * @param n the node. Ignored, if null. * @throws IllegalStateException if this way is marked as incomplete. We can't add a node to an * incomplete way * @throws IndexOutOfBoundsException if offs is out of bounds * @since 1313 */ public void addNode(int offs, Node n) throws IndexOutOfBoundsException { if (n == null) return; boolean locked = writeLock(); try { if (isIncomplete()) throw new IllegalStateException( tr("Cannot add node {0} to incomplete way {1}.", n.getId(), getId())); clearCachedStyle(); n.addReferrer(this); 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; n.clearCachedStyle(); fireNodesChanged(); } finally { writeUnlock(locked); } }
/** * Removes the given {@link Node} from this way. Ignored, if n is null. * * @param n The node to remove. Ignored, if null * @since 1463 */ public void removeNode(Node n) { if (n == null || isIncomplete()) return; boolean locked = writeLock(); try { boolean closed = lastNode() == n && firstNode() == n; int i; List<Node> copy = getNodes(); while ((i = copy.indexOf(n)) >= 0) { copy.remove(i); } i = copy.size(); if (closed && i > 2) { copy.add(copy.get(0)); } else if (i >= 2 && i <= 3 && copy.get(0) == copy.get(i - 1)) { copy.remove(i - 1); } setNodes(removeDouble(copy)); n.clearCachedStyle(); } finally { writeUnlock(locked); } }
public void clearCachedNodeStyles() { for (final Node n : nodes) { n.clearCachedStyle(); } }