@Override public Node<T> clone() { Node<T> result = new Node<>(m_object); for (T pred : m_predecessors.values()) { result.addPredecessor(pred); } return result; }
private void initializeIndependentNodes() { if (null == m_independentNodes) { List<Node<T>> list = Lists.newArrayList(m_nodes.values()); // Ideally, we should not have to sort this. However, due to a bug where it treats all the // methods as // dependent nodes. list.sort(comparator); m_independentNodes = Maps.newLinkedHashMap(); for (Node<T> node : list) { m_independentNodes.put(node.getObject(), node); } } }
public Set<T> getPredecessors(T node) { return findNode(node).getPredecessors().keySet(); }
if (!isIndependent(n.getObject())) { ppp("ADDING FOR SORT: " + n.getObject()); nodes2.add(n.clone()); } else { ppp("SKIPPING INDEPENDENT NODE " + n); List<T> cycle = new Tarjan<>(this, nodes2.get(0).getObject()).getCycle(); StringBuilder sb = new StringBuilder(); sb.append("The following methods have cyclic dependencies:\n"); m_strictlySortedNodes.add(node.getObject()); removeFromNodes(nodes2, node);
if (! isIndependent(n.getObject())) { ppp("ADDING FOR SORT: " + n.getObject()); nodes2.add(n.clone()); List<T> cycle = new Tarjan<>(this, nodes2.get(0).getObject()).getCycle(); StringBuilder sb = new StringBuilder(); sb.append("The following methods have cyclic dependencies:\n"); m_strictlySortedNodes.add(node.getObject()); removeFromNodes(nodes2, node);
public Set<T> getPredecessors(T node) { return findNode(node).getPredecessors().keySet(); }
public void addPredecessor(T tm, T predecessor) { Node<T> node = findNode(tm); if (null == node) { throw new TestNGException("Non-existing node: " + tm); } else { node.addPredecessor(predecessor); addNeighbor(tm, predecessor); // Remove these two nodes from the independent list initializeIndependentNodes(); m_independentNodes.remove(predecessor); m_independentNodes.remove(tm); ppp(" REMOVED " + predecessor + " FROM INDEPENDENT OBJECTS"); } }
private void addNeighbor(T tm, T predecessor) { findNode(tm).addNeighbor(findNode(predecessor)); }
private Node<T> findNodeWithNoPredecessors(List<Node<T>> nodes) { for (Node<T> n : nodes) { if (!n.hasPredecessors()) { return n; } } return null; }
/** * Remove a node from a list of nodes and update the list of predecessors for all the remaining * nodes. */ private void removeFromNodes(List<Node<T>> nodes, Node<T> node) { nodes.remove(node); for (Node<T> n : nodes) { n.removePredecessor(node.getObject()); } }
public void addNode(T tm) { ppp("ADDING NODE " + tm + " " + tm.hashCode()); m_nodes.put(tm, new Node<>(tm)); // Initially, all the nodes are put in the independent list as well }
public void addPredecessor(T tm, T predecessor) { Node<T> node = findNode(tm); if (null == node) { throw new TestNGException("Non-existing node: " + tm); } else { node.addPredecessor(predecessor); addNeighbor(tm, predecessor); // Remove these two nodes from the independent list initializeIndependentNodes(); m_independentNodes.remove(predecessor); m_independentNodes.remove(tm); ppp(" REMOVED " + predecessor + " FROM INDEPENDENT OBJECTS"); } }
private void addNeighbor(T tm, T predecessor) { findNode(tm).addNeighbor(findNode(predecessor)); }
private void initializeIndependentNodes() { if (null == m_independentNodes) { List<Node<T>> list = Lists.newArrayList(m_nodes.values()); // Ideally, we should not have to sort this. However, due to a bug where it treats all the methods as // dependent nodes. Collections.sort(list, comparator); m_independentNodes = Maps.newLinkedHashMap(); for (Node<T> node : list) { m_independentNodes.put(node.getObject(), node); } } }
public void addNode(T tm) { ppp("ADDING NODE " + tm + " " + tm.hashCode()); m_nodes.put(tm, new Node<>(tm)); // Initially, all the nodes are put in the independent list as well }
private Node<T> findNodeWithNoPredecessors(List<Node<T>> nodes) { for (Node<T> n : nodes) { if (! n.hasPredecessors()) { return n; } } return null; }
public Set<T> getNeighbors(T t) { Set<T> result = new HashSet<>(); for (Node<T> n : findNode(t).getNeighbors()) { result.add(n.getObject()); } return result; }
@Override public Node<T> clone() { Node<T> result = new Node<>(m_object); for (T pred : m_predecessors.values()) { result.addPredecessor(pred); } return result; }