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

Updating database using SQL prepared statement

A Rectangle specifies an area in a coordinate space that is enclosed by the 
Rectangle object's top-

java.awt.Rectangle

Represents a command that can be executed. Often used to run code in a different
Thread.

java.lang.Runnable

Doubly-linked list implementation of the List and Dequeinterfaces. Implements
all optional list oper

java.util.LinkedList

 Locale represents a language/country/variant combination. Locales are used to
alter the presentatio

java.util.Locale

javax.swing.JFileChooser

org.openjdk.jmh.runner.Runner

scheduleAtFixedRate

getSupportFragmentManager

/**
     * 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