Internal(GraphAdapter<N, E> adapter) { this.adapter = adapter; this.basic = new GraphBasicQueries<>(adapter); if (isEnabled(Feature.SHOW_CYCLES)) { this.cycles = new GraphCycles<>(adapter); } else { this.cycles = null; } }
public void printToGv(GraphAdapter<N, E> adapter, String basename) { final GraphToGv g2gv = new GraphToGv(); g2gv.writeNoException(adapter, getDebugOutputDir(), getPrefix() + basename); }
public final boolean areStrictlyRelated(N node1, N node2) { if (node1 == node2) { return false; } else { return isStrictlyOver(node1, node2) || isStrictlyOver(node2, node1); } }
public ExplicitSubGraph<N, E> computeTransitiveReduction() { final ExplicitSubGraph<N, E> result = new RestrictionSubGraph<>(adapter); final Set<N> done = new HashSet<>(); for (final N node : result.getNodes()) { for (final E edge : result.getEdges(node, EdgeDirection.OUTGOING)) { final N child = result.getTip(edge, EdgeTip.TARGET); done.clear(); df(result, node, child, done); } } return result; }
public ExplicitSubGraph<N, E> computeTransitiveClosure(N node, EdgeDirection direction) { final ExplicitSubGraph<N, E> resultIn = direction != EdgeDirection.OUTGOING ? new ExtensionSubGraph<>(adapter) : null; final ExplicitSubGraph<N, E> resultOut = direction != EdgeDirection.INGOING ? new ExtensionSubGraph<>(adapter) : null; if (resultOut != null) { addOutgoingClosure(node, resultOut); } if (resultIn != null) { addIngoingClosure(node, resultIn); } return merge(resultIn, resultOut); }
/** * Return true when a node is a root: It has no ingoing edges. * * @param node The node. * @return true when node is a root. */ public final boolean isRoot(N node) { return !hasEdges(node, EdgeDirection.INGOING); }
/** * Returns true when 2 nodes are connected. * * @param source The source node. * @param target The target node. * @return True when source is connected to target. */ public boolean areConnected(N source, N target) { final ConnectionDetector<N, E> detector = new ConnectionDetector<>(adapter, source, target); return detector.areConnected(); }
/** * Returns whether a particular node is member of a cycle or not. * * @param node The tested node. * @return whether node is member of a cycle or not. */ public boolean nodeIsCycleMember(N node) { return areConnected(node, node); }
/** * Returns {@code true} when a first node is under or equal to a second node. * * @param node1 The first node. * @param node2 The second node. * @return {@code true} when {@code node1} is under or equal to {@code node2}. */ public final boolean isUnderOrEqual(N node1, N node2) { return isOverOrEqual(node2, node1); }
/** * @return whether the graph contains cycles or not. */ public boolean containsCycles() { final CycleDetector<N, E> internal = new CycleDetector<>(adapter); return internal.eval(); }
/** * Breadth first pre order traversal without evaluator. * * @param node The initial node. Must not be null. * @param direction The edge direction to follow for traversal. Must not be null. * @param visitor Visitor that will be invoked for each visited node. */ public void traverseBreadthFirstPre(N node, EdgeDirection direction, Visitor<N> visitor) { traverseBreadthFirst(node, TraversalOrder.PRE_ORDER, direction, visitor, null); }
/** * Depth first pre order traversal without evaluator. * * @param node The initial node. Must not be null. * @param direction The edge direction to follow for traversal. Must not be null. * @param visitor Visitor that will be invoked for each visited node. */ public void traverseDepthFirstPre(N node, EdgeDirection direction, Visitor<N> visitor) { traverseDepthFirst(node, TraversalOrder.PRE_ORDER, direction, visitor, null); }
/** * Returns {@code true} when a node is a root node. * <p> * It is non null and has a null parent. * * @param node The node. * @return {@code true} when {@code node} is a root. */ public final boolean isRoot(N node) { return node != null && getParent(node) == null; }
/** * Depth first pre order traversal without evaluator. * * @param node The initial node. Must not be null. * @param direction The edge direction to follow for traversal. Must not be null. * @param visitor Visitor that will be invoked for each visited node. Must not be null. */ public void traverseDepthFirstPre(N node, EdgeDirection direction, Visitor<N> visitor) { traverseDepthFirstPre(node, direction, visitor, null); }
/** * Breadth first pre order traversal without evaluator. * * @param node The initial node. Must not be null. * @param direction The edge direction to follow for traversal. Must not be null. * @param visitor Visitor that will be invoked for each visited node. Must not be null. */ public void traverseBreadthFirstPre(N node, EdgeDirection direction, Visitor<N> visitor) { traverseBreadthFirstPre(node, direction, visitor, null); }
/** * Breadth first post order traversal without evaluator. * * @param node The initial node. Must not be null. * @param direction The edge direction to follow for traversal. Must not be null. * @param visitor Visitor that will be invoked for each visited node. Must not be null. */ public void traverseBreadthFirstPost(N node, EdgeDirection direction, Visitor<N> visitor) { traverseBreadthFirstPost(node, direction, visitor, null); }
/** * Returns {@code true} when a first node is strictly under a second node. * * @param node1 The first node. * @param node2 The second node. * @return {@code true} when {@code node1} strictly under {@code node2}. */ public final boolean isStrictlyUnder(N node1, N node2) { return isStrictlyOver(node2, node1); }
/** * Return whether a node is a leaf : It has no outgoing edges. * * @param node The node. * @return true when node is a leaf. */ public final boolean isLeaf(N node) { return !hasEdges(node, EdgeDirection.OUTGOING); }
/** * Breadth first post order traversal without evaluator. * * @param node The initial node. Must not be null. * @param direction The edge direction to follow for traversal. Must not be null. * @param visitor Visitor that will be invoked for each visited node. */ public void traverseBreadthFirstPost(N node, EdgeDirection direction, Visitor<N> visitor) { traverseBreadthFirst(node, TraversalOrder.POST_ORDER, direction, visitor, null); }