public Object getOrigin() { return wrappedIterator.getDestination(); } public Object getDestination() {
public void convert(Digraph digraph) { for (Iterator i = digraph.vertexIterator(); i.hasNext();) { Object origin = i.next(); String key = vertexAccessor.getId(origin).toString(); StringBuffer value = new StringBuffer(); boolean firstDst = true; for (ArcIterator j = digraph.outgoingIterator(origin); j.hasNext();) { j.next(); if (firstDst) { value.append(vertexAccessor.getId(j.getDestination())); firstDst = false; } else value.append(';').append(j.getDestination()); } graphData.setProperty(key, value.toString()); } } public void setVertexAccessor(DataAccessor vertexAccessor) {
public Object getDestination() { return transformDst(((ArcIterator)getIterator()).getDestination()); }
private void removeVertex(Object vertex) { for (ArcIterator i = digraph.outgoingIterator(vertex); i.hasNext();) { i.next(); Object dst = i.getDestination(); InDegree indegree = (InDegree)inDegrees.get(dst); indegree.value--; } }
public FilterArcIterator(ArcIterator iterator, Predicate acceptOrigin, Predicate acceptDestination, Predicate acceptArc) { super(iterator); this.acceptOrigin = acceptOrigin; this.acceptDestination = acceptDestination; this.acceptArc = acceptArc; nextOrigin = iterator.getOrigin(); if (!acceptOrigin.evaluate(nextOrigin)) nextOrigin = null; nextDst = iterator.getDestination(); if (!acceptDestination.evaluate(nextDst)) nextDst = null; }
i.next(); Object origin = i.getOrigin(); Object dst = i.getDestination(); int originLevel = wrapperLevelMap.get(origin).hashCode(); int dstLevel = wrapperLevelMap.get(dst).hashCode();
public static boolean isAcyclic(Digraph digraph) { int order = digraph.order(); if (order == 0) return true; Set spanned = new HashSet(order); DepthFirstStampSearch dfs = new DepthFirstStampSearch(digraph, digraph.vertexIterator().next()); for (Iterator i = digraph.vertexIterator(); i.hasNext();) { Object dfsRoot = i.next(); if (spanned.contains(dfsRoot)) continue; dfs.reset(dfsRoot); Map dfsOrders = dfs.traverse(new HashMap(digraph.order())); for (Iterator j = dfsOrders.entrySet().iterator(); j.hasNext();) { Map.Entry entry = (Map.Entry)j.next(); Object origin = entry.getKey(); DepthFirstStampSearch.OrderPair orgOrders = (DepthFirstStampSearch.OrderPair)entry.getValue(); spanned.add(origin); for (ArcIterator k = digraph.outgoingIterator(origin); k.hasNext();) { k.next(); Object dst = k.getDestination(); DepthFirstStampSearch.OrderPair dstOrders = (DepthFirstStampSearch.OrderPair)dfsOrders.get(dst); if (dstOrders.getPostOrder() > orgOrders.getPostOrder()) return false; } } if (dfsOrders.size() == order) break; } return true; }
public static Digraph merge(Digraph destination,DigraphIteration graphToMerge) { for (Iterator i = graphToMerge.vertexIterator(); i.hasNext();) { destination.addVertex(i.next()); } for (ArcIterator i = graphToMerge.arcIterator(); i.hasNext();) { Object arc = i.next(); Object origin = i.getOrigin(); Object dst = i.getDestination(); destination.putArc(origin, dst, arc); } return destination; }
public Object next() { ArcIterator i = (ArcIterator)stack.pop(); Object origin = i.getOrigin(); while (i.hasNext()) { i.next(); //origin = i.getOrigin(); Object dst = i.getDestination(); if (seen.add(dst)) stack.push(factory.outgoingIterator(dst)); } return origin; } }
public Object next() { ArcIterator i = factory.outgoingIterator(queue.remove()); Object origin = i.getOrigin(); Integer childLevelValue = new Integer(level.get(origin).hashCode() + 1); while (i.hasNext()) { i.next(); Object dst = i.getDestination(); if (seen.add(dst)) { queue.add(dst); level.set(dst, childLevelValue); } else validTree = false; } return origin; }
private void createWrapperDigraph() { wrapperDigraph = new MapDigraph(MapDigraph.HASHMAP_FACTORY); vertexWrapperMap = new HashMap(digraph.order()); for (Iterator i = digraph.vertexIterator(); i.hasNext();) { Object vertex = i.next(); VertexWrapper wrapper = new VertexWrapper(vertex); vertexWrapperMap.put(vertex, wrapper); wrapperDigraph.addVertex(wrapper); } for (ArcIterator i = digraph.arcIterator(); i.hasNext();) { i.next(); Object wrapper1 = vertexWrapperMap.get(i.getOrigin()); Object wrapper2 = vertexWrapperMap.get(i.getDestination()); if (rootsUpwards) wrapperDigraph.putArc(wrapper1, wrapper2, Boolean.TRUE); else wrapperDigraph.putArc(wrapper2, wrapper1, Boolean.TRUE); } }
i.next(); Object origin = vertexToTable.get(i.getOrigin()); Object dst = vertexToTable.get(i.getDestination()); schemaGraph.putArc(origin, dst, Boolean.TRUE);
public static Map shiftLevelsDown(Map vertexLevelMap, DigraphIteration digraph, Object root) { int minChildLevel = Integer.MAX_VALUE; for (ArcIterator i = digraph.outgoingIterator(root); i.hasNext(); ) { i.next(); Object child = i.getDestination(); shiftLevelsDown(vertexLevelMap, digraph, child); MutableInteger childLevel = (MutableInteger)vertexLevelMap.get(child); minChildLevel = (minChildLevel <= childLevel.intValue() ? minChildLevel : childLevel.intValue()); } if (minChildLevel != Integer.MAX_VALUE) { MutableInteger rootLevel = (MutableInteger)vertexLevelMap.get(root); rootLevel.setValue(minChildLevel - 1); } return vertexLevelMap; }
public static Map computeLevels(Map vertexLevelMap, DigraphIteration digraph, Object root, boolean longest) { if (vertexLevelMap == null) vertexLevelMap = new HashMap(); MutableInteger rootLevel = (MutableInteger)vertexLevelMap.get(root); if (rootLevel == null) { rootLevel = new MutableInteger(0); vertexLevelMap.put(root, rootLevel); } for (ArcIterator i = digraph.outgoingIterator(root); i.hasNext(); ) { i.next(); Object child = i.getDestination(); int childLevelCandidate = rootLevel.intValue()+1; MutableInteger childLevel = (MutableInteger)vertexLevelMap.get(child); if (childLevel == null) { childLevel = new MutableInteger(childLevelCandidate); vertexLevelMap.put(child, childLevel); computeLevels(vertexLevelMap, digraph, child, longest); } else if ((longest && childLevel.intValue() < childLevelCandidate) || (!longest && childLevel.intValue() > childLevelCandidate)) { childLevel.setValue(childLevelCandidate); computeLevels(vertexLevelMap, digraph, child, longest); } } return vertexLevelMap; }
public static Digraph transform(Digraph result, DigraphIteration source, Transformer vertexTransform, Transformer arcTransform) { for (Iterator i = new TransformIterator(source.vertexIterator(), vertexTransform); i.hasNext();) { result.addVertex(i.next()); } for (ArcIterator i = new TransformArcIterator(source.arcIterator(), vertexTransform, arcTransform); i.hasNext();) { Object arc = i.next(); Object origin = i.getOrigin(); Object dst = i.getDestination(); result.putArc(origin, dst, arc); } return result; }
public Object next() { Object currentVertex = queue.remove(); ArcIterator i = factory.outgoingIterator(currentVertex); Object origin = i.getOrigin(); while (i.hasNext()) { i.next(); Object dst = i.getDestination(); if (seen.add(dst)) queue.add(dst); } i = factory.incomingIterator(currentVertex); while (i.hasNext()) { i.next(); Object org = i.getOrigin(); if (seen.add(org)) queue.add(org); } return origin; }
while (i.hasNext()) { i.next(); Object dst = i.getDestination(); int index = path.indexOf(dst); if (index < 0) {
for (ArcIterator i = digraph.outgoingIterator(vertex); i.hasNext(); ) { i.next(); Object child = i.getDestination(); shape = (RectangularShape)vertexShape.get(child); System.out.print("(" + vertex + "->" + child + ")[" + shape.getCenterX() + "," + shape.getMinY() + "]");
public Object next() { ArcIterator i = (ArcIterator)stack.peek(); Object origin = i.getOrigin(); Object dst = i.getDestination(); if (dst == null) { if (i.hasNext()) { i.next(); dst = i.getDestination(); } else { stack.pop();
private boolean setNextObject() { ArcIterator iterator = (ArcIterator)getIterator(); while ( iterator.hasNext() ) { Object arc = iterator.next(); Object origin = iterator.getOrigin(); Object dst = iterator.getDestination(); if (acceptOrigin.evaluate(origin) && acceptArc.evaluate(arc) && acceptDestination.evaluate(dst)) { nextArc = arc; nextOrigin = origin; nextDst = dst; nextObjectSet = true; return true; } } return false; } }