All Superinterfaces:

java.io.Serializable

All Known Subinterfaces:

Definition<T>, DescribedNode<T>, DirectivesContainer<T>, ImplementingTypeDefinition<T>, NamedNode<T>, ScalarValue<T>, SDLDefinition<T>, SDLNamedDefinition<T>, Selection<T>, SelectionSetContainer<T>, Type<T>, TypeDefinition<T>, Value<T>

All Known Implementing Classes:

AbstractDescribedNode, AbstractNode, Argument, ArrayValue, BooleanValue, Directive, DirectiveDefinition, DirectiveLocation, Document, EnumTypeDefinition, EnumTypeExtensionDefinition, EnumValue, EnumValueDefinition, Field, FieldDefinition, FloatValue, FragmentDefinition, FragmentSpread, InlineFragment, InputObjectTypeDefinition, InputObjectTypeExtensionDefinition, InputValueDefinition, InterfaceTypeDefinition, InterfaceTypeExtensionDefinition, IntValue, ListType, NonNullType, NullValue, ObjectField, ObjectTypeDefinition, ObjectTypeExtensionDefinition, ObjectValue, OperationDefinition, OperationTypeDefinition, ScalarTypeDefinition, ScalarTypeExtensionDefinition, SchemaDefinition, SchemaExtensionDefinition, SelectionSet, StringValue, TypeName, UnionTypeDefinition, UnionTypeExtensionDefinition, VariableDefinition, VariableReference
```
@PublicApi
public interface Node<T extends Node>
extends java.io.Serializable
```
The base interface for virtually all graphql language elements NOTE: This class implements Serializable and hence it can be serialised and placed into a distributed cache. However we are not aiming to provide long term compatibility and do not intend for you to place this serialised data into permanent storage, with times frames that cross graphql-java versions. While we don't change things unnecessarily, we may inadvertently break the serialised compatibility across versions. Every Node is immutable

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method	Description
`TraversalControl`	`accept(TraverserContext<Node> context, NodeVisitor visitor)`	Double-dispatch entry point.
`T`	`deepCopy()`
`java.util.Map<java.lang.String,java.lang.String>`	`getAdditionalData()`	A node can have a map of additional data associated with it.
`java.util.List<Node>`	`getChildren()`
`java.util.List<Comment>`	`getComments()`	Nodes can have comments made on them, the following is one comment per line before a node.
`IgnoredChars`	`getIgnoredChars()`	The chars which are ignored by the parser.
`NodeChildrenContainer`	`getNamedChildren()`	Alternative to `getChildren()` where the children are not all in one list regardless of type but grouped by name/type of the child.
`SourceLocation`	`getSourceLocation()`
`boolean`	`isEqualTo(Node node)`	Compares just the content and not the children.
`T`	`withNewChildren(NodeChildrenContainer newChildren)`	Replaces the specified children and returns a new Node.

- Method Detail
  - getChildren
```
java.util.List<Node> getChildren()
```
    Returns:
    
    a list of the children of this node
  - getNamedChildren
```
NodeChildrenContainer getNamedChildren()
```
    Alternative to getChildren() where the children are not all in one list regardless of type but grouped by name/type of the child.
    
    Returns:
    
    a container of the child nodes
  - withNewChildren
```
T withNewChildren(NodeChildrenContainer newChildren)
```
    Replaces the specified children and returns a new Node.
    
    Parameters:
    
    newChildren - must be empty for Nodes without children
    
    Returns:
    
    a new node
  - getSourceLocation
```
SourceLocation getSourceLocation()
```
    Returns:
    
    the source location where this node occurs
  - getComments
```
java.util.List<Comment> getComments()
```
    Nodes can have comments made on them, the following is one comment per line before a node.
    
    Returns:
    
    the list of comments or an empty list of there are none
  - getIgnoredChars
```
IgnoredChars getIgnoredChars()
```
    The chars which are ignored by the parser. (Before and after the current node)
    
    Returns:
    
    the ignored chars
  - getAdditionalData
```
java.util.Map<java.lang.String,java.lang.String> getAdditionalData()
```
    A node can have a map of additional data associated with it.
    NOTE: The reason this is a map of strings is so the Node can stay an immutable object, which Map<String,Object> would not allow say.
    
    Returns:
    
    the map of additional data about this node
  - isEqualTo
```
boolean isEqualTo(Node node)
```
    Compares just the content and not the children.
    
    Parameters:
    
    node - the other node to compare to
    
    Returns:
    
    isEqualTo
  - deepCopy
```
T deepCopy()
```
    Returns:
    
    a deep copy of this node
  - accept
```
TraversalControl accept(TraverserContext<Node> context,
                        NodeVisitor visitor)
```
    Double-dispatch entry point. A node receives a Visitor instance and then calls a method on a Visitor that corresponds to a actual type of this Node. This binding however happens at the compile time and therefore it allows to save on rather expensive reflection based instanceOf check when decision based on the actual type of Node is needed, which happens redundantly during traversing AST. Additional advantage of this pattern is to decouple tree traversal mechanism from the code that needs to be executed when traversal "visits" a particular Node in the tree. This leads to a better code re-usability and maintainability.
    
    Parameters:
    
    context - TraverserContext bound to this Node object
    
    visitor - Visitor instance that performs actual processing on the Nodes(s)
    
    Returns:
    
    Result of Visitor's operation. Note! Visitor's operation might return special results to control traversal process.

Interface Node<T extends Node>

Method Summary

Method Detail

getChildren

getNamedChildren

withNewChildren

getSourceLocation

getComments

getIgnoredChars

getAdditionalData

isEqualTo

deepCopy

accept