/** * @see edu.uci.ics.jung.graph.Graph#getPredecessors(java.lang.Object) */ public synchronized Collection<V> getPredecessors(V vertex) { return delegate.getPredecessors(vertex); }
public Collection<V> getPredecessors(V vertex) { return graph.getPredecessors(vertex); } public V getSource(E directedEdge) {
/** * Returns the vertices that have an outgoing edge to the given vertex. * @param vertex The vertex. * @return The collection of vertices. */ public Collection getPredecessors(Object vertex) { return delegate.getPredecessors(vertex); }
/** * @see edu.uci.ics.jung.graph.Graph#getPredecessors(java.lang.Object) */ @Override public synchronized Collection<V> getPredecessors(V vertex) { return delegate.getPredecessors(vertex); }
/** * @see edu.uci.ics.jung.graph.Graph#getPredecessors(java.lang.Object) */ @Override public Collection<V> getPredecessors(V vertex) { return delegate.getPredecessors(vertex); }
/** * @see edu.uci.ics.jung.graph.Graph#getPredecessors(java.lang.Object) */ @Override public Collection<V> getPredecessors(V vertex) { return delegate.getPredecessors(vertex); }
/** * @see edu.uci.ics.jung.graph.Graph#getPredecessors(java.lang.Object) */ public Collection<V> getPredecessors(V vertex) { return delegate.getPredecessors(vertex); }
/** * @see edu.uci.ics.jung.graph.Graph#getPredecessors(java.lang.Object) */ public Collection<V> getPredecessors(V vertex) { return delegate.getPredecessors(vertex); }
@Override public V getParent(V child) { if (!delegate.containsVertex(child)) { return null; } Collection<V> parents = delegate.getPredecessors(child); if (parents.size() > 0) { return parents.iterator().next(); } return null; }
/** * get the single parent node of the passed child */ public V getParent(V child) { if (!delegate.containsVertex(child)) return null; Collection<V> predecessors = delegate.getPredecessors(child); if(predecessors.size() == 0) { return null; } return predecessors.iterator().next(); }
public V getParent(V child) { if (!delegate.containsVertex(child)) return null; Collection<V> parents = delegate.getPredecessors(child); if(parents.size() > 0) { return parents.iterator().next(); } return null; }
/** * get the single parent node of the passed child */ @Override public V getParent(V child) { if (!delegate.containsVertex(child)) { return null; } Collection<V> predecessors = delegate.getPredecessors(child); if (predecessors.size() == 0) { return null; } return predecessors.iterator().next(); }
/** * Dimension are calculated directed. * * @param v * node to start with * @return max X for subtree starting at v */ private int calculateDimensionX(ONDEXConcept v) { int size = 0; // stack for performing a breadth first search LinkedList<ONDEXConcept> stack = new LinkedList<ONDEXConcept>(); stack.add(v); Set<ONDEXConcept> seen = new HashSet<ONDEXConcept>(); while (!stack.isEmpty()) { ONDEXConcept current = stack.pop(); if (!seen.contains(current)) { // check selection of edge direction if (reversed) stack.addAll(graph.getPredecessors(current)); else stack.addAll(graph.getSuccessors(current)); // check dimension for children size = distX; size = Math.max(0, size - distX); basePositions.put(current, size); seen.add(current); } } return size; }
/** * A recursive method for allocating the level for each vertex. Ensures * that all predecessors of v have a level which is at least one greater * than the level of v. * * @param v the vertex whose minimum level is to be calculated */ public void propagateMinimumLevel(V v) { int level = minLevels.get(v).intValue(); for(V child : getGraph().getPredecessors(v)) { int oldLevel, newLevel; Number o = minLevels.get(child); if (o != null) oldLevel = o.intValue(); else oldLevel = 0; newLevel = Math.max(oldLevel, level + 1); minLevels.put(child, new Integer(newLevel)); if (newLevel > graphHeight) graphHeight = newLevel; propagateMinimumLevel(child); } }
/** * A recursive method for allocating the level for each vertex. Ensures * that all predecessors of v have a level which is at least one greater * than the level of v. * * @param v */ public void propagateMinimumLevel(V v) { int level = minLevels.get(v).intValue(); for(V child : getGraph().getPredecessors(v)) { int oldLevel, newLevel; Number o = minLevels.get(child); if (o != null) oldLevel = o.intValue(); else oldLevel = 0; newLevel = Math.max(oldLevel, level + 1); minLevels.put(child, new Integer(newLevel)); if (newLevel > graphHeight) graphHeight = newLevel; propagateMinimumLevel(child); } }
private void assembleTraceBack(MethodProfile pivot, Graph<MethodProfile, InvocationProfile> neighborhood, List<MethodElement> bag, int maxDepth, int depth) { bag.add(assembleMethodElement(pivot, depth)); if (depth < maxDepth) { Collection<MethodProfile> callers = neighborhood.getPredecessors(pivot); if (callers != null) { List<MethodProfile> callersList = Lists.newArrayList(callers); Collections.sort(callersList, new Comparator<MethodProfile>() { @Override public int compare(MethodProfile p1, MethodProfile p2) { return -Double.compare(p1.getInStackRatio(), p2.getInStackRatio()); } }); for (MethodProfile caller : callersList) { assembleTraceBack(caller, neighborhood, bag, maxDepth, depth + 1); } } } }
/** * Calculate the global size of trees for all nodes. * * @param roots * list of roots * @return max X for all subtrees */ private int calculateDimensionX(Collection<ONDEXConcept> roots) { int size = 0; for (ONDEXConcept v : roots) { // check selection of edge direction Collection<ONDEXConcept> children = null; if (reversed) children = graph.getPredecessors(v); else children = graph.getSuccessors(v); // check dimension for children int childrenNum = children.size(); if (childrenNum != 0) { for (ONDEXConcept element : children) { // recursion step size += calculateDimensionX(element) + distX; } } // base step size = Math.max(0, size - distX); basePositions.put(v, size); } return size; }
/** * Returns the list of siblings, which are leaf nodes of the graph. * * @param p * current ONDEXConcept to start with * @param v * List<ONDEXConcept> contains siblings of p */ private void getAtomics(ONDEXConcept p, List<ONDEXConcept> v) { // check selection of edge direction Collection<ONDEXConcept> parents = null; if (reversed) parents = graph.getPredecessors(p); else parents = graph.getSuccessors(p); for (ONDEXConcept c : parents) { // check selection of edge direction Collection<ONDEXConcept> children = null; if (reversed) children = graph.getPredecessors(c); else children = graph.getSuccessors(c); if (children.size() == 0) { v.add(c); } else { getAtomics(c, v); } } }
parents = graph.getPredecessors(v); else parents = graph.getSuccessors(v); children = graph.getPredecessors(c); else children = graph.getSuccessors(c);
/** * Calculate the overall X dimension for a number of roots. * * @param roots * Collection<ONDEXConcept> containing roots * @return total X dimension */ private int calculateDimensionX(Collection<ONDEXConcept> roots) { int size = 0; for (ONDEXConcept v : roots) { // check selection of edge direction Collection<ONDEXConcept> children = null; if (reversed) children = graph.getPredecessors(v); else children = graph.getSuccessors(v); // check dimension for children int childrenNum = children.size(); if (childrenNum != 0) { for (ONDEXConcept element : children) { // recursion step size += calculateDimensionX(element) + distX; } } // base step size = Math.max(0, size - distX); basePositions.put(v, size); } return size; }