All Classes

Class	Description
AbstractGremlinPlugin
AbstractGremlinScriptEngineFactory	A simple base implementation of the GremlinScriptEngineFactory.
AbstractIoRegistry	Base implementation of the IoRegistry interface that provides implementation of the methods using a a HashMap.
AnonymousTraversalSource<T extends TraversalSource>	Provides a unified way to construct a TraversalSource from the perspective of the traversal.
AuthProperties	Properties to supply to the Cluster for authentication purposes.
AuthProperties.Property	An enum of the available authorization properties.
Bindings	Bindings are used to associate a variable with a value.
BindingsCustomizer	Provides a way to alter the bindings on a GremlinScriptEngine.
BindingsGremlinPlugin	A plugin that allows Bindings to be applied to a GremlinScriptEngine at the time of creation.
BindingsGremlinPlugin.Builder
Buffer	Represents an abstract view for one or more primitive byte arrays and NIO buffers.
BufferFactory<T>	Represents a factory to create Buffer instances from BufferFactory instances.
Bytecode	When a TraversalSource is manipulated and then a Traversal is spawned and mutated, a language agnostic representation of those mutations is recorded in a bytecode instance.
Bytecode.Binding<V>
Bytecode.Instruction
CachedGremlinScriptEngineManager	An implementation of the GremlinScriptEngineManager that caches the instances of the GremlinScriptEngine instances that are created by it.
Channelizer	Client-side channel initializer interface.
Channelizer.AbstractChannelizer	Base implementation of the client side Channelizer.
Channelizer.HttpChannelizer	Sends requests over the HTTP endpoint.
Channelizer.WebSocketChannelizer	WebSocket Channelizer implementation.
Client	A Client is constructed from a Cluster and represents a way to send messages to Gremlin Server.
Client.AliasClusteredClient	Uses a Client.ClusteredClient that rebinds requests to a specified Graph or TraversalSource instances on the server-side.
Client.ClusteredClient	A Client implementation that does not operate in a session.
Client.SessionedClient	A Client implementation that operates in the context of a session.
Client.SessionSettings	Settings for a Client that involve a session.
Client.SessionSettings.Builder
Client.Settings	Settings given to Cluster.connect(Client.Settings) that configures how a Client will behave.
Client.Settings.Builder
Cluster	A connection to a set of one or more Gremlin Server instances.
Cluster.Builder
Column	Column references a particular type of column in a complex data structure such as a Map, a Map.Entry, or a Path.
Compare	Compare is a BiPredicate that determines whether the first argument is ==, !=, >, >=, <, <= to the second argument.
Computer
ComputerResult	The result of the GraphComputer's computation.
ConcurrentBindings	A Bindings that can be accessed concurrently by multiple threads.
ConnectedComponentVertexProgram	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.
ConnectedComponentVertexProgram.Builder
ConsoleCustomizer	A Customizer that allows a RemoteAcceptor to be used with a console implementation.
Contains	Contains is a BiPredicate that evaluates whether the first object is contained within (or not within) the second collection object.
CoreGremlinPlugin	This module is required for a ScriptEngine to be Gremlin-enabled.
CoreImports
Customizer	The Customizer provides a general way to provide configurations to a GremlinScriptEngine.
DefaultBindingsCustomizer	Default implementation of the BindingsCustomizer which adds bindings to the ScriptContext.GLOBAL_SCOPE.
DefaultGremlinScriptEngineManager	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.
DefaultImportCustomizer	Simple implementation of the ImportCustomizer which allows direct setting of all the different import types.
DefaultImportCustomizer.Builder
DefaultScriptCustomizer	Default implementation of the ScriptCustomizer that can create the script list from a list of files or from lines of script.
Direction	Direction is used to denote the direction of an Edge or location of a Vertex on an Edge.
Edge	An Edge links two Vertex objects.
Edge.Exceptions	Common exceptions to use with an edge.
Element	An Element is the base class for both Vertex and Edge.
Element.Exceptions	Common exceptions to use with an element.
Failure
Graph	A Graph is a container object for a collection of Vertex, Edge, VertexProperty, and Property objects.
Graph.Exceptions	Common exceptions to use with a graph.
Graph.Features	An interface that represents the capabilities of a Graph implementation.
Graph.Features.DataTypeFeatures	Base interface for features that relate to supporting different data types.
Graph.Features.EdgeFeatures	Features that are related to Edge operations.
Graph.Features.EdgePropertyFeatures	Features that are related to Edge Property objects.
Graph.Features.ElementFeatures	Features that are related to Element objects.
Graph.Features.FeatureSet	A marker interface to identify any set of Features.
Graph.Features.GraphFeatures	Features specific to a operations of a "graph".
Graph.Features.PropertyFeatures	A base interface for Edge or Vertex Property features.
Graph.Features.VariableFeatures	Features for Graph.Variables.
Graph.Features.VertexFeatures	Features that are related to Vertex operations.
Graph.Features.VertexPropertyFeatures	Features that are related to Vertex Property objects.
Graph.Hidden	This should only be used by providers to create keys, labels, etc.
Graph.OptIn	Defines the test suite that the implementer has decided to support and represents publicly as "passing".
Graph.OptIns	Holds a collection of Graph.OptIn enabling multiple Graph.OptIn to be applied to a single suite.
Graph.OptOut	Defines a test in the suite that the implementer does not want to run.
Graph.OptOuts	Holds a collection of Graph.OptOut enabling multiple Graph.OptOut to be applied to a single suite.
Graph.Variables	Graph variables are a set of key/value pairs associated with the graph.
Graph.Variables.Exceptions
GraphComputer	The GraphComputer is responsible for the execution of a VertexProgram and then a set of MapReduce jobs over the vertices in the Graph.
GraphComputer.Exceptions
GraphComputer.Features
GraphComputer.Persist
GraphComputer.ResultGraph
GraphFilter	GraphFilter is used by GraphComputer implementations to prune the source graph data being loaded into the OLAP system.
GraphFilter.Legal	A enum denoting whether a particular result will be allowed or not.
GraphMigrator	GraphMigrator takes the data in one graph and pipes it to another graph.
GraphMLReader	GraphMLReader writes the data from a GraphML stream to a graph.
GraphMLReader.Builder	Allows configuration and construction of the GraphMLReader instance.
GraphMLWriter	GraphMLWriter writes a Graph to a GraphML OutputStream.
GraphMLWriter.Builder
GraphOp	A GraphOp or "graph operation" is a static Bytecode form that does not translate to a traversal but instead refers to a specific function to perform on a graph instance.
GraphReader	Functions for reading a graph and its graph elements from a different serialization format.
GraphReader.ReaderBuilder<T extends GraphReader>	Largely a marker interface for builder classes that construct a GraphReader.
GraphSONReader	A @{link GraphReader} that constructs a graph from a JSON-based representation of a graph and its elements.
GraphSONReader.Builder
GraphSONWriter	A @{link GraphWriter} that writes a graph and its elements to a JSON-based representation.
GraphSONWriter.Builder
GraphTraversal<S,E>
GraphTraversal.Admin<S,E>
GraphTraversal.Symbols
GraphTraversalSource	A GraphTraversalSource is the primary DSL of the Gremlin traversal machine.
GraphTraversalSource.Symbols
GraphWriter	Functions for writing a graph and its elements to a serialized format.
GraphWriter.WriterBuilder<T extends GraphWriter>	Largely a marker interface for builder classes that construct a GraphWriter.
GremlinLangScriptEngine	A GremlinScriptEngine implementation that evaluates Gremlin scripts using gremlin-language.
GremlinLangScriptEngineFactory	A GremlinScriptEngineFactory implementation that creates GremlinLangScriptEngine instances.
GremlinPlugin	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.
GremlinScriptChecker	Processes Gremlin strings using regex to try to detect certain properties from the script without actual having to execute a eval() on it.
GremlinScriptChecker.Result	A result returned from a GremlinScriptChecker.parse(String) of a Gremlin string.
GremlinScriptContext	A ScriptContext that doesn't create new instances of Reader and Writer classes on initialization.
GremlinScriptEngine	A GremlinScriptEngine is an extension of the standard ScriptEngine and provides some specific methods that are important to the TinkerPop environment.
GremlinScriptEngineFactory	Creates a GremlinScriptEngine implementation and supplies to it any Customizer implementations to it that are available on the GremlinScriptEngineManager.
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.
GremlinShellEnvironment	Provides an abstraction over a "Gremlin Shell" (i.e.
GremlinTypeErrorException	We use this exception type to signify ERROR in Ternary Boolean Logics.
GryoReader	The GraphReader for the Gremlin Structure serialization format based on Kryo.
GryoReader.Builder
GryoWriter	The GraphWriter for the Gremlin Structure serialization format based on Kryo.
GryoWriter.Builder
HandshakeInterceptor	Deprecated. As of release 3.6.6, replaced by RequestInterceptor.
Host	Identifies a server within the Cluster at a specific address.
Host.Listener
ImportCustomizer	Provides the list of imports to apply to a GremlinScriptEngine instance.
ImportGremlinPlugin	A module that allows custom class, static method and enum imports (i.e.
ImportGremlinPlugin.Builder
Io<R extends GraphReader.ReaderBuilder,W extends GraphWriter.WriterBuilder,M extends Mapper.Builder>	Ties together the core interfaces of an IO format: GraphReader, GraphWriter and Mapper.
IO	Fields that can be provided to the GraphTraversalSource.io(String) using the GraphTraversal.with(String,Object) step modulator to provide additional configurations.
Io.Builder<I extends Io>	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.
Io.Exceptions
IoCore	Deprecated. As of release 3.4.0, partially replaced by GraphTraversalSource.io(String).
IoRegistry	A generalized custom serializer registry for providers implementing a Graph.
JavaTranslator<S extends TraversalSource,T extends Traversal.Admin<?,?>>
KeyValue<K,V>
LazyBindingsCustomizer	A customizer implementation that provides bindings to a GremlinScriptEngine in the ScriptContext.GLOBAL_SCOPE.
LoadBalancingStrategy	Provides a method for selecting the host from a Cluster.
LoadBalancingStrategy.RoundRobin	A simple round-robin strategy that simply selects the next host in the Cluster to send the RequestMessage to.
Mapper<T>	Represents a low-level serialization class that can be used to map classes to serializers.
Mapper.Builder<B extends Mapper.Builder>	Largely a marker interface for builders that construct Mapper instances.
MapReduce<MK,MV,RK,RV,R>	A MapReduce is composed of map(), combine(), and reduce() stages.
MapReduce.MapEmitter<K,V>	The MapEmitter is used to emit key/value pairs from the map() stage of the MapReduce job.
MapReduce.NullObject	A convenience singleton when a single key is needed so that all emitted values converge to the same combiner/reducer.
MapReduce.ReduceEmitter<OK,OV>	The ReduceEmitter is used to emit key/value pairs from the combine() and reduce() stages of the MapReduce job.
MapReduce.Stage	MapReduce is composed of three stages: map, combine, and reduce.
Memory	The Memory of a GraphComputer is a global data structure where by vertices can communicate information with one another.
Memory.Admin	The Admin interface is used by the GraphComputer to update the Memory.
Memory.Exceptions
MemoryComputeKey<A>	A MemoryComputeKey specifies what keys will be used by a Memory during a GraphComputer computation.
Merge	Merge options relevant to upsert-like steps mergeV() and mergeE() that are applied to the relevant option() modulator.
MessageCombiner<M>	A MessageCombiner allows two messages in route to the same vertex to be aggregated into a single message.
MessageScope	A MessageScope represents the range of a message.
MessageScope.Global	A Global message is directed at an arbitrary vertex in the graph.
MessageScope.Local<M>	A Local message is directed to an adjacent (or "memory adjacent") vertex.
MessageScope.Local.ReverseTraversalSupplier	A helper class that can be used to generate the reverse traversal of the traversal within a MessageScope.Local.
MessageSerializer<M>	Serializes data to and from Gremlin Server.
Messenger<M>	The Messenger serves as the routing system for messages between vertices.
Operator	A set of BinaryOperator instances that handle common operations for traversal steps.
Order	Provides Comparator instances for ordering traversers.
P<V>	Predefined Predicate values that can be used to define filters to has() and where().
PageRankVertexProgram
PageRankVertexProgram.Builder
Path	A Path denotes a particular walk through a Graph as defined by a Traversal.
Path.Exceptions
PeerPressureVertexProgram
PeerPressureVertexProgram.Builder
Pick	A token used with option().
Pop	A Path may have multiple values associated with a single label.
ProgramPhase
Property<V>	A Property denotes a key/value pair associated with an Edge.
Property.Exceptions	Common exceptions to use with a property.
PropertyType	This enumeration allows for the specification of the type of a Property.
RemoteAcceptor	The Gremlin Console supports the :remote and :submit commands which provide standardized ways for plugins to provide "remote connections" to resources and a way to "submit" a command to those resources.
RemoteException	A mapper Exception to be thrown when there are problems with processing a command given to a RemoteAcceptor.
RequestInterceptor	This function is called a FullHttpRequest constructed and allow it to be modified as needed before it is sent to the server.
RequestOptions	Options that can be supplied on a per request basis.
RequestOptions.Builder
Result	A Result represents a result value from the server-side Iterator of results.
ResultSet	A ResultSet is returned from the submission of a Gremlin script to the server and represents the results provided by the server.
SackFunctions
SackFunctions.Barrier
Scope	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.
Script	General representation of script
ScriptCustomizer	A Customizer that executes scripts in a GremlinScriptEngine instance for purpose of initialization.
ScriptEngineCache	A cache of standard ScriptEngine instances, instantiated by the standard ScriptEngineManager.
ScriptFileGremlinPlugin	Loads scripts from one or more files into the GremlinScriptEngine at startup.
ScriptFileGremlinPlugin.Builder
ShortestPathVertexProgram
ShortestPathVertexProgram.Builder
SingleGremlinScriptEngineManager	Provides static access to a CachedGremlinScriptEngineManager instance.
Step<S,E>	A Step denotes a unit of computation within a Traversal.
Storage	Storage is a standard API that providers can implement to allow abstract UNIX-like file system for data sources.
T	A collection of (T)okens which allows for more concise Traversal definitions.
Text	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.
Text.RegexPredicate	Allows for a compiled version of the regex pattern.
TextP	Predefined Predicate values that can be used as String filters.
Tokens	String constants used in gremlin-driver and gremlin-server.
Transaction	A set of methods that allow for control of transactional behavior of a Graph instance.
Transaction.CLOSE_BEHAVIOR	Behaviors to supply to the Transaction.onClose(Consumer).
Transaction.Exceptions
Transaction.READ_WRITE_BEHAVIOR	Behaviors to supply to the Transaction.onReadWrite(Consumer).
Transaction.Status	A status provided to transaction listeners to inform whether a transaction was successfully committed or rolled back.
Transaction.Symbols
Translator<S,T>	A Translator will translate Bytecode into another representation.
Translator.ScriptTranslator	Translates bytecode to a Script representation.
Translator.ScriptTranslator.AbstractTypeTranslator
Translator.ScriptTranslator.TypeTranslator	Provides a way for the Translator.ScriptTranslator to convert various data types to their string representations in their target language.
Translator.StepTranslator<S extends TraversalSource,T extends Traversal.Admin<?,?>>	Translates bytecode to actual steps.
TranslatorCustomizer	Provides a way to customize and override Bytecode to script translation.
Traversal<S,E>	A Traversal represents a directed walk over a Graph.
Traversal.Admin<S,E>
Traversal.Exceptions	A collection of Exception types associated with Traversal execution.
Traversal.Symbols
TraversalSideEffects	A Traversal can maintain global sideEffects.
TraversalSideEffects.Exceptions
TraversalSource	A TraversalSource is used to create Traversal instances.
TraversalSource.Symbols
TraversalStrategies	A Traversal maintains a set of TraversalStrategy instances within a TraversalStrategies object.
TraversalStrategies.GlobalCache
TraversalStrategy<S extends TraversalStrategy>	A TraversalStrategy defines a particular atomic operation for mutating a Traversal prior to its evaluation.
TraversalStrategy.DecorationStrategy	Implemented by strategies that adds "application logic" to the traversal (e.g.
TraversalStrategy.FinalizationStrategy	Implemented by strategies that do final behaviors that require a fully compiled traversal to work (e.g.
TraversalStrategy.OptimizationStrategy	Implemented by strategies that rewrite the traversal to be more efficient, but with the same semantics (e.g.
TraversalStrategy.ProviderOptimizationStrategy	Implemented by strategies that rewrite the traversal to be more efficient, but with the same semantics.
TraversalStrategy.VerificationStrategy	Implemented by strategies where there is no more behavioral tweaking of the traversal required.
TraversalVertexProgram	TraversalVertexProgram enables the evaluation of a Traversal on a GraphComputer.
TraversalVertexProgram.Builder
Traverser<T>	A Traverser represents the current state of an object flowing through a Traversal.
Traverser.Admin<T>	The methods in System.Traverser are useful to underlying Step and Traversal implementations.
TraverserGenerator	A TraverserGenerator will generate traversers for a particular Traversal.
UserAgent
Vertex	A Vertex maintains pointers to both a set of incoming and outgoing Edge objects.
Vertex.Exceptions	Common exceptions to use with a vertex.
VertexComputeKey	A VertexComputeKey specifies a property of a vertex that will be used to store GraphComputer data.
VertexProgram<M>	A VertexProgram represents one component of a distributed graph computation.
VertexProgram.Builder
VertexProgram.Features
VertexProperty<V>	A VertexProperty is similar to a Property in that it denotes a key/value pair associated with an Vertex, however it is different in the sense that it also represents an entity that it is an Element that can have properties of its own.
VertexProperty.Cardinality
VertexProperty.Exceptions	Common exceptions to use with a property.