All Classes and Interfaces
Class
Description
An
Iterator that checks a Predicate prior to processing the specified child Iterator
instances.Provides an abstraction point to allow for http auth schemes beyond basic auth.
A base implementation for the
Channelizer which does a basic configuration of the pipeline, one that
is generally common to virtually any Gremlin Server operation (i.e.Base class for "TraversalExplanation" instances and centralizes the key functionality which is the job of doing
AbstractExplanation.prettyPrint().A base
GraphProvider that is typically for use with Hadoop-based graphs as it enables access to the various
resource data files that are used in the tests.Base class for all synthetic network generators.
A basic GraphProvider which simply requires the implementer to supply their base configuration for their
Graph instance.
Extension of the Jackson's default TypeSerializer.
Base test class for Gremlin Process tests.
A simple base implementation of the
GremlinScriptEngineFactory.Base Gremlin test suite from which different classes of tests can be exposed to implementers.
Filter for tests in the suite which is controlled by the
Graph.OptOut annotation.Sets up g based on the current graph configuration and checks required features for the test.
This mapper implementation of the
ClassResolver helps ensure that all Vertex and Edge concrete classes
get properly serialized and deserialized by stripping them of their concrete class name so that they are treated
generically.Base class for implementing a custom
ObjectFactory for cucumber tests and is based on the basic
GuiceFactory implementation which can't be extended.Base implementation of the
IoRegistry interface that provides implementation of the methods using a
a HashMap.Base
MessageSerializer that serializers can implement to get some helper methods around configuring a
Mapper.Builder.Base class for creating deserializers which parses JSON to a
Map to more easily reconstruct an object.This is a stub implementation for
RemoteTraversal and requires that the AbstractRemoteTraversal.nextTraverser() method
is implemented from Traversal.Admin.A base implementation of
Transaction that provides core functionality for transaction listeners using a
shared set of transaction listeners.A base implementation of
Transaction that provides core functionality for transaction listeners using
ThreadLocal.Base class for
TinkerGraph and TinkerTransactionGraph.A default set of
AbstractTinkerGraph.IdManager implementations for common identifier types.TinkerGraph will use an implementation of this interface to generate identifiers when a user does not supply
them and to handle identifier conversions when querying to provide better flexibility with respect to
handling different data types that mean the same thing.
Storage for indexes that can be used by different implementations of
AbstractTinkerGraph.A simple base class for
Transaction that provides some common functionality and default behavior.A base class for visitors that translate Gremlin AST nodes to Gremlin strings.
Base
TraversalStrategy class that is configurable to throw warnings or exceptions.AbstractWarningVerificationStrategy.Builder<T extends AbstractWarningVerificationStrategy,B extends AbstractWarningVerificationStrategy.Builder>
Side-effect step that adds labels to the current element by calling
Element.addLabel(String, String...).This strategy looks for vertex- and value-emitting steps followed by a
CountGlobalStep and replaces the
pattern with an edge- or property-emitting step followed by a CountGlobalStep.Allows all requests to be authenticated.
A translator that anonymizes Gremlin so that arguments that might contain sensitive information are removed.
Provides a unified way to construct a
TraversalSource from the perspective of the traversal.A software artifact identified by its maven coordinates.
Reference implementation for boolean parsing step.
Reference implementation for date parsing step.
Reference implementation for number parsing step.
Reference implementation for asString() step, a mid-traversal step which returns the incoming traverser value
as a string.
Reference implementation for asString(Scope.local), a mid-traversal step which returns the value of the incoming
traverser as a string.
An interface that provides methods for detached properties and elements to be re-attached to the
Graph.A collection of general methods of attachment.
An exception that occurs when during authentication such as a failed login.
Provides methods related to authentication of a request.
Performs the actual SASL negotiation for a single authentication attempt.
An exception that occurs during authorization, i.e.
Provides the interface for authorizing a user per request.
A Barrier is any step that requires all left traversers to be processed prior to emitting result traversers to the right.
Provides a way to alter the bindings on a
GremlinScriptEngine.Represents an abstract view for one or more primitive byte arrays and NIO buffers.
Represents a factory to create
Buffer instances from BufferFactory instances.BulkSet is a weighted set (i.e.
A
ByModulating step is able to take GraphTraversal.by() calls.This strategy looks for standard traversals in by-modulators and replaces them with more optimized traversals
(e.g.
A
ByPassing step can be stated (at runtime) to simply enact the identity function.An implementation of the
GremlinScriptEngineManager that caches the instances of the
GremlinScriptEngine instances that are created by it.Reference implementation for service calls via the
ServiceRegistry and Service APIs.Reference implementation for service calls via the
ServiceRegistry and Service APIs.Deprecated.
As of release 3.6.0, not replaced.
Client-side channel initializer interface.
An interface that makes it possible to plugin different Netty pipelines to Gremlin Server, enabling the use of
different protocols, mapper security and other such functions.
Base implementation of the client side
Channelizer.Sends requests over the HTTP endpoint.
A
GraphManager that will prevent Gremlin Server from starting if all configured graphs fail.A step which offers a choice of two or more Traversals to take.
Defines the manner in which the
ChooseStep is configured to work.A
Client is constructed from a Cluster and represents a way to send messages to Gremlin Server.Uses a
Client.ClusteredClient that rebinds requests to a specified Graph or
TraversalSource instances on the server-side.A
Client implementation.An extension of
Iterator that implements AutoCloseable which allows a Graph implementation
that hold open resources to provide the user the option to release those resources.A connection to a set of one or more Gremlin Server instances.
A filter step that will randomly allow traversers to pass through the step based on a probability value.
Utility class for working with collections and arrays.
Column references a particular type of column in a complex data structure such as a
Map, a
Map.Entry, or a Path.A map step that returns the combination of the traverser and the provided arguments.
Generates a synthetic network with a community structure, that is, several densely connected
sub-networks that are loosely connected with one another.
A collection of commonly used
Comparator instances.Compare is a BiPredicate that determines whether the first argument is ==, !=,
>, >=, <, <= to the second argument.CompareType is a BiPredicate that determines whether the first argument is a type of the second argument.An immutable representation of a provider-defined type consisting of a name and a map of fields.
Adapter for converting between a typed object and a
CompositePDT field map.The wire compression algorithm that the driver negotiates with the server.
The result of the
GraphComputer's computation.Reference implementation for String concatenation step, a mid-traversal step which concatenates one or more
String values together to the incoming String traverser.
A
Bindings that can be accessed concurrently by multiple threads.An internal application used to test out ranges of configuration parameters for Gremlin Driver.
Identifies a
Step as one that can accept configurations via the GraphTraversal.with(String, Object)
step modulator.A map step that returns the result of joining every element in the traverser using the delimiter argument.
Configuration options to be passed to the
GraphTraversal.with(String, Object) step on
GraphTraversal.connectedComponent() ()}.Identifies "Connected Component" instances in a graph by assigning a component identifier (the lexicographically
least string value of the vertex in the component) to each vertex.
This exception signifies network connection failure.
An example listener that writes a message to the console for each event that fires from the graph.
A
Traversal that always returns a constant value.Contains is a BiPredicate that evaluates whether the first object is contained within (or not
within) the second collection object.The context of Gremlin Server within which a particular request is made.
CopyDistribution returns the conditional value.
This module is required for a
ScriptEngine to be Gremlin-enabled.This strategy optimizes any occurrence of
CountGlobalStep followed by an IsStep.Plugin for the Credentials DSL that helps maintain a list of users and passwords in a graph for use with Gremlin
Server authentication.
A DSL for managing a "credentials graph" used by Gremlin Server for simple authentication functions.
A mock identifier for use in ensuring that custom serializers work around element identifiers.
The
Customizer provides a general way to provide configurations to a GremlinScriptEngine.Represents a GraphBinary data type.
Reference implementation for date concatenation step.
Reference implementation for date difference step.
Utility class for parsing and formatting dates/times.
A placeholder step that represents a declarative pattern-matching query.
Default implementation of the
BindingsCustomizer which adds bindings to the ScriptContext.GLOBAL_SCOPE.A default implementation of
CloseableIterator that simply wraps an existing Iterator.The result of the
GraphComputer's computation.Executes a
GqlMatchPlan against any TinkerPop Graph using a DFS
backtracking pattern matching algorithm.Compiles a
QueryGraph into an executable GqlMatchPlan.Holder for
Graph and TraversalSource instances configured for the server to be passed to script
engine bindings.This class provides implementation of
GremlinVisitor, where each method will throw
UnsupportedOperationException.The
ScriptEngineManager implements a discovery, instantiation and configuration mechanism for
GremlinScriptEngine classes and also maintains a collection of key/value pairs storing state shared by all
engines created by it.Simple implementation of the
ImportCustomizer which allows direct setting of all the different import types.Default implementation of the
ScriptCustomizer that can create the script list from a list of files or
from lines of script.This is a default
TemporaryException implementation that server implementers could use if they wished
to indicate retry operations to the client.Default implementation for
TraversalMetrics that aggregates ImmutableMetrics instances from a
Traversal.A marker interface for steps that deletes the graph data.
A
Comparator that compares steps on the depth of the traversal that they are in.A map step that returns the difference of the traverser and the provided arguments without duplicates.
A map step that returns the disjunction of the traverser and the provided arguments without duplicates.
Interface for a distribution over discrete values.
Generates a synthetic network for a given out- and (optionally) in-degree distribution.
Converts a Gremlin traversal string into a C# source code representation of that traversal with an aim at
sacrificing some formatting for the ability to compile correctly.
A
RemoteConnection implementation for Gremlin Server.A
AbstractRemoteTraversal implementation for the Gremlin Driver.Side-effect step that removes labels from the current element by calling
Element.dropLabels() or Element.dropLabel(String, String...).Tokens that are used to denote different periods of time.
Similar to the EmptyTraverser, except the DummyTraverser can split.
This strategy looks for
RangeGlobalSteps that can be moved further left in the traversal and thus be applied
earlier.Common exceptions to use with an edge.
EdgeLabelVerificationStrategy does not allow edge traversal steps to have no label specified.Common exceptions to use with an element.
Utility class supporting common functions for
Element.Provides a degree of control over element identifier assignment as some graphs don't provide that feature.
Converts a
Element to a Map.Allows a
RemoteConnection to be submitted to a "local" Graph instance thus simulating a connection
to a remote source.Generated by the
EmbeddedRemoteConnection to help simulate a remote traversal execution within the same JVM.EmptyGraph doesn't have a standard open() method because it is a singleton.Features defined such that they support immutability but allow all other possibilities.
Generalized serializer for {#code Enum} value types.
An event that represents a label change on an element (vertex or edge).
A base class for
Property mutation events.A base class for
Property mutation events.Represents an action where a
VertexProperty is modified on a Vertex.Represents an action where a
Property is modified on a VertexProperty.Represents an action where a
Property is removed from a VertexProperty.A strategy that raises events when
Mutating steps are encountered and successfully executed.Immediately notifies all listeners as events arrive.
A common interface for detachment.
Options for detaching elements from the graph during eventing.
Gathers messages from callbacks and fires them to listeners.
Stores events in a queue that builds up until the transaction is committed which then fires them in the order
they were received.
Logic for registering events with the
EventStrategy and the callback registry.Defines the list of standard exceptions covered by a test set.
A group of
ExceptionCoverage sideEffects.Deprecated.
As of release 3.5.3, replaced by
ExceptionHelper in gremlin-coreUtility class with helpful functions for exceptions.
A single join step in a compiled
GqlMatchPlan.Provides a
Failure implementation for ResponseException.Triggers an immediate failure of the traversal by throwing a
RuntimeException.Represents a failure raised by the
GraphTraversal.fail() step which forces a traversal to immediately stop
in an error state.Retrieve a singleton, fast
NoSuchElementException without a stack trace.A annotation for feature methods.
A FeatureRequirement annotation defines a feature to check for a test in the Gremlin Test Suite.
Holds a collection of
FeatureRequirement annotations enabling multiple FeatureRequirement
definitions to be applied to a single test method.Logically grouped features used to simplify test annotations.
Tests that do basic validation of proper Feature settings in Graph implementations.
Feature checks that test
Edge functionality to determine if a feature
should be on when it is marked as not supported.Feature checks that test
Graph functionality to determine if a feature should be on when it is marked
as not supported.Feature checks that tests if
Graph.Variables
functionality to determine if a feature should be on when it is marked as not supported.Feature checks that simply evaluate conflicting feature definitions without evaluating the actual implementation
itself.
Feature checks that test
Vertex functionality to determine if a feature
should be on when it is marked as not supported.Marker interface for a
Barrier that can behave as a filter, like RangeGlobalStepFilterRankingStrategy reorders filter- and order-steps according to their rank.Reference implementation for String format step, a mid-traversal step which substitutes
%{variable_name}
and %{_} references in a format string with property values, scope values, or by() modulator
results from the incoming traverser.FromToModulating are for
Steps that support from()- and to()-modulation.A
Generating step is one that has a side-effect that needs post-processing prior to being returned.Interface for Graph generators.
Visitor class to handle generic literal.
This class provides an empty implementation of
GQLListener,
which can be extended to create a listener which only needs to handle a subset
of the available methods.This class provides an empty implementation of
GQLVisitor,
which can be extended to create a visitor which only needs to handle a subset
of the available methods.TraversalStrategy.ProviderOptimizationStrategy that replaces every
DeclarativeMatchStep in a traversal with a concrete GqlMatchStep backed
by a DefaultGqlPlanner and DefaultGqlExecutor.Executes a
GqlMatchPlan against a graph and returns result rows.This interface defines a complete listener for a parse tree produced by
GQLParser.The compiled physical execution plan for a GQL MATCH query.
Concrete executable replacement for the generic
DeclarativeMatchStep that runs
TinkerGQL patterns via a GqlPlanner and GqlExecutor.Compiles a GQL MATCH string into an executable
GqlMatchPlan.This interface defines a complete generic visitor for a parse tree produced
by
GQLParser.A
Graph is a container object for a collection of Vertex, Edge, VertexProperty,
and Property objects.Common exceptions to use with a graph.
An interface that represents the capabilities of a
Graph implementation.Base interface for features that relate to supporting different data types.
Features that are related to
Edge operations.Features that are related to
Element objects.A marker interface to identify any set of Features.
Features specific to a operations of a "graph".
Features for
Graph.Variables.Features that are related to
Vertex operations.This should only be used by providers to create keys, labels, etc.
Provides access to property index lookups for the graph.
Defines the test suite that the implementer has decided to support and represents publicly as "passing".
Holds a collection of
Graph.OptIn enabling multiple Graph.OptIn to be applied to a
single suite.Defines a test in the suite that the implementer does not want to run.
Holds a collection of
Graph.OptOut enabling multiple Graph.OptOut to be applied to a
single suite.Graph variables are a set of key/value pairs associated with the graph.
Holds a
GraphBinaryReader and GraphBinaryWriter which together allow mapping in and out of the
GraphBinary format.Reads a value from a buffer using the
TypeSerializer instances configured in the
TypeSerializerRegistry.Performs pull-based streaming deserialization of a GraphBinary v4 response from an
InputStreamBuffer.Writes a value to a buffer using the
TypeSerializer instances configured in the
TypeSerializerRegistry.The
GraphComputer is responsible for the execution of a VertexProgram and then a set of
MapReduce jobs over the vertices in the Graph.A
GraphComputing step is one that will change its behavior whether its on a GraphComputer or not.Tests that support the creation of
Graph instances which occurs via GraphFactory.Factory to construct new
Graph instances from a Configuration object or properties file.A graph vendor may use this annotation to specify the factory class that
GraphFactory should use to
open a new graph.GraphFilter is used by
GraphComputer implementations to prune the source graph data being loaded into the OLAP system.A enum denoting whether a particular result will be allowed or not.
Utility class supporting common functions for
Graph.Holds objects specified by the test suites supplying them in a static manner to the test cases.
The
GraphManager interface allows for reference tracking of Graph references through
a Map<String, Graph>; the interface plugs into the lifeline of gremlin script
executions, meaning that commit() and rollback() will be called on all graphs stored in the
graph reference tracker at the end of the script executions; you may want to implement
this interface if you want to define a custom graph instantiation/closing mechanism; note that
the interface also defines similar features for TraversalSource objects.This class provides a way to intercepts calls to
Graph implementation's GraphProvider instances.GraphMigrator takes the data in one graph and pipes it to another graph.Constructs GraphML IO implementations given a
Graph and IoRegistry.This is an "empty" implementation only present for compatibility with
Io.GraphMLReader writes the data from a GraphML stream to a graph.Allows configuration and construction of the GraphMLReader instance.
Provides path access to test data resources.
GraphMLWriter writes a Graph to a GraphML OutputStream.
A
GraphOp or "graph operation" is a static GremlinLang form that does not translate to a traversal
but instead refers to a specific function to perform on a graph instance.Those developing Gremlin implementations must provide a GraphProvider implementation so that the
different test suites know how to instantiate their implementations.
An annotation to be applied to a
GraphProvider implementation that provides additional information
about its intentions.The GraphProvider instance that will be used to generate a Graph instance.
Functions for reading a graph and its graph elements from a different serialization format.
Largely a marker interface for builder classes that construct a
GraphReader.Constructs GraphSON IO implementations given a
Graph and IoRegistry.An extension to the standard Jackson
ObjectMapper which automatically registers the standard
GraphSONModule for serializing Graph elements.Serialize results to JSON with version 4.0.x schema and the extended module.
A @{link GraphReader} that constructs a graph from a JSON-based representation of a graph and its elements.
Provides path access to test data resources.
Contains main logic for the whole JSON to Java deserialization.
Provides quick lookup for Type deserialization extracted from the JSON payload.
Creates the Type serializers as well as the Typed deserializers that will be provided to the serializers and
deserializers.
GraphSON 2.0
TypeSerializer.GraphSON 2.0
TypeSerializer.GraphSON 4.0
TypeSerializer.Serialize results to JSON with version 4 schema and the extended module without embedded types.
Utility methods for GraphSON serialization.
The set of available GraphSON versions.
A @{link GraphWriter} that writes a graph and its elements to a JSON-based representation.
Version 2.0 of GraphSON extensions.
Version 3.0 of GraphSON extensions.
Version 4.0 of GraphSON extensions.
Exposes administrative methods that are either internal to TinkerPop or for users with advanced needs.
A
GraphTraversalSource is the primary DSL of the Gremlin traversal machine.This class implements the
GraphTraversalSource producing methods of Gremlin grammar.Functions for writing a graph and its elements to a serialized format.
Largely a marker interface for builder classes that construct a
GraphWriter.This is the entry point for converting the Gremlin Antlr grammar into Java.
This class provides an empty implementation of
GremlinListener,
which can be extended to create a listener which only needs to handle a subset
of the available methods.This class provides an empty implementation of
GremlinVisitor,
which can be extended to create a visitor which only needs to handle a subset
of the available methods.Special handler that prevents the list delimiter from flattening iterable values that are used for configuration,
like a
Traversal when given to SubgraphStrategyAn annotation that specifies that an interface is meant to be used to produce Gremlin DSL.
Annotation that allows the user to directly override the type parameters on generated anonymous methods.
A custom Java annotation processor for the
GremlinDsl annotation that helps to generate DSLs classes.This is an important test case in that it validates that core features of
ScriptEngine instances that claim
to be "Gremlin-enabled" work in the expected fashion.Exception utility class that generates exceptions in the form expected in a
ResponseStatus for different
issues that the server can encounter.Gremlin error listener class which throw
GremlinParserException on syntax error.Execute Gremlin scripts against a
ScriptEngine instance.The lifecycle of execution within the
GremlinExecutor.eval(String, String, Bindings, LifeCycle) method.Provides methods to compile and evaluate Gremlin scripts.
A
GremlinScriptEngineFactory implementation that creates GremlinGroovyScriptEngine instances.This class helps to build a gremlin-lang compatible string representation based on a
TraversalSource
and then a Traversal.Designed to provide basic configuration options to the
GremlinLangScriptEngine.Exposes
Customizer implementations for configuring the GremlinLangScriptEngine.A
GremlinScriptEngine implementation that evaluates Gremlin scripts using gremlin-language.A
GremlinScriptEngineFactory implementation that creates GremlinLangScriptEngine instances.This interface defines a complete listener for a parse tree produced by
GremlinParser.This exception is thrown when a parser error is encountered.
A plugin interface that is used by the
GremlinScriptEngineManager to configure special Customizer
instances that will alter the features of any GremlinScriptEngine created by the manager itself.Parses Gremlin strings to an
Object, typically to a Traversal.Writes responses to the
ResultSet of a request as the ResponseMessage objects are deserialized.Processes Gremlin strings using regex to try to detect certain properties from the script without actual
having to execute a
eval() on it.A result returned from a
GremlinScriptChecker.parse(String) of a Gremlin string.A
ScriptContext that doesn't create new instances of Reader and Writer classes on
initialization.A
GremlinScriptEngine is an extension of the standard ScriptEngine and provides some specific
methods that are important to the TinkerPop environment.Creates a
GremlinScriptEngine implementation and supplies to it any Customizer implementations to
it that are available on the GremlinScriptEngineManager.The
ScriptEngineManager implements a discovery, instantiation and configuration mechanism for
GremlinScriptEngine classes and also maintains a collection of key/value pairs storing state shared by all
engines created by it.Start and stop Gremlin Server.
A
GremlinPlugin implementation that adds Gremlin Server specific classes to the imports.Command line installer for plugins to Gremlin Server.
Provides an abstraction over a "Gremlin Shell" (i.e.
Translates a String representation of a Gremlin traversal into a various source code representation of that traversal
using the ANTLR grammar.
An implementation of the Comparability/Orderability semantics as defined in the Apache TinkerPop Provider
documentation.
The typespace.
This interface defines a complete generic visitor for a parse tree produced
by
GremlinParser.A
GremlinPlugin that provides access to low-level configuration options of the GroovyScriptEngine
itself.Converts a Gremlin traversal string into a Groovy source code representation of that traversal with an aim at
sacrificing some formatting for the ability to compile correctly.
An interface for common functionality of
GroupStep and GroupSideEffectStep.AbstractGryoClassResolver for Gryo 1.0.AbstractGryoClassResolver for Gryo 3.0.Constructs Gryo IO implementations given a
Graph and IoRegistry.A
Mapper implementation for Kryo.A builder to construct a
GryoMapper instance.Gryo objects are somewhat expensive to construct (given the dependency on Kryo), therefore this pool helps re-use
those objects.
The
GraphReader for the Gremlin Structure serialization format based on Kryo.Provides path access to test data resources.
This class holds serializers for graph-based objects such as vertices, edges, properties, and paths.
Serializes any
Edge implementation encountered to a DetachedEdge.Serializes any
Path implementation encountered to an DetachedPath.Serializes any
Property implementation encountered to an DetachedProperty.Serializes any
VertexProperty implementation encountered to an DetachedVertexProperty.Serializes any
Vertex implementation encountered to an DetachedVertex.This class holds serializers for graph-based objects such as vertices, edges, properties, and paths.
Serializes any
Edge implementation encountered to a DetachedEdge.Serializes any
Path implementation encountered to an DetachedPath.Serializes any
Property implementation encountered to an DetachedProperty.Serializes any
VertexProperty implementation encountered to an DetachedVertexProperty.Serializes any
Vertex implementation encountered to an DetachedVertex.The
GraphWriter for the Gremlin Structure serialization format based on Kryo.Enumeration of Gremlin data types used for type checking and filtering operations.
A
GValue is a variable or literal value that is used in a Traversal.A
Traversal that always returns a constant value.Utility class for
GValue helper methodsThe
GValueManager class is responsible for managing the state of GValue instances and their
associations with `Step` objects in a traversal.Converts placeholder steps that hold
GValue objects to their concrete implementations.Identifies a server within the
Cluster at a specific address.A marker interface that identifies an object as something that an
Attachable can connect to.Implements basic HTTP authentication for use with the
HttpGremlinEndpointHandler and HTTP based API calls.An authorization handler for the http channel that allows the
Authorizer to be plugged into it.Constructs a
Channelizer that exposes an HTTP endpoint in Gremlin Server.Handles compression of content when the response contains the "Content-Encoding" header.
Handles decompression of content when the response contains the "Content-Encoding" header.
Handler that processes RequestMessage.
Converts
RequestMessage to an HTTP request, running interceptors and serializing the body to JSON.Provides methods shared by the HTTP handlers.
A
Transaction implementation for HTTP-based remote connections.Represents the HTTP request that will be sent to the server.
A handler that checks for errors in the HTTP request for all routes.
A handler that generates a Request ID for the incoming HTTP request and injects the same ID into the response header.
Decodes the contents of a
FullHttpRequest.Decodes chunked HTTP responses into streaming results without buffering the full response body.
IdentityRemovalStrategy looks for IdentityStep instances and removes them.Detects
IdleStateEvents and closes the channel with the goal of releasing pooled connections that have not
been used in a while.A data-only representation of a
TraversalExplanation which doesn't re-calculate the "explanation" from
the raw traversal data each time the explanation is displayed.A
Metrics implementation that cannot be modified.Provides the list of imports to apply to a
GremlinScriptEngine instance.A module that allows custom class, static method and enum imports (i.e.
Handler used to detect if the channel has become inactive and throw an error in certain scenarios.
This strategy looks for
.outE().inV(), .inE().outV() and .bothE().otherV()
and replaces these step sequences with .out(), .in() or .both() respectively.A
TraverserSet that has an index back to the object in the Traverser.An
IndexedTraverserSet that indexes based on a Vertex traverser.Type of the index as it corresponds to the associated
WithOptions.list and WithOptions.map.This strategy analyzes filter-steps with child traversals that themselves are pure filters.
A minimal
Input-like abstraction.A map step that returns the intersection of the traverser and the provided arguments.
Io<R extends GraphReader.ReaderBuilder,W extends GraphWriter.WriterBuilder,M extends Mapper.Builder>
Fields that can be provided to the
GraphTraversalSource.io(String) using the
GraphTraversal.with(String,Object) step modulator to provide additional configurations.Helps to construct an
Io implementation and should be implemented by every such implementation as
that class will be passed to Graph.io(Io.Builder) by the user.Deprecated.
As of release 3.4.0, partially replaced by
GraphTraversalSource.io(String).Tests for all IO implementations that are specific to reading and writing of a
Edge.Tests for all IO implementations that are specific to reading and writing of a
Graph.A generalized custom serializer registry for providers implementing a
Graph.Handles read and write operations into the
Graph.Defines the contract for steps containing a single
P.Converts a Gremlin traversal string into a Javascript source code representation of that traversal with an aim at
sacrificing some formatting for the ability to compile correctly.
Converts a Gremlin traversal string into a Java source code representation of that traversal with an aim at
sacrificing some formatting for the ability to compile correctly.
Utility class to easily concatenate multiple JsonParsers.
A utility implementation of a
Property that only has a key but no value.A utility implementation of a
Property that only has a key but no value and no meta-properties.A minimal
Kryo-like abstraction.This interface exists to decouple HadoopPools from TinkerPop's shaded Kryo.
Loads the highest-priority or user-selected
KryoShimService.Defines the label cardinality for graph elements.
Validates label operations against a
LabelCardinality constraint.Class to track a count associated with a Label
Maps an
Element to its labels, emitting each label as a separate traverser.Provides a way to serialize string lambdas as scripts which can be evaluated by a
GremlinScriptEngine.This is a marker interface stating that the
Step contains a
lambda/anonymous function.LambdaRestrictionStrategy does not allow lambdas to be used in a Traversal.Tests that cover lambda steps that are used in embedded cases.
LazyBarrierStrategy is an OLTP-only strategy that automatically inserts a NoOpBarrierStep after every
FlatMapStep if neither path-tracking nor partial path-tracking is required, and the next step is not the
traversal's last step or a Barrier.A customizer implementation that provides bindings to a
GremlinScriptEngine in the
ScriptContext.GLOBAL_SCOPE.A @{link GraphReader} that constructs a graph from a JSON-based representation of a graph and its elements given
the "legacy" Blueprints 2.x version of GraphSON.
Reference implementation for length() step, a mid-traversal step which returns the length of the incoming string
traverser.
Reference implementation for length() step, a mid-traversal step which returns the length of the incoming string
traverser.
Provides a method in which users can hook into the startup and shutdown lifecycle of Gremlin Server.
Contains objects from the server that might be useful to scripting during the startup and shutdown process.
List functions are a separate paradigm for Steps as they behave in a Scope.Local manner by default.
Provides a method for selecting the host from a
Cluster.A simple round-robin strategy that simply selects the next host in the
Cluster to send the
RequestMessage to.Annotations to define a graph example to load from test resources prior to test execution.
Reference implementation for lTrim() step, a mid-traversal step which returns a string with leading
whitespace removed.
Reference implementation for lTrim() step, a mid-traversal step which returns a string with leading
whitespace removed.
Represents a low-level serialization class that can be used to map classes to serializers.
Largely a marker interface for builders that construct
Mapper instances.A MapReduce is composed of map(), combine(), and reduce() stages.
The MapEmitter is used to emit key/value pairs from the map() stage of the MapReduce job.
A convenience singleton when a single key is needed so that all emitted values converge to the same combiner/reducer.
The ReduceEmitter is used to emit key/value pairs from the combine() and reduce() stages of the MapReduce job.
MapReduce is composed of three stages: map, combine, and reduce.
MatchWhereStrategy will fold any post-where() step that maintains a traversal constraint into
match().Deprecated.
As of release 4.0.0, replaced by
DeclarativeMatchStep for declarative pattern matching.A wrapper for the
Expression class.The Memory of a
GraphComputer is a global data structure where by vertices can communicate information with one another.The Admin interface is used by the
GraphComputer to update the Memory.Merge options relevant to upsert-like steps
mergeV() and mergeE() that are applied to the relevant
option() modulator.Implementation for the
mergeE() step covering both the start step version and the one used mid-traversal.Implementation for the
mergeV() step covering both the start step version and the one used mid-traversal.Abstract base class for the
mergeV/E() implementations.A map step that returns the merger of the traverser and the provided arguments without duplicates.
Implementation for the
mergeV() step covering both the start step version and the one used mid-traversal.Implementation for the
mergeV() step covering both the start step version and the one used mid-traversal.A MessageCombiner allows two messages in route to the same vertex to be aggregated into a single message.
A
MessageScope represents the range of a message.A Global message is directed at an arbitrary vertex in the graph.
A Local message is directed to an adjacent (or "memory adjacent") vertex.
A helper class that can be used to generate the reverse traversal of the traversal within a
MessageScope.Local.Serializes data to and from Gremlin Server.
The
Messenger serves as the routing system for messages between vertices.Singleton that contains and configures Gremlin Server's
MetricRegistry.Holds metrics data; typically for .profile()-step analysis.
This is a "do nothing" implementation of the
GremlinScriptEngine which can be used to help test plugin
implementations which don't have reference to a GremlinScriptEngine as a dependency.This is a "do nothing" implementation of the
GremlinScriptEngineFactory which can be used to help test plugin
implementations which don't have reference to a GremlinScriptEngine as a dependency.A number of static methods to interact with a multi map, i.e.
A
Metrics implementation that can be modified.A marker interface for steps that modify the graph.
Interface for a listener to
EventStrategy change events.This class implements Gremlin grammar's nested-traversal-list methods that returns a
Traversal []
to the callers.Represents a factory to create
Buffer instances from wrapped ByteBuf instances.Intermediate helper interface for
Traversers that support loops.This is the entry point for converting the Gremlin Antlr grammar into Java.
Generates values according to a normal distribution with the configured standard deviation.
A NotP wraps a P and represents its negation.
A NotPBiPredicate wraps a PBiPredicate and represents its negation.
A set of
BinaryOperator instances that handle common operations for traversal steps.This strategy will not alter the traversal.
Provides
Comparator instances for ordering traversers.OrderLimitStrategy is an OLAP strategy that folds a RangeGlobalStep into a preceding
OrderGlobalStep.A minimal
Output-like abstraction.Predefined
Predicate values that can be used to define filters to has() and where().Configuration options to be passed to the
GraphTraversal.with(String, Object) step on
GraphTraversal.pageRank().An interface for
Step implementations that hold a Parameters object, which fold in arguments from
other steps.A visitor for parsing parameter map strings that prevents traversal injection.
The parameters held by a
Traversal.Antlr parse tree context cast helper.
PartitionStrategy partitions the vertices, edges and vertex properties of a graph into String named
partitions (i.e.PathProcessStrategy is an OLAP strategy that does its best to turn non-local children in where()
and select() into local children by inlining components of the non-local child.Marker interface for predefined
BiPredicate predicates that can be used in Predicate}.Registry for
ProviderDefinedTypeAdapter instances that supports hydration of
CompositePDT values into typed objects.Configuration options to be passed to the
GraphTraversal.with(String, Object) step on
GraphTraversal.peerPressure().A token used with
option().A
Path may have multiple values associated with a single label.The
PopContaining interface is implemented by traversal steps that maintain Pop instructions
for label access.A class for storing the Scope Context.
Generates values according to a scale-free distribution with the configured gamma value.
An immutable representation of a primitive provider-defined type consisting of a name and an opaque string value.
Adapter for converting between a typed object and a
PrimitivePDT string value.The
ProcessEmbeddedComputerSuite is a set of tests that providers may implement in addition to the standard
Gherkin feature tests.The
ProcessEmbeddedStandardSuite is a set of tests that providers may implement in addition to the standard
Gherkin feature tests.Exception thrown by the
GremlinDslProcessor.Takes an argument of
by() and wraps it CoalesceStep so that the result is either the initial
Traversal argument or null.A map step that returns the cartesian product of the traverser and the provided arguments.
ProfileStrategy callback test.
Traversals
A
Step can implement this interface in order to receive a reference to the MutableMetrics object
for the Step.An internal application used to test out configuration parameters for Gremlin Driver.
Marks a
Step as one that is aware of profiling.A helper class which holds a
Barrier and it's related ProfileStep so that the latter can have
its timer started and stopped appropriately.Common exceptions to use with a property.
A single property equality predicate attached to a node pattern in a GQL MATCH clause.
Gremlin Test Suite for
Property operations.Basic tests for the
Property class.Test exceptions around use of
Element.value(String).Tests for feature support on
Property.This enumeration allows for the specification of the type of a
Property.Marks a class as a provider-defined type for serialization via
CompositePDT.Common supertype for all PDT adapters.
Converts placeholder steps that hold
GValue objects to their concrete implementations.Describes an HTTP proxy that the driver routes connections through.
Converts a Gremlin traversal string into a Python source code representation of that traversal with an aim at
sacrificing some formatting for the ability to compile correctly.
Represents an edge pattern element in a GQL MATCH clause.
The logical graph structure produced by parsing a GQL MATCH clause.
Represents a vertex pattern element in a GQL MATCH clause.
Defines the contract for
range related steps.Defines the contract for
range related steps.Validates that child traversals do not contain mutating steps.
Detects steps marked with
Mutating and throws an IllegalStateException if one is found.Marker interface for
TraversalParent steps whose child traversals must be read-only
(no mutating steps allowed).Bounds the idle time between inbound response chunks on a per-request basis.
Determines the mode of the the IO operation as being for reading or writing (or by default "unset")
A class that represents a value that is not be to be emitted which helps with flow control internal to the class
and is serializable in Gryo for use in OLAP.
A strategy that detaches traversers with graph elements as references (i.e.
A simple abstraction of a "connection" to a "server" that is capable of processing a
Traversal and
returning results.A generalized exception for any errors related to
RemoteConnection.RemoteGraph is only required for integrating with the test suite as there must be a Graph instance
for the test suite to bind to.Sends a
Traversal to a RemoteConnection and iterates back the results.Reconstructs a
Traversal by appending a RemoteStep to its end.A
Transaction interface for remote connections that combine lifecycle management and synchronous submission.A
RemoteTraversal is returned from RemoteConnection.submitAsync(GremlinLang).RepeatUnrollStrategy is an OLTP-only strategy that unrolls any RepeatStep if it uses a constant
number of loops (times(x)) and doesn't emit intermittent elements.Reference implementation for substring step, a mid-traversal step which returns a string with the specified
characters in the original string replaced with the new characters.
Reference implementation for substring step, a mid-traversal step which returns a string with the specified
characters in the original string replaced with the new characters.
Interceptors are run as an ordered list to allow modification of the
HttpRequest before it is sent to the
server.The model for a request message in the HTTP body that is sent to the server beginning in 4.0.0.
Builder class for
RequestMessage.Options that can be supplied on a per request basis.
Defines the synchronous request submission contract for Gremlin requests.
Defines the asynchronous request submission contract for Gremlin requests.
This verification strategy detects property keys that should not be used by the traversal.
The model for a response message that is sent to the server beginning in 4.0.0.
Data model for the "result" portion of a
ResponseMessage.A
Result represents a result value from the server-side Iterator of results.A
ResultSet is returned from the submission of a Gremlin script to the server and represents the
results provided by the server.Reference implementation for reverse() step, a mid-traversal step which returns the reverse value.
Reference implementation for rTrim() step, a mid-traversal step which a string with trailing
whitespace removed.
Reference implementation for rTrim() step, a mid-traversal step which a string with trailing
whitespace removed.
The
SackStrategy is used internal to the withSack() steps of TraversalSource and is not
typically constructed directly.Many
Step instance can have a variable scope which alter the manner in which the step will behave in
relation to how the traversers are processed.This interface is implemented by
Step implementations that access labeled path steps, side-effects or
Map values by key, such as select('a') step.General representation of script
A
Customizer that executes scripts in a GremlinScriptEngine instance for purpose of initialization.A cache of standard
ScriptEngine instances, instantiated by the standard ScriptEngineManager.Loads scripts from one or more files into the
GremlinScriptEngine at startup.Provides path access to test data resources.
ScriptTraversal encapsulates a
ScriptEngine and a script which is compiled into a Traversal at Traversal.Admin.applyStrategies().An interface implemented by steps that have some form of
Random usage that can be configured by way of a
seed to allow for deterministic behavior of the step.A strategy that resets the specified
seed value for Seedable steps, which in turn will produce
deterministic results from those steps.Serialization tests that occur at a lower level than IO.
An enum of the default serializers available starting in v4.0.
A minimal
Serializer-like abstraction.The core of script execution in Gremlin Server.
Service call with I input type and R return type.
Meta-service to list and describe registered callable services.
Context information for service call invocation.
The service factory creates instances of callable services based on the desired execution type.
Service calls can appear at the start of a traversal or mid-traversal.
A basic service registry implementation used by
CallStep.Settings for the
Cluster and its related components.Server settings as configured by a YAML file.
Settings for the
Authenticator implementation.Settings for the
Authenticator implementation.Settings for a
Metrics reporter that writes to the console.Settings to configure CORS (Cross-Origin Resource Sharing) for the HTTP endpoint.
Settings for a
Metrics reporter that writes to a CSV file.Settings for a
Metrics reporter that writes to Ganglia.Settings for a
Metrics reporter that writes to Graphite.Settings for a
Graph entry in the server YAML.Settings for a
Metrics reporter that writes to JMX.Settings for a Java-based
LifeCycleHook configured in the server YAML.Settings for the
ScriptEngine.Settings for the
MessageSerializer implementations.Settings for
Metrics recorded by Gremlin Server.Settings for a
Metrics reporter that writes to the SL4J output.Settings to configure SSL support.
Settings for a declarative
TraversalSource entry nested under a graph in the server YAML.Configuration options to be passed to the
GraphTraversal.with(String, Object) step.A
SideEffectCapable step stores a side-effect data structure accessible by a side-effect key.A
RequestInterceptor that signs requests with AWS SigV4.A simple implementation of an
Authenticator that uses a Graph instance as a credential store.A simple, non-thread safe Gremlin Server client using HTTP.
Base class for serialization of types that don't contain type specific information only {type_code}, {value_flag}
and {value}.
Provides static access to a
CachedGremlinScriptEngineManager instance.Represents a serializer for types that can be represented as a single value and that can be read and write
in a single operation.
Utility class to make size determinations for
Iterable for efficient.Reference implementation for substring step, a mid-traversal step which returns a list of strings created by
splitting the incoming string traverser around the matches of the given separator.
Reference implementation for substring step, a mid-traversal step which returns a list of strings created by
splitting the incoming string traverser around the matches of the given separator.
FileWatcher monitoring changes to SSL keyStore/trustStore files.
A
StarGraph is a form of Attachable (though the Graph implementation does not implement
that interface itself).StarGraph builder with options to customize its internals
Provides helper functions for reading vertex and edges from their serialized GraphSON forms.
A wrapper for
StarGraphSerializer that makes it compatible with TinkerPop's
shaded Kryo.Kryo serializer for
StarGraph.Keys used in the various handlers to store state in the pipeline.
Output Arity Predictor for Tinkerpop steps
Storage is a standard API that providers can implement to allow abstract UNIX-like file system for data sources.
Utility class which can be used by providers to keep a count of the number of
open iterators to the underlying storage.
A collection of helpful methods for creating standard
Object.toString() representations of graph-related
objects.Utility class for Strings.
The
StructureStandardSuite is a JUnit test runner that executes the Gremlin Test Suite over a
Graph implementation.A side-effect step that produces an edge induced subgraph.
This
TraversalStrategy provides a way to limit the view of a Traversal.Reference implementation for substring step, a mid-traversal step which returns a substring of the incoming string
traverser with a 0-based start index (inclusive) and optionally an end index (exclusive).
Reference implementation for substring step, a mid-traversal step which returns a substring of the incoming string
traverser with a 0-based start index (inclusive) and optionally an end index (exclusive).
A plugin implementation which allows for the usage of Gremlin Groovy's syntactic sugar.
A collection of (T)okens which allows for more concise Traversal definitions.
Any exception that implements this interface will be recognized as one whose throwing operation is correct but can
be retried.
Handles terminal steps for
GremlinLang as they are not added this way naturally.Utility methods for test development.
This is a utility class that is for support of various testing activities and is not meant to be used in other
contexts.
Text is a BiPredicate that determines whether the first string starts with, starts
not with, ends with, ends not with, contains or does not contain the second string argument.Allows for a compiled version of the regex pattern.
Predefined
Predicate values that can be used as String filters.A highly use-case specific serializer that only has context for HTTP where results simply need to be converted
to string in a line by line fashion for text based returns.
An exception thrown from the
TimedInterruptGroovyCustomizer when the timeout is exceeded.A
TimesModulating step is one that can do something with GraphTraversal.times(int).Count the IN/OUT/BOTH edges for a set of vertices.
Helps create a variety of different toy graphs for testing and learning purposes.
A
LifeCycleHook that loads TinkerFactory sample datasets into a graph during server startup.An in-memory (with optional persistence on calls to
AbstractTinkerGraph.close()), reference implementation of the property
graph interfaces provided by TinkerPop.This strategy will do a graph size call if the traversal is a count of the vertices and edges of the graph
or a one-to-one map chain thereof.
Wrapper on top of Iterator representing a closable resource to the underlying storage.
An implementation of the
IoRegistry interface that provides serializers with custom configurations for
implementation specific classes that might need to be serialized.An implementation of the
IoRegistry interface that provides serializers with custom configurations for
implementation specific classes that might need to be serialized.An implementation of the
IoRegistry interface that provides serializers with custom configurations for
implementation specific classes that might need to be serialized.An implementation of the
IoRegistry interface that provides serializers with custom configurations for
implementation specific classes that might need to be serialized.A
SimpleModule extension that does the necessary work to make the automatic typed deserialization
without full canonical class names work.TinkerGraph services are currently just "toy" services, used to demonstrate and to test.
Inefficient text search implementation (scan+filter), searches for
Propertys by token/regex.An in-memory (with optional persistence on calls to
AbstractTinkerGraph.close()), reference implementation of the property
graph interfaces with transaction support provided by TinkerPop.String constants used in gremlin-driver and gremlin-server.
String constants used in the HTTP API.
Reference implementation for toLower() step, a mid-traversal step which returns a lower case string representation
of the incoming string traverser.
Reference implementation for the local scope of the toUpper() step, a mid-traversal step which returns an upper case
string representation of all elements inside the incoming list traverser.
A different implementation of the
ToStringSerializer that does not serialize types by calling
`typeSerializer.writeTypePrefixForScalar()` for unknown objects, because it doesn't make sense when there is a
custom types mechanism in place.Reference implementation for toUpper() step, a mid-traversal step which returns an upper case string representation
of the incoming string traverser.
Reference implementation for the local scope of the toUpper() step, a mid-traversal step which returns an upper case
string representation of all elements inside the incoming list traverser.
A set of methods that allow for control of transactional behavior of a
Graph instance.Behaviors to supply to the
Transaction.onClose(Consumer).Behaviors to supply to the
Transaction.onReadWrite(Consumer).A status provided to transaction listeners to inform whether a transaction was successfully committed
or rolled back.
An exception thrown by providers when calls to
AbstractTransaction.doCommit() or
AbstractTransaction.doRollback() fail.Tracks active transactions and returns references of them.
Tests for graphs that has multithreaded access
Represents a special TypeSerializer placeholder that transforms the value into another before serializing it.
A Gremlin to Gremlin translator.
A translation of a script.
Built in translator implementations to be provided
Exception produced by the
Translator when it encounters an error.A collection of
Exception types associated with Traversal execution.A TraversalEngine is a test component that helps determine the engine on which a traversal test will execute.
Traversal enum parser parses all the enums like (e.g.
A TraversalExplanation takes a
Traversal and, for each registered TraversalStrategy, it creates a
mapping reflecting how each strategy alters the traversal.Utility class that provides functions that manipulate
Traversal isntances.Thrown if a
Traversal is interrupted during execution.A TraversalMatrix provides random, non-linear access to the steps of a traversal by their step id.
Specific case of TraversalRootVisitor where all TraversalMethods returns
a GraphTraversal object.
Contains the Metrics gathered for a Traversal as the result of the .profile()-step.
Describes steps that can be parent to a
Traversal from the option() modulator.Indicates that a step can contain child Traversals.
This class represents the state of the output of a child
Traversal where it is either productive or not.This visitor handles the cases when a new traversal is getting started.
A
Traversal can maintain global sideEffects.A
TraversalSource is used to create Traversal instances.TraversalSource is not Serializable.A
GraphTraversalSource self method visitor.Use a
GraphTraversalSource as the source and returns a GraphTraversal object.Handles transactions via calls to
tx().A
Traversal maintains a set of TraversalStrategy instances within a TraversalStrategies}
object.A
TraversalStrategy defines a particular atomic operation for mutating a Traversal prior to its
evaluation.Implemented by strategies that adds "application logic" to the traversal (e.g.
Implemented by strategies that do final behaviors that require a fully compiled traversal to work (e.g.
Implemented by strategies that rewrite the traversal to be more efficient, but with the same semantics
(e.g.
Implemented by strategies that rewrite the traversal to be more efficient, but with the same semantics.
Implemented by strategies where there is no more behavioral tweaking of the traversal required.
This class is for use with
GremlinLang and for serialization purposes.Traversal terminal method visitor
A
Traverser represents the current state of an object flowing through a Traversal.The methods in System.Traverser are useful to underlying Step and Traversal implementations.
A TraverserGenerator will generate traversers for a particular
Traversal.A tree data structure with a tree-shaped public API.
Represents an operation that accepts two input arguments and returns no result.
Reference implementation for trim() step, a mid-traversal step which returns a string with leading and trailing
whitespace removed.
Reference implementation for trim() step, a mid-traversal step which returns a string with leading and trailing
whitespace removed.
Defines how data types are handled in GraphSON through the
GraphSONMapper.Represents a class serializable with Gryo.
Represents a serializer for a given type.
Maintains state for an active transaction over HTTP.
More efficiently extracts a value from an
Element or Map to avoid strategy application costs.Resolves parameters in Gremlin to objects.
Allows for a provided variable set in the form of a
Map, where the keys are variable names and the
values are the parameter values to be injected into the traversal in their place.Allows for a provided variable set in the form of a
Map, where the keys are variable names and the
values are the parameter values to be injected into the traversal in their place.This
VariableResolver implementation throws exceptions for all variable names.This
VariableResolver simply provides a null value for all variable names.Supplies a
VariableResolver implementation to the GremlinLangScriptEngine.The exception thrown when a variable cannot be resolved for a particular parameter name.
A plugin that allows for the configuration of a
VariableResolver implementation to be used by the
GremlinLangScriptEngine.Gremlin Test Suite for
Graph.Variables operations.Tests for feature support on
Graph.Variables.Basic tests to ensure that
Graph.Variables have appropriate String representations.Ensure that the
Graph.Variables.asMap() method returns some basics.Test exceptions around
Graph.Variables.Common exceptions to use with a vertex.
An
InputStream implementation that can independently process a Gryo file written with
GryoWriter.writeVertices(OutputStream, Iterator).A
VertexComputeKey specifies a property of a vertex that will be used to store GraphComputer data.A
VertexProgram represents one component of a distributed graph computation.Detects the presence of a
VertexProgramStrategy and throws an IllegalStateException if it is found.Common exceptions to use with a property.
Handles the logic of traversing to adjacent vertices or edges given a direction and edge labels for steps like,
out, in, both, outE, inE, and bothE.Handles the logic of traversing to adjacent vertices or edges given a direction and edge labels for steps like,
out, in, both, outE, inE, and bothE.Represents the end of a vertex in a serialization stream.
Configuration options to be passed to the
GraphTraversal.with(String, Object).Covers
String oriented constants used as arguments to GraphTraversal.with(String) steps.This interface provides the context the test suite needs in order to execute the Gherkin tests.
Graph implementations that don't natively implement the TinkerPop interfaces should implement the
"wrapped" classes to provide a standard way for users to get the vendor's "raw" object that represents their
graph.A marker interface for steps that writes the graph data.
An anonymous
GraphTraversal.