private void markEdgeRemoved(String edgeId) { graph.getEdge(edgeId).addAttribute("ui.class", "removed"); }
private void removeNodeAndBelongingEdges(String nodeId, VehicleRoute fromRoute) { Node node = graph.getNode(nodeId); markRemoved(node); Edge entering = getEnteringEdge(nodeId); removeEdge(entering.getId()); if (node.getLeavingEdgeSet().isEmpty()) { if (fromRoute.getVehicle().isReturnToDepot()) throw new IllegalStateException("leaving edge is missing"); return; } Edge leaving = getLeavingEdge(nodeId); removeEdge((leaving.getId())); Node from = entering.getNode0(); Node to = leaving.getNode1(); if (!fromRoute.getActivities().isEmpty()) { addEdge(makeEdgeId(from, to), from.getId(), to.getId()); } }
private void markEdgeInserted(String edgeId) { graph.getEdge(edgeId).addAttribute("ui.class", "inserted"); graph.getEdge(edgeId).removeAttribute("ui.class"); }
/** * Checks if an edge enters this node. Utility method that can be useful in * subclasses. * * @param e * an edge * @return {@code true} if {@code e} is entering edge for this node. */ public boolean isEnteringEdge(Edge e) { return e.getTargetNode() == this || (!e.isDirected() && e.getSourceNode() == this); }
String edgeId = edge.getId(); sendEdgeAdded(sourceId, edgeId, edge.getNode0().getId(), edge .getNode1().getId(), edge.isDirected()); if (edge.getAttributeCount() > 0) for (String key : edge.getAttributeKeySet()) sendEdgeAttributeAdded(sourceId, edgeId, key, edge.getAttribute(key));
Edge e = this.graph.addEdge(edge.getId(), edge.getSourceNode().getId(), edge.getTargetNode().getId(), edge.isDirected()); if (edge.getAttributeKeySet() != null) { for (String key : edge.getAttributeKeySet()) { e.addAttribute(key, edge.getAttribute(key));
protected void modifyCost(String edgeId, double cval) { Edge e = env.getEdge(edgeId); if (e.isDirected()) modifyCost(getState(e.getSourceNode()), getState(e.getTargetNode()), cval); else { modifyCost(getState(e.getNode0()), getState(e.getNode1()), cval); modifyCost(getState(e.getNode1()), getState(e.getNode0()), cval); } }
/** * Set the name of the attribute used to store the number of passes of each * entity on each edge or node. * * @param name * A string giving the passes name. */ public void setPassesAttribute(String name) { if (context.graph != null) { for (Edge e : context.graph.getEachEdge()) { e.addAttribute(name, e.getNumber(context.passesAttribute)); e.removeAttribute(context.passesAttribute); } for (Node n : context.graph) { n.addAttribute(name, n.getNumber(context.passesAttribute)); n.removeAttribute(context.passesAttribute); } } context.passesAttribute = name; }
/** * Add an edge to the spanning tree. * * @param e * edge to add */ protected void edgeOn(Edge e) { if (flagAttribute != null) { if (flagOn != null) e.changeAttribute(flagAttribute, flagOn); else e.removeAttribute(flagAttribute); } }
private Edge getEnteringEdge(String toNodeId) { Collection<Edge> enteringEdges = graph.getNode(toNodeId).getEnteringEdgeSet(); if (enteringEdges.size() == 1) return enteringEdges.iterator().next(); else { for (Edge e : enteringEdges) { if (e.getId().startsWith("shipment")) { continue; } return e; } } return null; }
public void setCapacity(Node u, Node v, double capacity) { Edge e = u.getEdgeBetween(v); if (e.getSourceNode() == u) capacities[e.getIndex()] = capacity; else capacities[e.getIndex() + n] = capacity; }
public void edgeRemoved(String sourceId, long timeId, String edgeId) { Edge edge = g.getEdge(edgeId); for (String key : edge.getAttributeKeySet()) edgeAttributeRemoved(sourceId, timeId, edgeId, key); Event e; e = new EdgeRemoved(edgeId, edge.getSourceNode().getId(), edge .getTargetNode().getId(), edge.isDirected()); events.add(e); }
private void gotoNext() { while (edgeIt.hasNext()) { next = edgeIt.next().getOpposite(AbstractNode.this); if (!visited.contains(next)) { visited.add(next); return; } } next = null; }
public Collection<Edge> getEdgeSet() { ArrayList<Edge> l; Iterator<Edge> it; elementLock.lock(); l = new ArrayList<Edge>(wrappedElement.getDegree()); it = wrappedElement.getEachEdge().iterator(); while (it.hasNext()) l.add(sg.getEdge(it.next().getIndex())); elementLock.unlock(); return l; }
/** * Checks if an edge is incident to this node. Utility method that can be * useful in subclasses. * * @param e * an edge * @return {@code true} if {@code e} is incident edge for this node. */ public boolean isIncidentEdge(Edge e) { return e.getSourceNode() == this || e.getTargetNode() == this; } }
public void clear() { if (flagAttribute != null) for (Edge edge : graph.getEachEdge()) edge.removeAttribute(flagAttribute); }
public <T extends Node> T getNode1() { T n; sg.elementLock.lock(); n = sg.getNode(wrappedElement.getNode1().getIndex()); sg.elementLock.unlock(); return n; }
public void edgeAttributeChanged(String sourceId, long timeId, String edgeId, String attribute, Object oldValue, Object newValue) { if (sinkTime.isNewEvent(sourceId, timeId)) { Edge edge = g.getEdge(edgeId); if (edge != null) { passYourWay = true; if (oldValue == null) oldValue = edge.getAttribute(attribute); try { edge.changeAttribute(attribute, newValue); } finally { passYourWay = false; } sendEdgeAttributeChanged(sourceId, timeId, edgeId, attribute, oldValue, newValue); } } }