All Classes and Interfaces
Class
Description
A simple base implementation of the
GremlinScriptEngineFactory.Base implementation of the
IoRegistry interface that provides implementation of the methods using a
a HashMap.Provides a unified way to construct a
TraversalSource from the perspective of the traversal.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.An implementation of the
GremlinScriptEngineManager that caches the instances of the
GremlinScriptEngine instances that are created by it.Client-side channel initializer interface.
Base implementation of the client side
Channelizer.Sends requests over the HTTP endpoint.
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.A connection to a set of one or more Gremlin Server instances.
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.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.The wire compression algorithm that the driver negotiates with the server.
The result of the
GraphComputer's computation.A
Bindings that can be accessed concurrently by multiple threads.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.
Contains is a BiPredicate that evaluates whether the first object is contained within (or not
within) the second collection object.This module is required for a
ScriptEngine to be Gremlin-enabled.The
Customizer provides a general way to provide configurations to a GremlinScriptEngine.Utility class for parsing and formatting dates/times.
Default implementation of the
BindingsCustomizer which adds bindings to the ScriptContext.GLOBAL_SCOPE.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.Tokens that are used to denote different periods of time.
Common exceptions to use with an edge.
Common exceptions to use with an element.
Utility class with helpful functions for exceptions.
Represents a failure raised by the
GraphTraversal.fail() step which forces a traversal to immediately stop
in an error state.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.
The
GraphComputer is responsible for the execution of a VertexProgram and then a set of
MapReduce jobs over the vertices in the 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.
GraphMigrator takes the data in one graph and pipes it to another graph.GraphMLReader writes the data from a GraphML stream to a graph.Allows configuration and construction of the GraphMLReader instance.
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.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.A @{link GraphReader} that constructs a graph from a JSON-based representation of a graph and its elements.
A @{link GraphWriter} that writes a graph and its elements to a JSON-based representation.
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.Functions for writing a graph and its elements to a serialized format.
Largely a marker interface for builder classes that construct a
GraphWriter.Special handler that prevents the list delimiter from flattening iterable values that are used for configuration,
like a
Traversal when given to SubgraphStrategyThis 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.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.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.Provides an abstraction over a "Gremlin Shell" (i.e.
An implementation of the Comparability/Orderability semantics as defined in the Apache TinkerPop Provider
documentation.
The typespace.
The
GraphReader for the Gremlin Structure serialization format based on Kryo.The
GraphWriter for the Gremlin Structure serialization format based on Kryo.Enumeration of Gremlin data types used for type checking and filtering operations.
The
GValueManager class is responsible for managing the state of GValue instances and their
associations with `Step` objects in a traversal.Identifies a server within the
Cluster at a specific address.Represents the HTTP request that will be sent to the server.
Provides the list of imports to apply to a
GremlinScriptEngine instance.A module that allows custom class, static method and enum imports (i.e.
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.
A generalized custom serializer registry for providers implementing a
Graph.Defines the label cardinality for graph elements.
A customizer implementation that provides bindings to a
GremlinScriptEngine in the
ScriptContext.GLOBAL_SCOPE.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.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.
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.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.A number of static methods to interact with a multi map, i.e.
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.Provides
Comparator instances for ordering traversers.Predefined
Predicate values that can be used to define filters to has() and where().Marker interface for predefined
BiPredicate predicates that can be used in Predicate}.A token used with
option().A
Path may have multiple values associated with a single label.Common exceptions to use with a property.
This enumeration allows for the specification of the type of a
Property.Describes an HTTP proxy that the driver routes connections through.
A
Transaction interface for remote connections that combine lifecycle management and synchronous submission.Interceptors are run as an ordered list to allow modification of the
HttpRequest before it is sent to the
server.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.
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.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.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.Settings for the
Cluster and its related components.Provides static access to a
CachedGremlinScriptEngineManager instance.Storage is a standard API that providers can implement to allow abstract UNIX-like file system for data sources.
Utility class for Strings.
A collection of (T)okens which allows for more concise Traversal definitions.
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.String constants used in gremlin-driver and gremlin-server.
String constants used in the HTTP API.
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.
A collection of
Exception types associated with Traversal execution.A
Traversal can maintain global sideEffects.A
TraversalSource is used to create Traversal instances.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.
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.Supplies a
VariableResolver implementation to the GremlinLangScriptEngine.A plugin that allows for the configuration of a
VariableResolver implementation to be used by the
GremlinLangScriptEngine.Common exceptions to use with a vertex.
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.Common exceptions to use with a property.
GraphTraversalSource.io(String).