Node

java.lang.Object
- org.graalvm.compiler.graph.Node

All Implemented Interfaces:

Cloneable, Formattable

Direct Known Subclasses:

CallNode, ValueNode, VirtualState
```
public abstract class Node
extends Object
implements Cloneable, Formattable
```
This class is the base class for all nodes. It represents a node that can be inserted in a Graph.
Once a node has been added to a graph, it has a graph-unique Node.id(). Edges in the subclasses are represented with annotated fields. There are two kind of edges: Node.Input and Node.Successor. If a field of type Node is annotated with Node.Input or Node.Successor, it must not be null. There is an edge from this node to the node denoted by the field's value. A field annotated with Node.OptionalInput is also such an edge but it may be null.
Exactly one of Node.Input, Node.OptionalInput, or Node.Successor must be applied to all fields of a node that are of type Node. A field of type NodeInputList must be annotated with Node.Input or Node.OptionalInput. A field of type NodeSuccessorList must be annotated with Node.Successor.
Nodes which are value numberable should implement the Node.ValueNumberable interface.
Assertions and Verification
The Node class supplies the Node.assertTrue(boolean, String, Object...) and Node.assertFalse(boolean, String, Object...) methods, which will check the supplied boolean and throw a VerificationError if it has the wrong value. Both methods will always either throw an exception or return true. They can thus be used within an assert statement, so that the check is only performed if assertions are enabled.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`Node.ConstantNodeParameter` Denotes that a parameter of an intrinsic method must be a compile time constant at all call sites to the intrinsic method.
`static class`	`Node.EdgeVisitor`
`static interface`	`Node.IndirectCanonicalization` Marker interface for nodes that contain other nodes.
`static interface`	`Node.InjectedNodeParameter` Denotes an injected parameter in a node intrinsic constructor.
`static interface`	`Node.Input` Denotes a non-optional (non-null) node input.
`static class`	`Node.NodeInsertionStackTrace`
`static interface`	`Node.NodeIntrinsic` Annotates a method that can be replaced by a compiler intrinsic.
`static interface`	`Node.NodeIntrinsicFactory` Marker annotation indicating that the class uses factory methods instead of constructors for intrinsification.
`static interface`	`Node.OptionalInput` Denotes an optional (nullable) node input.
`static interface`	`Node.Successor` Denotes a non-optional (non-null) node successor.
`static interface`	`Node.ValueNumberable` Marker for a node that can be replaced by another node via global value numbering.

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`NODE_LIST`
`static int`	`NOT_ITERABLE`
`static boolean`	`TRACK_CREATION_POSITION`
`static NodeClass<?>`	`TYPE`
`static EnumSet<Edges.Type>`	`WithAllEdges`
`static EnumSet<Edges.Type>`	`WithNoEdges`
`static EnumSet<Edges.Type>`	`WithOnlyInputEdges`
`static EnumSet<Edges.Type>`	`WithOnlySucessorEdges`

Constructor Summary

Constructors
Constructor and Description

Node(NodeClass<? extends Node> c)

Constructors
Constructor and Description
`Node(NodeClass<? extends Node> c)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`afterClone(Node other)`
`void`	`applyInputs(Node.EdgeVisitor visitor)` Applies the given visitor to all inputs of `this`.
`void`	`applySuccessors(Node.EdgeVisitor visitor)` Applies the given visitor to all successors of `this`.
`boolean`	`assertFalse(boolean condition, String message, Object... args)`
`boolean`	`assertTrue(boolean condition, String message, Object... args)`
`Iterable<? extends Node>`	`cfgPredecessors()`
`Iterable<? extends Node>`	`cfgSuccessors()` Returns an iterator that will provide all control-flow successors of `this`.
`protected boolean`	`checkReplaceAtUsagesInvariants(Node replacement)` Subclasses can override this to check invariants related to replacing uses of `this`.
`void`	`clearInputs()`
`void`	`clearNodeSourcePosition()`
`void`	`clearSuccessors()`
`Node`	`copyWithInputs()`
`Node`	`copyWithInputs(boolean insertIntoGraph)`
`boolean`	`dataFlowEquals(Node other)` Determines if `this` is equal to the other node while ignoring differences in control-flow edges.
`protected NodeSize`	`dynamicNodeSizeEstimate()` Node subclasses should override this method if they need to specify a dynamically calculated `NodeSize` value.
`NodeCycles`	`estimatedNodeCycles()`
`NodeSize`	`estimatedNodeSize()`
`protected GraalGraphError`	`fail(String message, Object... args)`
`void`	`formatTo(Formatter formatter, int flags, int width, int precision)`
`org.graalvm.compiler.graph.Node.NodeCreationStackTrace`	`getCreationPosition()`
`DebugContext`	`getDebug()` Gets the debug context associated with `this.graph()`.
`Map<Object,Object>`	`getDebugProperties()` Provides a `Map` of properties of `this` for use in debugging (e.g., to view in the ideal graph visualizer).
`Map<Object,Object>`	`getDebugProperties(Map<Object,Object> map)` Fills a `Map` with properties of `this` for use in debugging (e.g., to view in the ideal graph visualizer).
`Node.NodeInsertionStackTrace`	`getInsertionPosition()`
`NodeClass<? extends Node>`	`getNodeClass()`
`NodeSourcePosition`	`getNodeSourcePosition()` Gets the source position information for `this` or null if it doesn't exist.
`OptionValues`	`getOptions()` Gets the option values associated with `this.graph()`.
`int`	`getUsageCount()` Gets the maximum number of usages `this` has had at any point in time.
`Graph`	`graph()` Gets the graph context of `this`.
`boolean`	`hasExactlyOneUsage()` Checks whether `this` has exactly one usage.
`int`	`hashCode()` Nodes using their `Node.id` as the hash code.
`boolean`	`hasMoreThanOneUsage()` Checks whether `this` has more than one usage.
`boolean`	`hasNoUsages()` Checks whether `this` has no usages.
`boolean`	`hasOnlyUsagesOfType(InputType inputType)` Checks whether `this` has only usages of type `inputType`.
`boolean`	`hasUsages()` Checks whether `this` has usages.
`boolean`	`hasUsagesOfType(InputType type)` Checks whether this node has usages of a given `InputType`.
`Iterable<Position>`	`inputPositions()` Returns an `iterable` which can be used to traverse all non-null input edges of `this`.
`NodeIterable<Node>`	`inputs()` Returns an `iterable` which can be used to traverse all non-null input edges of `this`.
`boolean`	`isAlive()`
`boolean`	`isAllowedUsageType(InputType type)`
`boolean`	`isDeleted()`
`boolean`	`isUnregistered()`
`void`	`markDeleted()`
`void`	`maybeNotifyZeroUsages(Node node)` Iterates over each `Graph.NodeEventListener` attached to `this.graph()` if `node.isAlive()` and notifies the listener that `node` has had its last usage removed.
`int`	`modCount()`
`Node`	`predecessor()`
`void`	`pushInputs(NodeStack stack)`
`boolean`	`removeUsage(Node node)` Removes one occurrence of a given node from this node's usages.
`void`	`replaceAllInputs(Node oldInput, Node newInput)` Finds all `Node.Input`s and `Node.OptionalInput`s in `this` whose value is `oldInput` and replaces them with `newInput`.
`void`	`replaceAndDelete(Node replacement)` Replaces `this` at its predecessor (if any) and its usages with `replacement` and removes it from its graph.
`void`	`replaceAtAllUsages(Node replacement, boolean forDeletion)` For each use of `this` in another node, replace it with `replacement`.
`void`	`replaceAtMatchingUsages(Node replacement, NodePredicate usagePredicate)` For each use of `this` in another node, `n`, replace it with `replacement` if `filter.test(n) == true`.
`void`	`replaceAtPredecessor(Node replacement)` Updates the control flow edge, if it exists, from `Node.predecessor()` to `this` to have a target of `replacement`.
`void`	`replaceAtUsages(Node replacement)` For each use of `this` in another node, replace it with `replacement`.
`void`	`replaceAtUsages(Node replacement, InputType... inputTypes)` For each use of `this` in another node, `n`, replace it with `replacement` if the type of the use is in `inputTypes`.
`void`	`replaceAtUsages(Node replacement, InputType inputType)` For each use of `this` in another node, `n`, replace it with `replacement` if the type of the use is `inputType`.
`void`	`replaceAtUsages(Node replacement, Predicate<Node> filter)` For each use of `this` in another node, `n`, replace it with `replacement` if `filter == null` or `filter.test(n) == true`.
`void`	`replaceAtUsages(Node replacement, Predicate<Node> filter, boolean checkInvariants)` For each use of `this` in another node, `n`, replace it with `replacement` if `filter == null` or `filter.test(n) == true`.
`void`	`replaceAtUsagesAndDelete(Node replacement)` For each use of `this` in another node, replace it with `replacement` and then remove `this` from the graph.
`void`	`replaceAtUsagesAndDelete(Node replacement, Predicate<Node> filter)` For each use of `this` in another node, `n`, replace it with `replacement` if `filter == null` or `filter.test(n) == true` and then remove `this` from the graph.
`void`	`replaceFirstInput(Node oldInput, Node newInput)` Finds the first `Node.Input` or `Node.OptionalInput` in `this` whose value is `oldInput` and replaces it with `newInput`.
`void`	`replaceFirstSuccessor(Node oldSuccessor, Node newSuccessor)` Finds the first `Node.Successor` in `this` whose value is `oldSuccessor` and replaces it with `newSuccessor`.
`void`	`safeDelete()` Removes `this` from `this.graph()`.
`void`	`setCreationPosition(org.graalvm.compiler.graph.Node.NodeCreationStackTrace trace)`
`void`	`setInsertionPosition(Node.NodeInsertionStackTrace trace)`
`void`	`setNodeSourcePosition(NodeSourcePosition sourcePosition)` Set the source position to `sourcePosition`.
`Node`	`singleUsage()`
`Iterable<Position>`	`successorPositions()` Returns an `iterable` which can be used to traverse all successor edge positions of `this`.
`NodeIterable<Node>`	`successors()` Returns an `iterable` which can be used to traverse all non-null successor edges of `this`.
`String`	`toString()` This method is a shortcut for `Node.toString(Verbosity)` with `Verbosity.Short`.
`String`	`toString(Verbosity verbosity)` Creates a String representation for `this` with a given `Verbosity`.
`void`	`updateNodeSourcePosition(Supplier<NodeSourcePosition> sourcePositionSupp)` Update the source position only if it is null.
`protected void`	`updatePredecessor(Node oldSuccessor, Node newSuccessor)` Updates the predecessor of the given nodes after a successor slot is changed from oldSuccessor to newSuccessor: removes `this` from oldSuccessor's predecessors and adds `this` to newSuccessor's predecessors.
`protected void`	`updateUsages(Node oldInput, Node newInput)` Removes one occurrence of `this` from `oldInput`'s usages and adds it to `newInput`'s usages.
`NodeIterable<Node>`	`usages()` Gets the list of nodes that use `this` (i.e., as an input).
`boolean`	`valueEquals(Node other)` Determines if this node's `data` fields are equal to the data fields of another node of the same type.
`boolean`	`verify()`
`boolean`	`verifyEdges()` Perform expensive verification of inputs, usages, predecessors and successors.
`protected boolean`	`verifyInputs()`
`boolean`	`verifySourcePosition()`
`DebugCloseable`	`withNodeSourcePosition()`

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

- Field Detail
  - TYPE
```
public static final NodeClass<?> TYPE
```
  - TRACK_CREATION_POSITION
```
public static final boolean TRACK_CREATION_POSITION
```
  - NODE_LIST
```
public static final int NODE_LIST
```
    See Also:
    
    Constant Field Values
  - NOT_ITERABLE
```
public static final int NOT_ITERABLE
```
    See Also:
    
    Constant Field Values
  - WithNoEdges
```
public static final EnumSet<Edges.Type> WithNoEdges
```
  - WithAllEdges
```
public static final EnumSet<Edges.Type> WithAllEdges
```
  - WithOnlyInputEdges
```
public static final EnumSet<Edges.Type> WithOnlyInputEdges
```
  - WithOnlySucessorEdges
```
public static final EnumSet<Edges.Type> WithOnlySucessorEdges
```
- Constructor Detail
  - Node
```
public Node(NodeClass<? extends Node> c)
```
- Method Detail
  - graph
```
public Graph graph()
```
    Gets the graph context of this.
  - getOptions
```
public final OptionValues getOptions()
```
    Gets the option values associated with this.graph().
  - getDebug
```
public final DebugContext getDebug()
```
    Gets the debug context associated with this.graph().
  - inputs
```
public NodeIterable<Node> inputs()
```
    Returns an iterable which can be used to traverse all non-null input edges of this.
    
    Returns:
    
    an iterable for all non-null input edges.
  - inputPositions
```
public Iterable<Position> inputPositions()
```
    Returns an iterable which can be used to traverse all non-null input edges of this.
    
    Returns:
    
    an iterable for all non-null input edges.
  - applyInputs
```
public void applyInputs(Node.EdgeVisitor visitor)
```
    Applies the given visitor to all inputs of this.
    
    Parameters:
    
    visitor - the visitor to be applied to the inputs
  - applySuccessors
```
public void applySuccessors(Node.EdgeVisitor visitor)
```
    Applies the given visitor to all successors of this.
    
    Parameters:
    
    visitor - the visitor to be applied to the successors
  - successors
```
public NodeIterable<Node> successors()
```
    Returns an iterable which can be used to traverse all non-null successor edges of this.
    
    Returns:
    
    an iterable for all non-null successor edges.
  - successorPositions
```
public Iterable<Position> successorPositions()
```
    Returns an iterable which can be used to traverse all successor edge positions of this.
    
    Returns:
    
    an iterable for all successor edge positoins.
  - getUsageCount
```
public int getUsageCount()
```
    Gets the maximum number of usages this has had at any point in time.
  - usages
```
public final NodeIterable<Node> usages()
```
    Gets the list of nodes that use this (i.e., as an input).
  - hasNoUsages
```
public final boolean hasNoUsages()
```
    Checks whether this has no usages.
  - hasUsages
```
public final boolean hasUsages()
```
    Checks whether this has usages.
  - hasMoreThanOneUsage
```
public final boolean hasMoreThanOneUsage()
```
    Checks whether this has more than one usage.
  - hasExactlyOneUsage
```
public final boolean hasExactlyOneUsage()
```
    Checks whether this has exactly one usage.
  - hasOnlyUsagesOfType
```
public final boolean hasOnlyUsagesOfType(InputType inputType)
```
    Checks whether this has only usages of type inputType.
    
    Parameters:
    
    inputType - the type of usages to look for
  - hasUsagesOfType
```
public final boolean hasUsagesOfType(InputType type)
```
    Checks whether this node has usages of a given InputType.
    
    Parameters:
    
    type - the type of usages to look for
  - removeUsage
```
public boolean removeUsage(Node node)
```
    Removes one occurrence of a given node from this node's usages.
    
    Parameters:
    
    node - the node to remove
    
    Returns:
    
    whether or not usage was in the usage list
  - predecessor
```
public final Node predecessor()
```
  - modCount
```
public final int modCount()
```
  - isDeleted
```
public final boolean isDeleted()
```
  - isAlive
```
public final boolean isAlive()
```
  - isUnregistered
```
public final boolean isUnregistered()
```
  - updateUsages
```
protected void updateUsages(Node oldInput,
                            Node newInput)
```
    Removes one occurrence of this from oldInput's usages and adds it to newInput's usages.
  - updatePredecessor
```
protected void updatePredecessor(Node oldSuccessor,
                                 Node newSuccessor)
```
    Updates the predecessor of the given nodes after a successor slot is changed from oldSuccessor to newSuccessor: removes this from oldSuccessor's predecessors and adds this to newSuccessor's predecessors.
  - getNodeSourcePosition
```
public NodeSourcePosition getNodeSourcePosition()
```
    Gets the source position information for this or null if it doesn't exist.
  - setNodeSourcePosition
```
public void setNodeSourcePosition(NodeSourcePosition sourcePosition)
```
    Set the source position to sourcePosition. Setting it to null is ignored so that it's not accidentally cleared. Use Node.clearNodeSourcePosition() instead.
  - clearNodeSourcePosition
```
public void clearNodeSourcePosition()
```
  - getCreationPosition
```
public org.graalvm.compiler.graph.Node.NodeCreationStackTrace getCreationPosition()
```
  - setCreationPosition
```
public void setCreationPosition(org.graalvm.compiler.graph.Node.NodeCreationStackTrace trace)
```
  - getInsertionPosition
```
public Node.NodeInsertionStackTrace getInsertionPosition()
```
  - setInsertionPosition
```
public void setInsertionPosition(Node.NodeInsertionStackTrace trace)
```
  - updateNodeSourcePosition
```
public void updateNodeSourcePosition(Supplier<NodeSourcePosition> sourcePositionSupp)
```
    Update the source position only if it is null.
  - withNodeSourcePosition
```
public DebugCloseable withNodeSourcePosition()
```
  - getNodeClass
```
public final NodeClass<? extends Node> getNodeClass()
```
  - isAllowedUsageType
```
public boolean isAllowedUsageType(InputType type)
```
  - replaceAtUsages
```
public final void replaceAtUsages(Node replacement)
```
    For each use of this in another node, replace it with replacement. This is shown by the graph transformation below where edges are from usages to inputs (e.g. this is an input of n0). Before:
```
       this
         ^
         |
        /|\
       / | \
      /  |  \
    n0  n1 ..nN

 
```
    After:
```
     replacement
         ^
         |
        /|\
       / | \
      /  |  \
    n0  n1 ..nN
 
```
    If replacement == null, then the edges are simply removed.
  - replaceAtUsages
```
public final void replaceAtUsages(Node replacement,
                                  Predicate<Node> filter)
```
    For each use of this in another node, n, replace it with replacement if filter == null or filter.test(n) == true.
    
    See Also:
    
    Node.replaceAtUsages(Node)
  - replaceAtUsages
```
public final void replaceAtUsages(Node replacement,
                                  Predicate<Node> filter,
                                  boolean checkInvariants)
```
    For each use of this in another node, n, replace it with replacement if filter == null or filter.test(n) == true.
    
    See Also:
    
    Node.replaceAtUsages(Node)
  - replaceAtUsagesAndDelete
```
public final void replaceAtUsagesAndDelete(Node replacement)
```
    For each use of this in another node, replace it with replacement and then remove this from the graph.
    
    See Also:
    
    Node.replaceAtUsages(Node)
  - replaceAtUsagesAndDelete
```
public final void replaceAtUsagesAndDelete(Node replacement,
                                           Predicate<Node> filter)
```
    For each use of this in another node, n, replace it with replacement if filter == null or filter.test(n) == true and then remove this from the graph.
    
    See Also:
    
    Node.replaceAtUsages(Node)
  - checkReplaceAtUsagesInvariants
```
protected boolean checkReplaceAtUsagesInvariants(Node replacement)
```
    Subclasses can override this to check invariants related to replacing uses of this.
    
    Parameters:
    
    replacement -
    
    Returns:
    
    true if all invariants hold
  - replaceAtAllUsages
```
public final void replaceAtAllUsages(Node replacement,
                                     boolean forDeletion)
```
    For each use of this in another node, replace it with replacement.
    
    Parameters:
    
    forDeletion - specifies if the caller will remove this from the graph after this method returns
  - singleUsage
```
public Node singleUsage()
```
  - replaceAtMatchingUsages
```
public void replaceAtMatchingUsages(Node replacement,
                                    NodePredicate usagePredicate)
```
    For each use of this in another node, n, replace it with replacement if filter.test(n) == true.
    
    See Also:
    
    Node.replaceAtUsages(Node)
  - replaceAtUsages
```
public void replaceAtUsages(Node replacement,
                            InputType inputType)
```
    For each use of this in another node, n, replace it with replacement if the type of the use is inputType.
    
    See Also:
    
    Node.replaceAtUsages(Node)
  - replaceAtUsages
```
public void replaceAtUsages(Node replacement,
                            InputType... inputTypes)
```
    For each use of this in another node, n, replace it with replacement if the type of the use is in inputTypes.
    
    See Also:
    
    Node.replaceAtUsages(Node)
  - maybeNotifyZeroUsages
```
public void maybeNotifyZeroUsages(Node node)
```
    Iterates over each Graph.NodeEventListener attached to this.graph() if node.isAlive() and notifies the listener that node has had its last usage removed.
  - replaceAtPredecessor
```
public void replaceAtPredecessor(Node replacement)
```
    Updates the control flow edge, if it exists, from Node.predecessor() to this to have a target of replacement.
  - replaceAndDelete
```
public void replaceAndDelete(Node replacement)
```
    Replaces this at its predecessor (if any) and its usages with replacement and removes it from its graph.
  - replaceFirstSuccessor
```
public void replaceFirstSuccessor(Node oldSuccessor,
                                  Node newSuccessor)
```
    Finds the first Node.Successor in this whose value is oldSuccessor and replaces it with newSuccessor. The predecessor fields in oldSuccessor and newSuccessor are updated to reflect any change made.
  - replaceFirstInput
```
public void replaceFirstInput(Node oldInput,
                              Node newInput)
```
    Finds the first Node.Input or Node.OptionalInput in this whose value is oldInput and replaces it with newInput. If the input is changed, the usage info for oldInput and newInput is updated as well. Before this.replaceFirstInput(n0, n2):
```
       n0  n1  n0
        \  |  /
         \ | /
          \|/
           |
           V
         this
 
```
    After this.replaceFirstInput(n0, n2):
```
       n2  n1  n0
        \  |  /
         \ | /
          \|/
           |
           V
         this
 
```
  - replaceAllInputs
```
public void replaceAllInputs(Node oldInput,
                             Node newInput)
```
    Finds all Node.Inputs and Node.OptionalInputs in this whose value is oldInput and replaces them with newInput. If any input is changed, the usage info for oldInput and newInput is updated as well. Before this.replaceAllInputs(n0, n2):
```
       n0  n1  n0
        \  |  /
         \ | /
          \|/
           |
           V
         this
 
```
    After this.replaceAllInputs(n0, n2):
```
       n2  n1  n2
        \  |  /
         \ | /
          \|/
           |
           V
         this
 
```
  - clearInputs
```
public void clearInputs()
```
  - clearSuccessors
```
public void clearSuccessors()
```
  - safeDelete
```
public void safeDelete()
```
    Removes this from this.graph(). This node must have no usages and no predecessor.
  - markDeleted
```
public void markDeleted()
```
  - copyWithInputs
```
public final Node copyWithInputs()
```
  - copyWithInputs
```
public final Node copyWithInputs(boolean insertIntoGraph)
```
  - afterClone
```
protected void afterClone(Node other)
```
  - verifyInputs
```
protected boolean verifyInputs()
```
  - verify
```
public boolean verify()
```
  - verifySourcePosition
```
public boolean verifySourcePosition()
```
  - verifyEdges
```
public boolean verifyEdges()
```
    Perform expensive verification of inputs, usages, predecessors and successors.
    
    Returns:
    
    true
  - assertTrue
```
public boolean assertTrue(boolean condition,
                          String message,
                          Object... args)
```
  - assertFalse
```
public boolean assertFalse(boolean condition,
                           String message,
                           Object... args)
```
  - fail
```
protected GraalGraphError fail(String message,
                               Object... args)
                        throws GraalGraphError
```
    Throws:
    
    GraalGraphError
  - cfgPredecessors
```
public Iterable<? extends Node> cfgPredecessors()
```
  - cfgSuccessors
```
public Iterable<? extends Node> cfgSuccessors()
```
    Returns an iterator that will provide all control-flow successors of this. Normally this will be the contents of all fields annotated with Node.Successor, but some node classes (like EndNode) may return different nodes.
  - hashCode
```
public final int hashCode()
```
    Nodes using their Node.id as the hash code. This works very well when nodes of the same graph are stored in sets. It can give bad behavior when storing nodes of different graphs in the same set.
    
    Overrides:
    
    hashCode in class Object
  - getDebugProperties
```
public final Map<Object,Object> getDebugProperties()
```
    Provides a Map of properties of this for use in debugging (e.g., to view in the ideal graph visualizer).
  - getDebugProperties
```
public Map<Object,Object> getDebugProperties(Map<Object,Object> map)
```
    Fills a Map with properties of this for use in debugging (e.g., to view in the ideal graph visualizer). Subclasses overriding this method should also fill the map using their superclass.
    
    Parameters:
    
    map -
  - toString
```
public final String toString()
```
    This method is a shortcut for Node.toString(Verbosity) with Verbosity.Short.
    
    Overrides:
    
    toString in class Object
  - toString
```
public String toString(Verbosity verbosity)
```
    Creates a String representation for this with a given Verbosity.
  - formatTo
```
public void formatTo(Formatter formatter,
                     int flags,
                     int width,
                     int precision)
```
    Specified by:
    
    formatTo in interface Formattable
  - valueEquals
```
public final boolean valueEquals(Node other)
```
    Determines if this node's data fields are equal to the data fields of another node of the same type. Primitive fields are compared by value and non-primitive fields are compared by Objects.equals(Object, Object). The result of this method undefined if other.getClass() != this.getClass().
    
    Parameters:
    
    other - a node of exactly the same type as this
    
    Returns:
    
    true if the data fields of this object and other are equal
  - dataFlowEquals
```
public final boolean dataFlowEquals(Node other)
```
    Determines if this is equal to the other node while ignoring differences in control-flow edges.
  - pushInputs
```
public final void pushInputs(NodeStack stack)
```
  - estimatedNodeSize
```
public final NodeSize estimatedNodeSize()
```
  - dynamicNodeSizeEstimate
```
protected NodeSize dynamicNodeSizeEstimate()
```
    Node subclasses should override this method if they need to specify a dynamically calculated NodeSize value. If the node size is static please use NodeInfo.size(). NOTE: When overriding this method, make sure that *all* field reads are null checked (even if Java semantics seemingly make the value of the field non-null). This is necessary because node size estimates are needed even during graph decoding which, for some nodes, first reflectively creates a stub and then later, reflectively, populates its fields. This method could be invoked between these two points. For this reason, when overriding this method assume that all fields can and will be null.
    
    Returns:
    
    The estimated node size for this node.
  - estimatedNodeCycles
```
public NodeCycles estimatedNodeCycles()
```

Class Node

Assertions and Verification

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

TYPE

TRACK_CREATION_POSITION

NODE_LIST

NOT_ITERABLE

WithNoEdges

WithAllEdges

WithOnlyInputEdges

WithOnlySucessorEdges

Constructor Detail

Node

Method Detail

graph

getOptions

getDebug

inputs

inputPositions

applyInputs

applySuccessors

successors

successorPositions

getUsageCount

usages

hasNoUsages

hasUsages

hasMoreThanOneUsage

hasExactlyOneUsage

hasOnlyUsagesOfType

hasUsagesOfType

removeUsage

predecessor

modCount

isDeleted

isAlive

isUnregistered

updateUsages

updatePredecessor

getNodeSourcePosition

setNodeSourcePosition

clearNodeSourcePosition

getCreationPosition

setCreationPosition

getInsertionPosition

setInsertionPosition

updateNodeSourcePosition

withNodeSourcePosition

getNodeClass

isAllowedUsageType

replaceAtUsages

replaceAtUsages

replaceAtUsages

replaceAtUsagesAndDelete

replaceAtUsagesAndDelete

checkReplaceAtUsagesInvariants

replaceAtAllUsages

singleUsage

replaceAtMatchingUsages

replaceAtUsages

replaceAtUsages

maybeNotifyZeroUsages

replaceAtPredecessor

replaceAndDelete

replaceFirstSuccessor

replaceFirstInput

replaceAllInputs

clearInputs

clearSuccessors

safeDelete

markDeleted

copyWithInputs

copyWithInputs

afterClone

verifyInputs