JIPipeGraph (jipipe 5.1.0-SNAPSHOT API)

java.lang.Object
- org.hkijena.jipipe.api.nodes.JIPipeGraph

All Implemented Interfaces:

JIPipeFunctionallyComparable, JIPipeGraphNode.NodeSlotsChangedEventListener, JIPipeParameterCollection.ParameterStructureChangedEventListener, JIPipeValidatable
```
public class JIPipeGraph
extends Object
implements JIPipeValidatable, JIPipeFunctionallyComparable, JIPipeGraphNode.NodeSlotsChangedEventListener, JIPipeParameterCollection.ParameterStructureChangedEventListener
```
Manages multiple JIPipeGraphNode instances as graph

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`JIPipeGraph.Deserializer` Deserializes an `JIPipeGraph`
`static class`	`JIPipeGraph.GraphChangedEvent` Event is triggered when algorithm graph is changed
`static class`	`JIPipeGraph.GraphChangedEventEmitter`
`static interface`	`JIPipeGraph.GraphChangedEventListener`
`static class`	`JIPipeGraph.NodeAddedEvent`
`static class`	`JIPipeGraph.NodeAddedEventEmitter`
`static interface`	`JIPipeGraph.NodeAddedEventListener`
`static class`	`JIPipeGraph.NodeConnectedEvent` Generated when a connection was made in `JIPipeGraph`
`static class`	`JIPipeGraph.NodeConnectedEventEmitter`
`static interface`	`JIPipeGraph.NodeConnectedEventListener`
`static class`	`JIPipeGraph.NodeDisconnectedEvent` Generated when slots are disconnected
`static class`	`JIPipeGraph.NodeDisconnectedEventEmitter`
`static interface`	`JIPipeGraph.NodeDisconnectedEventListener`
`static class`	`JIPipeGraph.NodeRemovedEvent`
`static class`	`JIPipeGraph.NodeRemovedEventEmitter`
`static interface`	`JIPipeGraph.NodeRemovedEventListener`
`static class`	`JIPipeGraph.Serializer` Serializes an `JIPipeGraph`

Constructor Summary

Constructors
Constructor and Description

JIPipeGraph()
Creates a new node type graph

JIPipeGraph(JIPipeGraph other)
Creates a deep copy of the other algorithm graph.

Constructors
Constructor and Description
`JIPipeGraph()` Creates a new node type graph
`JIPipeGraph(JIPipeGraph other)` Creates a deep copy of the other algorithm graph.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`attach(Class<?> klass, Object attachment)` Attaches an object as the specified type Warning: Attachments are not serialized
`void`	`attach(Object attachment)` Attaches the object with its class as key.
`void`	`attachAdditionalMetadata(String key, JIPipeMetadataObject object)` Attaches additional metadata (persistent)
`boolean`	`canConnect(JIPipeDataSlot source, JIPipeDataSlot target, boolean user)` Slow implementation of connection checking that tests for graph cycles
`boolean`	`canConnectFast(JIPipeDataSlot source, JIPipeDataSlot target, boolean user)` Fast implementation of connection checking without copying the graph
`boolean`	`canUserDelete(JIPipeGraphNode algorithm)` Returns true if the user can delete the algorithm
`boolean`	`canUserDisconnect(JIPipeDataSlot source, JIPipeDataSlot target)` Returns true if the user can disconnect the slots
`void`	`clear()` Clears this graph
`void`	`connect(JIPipeDataSlot source, JIPipeDataSlot target)` Connects an output slot to an input slot.
`void`	`connect(JIPipeDataSlot source, JIPipeDataSlot target, boolean userCanDisconnect)` Connects an output slot to an input slot.
`boolean`	`containsNode(JIPipeDataSlot slot)` Returns true if the slot is in this graph
`boolean`	`containsNode(JIPipeGraphNode node)` Returns true if this graph contains the algorithm
`boolean`	`containsNode(UUID nodeUUID)`
`boolean`	`disconnect(JIPipeDataSlot source, JIPipeDataSlot target, boolean user)` Disconnects an input and an output slot
`void`	`disconnect(JIPipeGraphConnection connection)`
`void`	`disconnect(JIPipeGraphConnection connection, boolean user)`
`void`	`disconnectAll(JIPipeDataSlot slot, boolean user)` Completely disconnects a slot
`JIPipeGraph`	`duplicate()`
`void`	`edgesFromJson(com.fasterxml.jackson.databind.JsonNode jsonNode, JIPipeValidationReportContext context, JIPipeValidationReport issues)`
`JIPipeGraph`	`extract(Collection<JIPipeGraphNode> nodes, boolean withInternal)` Copies the selected algorithms into a new graph Connections between the nodes are kept UUIDs are kept
`JIPipeGraph`	`extract(Collection<JIPipeGraphNode> nodes, boolean withInternal, boolean skipLocked)` Copies the selected algorithms into a new graph Connections between the nodes are kept UUIDs are kept
`List<LoopGroup>`	`extractLoopGroups(Set<JIPipeGraphNode> additionalLoopEnds, Set<JIPipeGraphNode> deactivatedNodes)` Converts loop structures into equivalent group nodes Please note that nested loops will be put into the group; only order 1 loops will be converted.
`JIPipeGraph`	`extractShallow(Collection<JIPipeGraphNode> nodes, boolean withInternal, boolean skipLocked)` Copies the selected algorithms into a new graph Connections between the nodes are kept UUIDs are kept Nodes are copied shallow
`<T extends JIPipeGraphNode> T`	`findFirstNodeOfType(Class<T> klass)`
`JIPipeGraphNode`	`findNode(String uuidOrAlias)` Finds a node by its UUID (as string) or alias ID.
`UUID`	`findNodeUUID(String uuidOrAlias)` Finds a node UUID by its UUID (as string) or alias ID.
`void`	`fromJson(com.fasterxml.jackson.databind.JsonNode jsonNode, JIPipeValidationReportContext context, JIPipeValidationReport issues, JIPipeNotificationInbox notifications)` Loads this graph from JSON
`boolean`	`functionallyEquals(Object other)`
`String`	`generateAliasIdFor(JIPipeGraphNode node)` Generates an alias ID for a node
`Map<String,JIPipeMetadataObject>`	`getAdditionalMetadata()`
`<T extends JIPipeMetadataObject> T`	`getAdditionalMetadata(Class<T> klass, String key)` Returns additional metadata or null if it does not exist
`String`	`getAliasIdOf(JIPipeGraphNode node)` Gets the alias ID of a node A unique alias ID is generated if none is assigned yet
`List<JIPipeGraphNode>`	`getAllPredecessorNodes(JIPipeGraphNode target, List<JIPipeGraphNode> traversed)` Returns ALL predecessor algorithms of an algorithm.
`<T> T`	`getAttachment(Class<T> klass)` Returns an attachment or null if it does not exist
`Map<Class<?>,Object>`	`getAttachments()`
`Set<JIPipeDataSlot>`	`getAvailableSources(JIPipeDataSlot target, boolean user, boolean fast)` Returns all available sources for an input slot.
`Set<JIPipeDataSlot>`	`getAvailableTargets(JIPipeDataSlot source, boolean user, boolean fast)` Returns all available target for an output slot Does not check for cycles.
`String`	`getCompartmentDisplayNameOf(JIPipeGraphNode node)` Returns a human-readable name of the compartment.
`UUID`	`getCompartmentUUIDOf(JIPipeGraphNode node)` Gets the UUID of the compartment
`JIPipeGraphConnection`	`getConnection(JIPipeDataSlot source, JIPipeDataSlot target)`
`Set<JIPipeGraphNode>`	`getDeactivatedNodes(boolean cascading)` Gets all algorithms and all dependent algorithms that are missing inputs or are deactivated by the user
`Set<JIPipeGraphNode>`	`getDeactivatedNodes(Set<JIPipeGraphNode> externallySatisfied)` Gets all algorithms and all dependent algorithms that are missing inputs or are deactivated by the user
`Set<JIPipeDependency>`	`getDependencies()` Gets all dependencies of all algorithms
`List<JIPipeGraphNode>`	`getDirectPredecessorNodes(JIPipeGraphNode target)` Returns DIRECT predecessor algorithms of an algorithm
`Set<Map.Entry<JIPipeDataSlot,JIPipeDataSlot>>`	`getEdgesBetween(JIPipeGraphNode source, JIPipeGraphNode target)` Gets all edges between two algorithm nodes
`JIPipeGraphNode`	`getEquivalentNode(JIPipeGraphNode foreign)` Returns the algorithm that has the same UUID as the foreign algorithm in the foreign graph.
`JIPipeDataSlot`	`getEquivalentSlot(JIPipeDataSlot foreign)` Returns the slot with the same name within the algorithm with the same ID.
`org.jgrapht.Graph<JIPipeDataSlot,JIPipeGraphEdge>`	`getGraph()`
`JIPipeGraph.GraphChangedEventEmitter`	`getGraphChangedEventEmitter()`
`Set<JIPipeGraphNode>`	`getGraphNodes()` Returns the set of node instances.
`Set<UUID>`	`getGraphNodeUUIDs()` Returns the set of node UUIDs.
`Set<JIPipeDataSlot>`	`getInputIncomingSourceSlots(JIPipeDataSlot target)` If exists, returns the output slots that provide data for the input slot Returns and empty list if there are none
`JIPipeGraph.NodeAddedEventEmitter`	`getNodeAddedEventEmitter()`
`JIPipeGraphNode`	`getNodeByUUID(UUID uuid)` Gets a node by its UUID
`JIPipeGraph.NodeConnectedEventEmitter`	`getNodeConnectedEventEmitter()`
`int`	`getNodeCount()`
`JIPipeGraph.NodeDisconnectedEventEmitter`	`getNodeDisconnectedEventEmitter()`
`Map<UUID,String>`	`getNodeLegacyCompartmentIDs()`
`JIPipeGraph.NodeRemovedEventEmitter`	`getNodeRemovedEventEmitter()`
`JIPipeGraphNode.NodeSlotsChangedEventEmitter`	`getNodeSlotsChangedEventEmitter()`
`Set<JIPipeGraphNode>`	`getNodesWithinCompartment(UUID compartmentId)` Returns the algorithms within the specified compartment ID.
`Set<JIPipeDataSlot>`	`getOutputOutgoingTargetSlots(JIPipeDataSlot source)` Returns the list of input slots that are provided by the source slot Returns an empty set if the target is an input or no slot exists
`JIPipeParameterCollection.ParameterStructureChangedEventEmitter`	`getParameterStructureChangedEventEmitter()`
`JIPipeParameterTree`	`getParameterTree(boolean useAliasIds, Set<UUID> restrictToCompartments)` Extracts all parameters as tree.
`JIPipeProject`	`getProject()` Gets the `JIPipeProject` if this is a project or project compartment graph.
`int`	`getSlotCount()`
`Set<Map.Entry<JIPipeDataSlot,JIPipeDataSlot>>`	`getSlotEdges()` Returns all edges as set of edges
`Set<JIPipeDataSlot>`	`getSlotNodes()`
`void`	`getTextDescription(StringBuilder stringBuilder, UUID compartment, Map<UUID,Integer> nodeIndices, int headingLevel)` Gets a description of the graph as text
`List<JIPipeDataSlot>`	`getUnconnectedSlots()`
`UUID`	`getUUIDOf(JIPipeGraphNode node)` Gets the UUID of a node
`Set<UUID>`	`getVisibleCompartmentUUIDsOf(JIPipeGraphNode node)` Gets the compartment UUIDs where the node is also visible inside
`boolean`	`hasAttachmentOfType(Class<?> klass)` Returns true if there is an attachment of given type
`UUID`	`insertNode(JIPipeGraphNode node)` Inserts a node into the graph.
`UUID`	`insertNode(JIPipeGraphNode node, UUID compartment)` Inserts a node into the graph.
`UUID`	`insertNode(UUID uuid, JIPipeGraphNode node, UUID compartment)` Inserts an algorithm into the graph
`boolean`	`isEmpty()`
`boolean`	`isProjectCompartmentGraph()`
`boolean`	`isProjectGraph()`
`Map<UUID,JIPipeGraphNode>`	`mergeWith(JIPipeGraph otherGraph)` Merges another graph into this graph The input is not copied!
`void`	`nodesFromJson(com.fasterxml.jackson.databind.JsonNode jsonNode, JIPipeValidationReportContext context, JIPipeValidationReport issues, JIPipeNotificationInbox notifications)`
`void`	`onNodeSlotsChanged(JIPipeGraphNode.NodeSlotsChangedEvent event)` Should be triggered when an `JIPipeGraphNode`'s slots are changed.
`void`	`onParameterStructureChanged(JIPipeParameterCollection.ParameterStructureChangedEvent event)` Should be triggered when an `JIPipeGraphNode`'s parameter structure is changed.
`void`	`rebuildAliasIds(boolean force)` Recreates the alias Ids based on their name
`void`	`removeAttachment(Class<?> klass)` Removes an attachment Warning: Attachments are not serialized
`void`	`removeCompartment(UUID compartmentUUID)` Removes a whole compartment from the graph.
`void`	`removeNode(JIPipeGraphNode node, boolean user)` Removes an algorithm.
`void`	`removeNodes(Set<JIPipeGraphNode> nodes, boolean user)` Removes multiple nodes at once
`void`	`repairGraph()` Repairs the graph by removing old nodes and adding missing ones
`void`	`replaceNode(JIPipeGraphNode target, JIPipeGraphNode replacement)` Replaces a node with another.
`void`	`replaceWith(JIPipeGraph other)` Replaces all contents with the ones in the other graph Does not apply copying!
`void`	`reportValidity(JIPipeValidationReportContext reportContext, JIPipeValidationReport report)` Generates a validity report
`void`	`reportValidity(JIPipeValidationReportContext context, JIPipeValidationReport report, JIPipeGraphNode targetNode)` Reports the validity for the target node and its dependencies
`void`	`reportValidity(JIPipeValidationReportContext context, JIPipeValidationReport report, JIPipeGraphNode targetNode, Set<JIPipeGraphNode> satisfied)` Reports the validity for the target node and its dependencies
`void`	`setAdditionalMetadata(Map<String,JIPipeMetadataObject> additionalMetadata)`
`void`	`setAttachments(Map<Class<?>,Object> attachments)` Sets the attachments map Warning: Attachments are not serialized
`void`	`setCompartment(UUID nodeUUID, UUID compartmentUUID)` Sets the compartment of a node
`void`	`setUUIDOf(JIPipeGraphNode node, UUID uuid)` Changes the UUID of the node
`String`	`toString()`
`List<JIPipeGraphNode>`	`traverse()` Traverses the graph in topological order.
`List<JIPipeDataSlot>`	`traverseSlots()` Traverses the graph in topological order.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.hkijena.jipipe.api.validation.JIPipeValidatable
generateValidityReport

- Constructor Detail
  - JIPipeGraph
```
public JIPipeGraph()
```
    Creates a new node type graph
  - JIPipeGraph
```
public JIPipeGraph(JIPipeGraph other)
```
    Creates a deep copy of the other algorithm graph. UUIDs are copied. Will not copy the additional metadata
    
    Parameters:
    
    other - The original graph
- Method Detail
  - getNodeAddedEventEmitter
```
public JIPipeGraph.NodeAddedEventEmitter getNodeAddedEventEmitter()
```
  - getNodeRemovedEventEmitter
```
public JIPipeGraph.NodeRemovedEventEmitter getNodeRemovedEventEmitter()
```
  - getGraphChangedEventEmitter
```
public JIPipeGraph.GraphChangedEventEmitter getGraphChangedEventEmitter()
```
  - getNodeConnectedEventEmitter
```
public JIPipeGraph.NodeConnectedEventEmitter getNodeConnectedEventEmitter()
```
  - getNodeDisconnectedEventEmitter
```
public JIPipeGraph.NodeDisconnectedEventEmitter getNodeDisconnectedEventEmitter()
```
  - getNodeSlotsChangedEventEmitter
```
public JIPipeGraphNode.NodeSlotsChangedEventEmitter getNodeSlotsChangedEventEmitter()
```
  - getParameterStructureChangedEventEmitter
```
public JIPipeParameterCollection.ParameterStructureChangedEventEmitter getParameterStructureChangedEventEmitter()
```
  - generateAliasIdFor
```
public String generateAliasIdFor(JIPipeGraphNode node)
```
    Generates an alias ID for a node
    
    Parameters:
    
    node - the node
    
    Returns:
    
    a unique alias ID for the node
  - getAliasIdOf
```
public String getAliasIdOf(JIPipeGraphNode node)
```
    Gets the alias ID of a node A unique alias ID is generated if none is assigned yet
    
    Parameters:
    
    node - the node
    
    Returns:
    
    the alias ID or null if the node is not contained within this graph.
  - getUUIDOf
```
public UUID getUUIDOf(JIPipeGraphNode node)
```
    Gets the UUID of a node
    
    Parameters:
    
    node - the node
    
    Returns:
    
    the UUID or null if the node is not contained within this graph.
  - getNodeByUUID
```
public JIPipeGraphNode getNodeByUUID(UUID uuid)
```
    Gets a node by its UUID
    
    Parameters:
    
    uuid - the UUID
    
    Returns:
    
    the node assigned to this UUID
  - setUUIDOf
```
public void setUUIDOf(JIPipeGraphNode node,
                      UUID uuid)
```
    Changes the UUID of the node
    
    Parameters:
    
    node - the node
    
    uuid - the uuid
  - getCompartmentUUIDOf
```
public UUID getCompartmentUUIDOf(JIPipeGraphNode node)
```
    Gets the UUID of the compartment
    
    Parameters:
    
    node - the node
    
    Returns:
    
    the UUID of the compartment
  - getVisibleCompartmentUUIDsOf
```
public Set<UUID> getVisibleCompartmentUUIDsOf(JIPipeGraphNode node)
```
    Gets the compartment UUIDs where the node is also visible inside
    
    Parameters:
    
    node - the node
    
    Returns:
    
    set of compartment UUIDs (writeable)
  - findNodeUUID
```
public UUID findNodeUUID(String uuidOrAlias)
```
    Finds a node UUID by its UUID (as string) or alias ID. Prefers UUID.
    
    Parameters:
    
    uuidOrAlias - the UUID string or alias ID
    
    Returns:
    
    the node or null if it could not be found
  - findNode
```
public JIPipeGraphNode findNode(String uuidOrAlias)
```
    Finds a node by its UUID (as string) or alias ID. Prefers UUID.
    
    Parameters:
    
    uuidOrAlias - the UUID string or alias ID
    
    Returns:
    
    the node or null if it could not be found
  - getAdditionalMetadata
```
public Map<String,JIPipeMetadataObject> getAdditionalMetadata()
```
  - setAdditionalMetadata
```
public void setAdditionalMetadata(Map<String,JIPipeMetadataObject> additionalMetadata)
```
  - insertNode
```
public UUID insertNode(UUID uuid,
                       JIPipeGraphNode node,
                       UUID compartment)
```
    Inserts an algorithm into the graph
    
    Parameters:
    
    uuid - The unique ID
    
    node - The node
    
    compartment - The compartment where the algorithm will be placed. Can be null.
    
    Returns:
    
    the ID of the inserted node
  - insertNode
```
public UUID insertNode(JIPipeGraphNode node)
```
    Inserts a node into the graph. Its compartment is null.
    
    Parameters:
    
    node - The node
    
    Returns:
    
    the ID of the inserted node
  - insertNode
```
public UUID insertNode(JIPipeGraphNode node,
                       UUID compartment)
```
    Inserts a node into the graph.
    
    Parameters:
    
    node - The node
    
    compartment - The compartment where the algorithm will be placed
    
    Returns:
    
    the ID of the inserted node
  - getAttachment
```
public <T> T getAttachment(Class<T> klass)
```
    Returns an attachment or null if it does not exist
    
    Type Parameters:
    
    T - the attachment class
    
    Parameters:
    
    klass - the attachment class
    
    Returns:
    
    the attachment or null
  - getAdditionalMetadata
```
public <T extends JIPipeMetadataObject> T getAdditionalMetadata(Class<T> klass,
                                                                String key)
```
    Returns additional metadata or null if it does not exist
    
    Type Parameters:
    
    T - returned metadata class
    
    Parameters:
    
    klass - returned metadata class
    
    key - metadata key
    
    Returns:
    
    the object or null
  - attachAdditionalMetadata
```
public void attachAdditionalMetadata(String key,
                                     JIPipeMetadataObject object)
```
    Attaches additional metadata (persistent)
    
    Parameters:
    
    key - the key
    
    object - JSON-serializable object
  - attach
```
public void attach(Class<?> klass,
                   Object attachment)
```
    Attaches an object as the specified type Warning: Attachments are not serialized
    
    Parameters:
    
    klass - the type the attachment is attached as
    
    attachment - the attachment
  - attach
```
public void attach(Object attachment)
```
    Attaches the object with its class as key. Warning: Attachments are not serialized
    
    Parameters:
    
    attachment - the attachment
  - removeAttachment
```
public void removeAttachment(Class<?> klass)
```
    Removes an attachment Warning: Attachments are not serialized
    
    Parameters:
    
    klass - the class
  - hasAttachmentOfType
```
public boolean hasAttachmentOfType(Class<?> klass)
```
    Returns true if there is an attachment of given type
    
    Parameters:
    
    klass - the attachment class
    
    Returns:
    
    if there is an attachment
  - canUserDelete
```
public boolean canUserDelete(JIPipeGraphNode algorithm)
```
    Returns true if the user can delete the algorithm
    
    Parameters:
    
    algorithm - The algorithm
    
    Returns:
    
    True if the user can delete the algorithm
  - canUserDisconnect
```
public boolean canUserDisconnect(JIPipeDataSlot source,
                                 JIPipeDataSlot target)
```
    Returns true if the user can disconnect the slots
    
    Parameters:
    
    source - Source slot
    
    target - Target slot
    
    Returns:
    
    True if the user can disconnect those slots. Returns false if the connection does not exist.
  - setCompartment
```
public void setCompartment(UUID nodeUUID,
                           UUID compartmentUUID)
```
    Sets the compartment of a node
    
    Parameters:
    
    nodeUUID - the node
    
    compartmentUUID - the compartment
  - removeCompartment
```
public void removeCompartment(UUID compartmentUUID)
```
    Removes a whole compartment from the graph. Will fail silently if the ID does not exist
    
    Parameters:
    
    compartmentUUID - The compartment ID
  - removeNode
```
public void removeNode(JIPipeGraphNode node,
                       boolean user)
```
    Removes an algorithm. The algorithm should exist within the graph.
    
    Parameters:
    
    node - The node to be removed
    
    user - if a user triggered the operation. If true, will not remove internal nodes
  - canConnect
```
public boolean canConnect(JIPipeDataSlot source,
                          JIPipeDataSlot target,
                          boolean user)
```
    Slow implementation of connection checking that tests for graph cycles
    
    Parameters:
    
    source - Source slot. Must be an output.
    
    target - Target slot. Must be an input.
    
    user - If true, the user is generating the connection
    
    Returns:
    
    True if the connection could be possible
  - canConnectFast
```
public boolean canConnectFast(JIPipeDataSlot source,
                              JIPipeDataSlot target,
                              boolean user)
```
    Fast implementation of connection checking without copying the graph
    
    Parameters:
    
    source - Source slot. Must be an output.
    
    target - Target slot. Must be an input.
    
    user - If triggered by a user
    
    Returns:
    
    True if the connection could be possible. Please check again with canConnect()
  - connect
```
public void connect(JIPipeDataSlot source,
                    JIPipeDataSlot target)
```
    Connects an output slot to an input slot. Allows users to disconnect this connection
    
    Parameters:
    
    source - An output slot
    
    target - An input slot
  - connect
```
public void connect(JIPipeDataSlot source,
                    JIPipeDataSlot target,
                    boolean userCanDisconnect)
```
    Connects an output slot to an input slot.
    
    Parameters:
    
    source - An output slot.
    
    target - An input slot.
    
    userCanDisconnect - If true, users are allowed to disconnect this connection again
  - getParameterTree
```
public JIPipeParameterTree getParameterTree(boolean useAliasIds,
                                            Set<UUID> restrictToCompartments)
```
    Extracts all parameters as tree.
    
    Parameters:
    
    useAliasIds - if enabled, paths will use alias Ids instead of UUIDs
    
    restrictToCompartments - if not null or empty, restrict to specific compartments
    
    Returns:
    
    the tree
  - repairGraph
```
public void repairGraph()
```
    Repairs the graph by removing old nodes and adding missing ones
  - getInputIncomingSourceSlots
```
public Set<JIPipeDataSlot> getInputIncomingSourceSlots(JIPipeDataSlot target)
```
    If exists, returns the output slots that provide data for the input slot Returns and empty list if there are none
    
    Parameters:
    
    target - The input slot
    
    Returns:
    
    The output slot that generates data for the input. Null if no source exists.
  - getOutputOutgoingTargetSlots
```
public Set<JIPipeDataSlot> getOutputOutgoingTargetSlots(JIPipeDataSlot source)
```
    Returns the list of input slots that are provided by the source slot Returns an empty set if the target is an input or no slot exists
    
    Parameters:
    
    source - An output slot
    
    Returns:
    
    All slots that receive data from the output slot
  - getAvailableSources
```
public Set<JIPipeDataSlot> getAvailableSources(JIPipeDataSlot target,
                                               boolean user,
                                               boolean fast)
```
    Returns all available sources for an input slot. This function does not check for cycles.
    
    Parameters:
    
    target - An input slot
    
    user - If true, only connections that can be created by a user are shown
    
    fast - If true, use canConnectFast instead of canConnect
    
    Returns:
    
    Set of potential sources
  - disconnectAll
```
public void disconnectAll(JIPipeDataSlot slot,
                          boolean user)
```
    Completely disconnects a slot
    
    Parameters:
    
    slot - An input or output slot
    
    user - If true, indicates that is disconnect was issued by a user
  - disconnect
```
public boolean disconnect(JIPipeDataSlot source,
                          JIPipeDataSlot target,
                          boolean user)
```
    Disconnects an input and an output slot
    
    Parameters:
    
    source - An output slot
    
    target - An input slot
    
    user - Indicates if the command was issued by a user
    
    Returns:
    
    True if the disconnect was successful, otherwise false
  - getAvailableTargets
```
public Set<JIPipeDataSlot> getAvailableTargets(JIPipeDataSlot source,
                                               boolean user,
                                               boolean fast)
```
    Returns all available target for an output slot Does not check for cycles.
    
    Parameters:
    
    source - An output slot
    
    user - Indicates that a user issues the connection
    
    fast - If true, use canConnectFast instead of canConnect
    
    Returns:
    
    A list of all available input slots
  - onNodeSlotsChanged
```
public void onNodeSlotsChanged(JIPipeGraphNode.NodeSlotsChangedEvent event)
```
    Should be triggered when an JIPipeGraphNode's slots are changed. Triggers a graph repair
    
    Specified by:
    
    onNodeSlotsChanged in interface JIPipeGraphNode.NodeSlotsChangedEventListener
    
    Parameters:
    
    event - The generated event
  - onParameterStructureChanged
```
public void onParameterStructureChanged(JIPipeParameterCollection.ParameterStructureChangedEvent event)
```
    Should be triggered when an JIPipeGraphNode's parameter structure is changed. This event is re-triggered into getEventBus()
    
    Specified by:
    
    onParameterStructureChanged in interface JIPipeParameterCollection.ParameterStructureChangedEventListener
    
    Parameters:
    
    event - Generated event
  - getDependencies
```
public Set<JIPipeDependency> getDependencies()
```
    Gets all dependencies of all algorithms
    
    Returns:
    
    Set of dependencies
  - getGraphNodeUUIDs
```
public Set<UUID> getGraphNodeUUIDs()
```
    Returns the set of node UUIDs. This is an immutable set. Not safe for modification.
    
    Returns:
    
    the UUIDs
  - getGraphNodes
```
public Set<JIPipeGraphNode> getGraphNodes()
```
    Returns the set of node instances. This is an immutable set. Not safe for modification.
    
    Returns:
    
    the node instances
  - containsNode
```
public boolean containsNode(JIPipeGraphNode node)
```
    Returns true if this graph contains the algorithm
    
    Parameters:
    
    node - The algorithm instance
    
    Returns:
    
    True if the algorithm is part of this graph
  - getSlotEdges
```
public Set<Map.Entry<JIPipeDataSlot,JIPipeDataSlot>> getSlotEdges()
```
    Returns all edges as set of edges
    
    Returns:
    
    Set of entries where the key is an output slot and the value is an input slot
  - fromJson
```
public void fromJson(com.fasterxml.jackson.databind.JsonNode jsonNode,
                     JIPipeValidationReportContext context,
                     JIPipeValidationReport issues,
                     JIPipeNotificationInbox notifications)
```
    Loads this graph from JSON
    
    Parameters:
    
    jsonNode - JSON data
    
    context - the context for the issue reporting
    
    issues - issues reported during deserializing
    
    notifications - notifications for the user
  - edgesFromJson
```
public void edgesFromJson(com.fasterxml.jackson.databind.JsonNode jsonNode,
                          JIPipeValidationReportContext context,
                          JIPipeValidationReport issues)
```
  - nodesFromJson
```
public void nodesFromJson(com.fasterxml.jackson.databind.JsonNode jsonNode,
                          JIPipeValidationReportContext context,
                          JIPipeValidationReport issues,
                          JIPipeNotificationInbox notifications)
```
  - mergeWith
```
public Map<UUID,JIPipeGraphNode> mergeWith(JIPipeGraph otherGraph)
```
    Merges another graph into this graph The input is not copied!
    
    Parameters:
    
    otherGraph - The other graph
    
    Returns:
    
    A map from old UUID in source graph to the node in the target graph
  - extract
```
public JIPipeGraph extract(Collection<JIPipeGraphNode> nodes,
                           boolean withInternal)
```
    Copies the selected algorithms into a new graph Connections between the nodes are kept UUIDs are kept
    
    Parameters:
    
    nodes - the nodes
    
    withInternal - also copy internal algorithms
    
    Returns:
    
    graph that only contains the selected algorithms, UUIDs are the same between the original and copies
  - extract
```
public JIPipeGraph extract(Collection<JIPipeGraphNode> nodes,
                           boolean withInternal,
                           boolean skipLocked)
```
    Copies the selected algorithms into a new graph Connections between the nodes are kept UUIDs are kept
    
    Parameters:
    
    nodes - the nodes
    
    withInternal - also copy internal algorithms
    
    skipLocked - skip locked nodes
    
    Returns:
    
    graph that only contains the selected algorithms, UUIDs are the same between the original and copies
  - extractShallow
```
public JIPipeGraph extractShallow(Collection<JIPipeGraphNode> nodes,
                                  boolean withInternal,
                                  boolean skipLocked)
```
    Copies the selected algorithms into a new graph Connections between the nodes are kept UUIDs are kept Nodes are copied shallow
    
    Parameters:
    
    nodes - the nodes
    
    withInternal - also copy internal algorithms
    
    skipLocked - skip locked nodes
    
    Returns:
    
    graph that only contains the selected algorithms, UUIDs are the same between the original and copies
  - getNodeCount
```
public int getNodeCount()
```
    Returns:
    
    The number of all algorithms
  - getSlotCount
```
public int getSlotCount()
```
    Returns:
    
    The number of all algorithm slots in this graph
  - traverseSlots
```
public List<JIPipeDataSlot> traverseSlots()
```
    Traverses the graph in topological order. The order guarantees that input is always available
    
    Returns:
    
    Sorted list of data slots
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getConnection
```
public JIPipeGraphConnection getConnection(JIPipeDataSlot source,
                                           JIPipeDataSlot target)
```
  - getDirectPredecessorNodes
```
public List<JIPipeGraphNode> getDirectPredecessorNodes(JIPipeGraphNode target)
```
    Returns DIRECT predecessor algorithms of an algorithm
    
    Parameters:
    
    target - the target algorithm
    
    Returns:
    
    predecessors in topological order
  - getAllPredecessorNodes
```
public List<JIPipeGraphNode> getAllPredecessorNodes(JIPipeGraphNode target,
                                                    List<JIPipeGraphNode> traversed)
```
    Returns ALL predecessor algorithms of an algorithm. The predecessors are ordered according to the list of traversed algorithms (topological order)
    
    Parameters:
    
    target - the target algorithm
    
    traversed - list of algorithms to sort by (usually this is in topological order)
    
    Returns:
    
    predecessors in topological order
  - getDeactivatedNodes
```
public Set<JIPipeGraphNode> getDeactivatedNodes(boolean cascading)
```
    Gets all algorithms and all dependent algorithms that are missing inputs or are deactivated by the user
    
    Parameters:
    
    cascading - if predecessors are also checked.
    
    Returns:
    
    set of algorithms
  - getDeactivatedNodes
```
public Set<JIPipeGraphNode> getDeactivatedNodes(Set<JIPipeGraphNode> externallySatisfied)
```
    Gets all algorithms and all dependent algorithms that are missing inputs or are deactivated by the user
    
    Parameters:
    
    externallySatisfied - list of algorithms that have their input set externally
    
    Returns:
    
    set of algorithms
  - traverse
```
public List<JIPipeGraphNode> traverse()
```
    Traverses the graph in topological order. The order guarantees that input is always available
    
    Returns:
    
    Sorted list of algorithms
  - getSlotNodes
```
public Set<JIPipeDataSlot> getSlotNodes()
```
    Returns:
    
    All data slots
  - containsNode
```
public boolean containsNode(JIPipeDataSlot slot)
```
    Returns true if the slot is in this graph
    
    Parameters:
    
    slot - A slot
    
    Returns:
    
    True if this graph contains the slot
  - getProject
```
public JIPipeProject getProject()
```
    Gets the JIPipeProject if this is a project or project compartment graph. Otherwise will return null
    
    Returns:
    
    the project or null if no project was attached to this graph
  - getCompartmentDisplayNameOf
```
public String getCompartmentDisplayNameOf(JIPipeGraphNode node)
```
    Returns a human-readable name of the compartment.
    
    Parameters:
    
    node - the node
    
    Returns:
    
    the compartment name, human-readable
  - reportValidity
```
public void reportValidity(JIPipeValidationReportContext reportContext,
                           JIPipeValidationReport report)
```
    Description copied from interface: JIPipeValidatable
    
    Generates a validity report
    
    Specified by:
    
    reportValidity in interface JIPipeValidatable
    
    Parameters:
    
    reportContext - the report context
    
    report - the report to be added to
  - getAttachments
```
public Map<Class<?>,Object> getAttachments()
```
  - setAttachments
```
public void setAttachments(Map<Class<?>,Object> attachments)
```
    Sets the attachments map Warning: Attachments are not serialized
    
    Parameters:
    
    attachments - attachments
  - reportValidity
```
public void reportValidity(JIPipeValidationReportContext context,
                           JIPipeValidationReport report,
                           JIPipeGraphNode targetNode)
```
    Reports the validity for the target node and its dependencies
    
    Parameters:
    
    context - the context
    
    report - the report
    
    targetNode - the target node
  - reportValidity
```
public void reportValidity(JIPipeValidationReportContext context,
                           JIPipeValidationReport report,
                           JIPipeGraphNode targetNode,
                           Set<JIPipeGraphNode> satisfied)
```
    Reports the validity for the target node and its dependencies
    
    Parameters:
    
    context - the context
    
    report - the report
    
    targetNode - the target node
    
    satisfied - all algorithms that are considered to have a satisfied input
  - getGraph
```
public org.jgrapht.Graph<JIPipeDataSlot,JIPipeGraphEdge> getGraph()
```
    Returns:
    
    The underlying graph
  - clear
```
public void clear()
```
    Clears this graph
  - replaceNode
```
public void replaceNode(JIPipeGraphNode target,
                        JIPipeGraphNode replacement)
```
    Replaces a node with another.
    
    Parameters:
    
    target - the target node
    
    replacement - the replacement node
  - getEquivalentNode
```
public JIPipeGraphNode getEquivalentNode(JIPipeGraphNode foreign)
```
    Returns the algorithm that has the same UUID as the foreign algorithm in the foreign graph.
    
    Parameters:
    
    foreign - An algorithm
    
    Returns:
    
    Equivalent algorithm within this graph
  - getEquivalentSlot
```
public JIPipeDataSlot getEquivalentSlot(JIPipeDataSlot foreign)
```
    Returns the slot with the same name within the algorithm with the same ID.
    
    Parameters:
    
    foreign - A data slot
    
    Returns:
    
    slot with the same name within the algorithm with the same ID
  - getUnconnectedSlots
```
public List<JIPipeDataSlot> getUnconnectedSlots()
```
    Returns:
    
    All unconnected slots
  - getNodesWithinCompartment
```
public Set<JIPipeGraphNode> getNodesWithinCompartment(UUID compartmentId)
```
    Returns the algorithms within the specified compartment ID.
    
    Parameters:
    
    compartmentId - The compartment ID
    
    Returns:
    
    Algorithms that have the specified compartment ID. Empty set if the compartment does not exist.
  - removeNodes
```
public void removeNodes(Set<JIPipeGraphNode> nodes,
                        boolean user)
```
    Removes multiple nodes at once
    
    Parameters:
    
    nodes - list of nodes
    
    user - if the operation is done by a user
  - replaceWith
```
public void replaceWith(JIPipeGraph other)
```
    Replaces all contents with the ones in the other graph Does not apply copying!
    
    Parameters:
    
    other - the other graph
  - getEdgesBetween
```
public Set<Map.Entry<JIPipeDataSlot,JIPipeDataSlot>> getEdgesBetween(JIPipeGraphNode source,
                                                                     JIPipeGraphNode target)
```
    Gets all edges between two algorithm nodes
    
    Parameters:
    
    source - the source
    
    target - the target
    
    Returns:
    
    all edges
  - getNodeLegacyCompartmentIDs
```
public Map<UUID,String> getNodeLegacyCompartmentIDs()
```
  - rebuildAliasIds
```
public void rebuildAliasIds(boolean force)
```
    Recreates the alias Ids based on their name
    
    Parameters:
    
    force - force rebuilding
  - isEmpty
```
public boolean isEmpty()
```
  - extractLoopGroups
```
public List<LoopGroup> extractLoopGroups(Set<JIPipeGraphNode> additionalLoopEnds,
                                         Set<JIPipeGraphNode> deactivatedNodes)
```
    Converts loop structures into equivalent group nodes Please note that nested loops will be put into the group; only order 1 loops will be converted.
    
    Parameters:
    
    additionalLoopEnds - nodes that are marked as loop ends
  - containsNode
```
public boolean containsNode(UUID nodeUUID)
```
  - functionallyEquals
```
public boolean functionallyEquals(Object other)
```
    Specified by:
    
    functionallyEquals in interface JIPipeFunctionallyComparable
  - disconnect
```
public void disconnect(JIPipeGraphConnection connection,
                       boolean user)
```
  - disconnect
```
public void disconnect(JIPipeGraphConnection connection)
```
  - getTextDescription
```
public void getTextDescription(StringBuilder stringBuilder,
                               UUID compartment,
                               Map<UUID,Integer> nodeIndices,
                               int headingLevel)
```
    Gets a description of the graph as text
    
    Parameters:
    
    stringBuilder - the string builder
    
    compartment - the targeted compartment (null to target all compartments)
    
    nodeIndices - map of node indices. used for sharing node IDs. can be null.
    
    headingLevel - the heading level
  - findFirstNodeOfType
```
public <T extends JIPipeGraphNode> T findFirstNodeOfType(Class<T> klass)
```
  - duplicate
```
public JIPipeGraph duplicate()
```
  - isProjectGraph
```
public boolean isProjectGraph()
```
  - isProjectCompartmentGraph
```
public boolean isProjectCompartmentGraph()
```

Class JIPipeGraph

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.hkijena.jipipe.api.validation.JIPipeValidatable

Constructor Detail

JIPipeGraph

JIPipeGraph

Method Detail

getNodeAddedEventEmitter

getNodeRemovedEventEmitter

getGraphChangedEventEmitter

getNodeConnectedEventEmitter

getNodeDisconnectedEventEmitter

getNodeSlotsChangedEventEmitter

getParameterStructureChangedEventEmitter

generateAliasIdFor

getAliasIdOf

getUUIDOf

getNodeByUUID

setUUIDOf

getCompartmentUUIDOf

getVisibleCompartmentUUIDsOf

findNodeUUID

findNode

getAdditionalMetadata

setAdditionalMetadata

insertNode

insertNode

insertNode

getAttachment

getAdditionalMetadata

attachAdditionalMetadata

attach

attach

removeAttachment

hasAttachmentOfType

canUserDelete

canUserDisconnect

setCompartment

removeCompartment

removeNode

canConnect

canConnectFast

connect

connect

getParameterTree

repairGraph

getInputIncomingSourceSlots

getOutputOutgoingTargetSlots

getAvailableSources

disconnectAll

disconnect

getAvailableTargets

onNodeSlotsChanged

onParameterStructureChanged

getDependencies

getGraphNodeUUIDs

getGraphNodes

containsNode

getSlotEdges

fromJson

edgesFromJson

nodesFromJson

mergeWith

extract

extract

extractShallow

getNodeCount

getSlotCount

traverseSlots

toString

getConnection

getDirectPredecessorNodes

getAllPredecessorNodes

getDeactivatedNodes

getDeactivatedNodes

traverse

getSlotNodes