Public

getLabel

getOutgoingEdges

getReachableNodes

newBuilder

getOutgoingEdgeWithLabel

Topographical sort all nodes reachable from the given root node. Nodes that are
farther away, or mor

getSortedNodes

Replace one node with another in this graph. All edges referencing node are
replaced with edges refe

replaceNode

breadthFirstEdges

<init>

Create a new builder initialized to build a copy of the specified node.

copyBuilder

Get the nodes that are adjacent to this node (only considering outgoing edges).

getAdjacentNodes

Get a multimap of incoming edges. For each node reachable from this node, the
map will contain each 

getIncomingEdgeMap

Initialize caches for traversing this node.

initializeCaches

Create a new DAG node with no outgoing edges.

singleton

Helper mode for #getSortedNodes(), via TopologicalSortSupplier. This method does
a depth-first trave

sortVisit

Transform the edges in this graph. Edges in parent nodes are passed after their
target nodes are rew

transformEdges

DAGNode

Reading from database using SQL prepared statement

Signals a general, I/O-related error. Error details may be specified when
calling the constructor, a

java.io.IOException

 Collection is the root of the collection hierarchy. It defines operations on
data collections and t

java.util.Collection

A legacy iteration interface.New code should use Iterator instead. Iterator
replaces the enumeration

java.util.Enumeration

A PriorityQueue holds elements on a priority heap, which orders the elements
according to their natu

java.util.PriorityQueue

A plug-in replacement for JDK1.5 java.util.concurrent.ConcurrentHashMap. This
version is based on or

java.util.concurrent.ConcurrentHashMap

Class that models an arbitrary location in a Resource.Typically used to track
the location of proble

org.springframework.beans.factory.parsing.Location

getSystemService

onRequestPermissionsResult

startActivity

/**
     * Find the set of shareable nodes (objects that will be replaced with instance satisfactions in
     * the final graph).
     *
     * @param graph The graph to analyze.
     * @return The set of root nodes - nodes that need to be instantiated and removed. These nodes
     *         are in topologically sorted order.
     */

// see if we depend on any non-shared nodes

// since nodes are sorted, all shared nodes will have been seen

"node {} not shared due to non-transient dependency on {}"

/**
     * Find the set of shareable nodes (objects that will be replaced with instance satisfactions in
     * the final graph).
     *
     * @param graph The graph to analyze.
     * @return The set of root nodes - nodes that need to be instantiated and removed. These nodes
     *         are in topologically sorted order.
     */

/**
     * Merge and simplify a graph.  This will coalesce redundant nodes (equivalent labels and
     * outgoing edge destinations), and will prefer to use nodes from graphs seen previously.
     * This allows deduplication across multiple graphs.
     *
     * <p><strong>Noteo:</strong> edge labels are ignored for the purpose of merging.</p>
     *
     * @param graph The graph to simplify.
     * @return The new simplified, merged graph.
     */

// We want to map nodes to their previous merged versions

// Resolve the merged neighbors of this node.  They have already been

// merged, since we are going in topological order.

// See if we have already created an equivalent to this node

"Adding new node to merged graph for satisfaction: {}"

// create a new edge with the merged tail and same label

// one of the node's neighbors has been replaced with merged version

// no edges were changed, leave the node unmodified

"Node already in merged graph for satisfaction: {}"

// update merge map so future equivalent nodes get replaced with this one

// now let's find our return value - what did we merge the graph root to?

// remember all its nodes for future merge operations

How to use getSortedNodesmethodin org.grouplens.grapht.graph.DAGNode

Best Java code snippets using org.grouplens.grapht.graph.DAGNode.getSortedNodes (Showing top 3 results out of 315)

How to use
getSortedNodes
method
in
org.grouplens.grapht.graph.DAGNode