java.lang.Object
- org.antlr.v4.runtime.Recognizer<org.antlr.v4.runtime.Token,org.antlr.v4.runtime.atn.ParserATNSimulator>
- - org.antlr.v4.runtime.Parser
  - - org.apache.tinkerpop.gremlin.language.grammar.GremlinParser

public class GremlinParser
extends org.antlr.v4.runtime.Parser

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`static class`	`GremlinParser.BooleanArgumentContext`
`static class`	`GremlinParser.BooleanLiteralContext`
`static class`	`GremlinParser.ChainedTraversalContext`
`static class`	`GremlinParser.ClassTypeContext`
`static class`	`GremlinParser.ClassTypeExprContext`
`static class`	`GremlinParser.ClassTypeListContext`
`static class`	`GremlinParser.ConfigurationContext`
`static class`	`GremlinParser.ConnectedComponentConstants_componentContext`
`static class`	`GremlinParser.ConnectedComponentConstants_edgesContext`
`static class`	`GremlinParser.ConnectedComponentConstants_propertyNameContext`
`static class`	`GremlinParser.ConnectedComponentConstantsContext`
`static class`	`GremlinParser.ConnectedComponentStringConstantContext`
`static class`	`GremlinParser.DateArgumentContext`
`static class`	`GremlinParser.DateLiteralContext`
`static class`	`GremlinParser.EmptyQueryContext`
`static class`	`GremlinParser.FloatArgumentContext`
`static class`	`GremlinParser.FloatLiteralContext`
`static class`	`GremlinParser.GenericArgumentContext`
`static class`	`GremlinParser.GenericArgumentVarargsContext`
`static class`	`GremlinParser.GenericCollectionLiteralContext`
`static class`	`GremlinParser.GenericLiteralContext`
`static class`	`GremlinParser.GenericLiteralExprContext`
`static class`	`GremlinParser.GenericLiteralVarargsContext`
`static class`	`GremlinParser.GenericMapArgumentContext`
`static class`	`GremlinParser.GenericMapLiteralContext`
`static class`	`GremlinParser.GenericMapNullableArgumentContext`
`static class`	`GremlinParser.GenericMapNullableLiteralContext`
`static class`	`GremlinParser.GenericRangeLiteralContext`
`static class`	`GremlinParser.GenericSetLiteralContext`
`static class`	`GremlinParser.InfLiteralContext`
`static class`	`GremlinParser.IntegerArgumentContext`
`static class`	`GremlinParser.IntegerLiteralContext`
`static class`	`GremlinParser.IoOptionsConstants_graphmlContext`
`static class`	`GremlinParser.IoOptionsConstants_graphsonContext`
`static class`	`GremlinParser.IoOptionsConstants_gryoContext`
`static class`	`GremlinParser.IoOptionsConstants_readerContext`
`static class`	`GremlinParser.IoOptionsConstants_writerContext`
`static class`	`GremlinParser.IoOptionsKeysContext`
`static class`	`GremlinParser.IoOptionsStringConstantContext`
`static class`	`GremlinParser.IoOptionsValuesContext`
`static class`	`GremlinParser.KeywordContext`
`static class`	`GremlinParser.MapEntryContext`
`static class`	`GremlinParser.MapKeyContext`
`static class`	`GremlinParser.NakedKeyContext`
`static class`	`GremlinParser.NanLiteralContext`
`static class`	`GremlinParser.NestedTraversalContext`
`static class`	`GremlinParser.NestedTraversalExprContext`
`static class`	`GremlinParser.NestedTraversalListContext`
`static class`	`GremlinParser.NullLiteralContext`
`static class`	`GremlinParser.NumericLiteralContext`
`static class`	`GremlinParser.PageRankConstants_edgesContext`
`static class`	`GremlinParser.PageRankConstants_propertyNameContext`
`static class`	`GremlinParser.PageRankConstants_timesContext`
`static class`	`GremlinParser.PageRankConstantsContext`
`static class`	`GremlinParser.PageRankStringConstantContext`
`static class`	`GremlinParser.PeerPressureConstants_edgesContext`
`static class`	`GremlinParser.PeerPressureConstants_propertyNameContext`
`static class`	`GremlinParser.PeerPressureConstants_timesContext`
`static class`	`GremlinParser.PeerPressureConstantsContext`
`static class`	`GremlinParser.PeerPressureStringConstantContext`
`static class`	`GremlinParser.QueryContext`
`static class`	`GremlinParser.QueryListContext`
`static class`	`GremlinParser.RootTraversalContext`
`static class`	`GremlinParser.ShortestPathConstants_distanceContext`
`static class`	`GremlinParser.ShortestPathConstants_edgesContext`
`static class`	`GremlinParser.ShortestPathConstants_includeEdgesContext`
`static class`	`GremlinParser.ShortestPathConstants_maxDistanceContext`
`static class`	`GremlinParser.ShortestPathConstants_targetContext`
`static class`	`GremlinParser.ShortestPathConstantsContext`
`static class`	`GremlinParser.ShortestPathStringConstantContext`
`static class`	`GremlinParser.StringArgumentContext`
`static class`	`GremlinParser.StringLiteralContext`
`static class`	`GremlinParser.StringNullableArgumentContext`
`static class`	`GremlinParser.StringNullableArgumentVarargsContext`
`static class`	`GremlinParser.StringNullableLiteralContext`
`static class`	`GremlinParser.StringNullableLiteralVarargsContext`
`static class`	`GremlinParser.TerminatedTraversalContext`
`static class`	`GremlinParser.TransactionPartContext`
`static class`	`GremlinParser.TraversalBarrierContext`
`static class`	`GremlinParser.TraversalBiFunctionContext`
`static class`	`GremlinParser.TraversalCardinalityContext`
`static class`	`GremlinParser.TraversalColumnContext`
`static class`	`GremlinParser.TraversalComparatorContext`
`static class`	`GremlinParser.TraversalDirectionContext`
`static class`	`GremlinParser.TraversalDirectionLongContext`
`static class`	`GremlinParser.TraversalDirectionShortContext`
`static class`	`GremlinParser.TraversalDTContext`
`static class`	`GremlinParser.TraversalFunctionContext`
`static class`	`GremlinParser.TraversalGTypeContext`
`static class`	`GremlinParser.TraversalMergeContext`
`static class`	`GremlinParser.TraversalMethod_addE_StringContext`
`static class`	`GremlinParser.TraversalMethod_addE_TraversalContext`
`static class`	`GremlinParser.TraversalMethod_addEContext`
`static class`	`GremlinParser.TraversalMethod_addV_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_addV_StringContext`
`static class`	`GremlinParser.TraversalMethod_addV_TraversalContext`
`static class`	`GremlinParser.TraversalMethod_addVContext`
`static class`	`GremlinParser.TraversalMethod_aggregate_Scope_StringContext`
`static class`	`GremlinParser.TraversalMethod_aggregate_StringContext`
`static class`	`GremlinParser.TraversalMethod_aggregateContext`
`static class`	`GremlinParser.TraversalMethod_all_PContext`
`static class`	`GremlinParser.TraversalMethod_allContext`
`static class`	`GremlinParser.TraversalMethod_andContext`
`static class`	`GremlinParser.TraversalMethod_any_PContext`
`static class`	`GremlinParser.TraversalMethod_anyContext`
`static class`	`GremlinParser.TraversalMethod_asBoolContext`
`static class`	`GremlinParser.TraversalMethod_asContext`
`static class`	`GremlinParser.TraversalMethod_asDateContext`
`static class`	`GremlinParser.TraversalMethod_asNumber_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_asNumber_traversalGTypeContext`
`static class`	`GremlinParser.TraversalMethod_asNumberContext`
`static class`	`GremlinParser.TraversalMethod_asString_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_asString_ScopeContext`
`static class`	`GremlinParser.TraversalMethod_asStringContext`
`static class`	`GremlinParser.TraversalMethod_barrier_ConsumerContext`
`static class`	`GremlinParser.TraversalMethod_barrier_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_barrier_intContext`
`static class`	`GremlinParser.TraversalMethod_barrierContext`
`static class`	`GremlinParser.TraversalMethod_bothContext`
`static class`	`GremlinParser.TraversalMethod_bothEContext`
`static class`	`GremlinParser.TraversalMethod_bothVContext`
`static class`	`GremlinParser.TraversalMethod_branchContext`
`static class`	`GremlinParser.TraversalMethod_by_ComparatorContext`
`static class`	`GremlinParser.TraversalMethod_by_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_by_Function_ComparatorContext`
`static class`	`GremlinParser.TraversalMethod_by_FunctionContext`
`static class`	`GremlinParser.TraversalMethod_by_OrderContext`
`static class`	`GremlinParser.TraversalMethod_by_String_ComparatorContext`
`static class`	`GremlinParser.TraversalMethod_by_StringContext`
`static class`	`GremlinParser.TraversalMethod_by_TContext`
`static class`	`GremlinParser.TraversalMethod_by_Traversal_ComparatorContext`
`static class`	`GremlinParser.TraversalMethod_by_TraversalContext`
`static class`	`GremlinParser.TraversalMethod_byContext`
`static class`	`GremlinParser.TraversalMethod_call_string_map_traversalContext`
`static class`	`GremlinParser.TraversalMethod_call_string_mapContext`
`static class`	`GremlinParser.TraversalMethod_call_string_traversalContext`
`static class`	`GremlinParser.TraversalMethod_call_stringContext`
`static class`	`GremlinParser.TraversalMethod_callContext`
`static class`	`GremlinParser.TraversalMethod_capContext`
`static class`	`GremlinParser.TraversalMethod_choose_FunctionContext`
`static class`	`GremlinParser.TraversalMethod_choose_Predicate_Traversal_TraversalContext`
`static class`	`GremlinParser.TraversalMethod_choose_Predicate_TraversalContext`
`static class`	`GremlinParser.TraversalMethod_choose_Traversal_Traversal_TraversalContext`
`static class`	`GremlinParser.TraversalMethod_choose_Traversal_TraversalContext`
`static class`	`GremlinParser.TraversalMethod_choose_TraversalContext`
`static class`	`GremlinParser.TraversalMethod_chooseContext`
`static class`	`GremlinParser.TraversalMethod_coalesceContext`
`static class`	`GremlinParser.TraversalMethod_coinContext`
`static class`	`GremlinParser.TraversalMethod_combine_ObjectContext`
`static class`	`GremlinParser.TraversalMethod_combineContext`
`static class`	`GremlinParser.TraversalMethod_concat_StringContext`
`static class`	`GremlinParser.TraversalMethod_concat_Traversal_TraversalContext`
`static class`	`GremlinParser.TraversalMethod_concatContext`
`static class`	`GremlinParser.TraversalMethod_conjoin_StringContext`
`static class`	`GremlinParser.TraversalMethod_conjoinContext`
`static class`	`GremlinParser.TraversalMethod_connectedComponentContext`
`static class`	`GremlinParser.TraversalMethod_constantContext`
`static class`	`GremlinParser.TraversalMethod_count_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_count_ScopeContext`
`static class`	`GremlinParser.TraversalMethod_countContext`
`static class`	`GremlinParser.TraversalMethod_cyclicPathContext`
`static class`	`GremlinParser.TraversalMethod_dateAddContext`
`static class`	`GremlinParser.TraversalMethod_dateDiff_DateContext`
`static class`	`GremlinParser.TraversalMethod_dateDiff_TraversalContext`
`static class`	`GremlinParser.TraversalMethod_dateDiffContext`
`static class`	`GremlinParser.TraversalMethod_dedup_Scope_StringContext`
`static class`	`GremlinParser.TraversalMethod_dedup_StringContext`
`static class`	`GremlinParser.TraversalMethod_dedupContext`
`static class`	`GremlinParser.TraversalMethod_difference_ObjectContext`
`static class`	`GremlinParser.TraversalMethod_differenceContext`
`static class`	`GremlinParser.TraversalMethod_discardContext`
`static class`	`GremlinParser.TraversalMethod_disjunct_ObjectContext`
`static class`	`GremlinParser.TraversalMethod_disjunctContext`
`static class`	`GremlinParser.TraversalMethod_dropContext`
`static class`	`GremlinParser.TraversalMethod_EContext`
`static class`	`GremlinParser.TraversalMethod_elementContext`
`static class`	`GremlinParser.TraversalMethod_elementMapContext`
`static class`	`GremlinParser.TraversalMethod_emit_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_emit_PredicateContext`
`static class`	`GremlinParser.TraversalMethod_emit_TraversalContext`
`static class`	`GremlinParser.TraversalMethod_emitContext`
`static class`	`GremlinParser.TraversalMethod_fail_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_fail_StringContext`
`static class`	`GremlinParser.TraversalMethod_failContext`
`static class`	`GremlinParser.TraversalMethod_filter_PredicateContext`
`static class`	`GremlinParser.TraversalMethod_filter_TraversalContext`
`static class`	`GremlinParser.TraversalMethod_filterContext`
`static class`	`GremlinParser.TraversalMethod_flatMapContext`
`static class`	`GremlinParser.TraversalMethod_fold_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_fold_Object_BiFunctionContext`
`static class`	`GremlinParser.TraversalMethod_foldContext`
`static class`	`GremlinParser.TraversalMethod_format_StringContext`
`static class`	`GremlinParser.TraversalMethod_formatContext`
`static class`	`GremlinParser.TraversalMethod_from_GenricArgumentContext`
`static class`	`GremlinParser.TraversalMethod_from_StringContext`
`static class`	`GremlinParser.TraversalMethod_from_TraversalContext`
`static class`	`GremlinParser.TraversalMethod_fromContext`
`static class`	`GremlinParser.TraversalMethod_group_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_group_StringContext`
`static class`	`GremlinParser.TraversalMethod_groupContext`
`static class`	`GremlinParser.TraversalMethod_groupCount_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_groupCount_StringContext`
`static class`	`GremlinParser.TraversalMethod_groupCountContext`
`static class`	`GremlinParser.TraversalMethod_has_String_ObjectContext`
`static class`	`GremlinParser.TraversalMethod_has_String_PContext`
`static class`	`GremlinParser.TraversalMethod_has_String_String_ObjectContext`
`static class`	`GremlinParser.TraversalMethod_has_String_String_PContext`
`static class`	`GremlinParser.TraversalMethod_has_StringContext`
`static class`	`GremlinParser.TraversalMethod_has_T_ObjectContext`
`static class`	`GremlinParser.TraversalMethod_has_T_PContext`
`static class`	`GremlinParser.TraversalMethod_hasContext`
`static class`	`GremlinParser.TraversalMethod_hasId_Object_ObjectContext`
`static class`	`GremlinParser.TraversalMethod_hasId_PContext`
`static class`	`GremlinParser.TraversalMethod_hasIdContext`
`static class`	`GremlinParser.TraversalMethod_hasKey_PContext`
`static class`	`GremlinParser.TraversalMethod_hasKey_String_StringContext`
`static class`	`GremlinParser.TraversalMethod_hasKeyContext`
`static class`	`GremlinParser.TraversalMethod_hasLabel_PContext`
`static class`	`GremlinParser.TraversalMethod_hasLabel_String_StringContext`
`static class`	`GremlinParser.TraversalMethod_hasLabelContext`
`static class`	`GremlinParser.TraversalMethod_hasNotContext`
`static class`	`GremlinParser.TraversalMethod_hasValue_Object_ObjectContext`
`static class`	`GremlinParser.TraversalMethod_hasValue_PContext`
`static class`	`GremlinParser.TraversalMethod_hasValueContext`
`static class`	`GremlinParser.TraversalMethod_idContext`
`static class`	`GremlinParser.TraversalMethod_identityContext`
`static class`	`GremlinParser.TraversalMethod_inContext`
`static class`	`GremlinParser.TraversalMethod_indexContext`
`static class`	`GremlinParser.TraversalMethod_inEContext`
`static class`	`GremlinParser.TraversalMethod_injectContext`
`static class`	`GremlinParser.TraversalMethod_intersect_ObjectContext`
`static class`	`GremlinParser.TraversalMethod_intersectContext`
`static class`	`GremlinParser.TraversalMethod_inVContext`
`static class`	`GremlinParser.TraversalMethod_is_ObjectContext`
`static class`	`GremlinParser.TraversalMethod_is_PContext`
`static class`	`GremlinParser.TraversalMethod_isContext`
`static class`	`GremlinParser.TraversalMethod_keyContext`
`static class`	`GremlinParser.TraversalMethod_labelContext`
`static class`	`GremlinParser.TraversalMethod_length_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_length_ScopeContext`
`static class`	`GremlinParser.TraversalMethod_lengthContext`
`static class`	`GremlinParser.TraversalMethod_limit_longContext`
`static class`	`GremlinParser.TraversalMethod_limit_Scope_longContext`
`static class`	`GremlinParser.TraversalMethod_limitContext`
`static class`	`GremlinParser.TraversalMethod_localContext`
`static class`	`GremlinParser.TraversalMethod_loops_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_loops_StringContext`
`static class`	`GremlinParser.TraversalMethod_loopsContext`
`static class`	`GremlinParser.TraversalMethod_lTrim_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_lTrim_ScopeContext`
`static class`	`GremlinParser.TraversalMethod_lTrimContext`
`static class`	`GremlinParser.TraversalMethod_mapContext`
`static class`	`GremlinParser.TraversalMethod_matchContext`
`static class`	`GremlinParser.TraversalMethod_mathContext`
`static class`	`GremlinParser.TraversalMethod_max_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_max_ScopeContext`
`static class`	`GremlinParser.TraversalMethod_maxContext`
`static class`	`GremlinParser.TraversalMethod_mean_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_mean_ScopeContext`
`static class`	`GremlinParser.TraversalMethod_meanContext`
`static class`	`GremlinParser.TraversalMethod_merge_ObjectContext`
`static class`	`GremlinParser.TraversalMethod_mergeContext`
`static class`	`GremlinParser.TraversalMethod_mergeE_emptyContext`
`static class`	`GremlinParser.TraversalMethod_mergeE_MapContext`
`static class`	`GremlinParser.TraversalMethod_mergeE_TraversalContext`
`static class`	`GremlinParser.TraversalMethod_mergeEContext`
`static class`	`GremlinParser.TraversalMethod_mergeV_emptyContext`
`static class`	`GremlinParser.TraversalMethod_mergeV_MapContext`
`static class`	`GremlinParser.TraversalMethod_mergeV_TraversalContext`
`static class`	`GremlinParser.TraversalMethod_mergeVContext`
`static class`	`GremlinParser.TraversalMethod_min_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_min_ScopeContext`
`static class`	`GremlinParser.TraversalMethod_minContext`
`static class`	`GremlinParser.TraversalMethod_none_PContext`
`static class`	`GremlinParser.TraversalMethod_noneContext`
`static class`	`GremlinParser.TraversalMethod_notContext`
`static class`	`GremlinParser.TraversalMethod_option_Merge_Map_CardinalityContext`
`static class`	`GremlinParser.TraversalMethod_option_Merge_MapContext`
`static class`	`GremlinParser.TraversalMethod_option_Merge_TraversalContext`
`static class`	`GremlinParser.TraversalMethod_option_Object_TraversalContext`
`static class`	`GremlinParser.TraversalMethod_option_Predicate_TraversalContext`
`static class`	`GremlinParser.TraversalMethod_option_TraversalContext`
`static class`	`GremlinParser.TraversalMethod_optionalContext`
`static class`	`GremlinParser.TraversalMethod_optionContext`
`static class`	`GremlinParser.TraversalMethod_orContext`
`static class`	`GremlinParser.TraversalMethod_order_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_order_ScopeContext`
`static class`	`GremlinParser.TraversalMethod_orderContext`
`static class`	`GremlinParser.TraversalMethod_otherVContext`
`static class`	`GremlinParser.TraversalMethod_outContext`
`static class`	`GremlinParser.TraversalMethod_outEContext`
`static class`	`GremlinParser.TraversalMethod_outVContext`
`static class`	`GremlinParser.TraversalMethod_pageRank_doubleContext`
`static class`	`GremlinParser.TraversalMethod_pageRank_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_pageRankContext`
`static class`	`GremlinParser.TraversalMethod_pathContext`
`static class`	`GremlinParser.TraversalMethod_peerPressureContext`
`static class`	`GremlinParser.TraversalMethod_product_ObjectContext`
`static class`	`GremlinParser.TraversalMethod_productContext`
`static class`	`GremlinParser.TraversalMethod_profile_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_profile_StringContext`
`static class`	`GremlinParser.TraversalMethod_profileContext`
`static class`	`GremlinParser.TraversalMethod_projectContext`
`static class`	`GremlinParser.TraversalMethod_propertiesContext`
`static class`	`GremlinParser.TraversalMethod_property_Cardinality_Object_Object_ObjectContext`
`static class`	`GremlinParser.TraversalMethod_property_Cardinality_ObjectContext`
`static class`	`GremlinParser.TraversalMethod_property_Object_Object_ObjectContext`
`static class`	`GremlinParser.TraversalMethod_property_ObjectContext`
`static class`	`GremlinParser.TraversalMethod_propertyContext`
`static class`	`GremlinParser.TraversalMethod_propertyMapContext`
`static class`	`GremlinParser.TraversalMethod_range_long_longContext`
`static class`	`GremlinParser.TraversalMethod_range_Scope_long_longContext`
`static class`	`GremlinParser.TraversalMethod_rangeContext`
`static class`	`GremlinParser.TraversalMethod_readContext`
`static class`	`GremlinParser.TraversalMethod_repeat_String_TraversalContext`
`static class`	`GremlinParser.TraversalMethod_repeat_TraversalContext`
`static class`	`GremlinParser.TraversalMethod_repeatContext`
`static class`	`GremlinParser.TraversalMethod_replace_Scope_String_StringContext`
`static class`	`GremlinParser.TraversalMethod_replace_String_StringContext`
`static class`	`GremlinParser.TraversalMethod_replaceContext`
`static class`	`GremlinParser.TraversalMethod_reverse_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_reverseContext`
`static class`	`GremlinParser.TraversalMethod_rTrim_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_rTrim_ScopeContext`
`static class`	`GremlinParser.TraversalMethod_rTrimContext`
`static class`	`GremlinParser.TraversalMethod_sack_BiFunctionContext`
`static class`	`GremlinParser.TraversalMethod_sack_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_sackContext`
`static class`	`GremlinParser.TraversalMethod_sample_intContext`
`static class`	`GremlinParser.TraversalMethod_sample_Scope_intContext`
`static class`	`GremlinParser.TraversalMethod_sampleContext`
`static class`	`GremlinParser.TraversalMethod_select_ColumnContext`
`static class`	`GremlinParser.TraversalMethod_select_Pop_String_String_StringContext`
`static class`	`GremlinParser.TraversalMethod_select_Pop_StringContext`
`static class`	`GremlinParser.TraversalMethod_select_Pop_TraversalContext`
`static class`	`GremlinParser.TraversalMethod_select_String_String_StringContext`
`static class`	`GremlinParser.TraversalMethod_select_StringContext`
`static class`	`GremlinParser.TraversalMethod_select_TraversalContext`
`static class`	`GremlinParser.TraversalMethod_selectContext`
`static class`	`GremlinParser.TraversalMethod_shortestPathContext`
`static class`	`GremlinParser.TraversalMethod_sideEffectContext`
`static class`	`GremlinParser.TraversalMethod_simplePathContext`
`static class`	`GremlinParser.TraversalMethod_skip_longContext`
`static class`	`GremlinParser.TraversalMethod_skip_Scope_longContext`
`static class`	`GremlinParser.TraversalMethod_skipContext`
`static class`	`GremlinParser.TraversalMethod_split_Scope_StringContext`
`static class`	`GremlinParser.TraversalMethod_split_StringContext`
`static class`	`GremlinParser.TraversalMethod_splitContext`
`static class`	`GremlinParser.TraversalMethod_storeContext`
`static class`	`GremlinParser.TraversalMethod_subgraphContext`
`static class`	`GremlinParser.TraversalMethod_substring_int_intContext`
`static class`	`GremlinParser.TraversalMethod_substring_intContext`
`static class`	`GremlinParser.TraversalMethod_substring_Scope_int_intContext`
`static class`	`GremlinParser.TraversalMethod_substring_Scope_intContext`
`static class`	`GremlinParser.TraversalMethod_substringContext`
`static class`	`GremlinParser.TraversalMethod_sum_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_sum_ScopeContext`
`static class`	`GremlinParser.TraversalMethod_sumContext`
`static class`	`GremlinParser.TraversalMethod_tail_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_tail_longContext`
`static class`	`GremlinParser.TraversalMethod_tail_Scope_longContext`
`static class`	`GremlinParser.TraversalMethod_tail_ScopeContext`
`static class`	`GremlinParser.TraversalMethod_tailContext`
`static class`	`GremlinParser.TraversalMethod_timeLimitContext`
`static class`	`GremlinParser.TraversalMethod_timesContext`
`static class`	`GremlinParser.TraversalMethod_to_Direction_StringContext`
`static class`	`GremlinParser.TraversalMethod_to_GenricArgumentContext`
`static class`	`GremlinParser.TraversalMethod_to_StringContext`
`static class`	`GremlinParser.TraversalMethod_to_TraversalContext`
`static class`	`GremlinParser.TraversalMethod_toContext`
`static class`	`GremlinParser.TraversalMethod_toEContext`
`static class`	`GremlinParser.TraversalMethod_toLower_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_toLower_ScopeContext`
`static class`	`GremlinParser.TraversalMethod_toLowerContext`
`static class`	`GremlinParser.TraversalMethod_toUpper_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_toUpper_ScopeContext`
`static class`	`GremlinParser.TraversalMethod_toUpperContext`
`static class`	`GremlinParser.TraversalMethod_toVContext`
`static class`	`GremlinParser.TraversalMethod_tree_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_tree_StringContext`
`static class`	`GremlinParser.TraversalMethod_treeContext`
`static class`	`GremlinParser.TraversalMethod_trim_EmptyContext`
`static class`	`GremlinParser.TraversalMethod_trim_ScopeContext`
`static class`	`GremlinParser.TraversalMethod_trimContext`
`static class`	`GremlinParser.TraversalMethod_unfoldContext`
`static class`	`GremlinParser.TraversalMethod_unionContext`
`static class`	`GremlinParser.TraversalMethod_until_PredicateContext`
`static class`	`GremlinParser.TraversalMethod_until_TraversalContext`
`static class`	`GremlinParser.TraversalMethod_untilContext`
`static class`	`GremlinParser.TraversalMethod_valueContext`
`static class`	`GremlinParser.TraversalMethod_valueMap_boolean_StringContext`
`static class`	`GremlinParser.TraversalMethod_valueMap_StringContext`
`static class`	`GremlinParser.TraversalMethod_valueMapContext`
`static class`	`GremlinParser.TraversalMethod_valuesContext`
`static class`	`GremlinParser.TraversalMethod_VContext`
`static class`	`GremlinParser.TraversalMethod_where_PContext`
`static class`	`GremlinParser.TraversalMethod_where_String_PContext`
`static class`	`GremlinParser.TraversalMethod_where_TraversalContext`
`static class`	`GremlinParser.TraversalMethod_whereContext`
`static class`	`GremlinParser.TraversalMethod_with_String_ObjectContext`
`static class`	`GremlinParser.TraversalMethod_with_StringContext`
`static class`	`GremlinParser.TraversalMethod_withContext`
`static class`	`GremlinParser.TraversalMethod_writeContext`
`static class`	`GremlinParser.TraversalMethodContext`
`static class`	`GremlinParser.TraversalOperatorContext`
`static class`	`GremlinParser.TraversalOrderContext`
`static class`	`GremlinParser.TraversalPickContext`
`static class`	`GremlinParser.TraversalPopContext`
`static class`	`GremlinParser.TraversalPredicate_betweenContext`
`static class`	`GremlinParser.TraversalPredicate_containingContext`
`static class`	`GremlinParser.TraversalPredicate_endingWithContext`
`static class`	`GremlinParser.TraversalPredicate_eqContext`
`static class`	`GremlinParser.TraversalPredicate_gtContext`
`static class`	`GremlinParser.TraversalPredicate_gteContext`
`static class`	`GremlinParser.TraversalPredicate_insideContext`
`static class`	`GremlinParser.TraversalPredicate_ltContext`
`static class`	`GremlinParser.TraversalPredicate_lteContext`
`static class`	`GremlinParser.TraversalPredicate_neqContext`
`static class`	`GremlinParser.TraversalPredicate_notContainingContext`
`static class`	`GremlinParser.TraversalPredicate_notContext`
`static class`	`GremlinParser.TraversalPredicate_notEndingWithContext`
`static class`	`GremlinParser.TraversalPredicate_notRegexContext`
`static class`	`GremlinParser.TraversalPredicate_notStartingWithContext`
`static class`	`GremlinParser.TraversalPredicate_outsideContext`
`static class`	`GremlinParser.TraversalPredicate_regexContext`
`static class`	`GremlinParser.TraversalPredicate_startingWithContext`
`static class`	`GremlinParser.TraversalPredicate_typeOfContext`
`static class`	`GremlinParser.TraversalPredicate_withinContext`
`static class`	`GremlinParser.TraversalPredicate_withoutContext`
`static class`	`GremlinParser.TraversalPredicateContext`
`static class`	`GremlinParser.TraversalSackMethodContext`
`static class`	`GremlinParser.TraversalScopeContext`
`static class`	`GremlinParser.TraversalSourceContext`
`static class`	`GremlinParser.TraversalSourceSelfMethod_withBulkContext`
`static class`	`GremlinParser.TraversalSourceSelfMethod_withContext`
`static class`	`GremlinParser.TraversalSourceSelfMethod_withoutStrategiesContext`
`static class`	`GremlinParser.TraversalSourceSelfMethod_withPathContext`
`static class`	`GremlinParser.TraversalSourceSelfMethod_withSackContext`
`static class`	`GremlinParser.TraversalSourceSelfMethod_withSideEffectContext`
`static class`	`GremlinParser.TraversalSourceSelfMethod_withStrategiesContext`
`static class`	`GremlinParser.TraversalSourceSelfMethodContext`
`static class`	`GremlinParser.TraversalSourceSpawnMethod_addEContext`
`static class`	`GremlinParser.TraversalSourceSpawnMethod_addVContext`
`static class`	`GremlinParser.TraversalSourceSpawnMethod_call_emptyContext`
`static class`	`GremlinParser.TraversalSourceSpawnMethod_call_string_map_traversalContext`
`static class`	`GremlinParser.TraversalSourceSpawnMethod_call_string_mapContext`
`static class`	`GremlinParser.TraversalSourceSpawnMethod_call_string_traversalContext`
`static class`	`GremlinParser.TraversalSourceSpawnMethod_call_stringContext`
`static class`	`GremlinParser.TraversalSourceSpawnMethod_callContext`
`static class`	`GremlinParser.TraversalSourceSpawnMethod_EContext`
`static class`	`GremlinParser.TraversalSourceSpawnMethod_injectContext`
`static class`	`GremlinParser.TraversalSourceSpawnMethod_ioContext`
`static class`	`GremlinParser.TraversalSourceSpawnMethod_mergeE_MapContext`
`static class`	`GremlinParser.TraversalSourceSpawnMethod_mergeE_TraversalContext`
`static class`	`GremlinParser.TraversalSourceSpawnMethod_mergeEContext`
`static class`	`GremlinParser.TraversalSourceSpawnMethod_mergeV_MapContext`
`static class`	`GremlinParser.TraversalSourceSpawnMethod_mergeV_TraversalContext`
`static class`	`GremlinParser.TraversalSourceSpawnMethod_mergeVContext`
`static class`	`GremlinParser.TraversalSourceSpawnMethod_unionContext`
`static class`	`GremlinParser.TraversalSourceSpawnMethod_VContext`
`static class`	`GremlinParser.TraversalSourceSpawnMethodContext`
`static class`	`GremlinParser.TraversalStrategyContext`
`static class`	`GremlinParser.TraversalStrategyExprContext`
`static class`	`GremlinParser.TraversalStrategyVarargsContext`
`static class`	`GremlinParser.TraversalTContext`
`static class`	`GremlinParser.TraversalTerminalMethod_explainContext`
`static class`	`GremlinParser.TraversalTerminalMethod_hasNextContext`
`static class`	`GremlinParser.TraversalTerminalMethod_iterateContext`
`static class`	`GremlinParser.TraversalTerminalMethod_nextContext`
`static class`	`GremlinParser.TraversalTerminalMethod_toBulkSetContext`
`static class`	`GremlinParser.TraversalTerminalMethod_toListContext`
`static class`	`GremlinParser.TraversalTerminalMethod_toSetContext`
`static class`	`GremlinParser.TraversalTerminalMethod_tryNextContext`
`static class`	`GremlinParser.TraversalTerminalMethodContext`
`static class`	`GremlinParser.TraversalTLongContext`
`static class`	`GremlinParser.TraversalTShortContext`
`static class`	`GremlinParser.UuidLiteralContext`
`static class`	`GremlinParser.VariableContext`
`static class`	`GremlinParser.WithOptionKeysContext`
`static class`	`GremlinParser.WithOptionsConstants_allContext`
`static class`	`GremlinParser.WithOptionsConstants_idsContext`
`static class`	`GremlinParser.WithOptionsConstants_indexerContext`
`static class`	`GremlinParser.WithOptionsConstants_keysContext`
`static class`	`GremlinParser.WithOptionsConstants_labelsContext`
`static class`	`GremlinParser.WithOptionsConstants_listContext`
`static class`	`GremlinParser.WithOptionsConstants_mapContext`
`static class`	`GremlinParser.WithOptionsConstants_noneContext`
`static class`	`GremlinParser.WithOptionsConstants_tokensContext`
`static class`	`GremlinParser.WithOptionsConstants_valuesContext`
`static class`	`GremlinParser.WithOptionsStringConstantContext`
`static class`	`GremlinParser.WithOptionsValuesContext`

Nested classes/interfaces inherited from class org.antlr.v4.runtime.Parser
org.antlr.v4.runtime.Parser.TraceListener, org.antlr.v4.runtime.Parser.TrimToSizeListener

Field Summary

Fields
Modifier and Type	Field	Description
`static org.antlr.v4.runtime.atn.ATN`	`_ATN`
`protected static org.antlr.v4.runtime.dfa.DFA[]`	`_decisionToDFA`
`static String`	`_serializedATN`
`protected static org.antlr.v4.runtime.atn.PredictionContextCache`	`_sharedContextCache`
`static int`	`ANON_TRAVERSAL_ROOT`
`static int`	`COLON`
`static int`	`COMMA`
`static int`	`DOT`
`static int`	`EmptyStringLiteral`
`static int`	`FloatingPointLiteral`
`static int`	`Identifier`
`static int`	`IntegerLiteral`
`static int`	`K_ADDALL`
`static int`	`K_ADDE`
`static int`	`K_ADDV`
`static int`	`K_AGGREGATE`
`static int`	`K_ALL`
`static int`	`K_AND`
`static int`	`K_ANY`
`static int`	`K_AS`
`static int`	`K_ASBOOL`
`static int`	`K_ASC`
`static int`	`K_ASDATE`
`static int`	`K_ASNUMBER`
`static int`	`K_ASSIGN`
`static int`	`K_ASSTRING`
`static int`	`K_BARRIER`
`static int`	`K_BARRIERU`
`static int`	`K_BEGIN`
`static int`	`K_BETWEEN`
`static int`	`K_BIGDECIMAL`
`static int`	`K_BIGDECIMALU`
`static int`	`K_BIGINT`
`static int`	`K_BIGINTU`
`static int`	`K_BINARY`
`static int`	`K_BINARYU`
`static int`	`K_BOOLEAN`
`static int`	`K_BOOLEANU`
`static int`	`K_BOTH`
`static int`	`K_BOTHE`
`static int`	`K_BOTHU`
`static int`	`K_BOTHV`
`static int`	`K_BRANCH`
`static int`	`K_BY`
`static int`	`K_BYTE`
`static int`	`K_BYTEU`
`static int`	`K_CALL`
`static int`	`K_CAP`
`static int`	`K_CARDINALITY`
`static int`	`K_CHAR`
`static int`	`K_CHARU`
`static int`	`K_CHOOSE`
`static int`	`K_COALESCE`
`static int`	`K_COIN`
`static int`	`K_COLUMN`
`static int`	`K_COMBINE`
`static int`	`K_COMMIT`
`static int`	`K_COMPONENT`
`static int`	`K_CONCAT`
`static int`	`K_CONJOIN`
`static int`	`K_CONNECTEDCOMPONENT`
`static int`	`K_CONNECTEDCOMPONENTU`
`static int`	`K_CONSTANT`
`static int`	`K_CONTAINING`
`static int`	`K_COUNT`
`static int`	`K_CYCLICPATH`
`static int`	`K_DATEADD`
`static int`	`K_DATEDIFF`
`static int`	`K_DATETIME`
`static int`	`K_DATETIMEC`
`static int`	`K_DATETIMEU`
`static int`	`K_DAY`
`static int`	`K_DECR`
`static int`	`K_DEDUP`
`static int`	`K_DESC`
`static int`	`K_DIFFERENCE`
`static int`	`K_DIRECTION`
`static int`	`K_DISCARD`
`static int`	`K_DISJUNCT`
`static int`	`K_DISTANCE`
`static int`	`K_DIV`
`static int`	`K_DOUBLE`
`static int`	`K_DOUBLEU`
`static int`	`K_DROP`
`static int`	`K_DT`
`static int`	`K_DURATION`
`static int`	`K_DURATIONU`
`static int`	`K_E`
`static int`	`K_EDGE`
`static int`	`K_EDGES`
`static int`	`K_EDGEU`
`static int`	`K_ELEMENT`
`static int`	`K_ELEMENTMAP`
`static int`	`K_EMIT`
`static int`	`K_ENDINGWITH`
`static int`	`K_EQ`
`static int`	`K_EXPLAIN`
`static int`	`K_FAIL`
`static int`	`K_FALSE`
`static int`	`K_FILTER`
`static int`	`K_FIRST`
`static int`	`K_FLATMAP`
`static int`	`K_FLOAT`
`static int`	`K_FLOATU`
`static int`	`K_FOLD`
`static int`	`K_FORMAT`
`static int`	`K_FROM`
`static int`	`K_GLOBAL`
`static int`	`K_GRAPH`
`static int`	`K_GRAPHML`
`static int`	`K_GRAPHSON`
`static int`	`K_GRAPHU`
`static int`	`K_GROUP`
`static int`	`K_GROUPCOUNT`
`static int`	`K_GRYO`
`static int`	`K_GT`
`static int`	`K_GTE`
`static int`	`K_GTYPE`
`static int`	`K_HAS`
`static int`	`K_HASID`
`static int`	`K_HASKEY`
`static int`	`K_HASLABEL`
`static int`	`K_HASNEXT`
`static int`	`K_HASNOT`
`static int`	`K_HASVALUE`
`static int`	`K_HOUR`
`static int`	`K_ID`
`static int`	`K_IDENTITY`
`static int`	`K_IDS`
`static int`	`K_IN`
`static int`	`K_INCLUDEEDGES`
`static int`	`K_INCR`
`static int`	`K_INDEX`
`static int`	`K_INDEXER`
`static int`	`K_INE`
`static int`	`K_INFINITY`
`static int`	`K_INJECT`
`static int`	`K_INSIDE`
`static int`	`K_INT`
`static int`	`K_INTERSECT`
`static int`	`K_INTU`
`static int`	`K_INU`
`static int`	`K_INV`
`static int`	`K_IO`
`static int`	`K_IOU`
`static int`	`K_IS`
`static int`	`K_ITERATE`
`static int`	`K_KEY`
`static int`	`K_KEYS`
`static int`	`K_LABEL`
`static int`	`K_LABELS`
`static int`	`K_LAST`
`static int`	`K_LENGTH`
`static int`	`K_LIMIT`
`static int`	`K_LIST`
`static int`	`K_LISTU`
`static int`	`K_LOCAL`
`static int`	`K_LONG`
`static int`	`K_LONGU`
`static int`	`K_LOOPS`
`static int`	`K_LT`
`static int`	`K_LTE`
`static int`	`K_LTRIM`
`static int`	`K_MAP`
`static int`	`K_MAPU`
`static int`	`K_MATCH`
`static int`	`K_MATH`
`static int`	`K_MAX`
`static int`	`K_MAXDISTANCE`
`static int`	`K_MEAN`
`static int`	`K_MERGE`
`static int`	`K_MERGEE`
`static int`	`K_MERGEU`
`static int`	`K_MERGEV`
`static int`	`K_MIN`
`static int`	`K_MINUS`
`static int`	`K_MINUTE`
`static int`	`K_MIXED`
`static int`	`K_MULT`
`static int`	`K_N`
`static int`	`K_NAN`
`static int`	`K_NEGATE`
`static int`	`K_NEQ`
`static int`	`K_NEW`
`static int`	`K_NEXT`
`static int`	`K_NONE`
`static int`	`K_NORMSACK`
`static int`	`K_NOT`
`static int`	`K_NOTCONTAINING`
`static int`	`K_NOTENDINGWITH`
`static int`	`K_NOTREGEX`
`static int`	`K_NOTSTARTINGWITH`
`static int`	`K_NULL`
`static int`	`K_NULLU`
`static int`	`K_NUMBER`
`static int`	`K_NUMBERU`
`static int`	`K_ONCREATE`
`static int`	`K_ONMATCH`
`static int`	`K_OPERATOR`
`static int`	`K_OPTION`
`static int`	`K_OPTIONAL`
`static int`	`K_OR`
`static int`	`K_ORDER`
`static int`	`K_ORDERU`
`static int`	`K_OTHERV`
`static int`	`K_OUT`
`static int`	`K_OUTE`
`static int`	`K_OUTSIDE`
`static int`	`K_OUTU`
`static int`	`K_OUTV`
`static int`	`K_P`
`static int`	`K_PAGERANK`
`static int`	`K_PAGERANKU`
`static int`	`K_PATH`
`static int`	`K_PATHU`
`static int`	`K_PEERPRESSURE`
`static int`	`K_PEERPRESSUREU`
`static int`	`K_PICK`
`static int`	`K_POP`
`static int`	`K_PRODUCT`
`static int`	`K_PROFILE`
`static int`	`K_PROJECT`
`static int`	`K_PROPERTIES`
`static int`	`K_PROPERTY`
`static int`	`K_PROPERTYMAP`
`static int`	`K_PROPERTYNAME`
`static int`	`K_PROPERTYU`
`static int`	`K_RANGE`
`static int`	`K_READ`
`static int`	`K_READER`
`static int`	`K_REGEX`
`static int`	`K_REPEAT`
`static int`	`K_REPLACE`
`static int`	`K_REVERSE`
`static int`	`K_ROLLBACK`
`static int`	`K_RTRIM`
`static int`	`K_SACK`
`static int`	`K_SAMPLE`
`static int`	`K_SCOPE`
`static int`	`K_SECOND`
`static int`	`K_SELECT`
`static int`	`K_SET`
`static int`	`K_SETU`
`static int`	`K_SHORT`
`static int`	`K_SHORTESTPATH`
`static int`	`K_SHORTESTPATHU`
`static int`	`K_SHORTU`
`static int`	`K_SHUFFLE`
`static int`	`K_SIDEEFFECT`
`static int`	`K_SIMPLEPATH`
`static int`	`K_SINGLE`
`static int`	`K_SKIP`
`static int`	`K_SPLIT`
`static int`	`K_STARTINGWITH`
`static int`	`K_STORE`
`static int`	`K_STRING`
`static int`	`K_STRINGU`
`static int`	`K_SUBGRAPH`
`static int`	`K_SUBSTRING`
`static int`	`K_SUM`
`static int`	`K_SUMLONG`
`static int`	`K_T`
`static int`	`K_TAIL`
`static int`	`K_TARGET`
`static int`	`K_TEXTP`
`static int`	`K_TIMELIMIT`
`static int`	`K_TIMES`
`static int`	`K_TO`
`static int`	`K_TOBULKSET`
`static int`	`K_TOE`
`static int`	`K_TOKENS`
`static int`	`K_TOLIST`
`static int`	`K_TOLOWER`
`static int`	`K_TOSET`
`static int`	`K_TOSTRING`
`static int`	`K_TOUPPER`
`static int`	`K_TOV`
`static int`	`K_TREE`
`static int`	`K_TREEU`
`static int`	`K_TRIM`
`static int`	`K_TRUE`
`static int`	`K_TRYNEXT`
`static int`	`K_TX`
`static int`	`K_TYPEOF`
`static int`	`K_UNFOLD`
`static int`	`K_UNION`
`static int`	`K_UNPRODUCTIVE`
`static int`	`K_UNTIL`
`static int`	`K_UUID`
`static int`	`K_UUIDL`
`static int`	`K_V`
`static int`	`K_VALUE`
`static int`	`K_VALUEMAP`
`static int`	`K_VALUES`
`static int`	`K_VERTEX`
`static int`	`K_VERTEXU`
`static int`	`K_VPROPERTY`
`static int`	`K_VPROPERTYU`
`static int`	`K_WHERE`
`static int`	`K_WITH`
`static int`	`K_WITHBULK`
`static int`	`K_WITHIN`
`static int`	`K_WITHOPTOPTIONS`
`static int`	`K_WITHOUT`
`static int`	`K_WITHOUTSTRATEGIES`
`static int`	`K_WITHPATH`
`static int`	`K_WITHSACK`
`static int`	`K_WITHSIDEEFFECT`
`static int`	`K_WITHSTRATEGIES`
`static int`	`K_WRITE`
`static int`	`K_WRITER`
`static int`	`LBRACE`
`static int`	`LBRACK`
`static int`	`LINE_COMMENT`
`static int`	`LPAREN`
`static int`	`NonEmptyStringLiteral`
`static int`	`RBRACE`
`static int`	`RBRACK`
`static int`	`RPAREN`
`static int`	`RULE_booleanArgument`
`static int`	`RULE_booleanLiteral`
`static int`	`RULE_chainedTraversal`
`static int`	`RULE_classType`
`static int`	`RULE_classTypeExpr`
`static int`	`RULE_classTypeList`
`static int`	`RULE_configuration`
`static int`	`RULE_connectedComponentConstants`
`static int`	`RULE_connectedComponentConstants_component`
`static int`	`RULE_connectedComponentConstants_edges`
`static int`	`RULE_connectedComponentConstants_propertyName`
`static int`	`RULE_connectedComponentStringConstant`
`static int`	`RULE_dateArgument`
`static int`	`RULE_dateLiteral`
`static int`	`RULE_emptyQuery`
`static int`	`RULE_floatArgument`
`static int`	`RULE_floatLiteral`
`static int`	`RULE_genericArgument`
`static int`	`RULE_genericArgumentVarargs`
`static int`	`RULE_genericCollectionLiteral`
`static int`	`RULE_genericLiteral`
`static int`	`RULE_genericLiteralExpr`
`static int`	`RULE_genericLiteralVarargs`
`static int`	`RULE_genericMapArgument`
`static int`	`RULE_genericMapLiteral`
`static int`	`RULE_genericMapNullableArgument`
`static int`	`RULE_genericMapNullableLiteral`
`static int`	`RULE_genericRangeLiteral`
`static int`	`RULE_genericSetLiteral`
`static int`	`RULE_infLiteral`
`static int`	`RULE_integerArgument`
`static int`	`RULE_integerLiteral`
`static int`	`RULE_ioOptionsConstants_graphml`
`static int`	`RULE_ioOptionsConstants_graphson`
`static int`	`RULE_ioOptionsConstants_gryo`
`static int`	`RULE_ioOptionsConstants_reader`
`static int`	`RULE_ioOptionsConstants_writer`
`static int`	`RULE_ioOptionsKeys`
`static int`	`RULE_ioOptionsStringConstant`
`static int`	`RULE_ioOptionsValues`
`static int`	`RULE_keyword`
`static int`	`RULE_mapEntry`
`static int`	`RULE_mapKey`
`static int`	`RULE_nakedKey`
`static int`	`RULE_nanLiteral`
`static int`	`RULE_nestedTraversal`
`static int`	`RULE_nestedTraversalExpr`
`static int`	`RULE_nestedTraversalList`
`static int`	`RULE_nullLiteral`
`static int`	`RULE_numericLiteral`
`static int`	`RULE_pageRankConstants`
`static int`	`RULE_pageRankConstants_edges`
`static int`	`RULE_pageRankConstants_propertyName`
`static int`	`RULE_pageRankConstants_times`
`static int`	`RULE_pageRankStringConstant`
`static int`	`RULE_peerPressureConstants`
`static int`	`RULE_peerPressureConstants_edges`
`static int`	`RULE_peerPressureConstants_propertyName`
`static int`	`RULE_peerPressureConstants_times`
`static int`	`RULE_peerPressureStringConstant`
`static int`	`RULE_query`
`static int`	`RULE_queryList`
`static int`	`RULE_rootTraversal`
`static int`	`RULE_shortestPathConstants`
`static int`	`RULE_shortestPathConstants_distance`
`static int`	`RULE_shortestPathConstants_edges`
`static int`	`RULE_shortestPathConstants_includeEdges`
`static int`	`RULE_shortestPathConstants_maxDistance`
`static int`	`RULE_shortestPathConstants_target`
`static int`	`RULE_shortestPathStringConstant`
`static int`	`RULE_stringArgument`
`static int`	`RULE_stringLiteral`
`static int`	`RULE_stringNullableArgument`
`static int`	`RULE_stringNullableArgumentVarargs`
`static int`	`RULE_stringNullableLiteral`
`static int`	`RULE_stringNullableLiteralVarargs`
`static int`	`RULE_terminatedTraversal`
`static int`	`RULE_transactionPart`
`static int`	`RULE_traversalBarrier`
`static int`	`RULE_traversalBiFunction`
`static int`	`RULE_traversalCardinality`
`static int`	`RULE_traversalColumn`
`static int`	`RULE_traversalComparator`
`static int`	`RULE_traversalDirection`
`static int`	`RULE_traversalDirectionLong`
`static int`	`RULE_traversalDirectionShort`
`static int`	`RULE_traversalDT`
`static int`	`RULE_traversalFunction`
`static int`	`RULE_traversalGType`
`static int`	`RULE_traversalMerge`
`static int`	`RULE_traversalMethod`
`static int`	`RULE_traversalMethod_addE`
`static int`	`RULE_traversalMethod_addV`
`static int`	`RULE_traversalMethod_aggregate`
`static int`	`RULE_traversalMethod_all`
`static int`	`RULE_traversalMethod_and`
`static int`	`RULE_traversalMethod_any`
`static int`	`RULE_traversalMethod_as`
`static int`	`RULE_traversalMethod_asBool`
`static int`	`RULE_traversalMethod_asDate`
`static int`	`RULE_traversalMethod_asNumber`
`static int`	`RULE_traversalMethod_asString`
`static int`	`RULE_traversalMethod_barrier`
`static int`	`RULE_traversalMethod_both`
`static int`	`RULE_traversalMethod_bothE`
`static int`	`RULE_traversalMethod_bothV`
`static int`	`RULE_traversalMethod_branch`
`static int`	`RULE_traversalMethod_by`
`static int`	`RULE_traversalMethod_call`
`static int`	`RULE_traversalMethod_cap`
`static int`	`RULE_traversalMethod_choose`
`static int`	`RULE_traversalMethod_coalesce`
`static int`	`RULE_traversalMethod_coin`
`static int`	`RULE_traversalMethod_combine`
`static int`	`RULE_traversalMethod_concat`
`static int`	`RULE_traversalMethod_conjoin`
`static int`	`RULE_traversalMethod_connectedComponent`
`static int`	`RULE_traversalMethod_constant`
`static int`	`RULE_traversalMethod_count`
`static int`	`RULE_traversalMethod_cyclicPath`
`static int`	`RULE_traversalMethod_dateAdd`
`static int`	`RULE_traversalMethod_dateDiff`
`static int`	`RULE_traversalMethod_dedup`
`static int`	`RULE_traversalMethod_difference`
`static int`	`RULE_traversalMethod_discard`
`static int`	`RULE_traversalMethod_disjunct`
`static int`	`RULE_traversalMethod_drop`
`static int`	`RULE_traversalMethod_E`
`static int`	`RULE_traversalMethod_element`
`static int`	`RULE_traversalMethod_elementMap`
`static int`	`RULE_traversalMethod_emit`
`static int`	`RULE_traversalMethod_fail`
`static int`	`RULE_traversalMethod_filter`
`static int`	`RULE_traversalMethod_flatMap`
`static int`	`RULE_traversalMethod_fold`
`static int`	`RULE_traversalMethod_format`
`static int`	`RULE_traversalMethod_from`
`static int`	`RULE_traversalMethod_group`
`static int`	`RULE_traversalMethod_groupCount`
`static int`	`RULE_traversalMethod_has`
`static int`	`RULE_traversalMethod_hasId`
`static int`	`RULE_traversalMethod_hasKey`
`static int`	`RULE_traversalMethod_hasLabel`
`static int`	`RULE_traversalMethod_hasNot`
`static int`	`RULE_traversalMethod_hasValue`
`static int`	`RULE_traversalMethod_id`
`static int`	`RULE_traversalMethod_identity`
`static int`	`RULE_traversalMethod_in`
`static int`	`RULE_traversalMethod_index`
`static int`	`RULE_traversalMethod_inE`
`static int`	`RULE_traversalMethod_inject`
`static int`	`RULE_traversalMethod_intersect`
`static int`	`RULE_traversalMethod_inV`
`static int`	`RULE_traversalMethod_is`
`static int`	`RULE_traversalMethod_key`
`static int`	`RULE_traversalMethod_label`
`static int`	`RULE_traversalMethod_length`
`static int`	`RULE_traversalMethod_limit`
`static int`	`RULE_traversalMethod_local`
`static int`	`RULE_traversalMethod_loops`
`static int`	`RULE_traversalMethod_lTrim`
`static int`	`RULE_traversalMethod_map`
`static int`	`RULE_traversalMethod_match`
`static int`	`RULE_traversalMethod_math`
`static int`	`RULE_traversalMethod_max`
`static int`	`RULE_traversalMethod_mean`
`static int`	`RULE_traversalMethod_merge`
`static int`	`RULE_traversalMethod_mergeE`
`static int`	`RULE_traversalMethod_mergeV`
`static int`	`RULE_traversalMethod_min`
`static int`	`RULE_traversalMethod_none`
`static int`	`RULE_traversalMethod_not`
`static int`	`RULE_traversalMethod_option`
`static int`	`RULE_traversalMethod_optional`
`static int`	`RULE_traversalMethod_or`
`static int`	`RULE_traversalMethod_order`
`static int`	`RULE_traversalMethod_otherV`
`static int`	`RULE_traversalMethod_out`
`static int`	`RULE_traversalMethod_outE`
`static int`	`RULE_traversalMethod_outV`
`static int`	`RULE_traversalMethod_pageRank`
`static int`	`RULE_traversalMethod_path`
`static int`	`RULE_traversalMethod_peerPressure`
`static int`	`RULE_traversalMethod_product`
`static int`	`RULE_traversalMethod_profile`
`static int`	`RULE_traversalMethod_project`
`static int`	`RULE_traversalMethod_properties`
`static int`	`RULE_traversalMethod_property`
`static int`	`RULE_traversalMethod_propertyMap`
`static int`	`RULE_traversalMethod_range`
`static int`	`RULE_traversalMethod_read`
`static int`	`RULE_traversalMethod_repeat`
`static int`	`RULE_traversalMethod_replace`
`static int`	`RULE_traversalMethod_reverse`
`static int`	`RULE_traversalMethod_rTrim`
`static int`	`RULE_traversalMethod_sack`
`static int`	`RULE_traversalMethod_sample`
`static int`	`RULE_traversalMethod_select`
`static int`	`RULE_traversalMethod_shortestPath`
`static int`	`RULE_traversalMethod_sideEffect`
`static int`	`RULE_traversalMethod_simplePath`
`static int`	`RULE_traversalMethod_skip`
`static int`	`RULE_traversalMethod_split`
`static int`	`RULE_traversalMethod_store`
`static int`	`RULE_traversalMethod_subgraph`
`static int`	`RULE_traversalMethod_substring`
`static int`	`RULE_traversalMethod_sum`
`static int`	`RULE_traversalMethod_tail`
`static int`	`RULE_traversalMethod_timeLimit`
`static int`	`RULE_traversalMethod_times`
`static int`	`RULE_traversalMethod_to`
`static int`	`RULE_traversalMethod_toE`
`static int`	`RULE_traversalMethod_toLower`
`static int`	`RULE_traversalMethod_toUpper`
`static int`	`RULE_traversalMethod_toV`
`static int`	`RULE_traversalMethod_tree`
`static int`	`RULE_traversalMethod_trim`
`static int`	`RULE_traversalMethod_unfold`
`static int`	`RULE_traversalMethod_union`
`static int`	`RULE_traversalMethod_until`
`static int`	`RULE_traversalMethod_V`
`static int`	`RULE_traversalMethod_value`
`static int`	`RULE_traversalMethod_valueMap`
`static int`	`RULE_traversalMethod_values`
`static int`	`RULE_traversalMethod_where`
`static int`	`RULE_traversalMethod_with`
`static int`	`RULE_traversalMethod_write`
`static int`	`RULE_traversalOperator`
`static int`	`RULE_traversalOrder`
`static int`	`RULE_traversalPick`
`static int`	`RULE_traversalPop`
`static int`	`RULE_traversalPredicate`
`static int`	`RULE_traversalPredicate_between`
`static int`	`RULE_traversalPredicate_containing`
`static int`	`RULE_traversalPredicate_endingWith`
`static int`	`RULE_traversalPredicate_eq`
`static int`	`RULE_traversalPredicate_gt`
`static int`	`RULE_traversalPredicate_gte`
`static int`	`RULE_traversalPredicate_inside`
`static int`	`RULE_traversalPredicate_lt`
`static int`	`RULE_traversalPredicate_lte`
`static int`	`RULE_traversalPredicate_neq`
`static int`	`RULE_traversalPredicate_not`
`static int`	`RULE_traversalPredicate_notContaining`
`static int`	`RULE_traversalPredicate_notEndingWith`
`static int`	`RULE_traversalPredicate_notRegex`
`static int`	`RULE_traversalPredicate_notStartingWith`
`static int`	`RULE_traversalPredicate_outside`
`static int`	`RULE_traversalPredicate_regex`
`static int`	`RULE_traversalPredicate_startingWith`
`static int`	`RULE_traversalPredicate_typeOf`
`static int`	`RULE_traversalPredicate_within`
`static int`	`RULE_traversalPredicate_without`
`static int`	`RULE_traversalSackMethod`
`static int`	`RULE_traversalScope`
`static int`	`RULE_traversalSource`
`static int`	`RULE_traversalSourceSelfMethod`
`static int`	`RULE_traversalSourceSelfMethod_with`
`static int`	`RULE_traversalSourceSelfMethod_withBulk`
`static int`	`RULE_traversalSourceSelfMethod_withoutStrategies`
`static int`	`RULE_traversalSourceSelfMethod_withPath`
`static int`	`RULE_traversalSourceSelfMethod_withSack`
`static int`	`RULE_traversalSourceSelfMethod_withSideEffect`
`static int`	`RULE_traversalSourceSelfMethod_withStrategies`
`static int`	`RULE_traversalSourceSpawnMethod`
`static int`	`RULE_traversalSourceSpawnMethod_addE`
`static int`	`RULE_traversalSourceSpawnMethod_addV`
`static int`	`RULE_traversalSourceSpawnMethod_call`
`static int`	`RULE_traversalSourceSpawnMethod_E`
`static int`	`RULE_traversalSourceSpawnMethod_inject`
`static int`	`RULE_traversalSourceSpawnMethod_io`
`static int`	`RULE_traversalSourceSpawnMethod_mergeE`
`static int`	`RULE_traversalSourceSpawnMethod_mergeV`
`static int`	`RULE_traversalSourceSpawnMethod_union`
`static int`	`RULE_traversalSourceSpawnMethod_V`
`static int`	`RULE_traversalStrategy`
`static int`	`RULE_traversalStrategyExpr`
`static int`	`RULE_traversalStrategyVarargs`
`static int`	`RULE_traversalT`
`static int`	`RULE_traversalTerminalMethod`
`static int`	`RULE_traversalTerminalMethod_explain`
`static int`	`RULE_traversalTerminalMethod_hasNext`
`static int`	`RULE_traversalTerminalMethod_iterate`
`static int`	`RULE_traversalTerminalMethod_next`
`static int`	`RULE_traversalTerminalMethod_toBulkSet`
`static int`	`RULE_traversalTerminalMethod_toList`
`static int`	`RULE_traversalTerminalMethod_toSet`
`static int`	`RULE_traversalTerminalMethod_tryNext`
`static int`	`RULE_traversalTLong`
`static int`	`RULE_traversalTShort`
`static int`	`RULE_uuidLiteral`
`static int`	`RULE_variable`
`static int`	`RULE_withOptionKeys`
`static int`	`RULE_withOptionsConstants_all`
`static int`	`RULE_withOptionsConstants_ids`
`static int`	`RULE_withOptionsConstants_indexer`
`static int`	`RULE_withOptionsConstants_keys`
`static int`	`RULE_withOptionsConstants_labels`
`static int`	`RULE_withOptionsConstants_list`
`static int`	`RULE_withOptionsConstants_map`
`static int`	`RULE_withOptionsConstants_none`
`static int`	`RULE_withOptionsConstants_tokens`
`static int`	`RULE_withOptionsConstants_values`
`static int`	`RULE_withOptionsStringConstant`
`static int`	`RULE_withOptionsValues`
`static String[]`	`ruleNames`
`static int`	`SEMI`
`static int`	`SignedInfLiteral`
`static String[]`	`tokenNames`	Deprecated. Use `VOCABULARY` instead.
`static int`	`TRAVERSAL_ROOT`
`static org.antlr.v4.runtime.Vocabulary`	`VOCABULARY`
`static int`	`WS`

Fields inherited from class org.antlr.v4.runtime.Parser
_buildParseTrees, _ctx, _errHandler, _input, _parseListeners, _precedenceStack, _syntaxErrors, matchedEOF

Fields inherited from class org.antlr.v4.runtime.Recognizer
_interp, EOF

Constructor Summary

Constructors
Constructor Description

GremlinParser(org.antlr.v4.runtime.TokenStream input)

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`GremlinParser.BooleanArgumentContext`	`booleanArgument()`
`GremlinParser.BooleanLiteralContext`	`booleanLiteral()`
`GremlinParser.ChainedTraversalContext`	`chainedTraversal()`
`GremlinParser.ClassTypeContext`	`classType()`
`GremlinParser.ClassTypeExprContext`	`classTypeExpr()`
`GremlinParser.ClassTypeListContext`	`classTypeList()`
`GremlinParser.ConfigurationContext`	`configuration()`
`GremlinParser.ConnectedComponentConstantsContext`	`connectedComponentConstants()`
`GremlinParser.ConnectedComponentConstants_componentContext`	`connectedComponentConstants_component()`
`GremlinParser.ConnectedComponentConstants_edgesContext`	`connectedComponentConstants_edges()`
`GremlinParser.ConnectedComponentConstants_propertyNameContext`	`connectedComponentConstants_propertyName()`
`GremlinParser.ConnectedComponentStringConstantContext`	`connectedComponentStringConstant()`
`GremlinParser.DateArgumentContext`	`dateArgument()`
`GremlinParser.DateLiteralContext`	`dateLiteral()`
`GremlinParser.EmptyQueryContext`	`emptyQuery()`
`GremlinParser.FloatArgumentContext`	`floatArgument()`
`GremlinParser.FloatLiteralContext`	`floatLiteral()`
`GremlinParser.GenericArgumentContext`	`genericArgument()`
`GremlinParser.GenericArgumentVarargsContext`	`genericArgumentVarargs()`
`GremlinParser.GenericCollectionLiteralContext`	`genericCollectionLiteral()`
`GremlinParser.GenericLiteralContext`	`genericLiteral()`
`GremlinParser.GenericLiteralExprContext`	`genericLiteralExpr()`
`GremlinParser.GenericLiteralVarargsContext`	`genericLiteralVarargs()`
`GremlinParser.GenericMapArgumentContext`	`genericMapArgument()`
`GremlinParser.GenericMapLiteralContext`	`genericMapLiteral()`
`GremlinParser.GenericMapNullableArgumentContext`	`genericMapNullableArgument()`
`GremlinParser.GenericMapNullableLiteralContext`	`genericMapNullableLiteral()`
`GremlinParser.GenericRangeLiteralContext`	`genericRangeLiteral()`
`GremlinParser.GenericSetLiteralContext`	`genericSetLiteral()`
`org.antlr.v4.runtime.atn.ATN`	`getATN()`
`String`	`getGrammarFileName()`
`String[]`	`getRuleNames()`
`String`	`getSerializedATN()`
`String[]`	`getTokenNames()`	Deprecated.
`org.antlr.v4.runtime.Vocabulary`	`getVocabulary()`
`GremlinParser.InfLiteralContext`	`infLiteral()`
`GremlinParser.IntegerArgumentContext`	`integerArgument()`
`GremlinParser.IntegerLiteralContext`	`integerLiteral()`
`GremlinParser.IoOptionsConstants_graphmlContext`	`ioOptionsConstants_graphml()`
`GremlinParser.IoOptionsConstants_graphsonContext`	`ioOptionsConstants_graphson()`
`GremlinParser.IoOptionsConstants_gryoContext`	`ioOptionsConstants_gryo()`
`GremlinParser.IoOptionsConstants_readerContext`	`ioOptionsConstants_reader()`
`GremlinParser.IoOptionsConstants_writerContext`	`ioOptionsConstants_writer()`
`GremlinParser.IoOptionsKeysContext`	`ioOptionsKeys()`
`GremlinParser.IoOptionsStringConstantContext`	`ioOptionsStringConstant()`
`GremlinParser.IoOptionsValuesContext`	`ioOptionsValues()`
`GremlinParser.KeywordContext`	`keyword()`
`GremlinParser.MapEntryContext`	`mapEntry()`
`GremlinParser.MapKeyContext`	`mapKey()`
`GremlinParser.NakedKeyContext`	`nakedKey()`
`GremlinParser.NanLiteralContext`	`nanLiteral()`
`GremlinParser.NestedTraversalContext`	`nestedTraversal()`
`GremlinParser.NestedTraversalExprContext`	`nestedTraversalExpr()`
`GremlinParser.NestedTraversalListContext`	`nestedTraversalList()`
`GremlinParser.NullLiteralContext`	`nullLiteral()`
`GremlinParser.NumericLiteralContext`	`numericLiteral()`
`GremlinParser.PageRankConstantsContext`	`pageRankConstants()`
`GremlinParser.PageRankConstants_edgesContext`	`pageRankConstants_edges()`
`GremlinParser.PageRankConstants_propertyNameContext`	`pageRankConstants_propertyName()`
`GremlinParser.PageRankConstants_timesContext`	`pageRankConstants_times()`
`GremlinParser.PageRankStringConstantContext`	`pageRankStringConstant()`
`GremlinParser.PeerPressureConstantsContext`	`peerPressureConstants()`
`GremlinParser.PeerPressureConstants_edgesContext`	`peerPressureConstants_edges()`
`GremlinParser.PeerPressureConstants_propertyNameContext`	`peerPressureConstants_propertyName()`
`GremlinParser.PeerPressureConstants_timesContext`	`peerPressureConstants_times()`
`GremlinParser.PeerPressureStringConstantContext`	`peerPressureStringConstant()`
`GremlinParser.QueryContext`	`query()`
`GremlinParser.QueryListContext`	`queryList()`
`GremlinParser.RootTraversalContext`	`rootTraversal()`
`boolean`	`sempred(org.antlr.v4.runtime.RuleContext _localctx, int ruleIndex, int predIndex)`
`GremlinParser.ShortestPathConstantsContext`	`shortestPathConstants()`
`GremlinParser.ShortestPathConstants_distanceContext`	`shortestPathConstants_distance()`
`GremlinParser.ShortestPathConstants_edgesContext`	`shortestPathConstants_edges()`
`GremlinParser.ShortestPathConstants_includeEdgesContext`	`shortestPathConstants_includeEdges()`
`GremlinParser.ShortestPathConstants_maxDistanceContext`	`shortestPathConstants_maxDistance()`
`GremlinParser.ShortestPathConstants_targetContext`	`shortestPathConstants_target()`
`GremlinParser.ShortestPathStringConstantContext`	`shortestPathStringConstant()`
`GremlinParser.StringArgumentContext`	`stringArgument()`
`GremlinParser.StringLiteralContext`	`stringLiteral()`
`GremlinParser.StringNullableArgumentContext`	`stringNullableArgument()`
`GremlinParser.StringNullableArgumentVarargsContext`	`stringNullableArgumentVarargs()`
`GremlinParser.StringNullableLiteralContext`	`stringNullableLiteral()`
`GremlinParser.StringNullableLiteralVarargsContext`	`stringNullableLiteralVarargs()`
`GremlinParser.TerminatedTraversalContext`	`terminatedTraversal()`
`GremlinParser.TransactionPartContext`	`transactionPart()`
`GremlinParser.TraversalBarrierContext`	`traversalBarrier()`
`GremlinParser.TraversalBiFunctionContext`	`traversalBiFunction()`
`GremlinParser.TraversalCardinalityContext`	`traversalCardinality()`
`GremlinParser.TraversalColumnContext`	`traversalColumn()`
`GremlinParser.TraversalComparatorContext`	`traversalComparator()`
`GremlinParser.TraversalDirectionContext`	`traversalDirection()`
`GremlinParser.TraversalDirectionLongContext`	`traversalDirectionLong()`
`GremlinParser.TraversalDirectionShortContext`	`traversalDirectionShort()`
`GremlinParser.TraversalDTContext`	`traversalDT()`
`GremlinParser.TraversalFunctionContext`	`traversalFunction()`
`GremlinParser.TraversalGTypeContext`	`traversalGType()`
`GremlinParser.TraversalMergeContext`	`traversalMerge()`
`GremlinParser.TraversalMethodContext`	`traversalMethod()`
`GremlinParser.TraversalMethod_addEContext`	`traversalMethod_addE()`
`GremlinParser.TraversalMethod_addVContext`	`traversalMethod_addV()`
`GremlinParser.TraversalMethod_aggregateContext`	`traversalMethod_aggregate()`
`GremlinParser.TraversalMethod_allContext`	`traversalMethod_all()`
`GremlinParser.TraversalMethod_andContext`	`traversalMethod_and()`
`GremlinParser.TraversalMethod_anyContext`	`traversalMethod_any()`
`GremlinParser.TraversalMethod_asContext`	`traversalMethod_as()`
`GremlinParser.TraversalMethod_asBoolContext`	`traversalMethod_asBool()`
`GremlinParser.TraversalMethod_asDateContext`	`traversalMethod_asDate()`
`GremlinParser.TraversalMethod_asNumberContext`	`traversalMethod_asNumber()`
`GremlinParser.TraversalMethod_asStringContext`	`traversalMethod_asString()`
`GremlinParser.TraversalMethod_barrierContext`	`traversalMethod_barrier()`
`GremlinParser.TraversalMethod_bothContext`	`traversalMethod_both()`
`GremlinParser.TraversalMethod_bothEContext`	`traversalMethod_bothE()`
`GremlinParser.TraversalMethod_bothVContext`	`traversalMethod_bothV()`
`GremlinParser.TraversalMethod_branchContext`	`traversalMethod_branch()`
`GremlinParser.TraversalMethod_byContext`	`traversalMethod_by()`
`GremlinParser.TraversalMethod_callContext`	`traversalMethod_call()`
`GremlinParser.TraversalMethod_capContext`	`traversalMethod_cap()`
`GremlinParser.TraversalMethod_chooseContext`	`traversalMethod_choose()`
`GremlinParser.TraversalMethod_coalesceContext`	`traversalMethod_coalesce()`
`GremlinParser.TraversalMethod_coinContext`	`traversalMethod_coin()`
`GremlinParser.TraversalMethod_combineContext`	`traversalMethod_combine()`
`GremlinParser.TraversalMethod_concatContext`	`traversalMethod_concat()`
`GremlinParser.TraversalMethod_conjoinContext`	`traversalMethod_conjoin()`
`GremlinParser.TraversalMethod_connectedComponentContext`	`traversalMethod_connectedComponent()`
`GremlinParser.TraversalMethod_constantContext`	`traversalMethod_constant()`
`GremlinParser.TraversalMethod_countContext`	`traversalMethod_count()`
`GremlinParser.TraversalMethod_cyclicPathContext`	`traversalMethod_cyclicPath()`
`GremlinParser.TraversalMethod_dateAddContext`	`traversalMethod_dateAdd()`
`GremlinParser.TraversalMethod_dateDiffContext`	`traversalMethod_dateDiff()`
`GremlinParser.TraversalMethod_dedupContext`	`traversalMethod_dedup()`
`GremlinParser.TraversalMethod_differenceContext`	`traversalMethod_difference()`
`GremlinParser.TraversalMethod_discardContext`	`traversalMethod_discard()`
`GremlinParser.TraversalMethod_disjunctContext`	`traversalMethod_disjunct()`
`GremlinParser.TraversalMethod_dropContext`	`traversalMethod_drop()`
`GremlinParser.TraversalMethod_EContext`	`traversalMethod_E()`
`GremlinParser.TraversalMethod_elementContext`	`traversalMethod_element()`
`GremlinParser.TraversalMethod_elementMapContext`	`traversalMethod_elementMap()`
`GremlinParser.TraversalMethod_emitContext`	`traversalMethod_emit()`
`GremlinParser.TraversalMethod_failContext`	`traversalMethod_fail()`
`GremlinParser.TraversalMethod_filterContext`	`traversalMethod_filter()`
`GremlinParser.TraversalMethod_flatMapContext`	`traversalMethod_flatMap()`
`GremlinParser.TraversalMethod_foldContext`	`traversalMethod_fold()`
`GremlinParser.TraversalMethod_formatContext`	`traversalMethod_format()`
`GremlinParser.TraversalMethod_fromContext`	`traversalMethod_from()`
`GremlinParser.TraversalMethod_groupContext`	`traversalMethod_group()`
`GremlinParser.TraversalMethod_groupCountContext`	`traversalMethod_groupCount()`
`GremlinParser.TraversalMethod_hasContext`	`traversalMethod_has()`
`GremlinParser.TraversalMethod_hasIdContext`	`traversalMethod_hasId()`
`GremlinParser.TraversalMethod_hasKeyContext`	`traversalMethod_hasKey()`
`GremlinParser.TraversalMethod_hasLabelContext`	`traversalMethod_hasLabel()`
`GremlinParser.TraversalMethod_hasNotContext`	`traversalMethod_hasNot()`
`GremlinParser.TraversalMethod_hasValueContext`	`traversalMethod_hasValue()`
`GremlinParser.TraversalMethod_idContext`	`traversalMethod_id()`
`GremlinParser.TraversalMethod_identityContext`	`traversalMethod_identity()`
`GremlinParser.TraversalMethod_inContext`	`traversalMethod_in()`
`GremlinParser.TraversalMethod_indexContext`	`traversalMethod_index()`
`GremlinParser.TraversalMethod_inEContext`	`traversalMethod_inE()`
`GremlinParser.TraversalMethod_injectContext`	`traversalMethod_inject()`
`GremlinParser.TraversalMethod_intersectContext`	`traversalMethod_intersect()`
`GremlinParser.TraversalMethod_inVContext`	`traversalMethod_inV()`
`GremlinParser.TraversalMethod_isContext`	`traversalMethod_is()`
`GremlinParser.TraversalMethod_keyContext`	`traversalMethod_key()`
`GremlinParser.TraversalMethod_labelContext`	`traversalMethod_label()`
`GremlinParser.TraversalMethod_lengthContext`	`traversalMethod_length()`
`GremlinParser.TraversalMethod_limitContext`	`traversalMethod_limit()`
`GremlinParser.TraversalMethod_localContext`	`traversalMethod_local()`
`GremlinParser.TraversalMethod_loopsContext`	`traversalMethod_loops()`
`GremlinParser.TraversalMethod_lTrimContext`	`traversalMethod_lTrim()`
`GremlinParser.TraversalMethod_mapContext`	`traversalMethod_map()`
`GremlinParser.TraversalMethod_matchContext`	`traversalMethod_match()`
`GremlinParser.TraversalMethod_mathContext`	`traversalMethod_math()`
`GremlinParser.TraversalMethod_maxContext`	`traversalMethod_max()`
`GremlinParser.TraversalMethod_meanContext`	`traversalMethod_mean()`
`GremlinParser.TraversalMethod_mergeContext`	`traversalMethod_merge()`
`GremlinParser.TraversalMethod_mergeEContext`	`traversalMethod_mergeE()`
`GremlinParser.TraversalMethod_mergeVContext`	`traversalMethod_mergeV()`
`GremlinParser.TraversalMethod_minContext`	`traversalMethod_min()`
`GremlinParser.TraversalMethod_noneContext`	`traversalMethod_none()`
`GremlinParser.TraversalMethod_notContext`	`traversalMethod_not()`
`GremlinParser.TraversalMethod_optionContext`	`traversalMethod_option()`
`GremlinParser.TraversalMethod_optionalContext`	`traversalMethod_optional()`
`GremlinParser.TraversalMethod_orContext`	`traversalMethod_or()`
`GremlinParser.TraversalMethod_orderContext`	`traversalMethod_order()`
`GremlinParser.TraversalMethod_otherVContext`	`traversalMethod_otherV()`
`GremlinParser.TraversalMethod_outContext`	`traversalMethod_out()`
`GremlinParser.TraversalMethod_outEContext`	`traversalMethod_outE()`
`GremlinParser.TraversalMethod_outVContext`	`traversalMethod_outV()`
`GremlinParser.TraversalMethod_pageRankContext`	`traversalMethod_pageRank()`
`GremlinParser.TraversalMethod_pathContext`	`traversalMethod_path()`
`GremlinParser.TraversalMethod_peerPressureContext`	`traversalMethod_peerPressure()`
`GremlinParser.TraversalMethod_productContext`	`traversalMethod_product()`
`GremlinParser.TraversalMethod_profileContext`	`traversalMethod_profile()`
`GremlinParser.TraversalMethod_projectContext`	`traversalMethod_project()`
`GremlinParser.TraversalMethod_propertiesContext`	`traversalMethod_properties()`
`GremlinParser.TraversalMethod_propertyContext`	`traversalMethod_property()`
`GremlinParser.TraversalMethod_propertyMapContext`	`traversalMethod_propertyMap()`
`GremlinParser.TraversalMethod_rangeContext`	`traversalMethod_range()`
`GremlinParser.TraversalMethod_readContext`	`traversalMethod_read()`
`GremlinParser.TraversalMethod_repeatContext`	`traversalMethod_repeat()`
`GremlinParser.TraversalMethod_replaceContext`	`traversalMethod_replace()`
`GremlinParser.TraversalMethod_reverseContext`	`traversalMethod_reverse()`
`GremlinParser.TraversalMethod_rTrimContext`	`traversalMethod_rTrim()`
`GremlinParser.TraversalMethod_sackContext`	`traversalMethod_sack()`
`GremlinParser.TraversalMethod_sampleContext`	`traversalMethod_sample()`
`GremlinParser.TraversalMethod_selectContext`	`traversalMethod_select()`
`GremlinParser.TraversalMethod_shortestPathContext`	`traversalMethod_shortestPath()`
`GremlinParser.TraversalMethod_sideEffectContext`	`traversalMethod_sideEffect()`
`GremlinParser.TraversalMethod_simplePathContext`	`traversalMethod_simplePath()`
`GremlinParser.TraversalMethod_skipContext`	`traversalMethod_skip()`
`GremlinParser.TraversalMethod_splitContext`	`traversalMethod_split()`
`GremlinParser.TraversalMethod_storeContext`	`traversalMethod_store()`
`GremlinParser.TraversalMethod_subgraphContext`	`traversalMethod_subgraph()`
`GremlinParser.TraversalMethod_substringContext`	`traversalMethod_substring()`
`GremlinParser.TraversalMethod_sumContext`	`traversalMethod_sum()`
`GremlinParser.TraversalMethod_tailContext`	`traversalMethod_tail()`
`GremlinParser.TraversalMethod_timeLimitContext`	`traversalMethod_timeLimit()`
`GremlinParser.TraversalMethod_timesContext`	`traversalMethod_times()`
`GremlinParser.TraversalMethod_toContext`	`traversalMethod_to()`
`GremlinParser.TraversalMethod_toEContext`	`traversalMethod_toE()`
`GremlinParser.TraversalMethod_toLowerContext`	`traversalMethod_toLower()`
`GremlinParser.TraversalMethod_toUpperContext`	`traversalMethod_toUpper()`
`GremlinParser.TraversalMethod_toVContext`	`traversalMethod_toV()`
`GremlinParser.TraversalMethod_treeContext`	`traversalMethod_tree()`
`GremlinParser.TraversalMethod_trimContext`	`traversalMethod_trim()`
`GremlinParser.TraversalMethod_unfoldContext`	`traversalMethod_unfold()`
`GremlinParser.TraversalMethod_unionContext`	`traversalMethod_union()`
`GremlinParser.TraversalMethod_untilContext`	`traversalMethod_until()`
`GremlinParser.TraversalMethod_VContext`	`traversalMethod_V()`
`GremlinParser.TraversalMethod_valueContext`	`traversalMethod_value()`
`GremlinParser.TraversalMethod_valueMapContext`	`traversalMethod_valueMap()`
`GremlinParser.TraversalMethod_valuesContext`	`traversalMethod_values()`
`GremlinParser.TraversalMethod_whereContext`	`traversalMethod_where()`
`GremlinParser.TraversalMethod_withContext`	`traversalMethod_with()`
`GremlinParser.TraversalMethod_writeContext`	`traversalMethod_write()`
`GremlinParser.TraversalOperatorContext`	`traversalOperator()`
`GremlinParser.TraversalOrderContext`	`traversalOrder()`
`GremlinParser.TraversalPickContext`	`traversalPick()`
`GremlinParser.TraversalPopContext`	`traversalPop()`
`GremlinParser.TraversalPredicateContext`	`traversalPredicate()`
`GremlinParser.TraversalPredicate_betweenContext`	`traversalPredicate_between()`
`GremlinParser.TraversalPredicate_containingContext`	`traversalPredicate_containing()`
`GremlinParser.TraversalPredicate_endingWithContext`	`traversalPredicate_endingWith()`
`GremlinParser.TraversalPredicate_eqContext`	`traversalPredicate_eq()`
`GremlinParser.TraversalPredicate_gtContext`	`traversalPredicate_gt()`
`GremlinParser.TraversalPredicate_gteContext`	`traversalPredicate_gte()`
`GremlinParser.TraversalPredicate_insideContext`	`traversalPredicate_inside()`
`GremlinParser.TraversalPredicate_ltContext`	`traversalPredicate_lt()`
`GremlinParser.TraversalPredicate_lteContext`	`traversalPredicate_lte()`
`GremlinParser.TraversalPredicate_neqContext`	`traversalPredicate_neq()`
`GremlinParser.TraversalPredicate_notContext`	`traversalPredicate_not()`
`GremlinParser.TraversalPredicate_notContainingContext`	`traversalPredicate_notContaining()`
`GremlinParser.TraversalPredicate_notEndingWithContext`	`traversalPredicate_notEndingWith()`
`GremlinParser.TraversalPredicate_notRegexContext`	`traversalPredicate_notRegex()`
`GremlinParser.TraversalPredicate_notStartingWithContext`	`traversalPredicate_notStartingWith()`
`GremlinParser.TraversalPredicate_outsideContext`	`traversalPredicate_outside()`
`GremlinParser.TraversalPredicate_regexContext`	`traversalPredicate_regex()`
`GremlinParser.TraversalPredicate_startingWithContext`	`traversalPredicate_startingWith()`
`GremlinParser.TraversalPredicate_typeOfContext`	`traversalPredicate_typeOf()`
`GremlinParser.TraversalPredicate_withinContext`	`traversalPredicate_within()`
`GremlinParser.TraversalPredicate_withoutContext`	`traversalPredicate_without()`
`GremlinParser.TraversalSackMethodContext`	`traversalSackMethod()`
`GremlinParser.TraversalScopeContext`	`traversalScope()`
`GremlinParser.TraversalSourceContext`	`traversalSource()`
`GremlinParser.TraversalSourceSelfMethodContext`	`traversalSourceSelfMethod()`
`GremlinParser.TraversalSourceSelfMethod_withContext`	`traversalSourceSelfMethod_with()`
`GremlinParser.TraversalSourceSelfMethod_withBulkContext`	`traversalSourceSelfMethod_withBulk()`
`GremlinParser.TraversalSourceSelfMethod_withoutStrategiesContext`	`traversalSourceSelfMethod_withoutStrategies()`
`GremlinParser.TraversalSourceSelfMethod_withPathContext`	`traversalSourceSelfMethod_withPath()`
`GremlinParser.TraversalSourceSelfMethod_withSackContext`	`traversalSourceSelfMethod_withSack()`
`GremlinParser.TraversalSourceSelfMethod_withSideEffectContext`	`traversalSourceSelfMethod_withSideEffect()`
`GremlinParser.TraversalSourceSelfMethod_withStrategiesContext`	`traversalSourceSelfMethod_withStrategies()`
`GremlinParser.TraversalSourceSpawnMethodContext`	`traversalSourceSpawnMethod()`
`GremlinParser.TraversalSourceSpawnMethod_addEContext`	`traversalSourceSpawnMethod_addE()`
`GremlinParser.TraversalSourceSpawnMethod_addVContext`	`traversalSourceSpawnMethod_addV()`
`GremlinParser.TraversalSourceSpawnMethod_callContext`	`traversalSourceSpawnMethod_call()`
`GremlinParser.TraversalSourceSpawnMethod_EContext`	`traversalSourceSpawnMethod_E()`
`GremlinParser.TraversalSourceSpawnMethod_injectContext`	`traversalSourceSpawnMethod_inject()`
`GremlinParser.TraversalSourceSpawnMethod_ioContext`	`traversalSourceSpawnMethod_io()`
`GremlinParser.TraversalSourceSpawnMethod_mergeEContext`	`traversalSourceSpawnMethod_mergeE()`
`GremlinParser.TraversalSourceSpawnMethod_mergeVContext`	`traversalSourceSpawnMethod_mergeV()`
`GremlinParser.TraversalSourceSpawnMethod_unionContext`	`traversalSourceSpawnMethod_union()`
`GremlinParser.TraversalSourceSpawnMethod_VContext`	`traversalSourceSpawnMethod_V()`
`GremlinParser.TraversalStrategyContext`	`traversalStrategy()`
`GremlinParser.TraversalStrategyExprContext`	`traversalStrategyExpr()`
`GremlinParser.TraversalStrategyVarargsContext`	`traversalStrategyVarargs()`
`GremlinParser.TraversalTContext`	`traversalT()`
`GremlinParser.TraversalTerminalMethodContext`	`traversalTerminalMethod()`
`GremlinParser.TraversalTerminalMethod_explainContext`	`traversalTerminalMethod_explain()`
`GremlinParser.TraversalTerminalMethod_hasNextContext`	`traversalTerminalMethod_hasNext()`
`GremlinParser.TraversalTerminalMethod_iterateContext`	`traversalTerminalMethod_iterate()`
`GremlinParser.TraversalTerminalMethod_nextContext`	`traversalTerminalMethod_next()`
`GremlinParser.TraversalTerminalMethod_toBulkSetContext`	`traversalTerminalMethod_toBulkSet()`
`GremlinParser.TraversalTerminalMethod_toListContext`	`traversalTerminalMethod_toList()`
`GremlinParser.TraversalTerminalMethod_toSetContext`	`traversalTerminalMethod_toSet()`
`GremlinParser.TraversalTerminalMethod_tryNextContext`	`traversalTerminalMethod_tryNext()`
`GremlinParser.TraversalTLongContext`	`traversalTLong()`
`GremlinParser.TraversalTShortContext`	`traversalTShort()`
`GremlinParser.UuidLiteralContext`	`uuidLiteral()`
`GremlinParser.VariableContext`	`variable()`
`GremlinParser.WithOptionKeysContext`	`withOptionKeys()`
`GremlinParser.WithOptionsConstants_allContext`	`withOptionsConstants_all()`
`GremlinParser.WithOptionsConstants_idsContext`	`withOptionsConstants_ids()`
`GremlinParser.WithOptionsConstants_indexerContext`	`withOptionsConstants_indexer()`
`GremlinParser.WithOptionsConstants_keysContext`	`withOptionsConstants_keys()`
`GremlinParser.WithOptionsConstants_labelsContext`	`withOptionsConstants_labels()`
`GremlinParser.WithOptionsConstants_listContext`	`withOptionsConstants_list()`
`GremlinParser.WithOptionsConstants_mapContext`	`withOptionsConstants_map()`
`GremlinParser.WithOptionsConstants_noneContext`	`withOptionsConstants_none()`
`GremlinParser.WithOptionsConstants_tokensContext`	`withOptionsConstants_tokens()`
`GremlinParser.WithOptionsConstants_valuesContext`	`withOptionsConstants_values()`
`GremlinParser.WithOptionsStringConstantContext`	`withOptionsStringConstant()`
`GremlinParser.WithOptionsValuesContext`	`withOptionsValues()`

Methods inherited from class org.antlr.v4.runtime.Parser
addContextToParseTree, addParseListener, compileParseTreePattern, compileParseTreePattern, consume, createErrorNode, createTerminalNode, dumpDFA, enterOuterAlt, enterRecursionRule, enterRecursionRule, enterRule, exitRule, getATNWithBypassAlts, getBuildParseTree, getContext, getCurrentToken, getDFAStrings, getErrorHandler, getExpectedTokens, getExpectedTokensWithinCurrentRule, getInputStream, getInvokingContext, getNumberOfSyntaxErrors, getParseInfo, getParseListeners, getPrecedence, getRuleContext, getRuleIndex, getRuleInvocationStack, getRuleInvocationStack, getSourceName, getTokenFactory, getTokenStream, getTrimParseTree, inContext, isExpectedToken, isMatchedEOF, isTrace, match, matchWildcard, notifyErrorListeners, notifyErrorListeners, precpred, pushNewRecursionContext, removeParseListener, removeParseListeners, reset, setBuildParseTree, setContext, setErrorHandler, setInputStream, setProfile, setTokenFactory, setTokenStream, setTrace, setTrimParseTree, triggerEnterRuleEvent, triggerExitRuleEvent, unrollRecursionContexts

Methods inherited from class org.antlr.v4.runtime.Recognizer
action, addErrorListener, getErrorHeader, getErrorListenerDispatch, getErrorListeners, getInterpreter, getRuleIndexMap, getState, getTokenErrorDisplay, getTokenType, getTokenTypeMap, removeErrorListener, removeErrorListeners, setInterpreter, setState

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

Field Detail
- _decisionToDFA
```
protected static final org.antlr.v4.runtime.dfa.DFA[] _decisionToDFA
```
- _sharedContextCache
```
protected static final org.antlr.v4.runtime.atn.PredictionContextCache _sharedContextCache
```
- K_ADDALL
```
public static final int K_ADDALL
```
  See Also:
  
  Constant Field Values
- K_ADDE
```
public static final int K_ADDE
```
  See Also:
  
  Constant Field Values
- K_ADDV
```
public static final int K_ADDV
```
  See Also:
  
  Constant Field Values
- K_AGGREGATE
```
public static final int K_AGGREGATE
```
  See Also:
  
  Constant Field Values
- K_ALL
```
public static final int K_ALL
```
  See Also:
  
  Constant Field Values
- K_AND
```
public static final int K_AND
```
  See Also:
  
  Constant Field Values
- K_ANY
```
public static final int K_ANY
```
  See Also:
  
  Constant Field Values
- K_AS
```
public static final int K_AS
```
  See Also:
  
  Constant Field Values
- K_ASBOOL
```
public static final int K_ASBOOL
```
  See Also:
  
  Constant Field Values
- K_ASC
```
public static final int K_ASC
```
  See Also:
  
  Constant Field Values
- K_ASDATE
```
public static final int K_ASDATE
```
  See Also:
  
  Constant Field Values
- K_ASNUMBER
```
public static final int K_ASNUMBER
```
  See Also:
  
  Constant Field Values
- K_ASSTRING
```
public static final int K_ASSTRING
```
  See Also:
  
  Constant Field Values
- K_ASSIGN
```
public static final int K_ASSIGN
```
  See Also:
  
  Constant Field Values
- K_BARRIER
```
public static final int K_BARRIER
```
  See Also:
  
  Constant Field Values
- K_BARRIERU
```
public static final int K_BARRIERU
```
  See Also:
  
  Constant Field Values
- K_BEGIN
```
public static final int K_BEGIN
```
  See Also:
  
  Constant Field Values
- K_BETWEEN
```
public static final int K_BETWEEN
```
  See Also:
  
  Constant Field Values
- K_BIGDECIMAL
```
public static final int K_BIGDECIMAL
```
  See Also:
  
  Constant Field Values
- K_BIGDECIMALU
```
public static final int K_BIGDECIMALU
```
  See Also:
  
  Constant Field Values
- K_BIGINT
```
public static final int K_BIGINT
```
  See Also:
  
  Constant Field Values
- K_BIGINTU
```
public static final int K_BIGINTU
```
  See Also:
  
  Constant Field Values
- K_BINARY
```
public static final int K_BINARY
```
  See Also:
  
  Constant Field Values
- K_BINARYU
```
public static final int K_BINARYU
```
  See Also:
  
  Constant Field Values
- K_BOOLEAN
```
public static final int K_BOOLEAN
```
  See Also:
  
  Constant Field Values
- K_BOOLEANU
```
public static final int K_BOOLEANU
```
  See Also:
  
  Constant Field Values
- K_BOTH
```
public static final int K_BOTH
```
  See Also:
  
  Constant Field Values
- K_BOTHU
```
public static final int K_BOTHU
```
  See Also:
  
  Constant Field Values
- K_BOTHE
```
public static final int K_BOTHE
```
  See Also:
  
  Constant Field Values
- K_BOTHV
```
public static final int K_BOTHV
```
  See Also:
  
  Constant Field Values
- K_BRANCH
```
public static final int K_BRANCH
```
  See Also:
  
  Constant Field Values
- K_BY
```
public static final int K_BY
```
  See Also:
  
  Constant Field Values
- K_BYTE
```
public static final int K_BYTE
```
  See Also:
  
  Constant Field Values
- K_BYTEU
```
public static final int K_BYTEU
```
  See Also:
  
  Constant Field Values
- K_CALL
```
public static final int K_CALL
```
  See Also:
  
  Constant Field Values
- K_CAP
```
public static final int K_CAP
```
  See Also:
  
  Constant Field Values
- K_CARDINALITY
```
public static final int K_CARDINALITY
```
  See Also:
  
  Constant Field Values
- K_CHAR
```
public static final int K_CHAR
```
  See Also:
  
  Constant Field Values
- K_CHARU
```
public static final int K_CHARU
```
  See Also:
  
  Constant Field Values
- K_CHOOSE
```
public static final int K_CHOOSE
```
  See Also:
  
  Constant Field Values
- K_COALESCE
```
public static final int K_COALESCE
```
  See Also:
  
  Constant Field Values
- K_COIN
```
public static final int K_COIN
```
  See Also:
  
  Constant Field Values
- K_COLUMN
```
public static final int K_COLUMN
```
  See Also:
  
  Constant Field Values
- K_COMBINE
```
public static final int K_COMBINE
```
  See Also:
  
  Constant Field Values
- K_COMMIT
```
public static final int K_COMMIT
```
  See Also:
  
  Constant Field Values
- K_COMPONENT
```
public static final int K_COMPONENT
```
  See Also:
  
  Constant Field Values
- K_CONCAT
```
public static final int K_CONCAT
```
  See Also:
  
  Constant Field Values
- K_CONJOIN
```
public static final int K_CONJOIN
```
  See Also:
  
  Constant Field Values
- K_CONNECTEDCOMPONENT
```
public static final int K_CONNECTEDCOMPONENT
```
  See Also:
  
  Constant Field Values
- K_CONNECTEDCOMPONENTU
```
public static final int K_CONNECTEDCOMPONENTU
```
  See Also:
  
  Constant Field Values
- K_CONSTANT
```
public static final int K_CONSTANT
```
  See Also:
  
  Constant Field Values
- K_CONTAINING
```
public static final int K_CONTAINING
```
  See Also:
  
  Constant Field Values
- K_COUNT
```
public static final int K_COUNT
```
  See Also:
  
  Constant Field Values
- K_CYCLICPATH
```
public static final int K_CYCLICPATH
```
  See Also:
  
  Constant Field Values
- K_DAY
```
public static final int K_DAY
```
  See Also:
  
  Constant Field Values
- K_DATEADD
```
public static final int K_DATEADD
```
  See Also:
  
  Constant Field Values
- K_DATEDIFF
```
public static final int K_DATEDIFF
```
  See Also:
  
  Constant Field Values
- K_DATETIME
```
public static final int K_DATETIME
```
  See Also:
  
  Constant Field Values
- K_DATETIMEC
```
public static final int K_DATETIMEC
```
  See Also:
  
  Constant Field Values
- K_DATETIMEU
```
public static final int K_DATETIMEU
```
  See Also:
  
  Constant Field Values
- K_DECR
```
public static final int K_DECR
```
  See Also:
  
  Constant Field Values
- K_DEDUP
```
public static final int K_DEDUP
```
  See Also:
  
  Constant Field Values
- K_DESC
```
public static final int K_DESC
```
  See Also:
  
  Constant Field Values
- K_DIFFERENCE
```
public static final int K_DIFFERENCE
```
  See Also:
  
  Constant Field Values
- K_DISCARD
```
public static final int K_DISCARD
```
  See Also:
  
  Constant Field Values
- K_DIRECTION
```
public static final int K_DIRECTION
```
  See Also:
  
  Constant Field Values
- K_DISJUNCT
```
public static final int K_DISJUNCT
```
  See Also:
  
  Constant Field Values
- K_DISTANCE
```
public static final int K_DISTANCE
```
  See Also:
  
  Constant Field Values
- K_DIV
```
public static final int K_DIV
```
  See Also:
  
  Constant Field Values
- K_DOUBLE
```
public static final int K_DOUBLE
```
  See Also:
  
  Constant Field Values
- K_DOUBLEU
```
public static final int K_DOUBLEU
```
  See Also:
  
  Constant Field Values
- K_DROP
```
public static final int K_DROP
```
  See Also:
  
  Constant Field Values
- K_DT
```
public static final int K_DT
```
  See Also:
  
  Constant Field Values
- K_DURATION
```
public static final int K_DURATION
```
  See Also:
  
  Constant Field Values
- K_DURATIONU
```
public static final int K_DURATIONU
```
  See Also:
  
  Constant Field Values
- K_E
```
public static final int K_E
```
  See Also:
  
  Constant Field Values
- K_EDGE
```
public static final int K_EDGE
```
  See Also:
  
  Constant Field Values
- K_EDGEU
```
public static final int K_EDGEU
```
  See Also:
  
  Constant Field Values
- K_EDGES
```
public static final int K_EDGES
```
  See Also:
  
  Constant Field Values
- K_ELEMENTMAP
```
public static final int K_ELEMENTMAP
```
  See Also:
  
  Constant Field Values
- K_ELEMENT
```
public static final int K_ELEMENT
```
  See Also:
  
  Constant Field Values
- K_EMIT
```
public static final int K_EMIT
```
  See Also:
  
  Constant Field Values
- K_ENDINGWITH
```
public static final int K_ENDINGWITH
```
  See Also:
  
  Constant Field Values
- K_EQ
```
public static final int K_EQ
```
  See Also:
  
  Constant Field Values
- K_EXPLAIN
```
public static final int K_EXPLAIN
```
  See Also:
  
  Constant Field Values
- K_FAIL
```
public static final int K_FAIL
```
  See Also:
  
  Constant Field Values
- K_FALSE
```
public static final int K_FALSE
```
  See Also:
  
  Constant Field Values
- K_FILTER
```
public static final int K_FILTER
```
  See Also:
  
  Constant Field Values
- K_FIRST
```
public static final int K_FIRST
```
  See Also:
  
  Constant Field Values
- K_FLATMAP
```
public static final int K_FLATMAP
```
  See Also:
  
  Constant Field Values
- K_FLOAT
```
public static final int K_FLOAT
```
  See Also:
  
  Constant Field Values
- K_FLOATU
```
public static final int K_FLOATU
```
  See Also:
  
  Constant Field Values
- K_FOLD
```
public static final int K_FOLD
```
  See Also:
  
  Constant Field Values
- K_FORMAT
```
public static final int K_FORMAT
```
  See Also:
  
  Constant Field Values
- K_FROM
```
public static final int K_FROM
```
  See Also:
  
  Constant Field Values
- K_GLOBAL
```
public static final int K_GLOBAL
```
  See Also:
  
  Constant Field Values
- K_GT
```
public static final int K_GT
```
  See Also:
  
  Constant Field Values
- K_GTE
```
public static final int K_GTE
```
  See Also:
  
  Constant Field Values
- K_GTYPE
```
public static final int K_GTYPE
```
  See Also:
  
  Constant Field Values
- K_GRAPHML
```
public static final int K_GRAPHML
```
  See Also:
  
  Constant Field Values
- K_GRAPHSON
```
public static final int K_GRAPHSON
```
  See Also:
  
  Constant Field Values
- K_GROUPCOUNT
```
public static final int K_GROUPCOUNT
```
  See Also:
  
  Constant Field Values
- K_GROUP
```
public static final int K_GROUP
```
  See Also:
  
  Constant Field Values
- K_GRYO
```
public static final int K_GRYO
```
  See Also:
  
  Constant Field Values
- K_GRAPH
```
public static final int K_GRAPH
```
  See Also:
  
  Constant Field Values
- K_GRAPHU
```
public static final int K_GRAPHU
```
  See Also:
  
  Constant Field Values
- K_HAS
```
public static final int K_HAS
```
  See Also:
  
  Constant Field Values
- K_HASID
```
public static final int K_HASID
```
  See Also:
  
  Constant Field Values
- K_HASKEY
```
public static final int K_HASKEY
```
  See Also:
  
  Constant Field Values
- K_HASLABEL
```
public static final int K_HASLABEL
```
  See Also:
  
  Constant Field Values
- K_HASNEXT
```
public static final int K_HASNEXT
```
  See Also:
  
  Constant Field Values
- K_HASNOT
```
public static final int K_HASNOT
```
  See Also:
  
  Constant Field Values
- K_HASVALUE
```
public static final int K_HASVALUE
```
  See Also:
  
  Constant Field Values
- K_HOUR
```
public static final int K_HOUR
```
  See Also:
  
  Constant Field Values
- K_ID
```
public static final int K_ID
```
  See Also:
  
  Constant Field Values
- K_IDENTITY
```
public static final int K_IDENTITY
```
  See Also:
  
  Constant Field Values
- K_IDS
```
public static final int K_IDS
```
  See Also:
  
  Constant Field Values
- K_IN
```
public static final int K_IN
```
  See Also:
  
  Constant Field Values
- K_INU
```
public static final int K_INU
```
  See Also:
  
  Constant Field Values
- K_INE
```
public static final int K_INE
```
  See Also:
  
  Constant Field Values
- K_INCLUDEEDGES
```
public static final int K_INCLUDEEDGES
```
  See Also:
  
  Constant Field Values
- K_INCR
```
public static final int K_INCR
```
  See Also:
  
  Constant Field Values
- K_INDEXER
```
public static final int K_INDEXER
```
  See Also:
  
  Constant Field Values
- K_INDEX
```
public static final int K_INDEX
```
  See Also:
  
  Constant Field Values
- K_INFINITY
```
public static final int K_INFINITY
```
  See Also:
  
  Constant Field Values
- K_INJECT
```
public static final int K_INJECT
```
  See Also:
  
  Constant Field Values
- K_INSIDE
```
public static final int K_INSIDE
```
  See Also:
  
  Constant Field Values
- K_INT
```
public static final int K_INT
```
  See Also:
  
  Constant Field Values
- K_INTU
```
public static final int K_INTU
```
  See Also:
  
  Constant Field Values
- K_INTERSECT
```
public static final int K_INTERSECT
```
  See Also:
  
  Constant Field Values
- K_INV
```
public static final int K_INV
```
  See Also:
  
  Constant Field Values
- K_IOU
```
public static final int K_IOU
```
  See Also:
  
  Constant Field Values
- K_IO
```
public static final int K_IO
```
  See Also:
  
  Constant Field Values
- K_IS
```
public static final int K_IS
```
  See Also:
  
  Constant Field Values
- K_ITERATE
```
public static final int K_ITERATE
```
  See Also:
  
  Constant Field Values
- K_KEY
```
public static final int K_KEY
```
  See Also:
  
  Constant Field Values
- K_KEYS
```
public static final int K_KEYS
```
  See Also:
  
  Constant Field Values
- K_LABELS
```
public static final int K_LABELS
```
  See Also:
  
  Constant Field Values
- K_LABEL
```
public static final int K_LABEL
```
  See Also:
  
  Constant Field Values
- K_LAST
```
public static final int K_LAST
```
  See Also:
  
  Constant Field Values
- K_LENGTH
```
public static final int K_LENGTH
```
  See Also:
  
  Constant Field Values
- K_LIMIT
```
public static final int K_LIMIT
```
  See Also:
  
  Constant Field Values
- K_LIST
```
public static final int K_LIST
```
  See Also:
  
  Constant Field Values
- K_LISTU
```
public static final int K_LISTU
```
  See Also:
  
  Constant Field Values
- K_LOCAL
```
public static final int K_LOCAL
```
  See Also:
  
  Constant Field Values
- K_LONG
```
public static final int K_LONG
```
  See Also:
  
  Constant Field Values
- K_LONGU
```
public static final int K_LONGU
```
  See Also:
  
  Constant Field Values
- K_LOOPS
```
public static final int K_LOOPS
```
  See Also:
  
  Constant Field Values
- K_LT
```
public static final int K_LT
```
  See Also:
  
  Constant Field Values
- K_LTE
```
public static final int K_LTE
```
  See Also:
  
  Constant Field Values
- K_LTRIM
```
public static final int K_LTRIM
```
  See Also:
  
  Constant Field Values
- K_MAP
```
public static final int K_MAP
```
  See Also:
  
  Constant Field Values
- K_MAPU
```
public static final int K_MAPU
```
  See Also:
  
  Constant Field Values
- K_MATCH
```
public static final int K_MATCH
```
  See Also:
  
  Constant Field Values
- K_MATH
```
public static final int K_MATH
```
  See Also:
  
  Constant Field Values
- K_MAX
```
public static final int K_MAX
```
  See Also:
  
  Constant Field Values
- K_MAXDISTANCE
```
public static final int K_MAXDISTANCE
```
  See Also:
  
  Constant Field Values
- K_MEAN
```
public static final int K_MEAN
```
  See Also:
  
  Constant Field Values
- K_MERGEU
```
public static final int K_MERGEU
```
  See Also:
  
  Constant Field Values
- K_MERGE
```
public static final int K_MERGE
```
  See Also:
  
  Constant Field Values
- K_MERGEE
```
public static final int K_MERGEE
```
  See Also:
  
  Constant Field Values
- K_MERGEV
```
public static final int K_MERGEV
```
  See Also:
  
  Constant Field Values
- K_MIN
```
public static final int K_MIN
```
  See Also:
  
  Constant Field Values
- K_MINUTE
```
public static final int K_MINUTE
```
  See Also:
  
  Constant Field Values
- K_MINUS
```
public static final int K_MINUS
```
  See Also:
  
  Constant Field Values
- K_MIXED
```
public static final int K_MIXED
```
  See Also:
  
  Constant Field Values
- K_MULT
```
public static final int K_MULT
```
  See Also:
  
  Constant Field Values
- K_N
```
public static final int K_N
```
  See Also:
  
  Constant Field Values
- K_NAN
```
public static final int K_NAN
```
  See Also:
  
  Constant Field Values
- K_NEGATE
```
public static final int K_NEGATE
```
  See Also:
  
  Constant Field Values
- K_NEXT
```
public static final int K_NEXT
```
  See Also:
  
  Constant Field Values
- K_NONE
```
public static final int K_NONE
```
  See Also:
  
  Constant Field Values
- K_NOTREGEX
```
public static final int K_NOTREGEX
```
  See Also:
  
  Constant Field Values
- K_NOTCONTAINING
```
public static final int K_NOTCONTAINING
```
  See Also:
  
  Constant Field Values
- K_NOTENDINGWITH
```
public static final int K_NOTENDINGWITH
```
  See Also:
  
  Constant Field Values
- K_NOTSTARTINGWITH
```
public static final int K_NOTSTARTINGWITH
```
  See Also:
  
  Constant Field Values
- K_NOT
```
public static final int K_NOT
```
  See Also:
  
  Constant Field Values
- K_NEQ
```
public static final int K_NEQ
```
  See Also:
  
  Constant Field Values
- K_NEW
```
public static final int K_NEW
```
  See Also:
  
  Constant Field Values
- K_NORMSACK
```
public static final int K_NORMSACK
```
  See Also:
  
  Constant Field Values
- K_NULL
```
public static final int K_NULL
```
  See Also:
  
  Constant Field Values
- K_NULLU
```
public static final int K_NULLU
```
  See Also:
  
  Constant Field Values
- K_NUMBER
```
public static final int K_NUMBER
```
  See Also:
  
  Constant Field Values
- K_NUMBERU
```
public static final int K_NUMBERU
```
  See Also:
  
  Constant Field Values
- K_ONCREATE
```
public static final int K_ONCREATE
```
  See Also:
  
  Constant Field Values
- K_ONMATCH
```
public static final int K_ONMATCH
```
  See Also:
  
  Constant Field Values
- K_OPERATOR
```
public static final int K_OPERATOR
```
  See Also:
  
  Constant Field Values
- K_OPTION
```
public static final int K_OPTION
```
  See Also:
  
  Constant Field Values
- K_OPTIONAL
```
public static final int K_OPTIONAL
```
  See Also:
  
  Constant Field Values
- K_ORDERU
```
public static final int K_ORDERU
```
  See Also:
  
  Constant Field Values
- K_ORDER
```
public static final int K_ORDER
```
  See Also:
  
  Constant Field Values
- K_OR
```
public static final int K_OR
```
  See Also:
  
  Constant Field Values
- K_OTHERV
```
public static final int K_OTHERV
```
  See Also:
  
  Constant Field Values
- K_OUTU
```
public static final int K_OUTU
```
  See Also:
  
  Constant Field Values
- K_OUT
```
public static final int K_OUT
```
  See Also:
  
  Constant Field Values
- K_OUTE
```
public static final int K_OUTE
```
  See Also:
  
  Constant Field Values
- K_OUTSIDE
```
public static final int K_OUTSIDE
```
  See Also:
  
  Constant Field Values
- K_OUTV
```
public static final int K_OUTV
```
  See Also:
  
  Constant Field Values
- K_P
```
public static final int K_P
```
  See Also:
  
  Constant Field Values
- K_PAGERANKU
```
public static final int K_PAGERANKU
```
  See Also:
  
  Constant Field Values
- K_PAGERANK
```
public static final int K_PAGERANK
```
  See Also:
  
  Constant Field Values
- K_PATH
```
public static final int K_PATH
```
  See Also:
  
  Constant Field Values
- K_PATHU
```
public static final int K_PATHU
```
  See Also:
  
  Constant Field Values
- K_PEERPRESSUREU
```
public static final int K_PEERPRESSUREU
```
  See Also:
  
  Constant Field Values
- K_PEERPRESSURE
```
public static final int K_PEERPRESSURE
```
  See Also:
  
  Constant Field Values
- K_PICK
```
public static final int K_PICK
```
  See Also:
  
  Constant Field Values
- K_POP
```
public static final int K_POP
```
  See Also:
  
  Constant Field Values
- K_PROFILE
```
public static final int K_PROFILE
```
  See Also:
  
  Constant Field Values
- K_PROJECT
```
public static final int K_PROJECT
```
  See Also:
  
  Constant Field Values
- K_PROPERTIES
```
public static final int K_PROPERTIES
```
  See Also:
  
  Constant Field Values
- K_PROPERTYMAP
```
public static final int K_PROPERTYMAP
```
  See Also:
  
  Constant Field Values
- K_PROPERTYNAME
```
public static final int K_PROPERTYNAME
```
  See Also:
  
  Constant Field Values
- K_PROPERTY
```
public static final int K_PROPERTY
```
  See Also:
  
  Constant Field Values
- K_PROPERTYU
```
public static final int K_PROPERTYU
```
  See Also:
  
  Constant Field Values
- K_PRODUCT
```
public static final int K_PRODUCT
```
  See Also:
  
  Constant Field Values
- K_RANGE
```
public static final int K_RANGE
```
  See Also:
  
  Constant Field Values
- K_READ
```
public static final int K_READ
```
  See Also:
  
  Constant Field Values
- K_READER
```
public static final int K_READER
```
  See Also:
  
  Constant Field Values
- K_REGEX
```
public static final int K_REGEX
```
  See Also:
  
  Constant Field Values
- K_REPLACE
```
public static final int K_REPLACE
```
  See Also:
  
  Constant Field Values
- K_REPEAT
```
public static final int K_REPEAT
```
  See Also:
  
  Constant Field Values
- K_REVERSE
```
public static final int K_REVERSE
```
  See Also:
  
  Constant Field Values
- K_ROLLBACK
```
public static final int K_ROLLBACK
```
  See Also:
  
  Constant Field Values
- K_RTRIM
```
public static final int K_RTRIM
```
  See Also:
  
  Constant Field Values
- K_SACK
```
public static final int K_SACK
```
  See Also:
  
  Constant Field Values
- K_SAMPLE
```
public static final int K_SAMPLE
```
  See Also:
  
  Constant Field Values
- K_SCOPE
```
public static final int K_SCOPE
```
  See Also:
  
  Constant Field Values
- K_SECOND
```
public static final int K_SECOND
```
  See Also:
  
  Constant Field Values
- K_SELECT
```
public static final int K_SELECT
```
  See Also:
  
  Constant Field Values
- K_SET
```
public static final int K_SET
```
  See Also:
  
  Constant Field Values
- K_SETU
```
public static final int K_SETU
```
  See Also:
  
  Constant Field Values
- K_SHORTESTPATHU
```
public static final int K_SHORTESTPATHU
```
  See Also:
  
  Constant Field Values
- K_SHORTESTPATH
```
public static final int K_SHORTESTPATH
```
  See Also:
  
  Constant Field Values
- K_SHUFFLE
```
public static final int K_SHUFFLE
```
  See Also:
  
  Constant Field Values
- K_SHORT
```
public static final int K_SHORT
```
  See Also:
  
  Constant Field Values
- K_SHORTU
```
public static final int K_SHORTU
```
  See Also:
  
  Constant Field Values
- K_SIDEEFFECT
```
public static final int K_SIDEEFFECT
```
  See Also:
  
  Constant Field Values
- K_SIMPLEPATH
```
public static final int K_SIMPLEPATH
```
  See Also:
  
  Constant Field Values
- K_SINGLE
```
public static final int K_SINGLE
```
  See Also:
  
  Constant Field Values
- K_SKIP
```
public static final int K_SKIP
```
  See Also:
  
  Constant Field Values
- K_SPLIT
```
public static final int K_SPLIT
```
  See Also:
  
  Constant Field Values
- K_STARTINGWITH
```
public static final int K_STARTINGWITH
```
  See Also:
  
  Constant Field Values
- K_STORE
```
public static final int K_STORE
```
  See Also:
  
  Constant Field Values
- K_STRING
```
public static final int K_STRING
```
  See Also:
  
  Constant Field Values
- K_STRINGU
```
public static final int K_STRINGU
```
  See Also:
  
  Constant Field Values
- K_SUBGRAPH
```
public static final int K_SUBGRAPH
```
  See Also:
  
  Constant Field Values
- K_SUBSTRING
```
public static final int K_SUBSTRING
```
  See Also:
  
  Constant Field Values
- K_SUM
```
public static final int K_SUM
```
  See Also:
  
  Constant Field Values
- K_SUMLONG
```
public static final int K_SUMLONG
```
  See Also:
  
  Constant Field Values
- K_T
```
public static final int K_T
```
  See Also:
  
  Constant Field Values
- K_TAIL
```
public static final int K_TAIL
```
  See Also:
  
  Constant Field Values
- K_TARGET
```
public static final int K_TARGET
```
  See Also:
  
  Constant Field Values
- K_TEXTP
```
public static final int K_TEXTP
```
  See Also:
  
  Constant Field Values
- K_TIMELIMIT
```
public static final int K_TIMELIMIT
```
  See Also:
  
  Constant Field Values
- K_TIMES
```
public static final int K_TIMES
```
  See Also:
  
  Constant Field Values
- K_TO
```
public static final int K_TO
```
  See Also:
  
  Constant Field Values
- K_TOBULKSET
```
public static final int K_TOBULKSET
```
  See Also:
  
  Constant Field Values
- K_TOKENS
```
public static final int K_TOKENS
```
  See Also:
  
  Constant Field Values
- K_TOLIST
```
public static final int K_TOLIST
```
  See Also:
  
  Constant Field Values
- K_TOLOWER
```
public static final int K_TOLOWER
```
  See Also:
  
  Constant Field Values
- K_TOSET
```
public static final int K_TOSET
```
  See Also:
  
  Constant Field Values
- K_TOSTRING
```
public static final int K_TOSTRING
```
  See Also:
  
  Constant Field Values
- K_TOUPPER
```
public static final int K_TOUPPER
```
  See Also:
  
  Constant Field Values
- K_TOE
```
public static final int K_TOE
```
  See Also:
  
  Constant Field Values
- K_TOV
```
public static final int K_TOV
```
  See Also:
  
  Constant Field Values
- K_TREE
```
public static final int K_TREE
```
  See Also:
  
  Constant Field Values
- K_TREEU
```
public static final int K_TREEU
```
  See Also:
  
  Constant Field Values
- K_TRIM
```
public static final int K_TRIM
```
  See Also:
  
  Constant Field Values
- K_TRUE
```
public static final int K_TRUE
```
  See Also:
  
  Constant Field Values
- K_TRYNEXT
```
public static final int K_TRYNEXT
```
  See Also:
  
  Constant Field Values
- K_TYPEOF
```
public static final int K_TYPEOF
```
  See Also:
  
  Constant Field Values
- K_TX
```
public static final int K_TX
```
  See Also:
  
  Constant Field Values
- K_UNFOLD
```
public static final int K_UNFOLD
```
  See Also:
  
  Constant Field Values
- K_UNION
```
public static final int K_UNION
```
  See Also:
  
  Constant Field Values
- K_UNPRODUCTIVE
```
public static final int K_UNPRODUCTIVE
```
  See Also:
  
  Constant Field Values
- K_UNTIL
```
public static final int K_UNTIL
```
  See Also:
  
  Constant Field Values
- K_UUID
```
public static final int K_UUID
```
  See Also:
  
  Constant Field Values
- K_UUIDL
```
public static final int K_UUIDL
```
  See Also:
  
  Constant Field Values
- K_V
```
public static final int K_V
```
  See Also:
  
  Constant Field Values
- K_VALUEMAP
```
public static final int K_VALUEMAP
```
  See Also:
  
  Constant Field Values
- K_VALUES
```
public static final int K_VALUES
```
  See Also:
  
  Constant Field Values
- K_VALUE
```
public static final int K_VALUE
```
  See Also:
  
  Constant Field Values
- K_VERTEX
```
public static final int K_VERTEX
```
  See Also:
  
  Constant Field Values
- K_VERTEXU
```
public static final int K_VERTEXU
```
  See Also:
  
  Constant Field Values
- K_VPROPERTY
```
public static final int K_VPROPERTY
```
  See Also:
  
  Constant Field Values
- K_VPROPERTYU
```
public static final int K_VPROPERTYU
```
  See Also:
  
  Constant Field Values
- K_WHERE
```
public static final int K_WHERE
```
  See Also:
  
  Constant Field Values
- K_WITH
```
public static final int K_WITH
```
  See Also:
  
  Constant Field Values
- K_WITHBULK
```
public static final int K_WITHBULK
```
  See Also:
  
  Constant Field Values
- K_WITHIN
```
public static final int K_WITHIN
```
  See Also:
  
  Constant Field Values
- K_WITHOPTOPTIONS
```
public static final int K_WITHOPTOPTIONS
```
  See Also:
  
  Constant Field Values
- K_WITHOUT
```
public static final int K_WITHOUT
```
  See Also:
  
  Constant Field Values
- K_WITHOUTSTRATEGIES
```
public static final int K_WITHOUTSTRATEGIES
```
  See Also:
  
  Constant Field Values
- K_WITHPATH
```
public static final int K_WITHPATH
```
  See Also:
  
  Constant Field Values
- K_WITHSACK
```
public static final int K_WITHSACK
```
  See Also:
  
  Constant Field Values
- K_WITHSIDEEFFECT
```
public static final int K_WITHSIDEEFFECT
```
  See Also:
  
  Constant Field Values
- K_WITHSTRATEGIES
```
public static final int K_WITHSTRATEGIES
```
  See Also:
  
  Constant Field Values
- K_WRITE
```
public static final int K_WRITE
```
  See Also:
  
  Constant Field Values
- K_WRITER
```
public static final int K_WRITER
```
  See Also:
  
  Constant Field Values
- IntegerLiteral
```
public static final int IntegerLiteral
```
  See Also:
  
  Constant Field Values
- FloatingPointLiteral
```
public static final int FloatingPointLiteral
```
  See Also:
  
  Constant Field Values
- SignedInfLiteral
```
public static final int SignedInfLiteral
```
  See Also:
  
  Constant Field Values
- NonEmptyStringLiteral
```
public static final int NonEmptyStringLiteral
```
  See Also:
  
  Constant Field Values
- EmptyStringLiteral
```
public static final int EmptyStringLiteral
```
  See Also:
  
  Constant Field Values
- LPAREN
```
public static final int LPAREN
```
  See Also:
  
  Constant Field Values
- RPAREN
```
public static final int RPAREN
```
  See Also:
  
  Constant Field Values
- LBRACE
```
public static final int LBRACE
```
  See Also:
  
  Constant Field Values
- RBRACE
```
public static final int RBRACE
```
  See Also:
  
  Constant Field Values
- LBRACK
```
public static final int LBRACK
```
  See Also:
  
  Constant Field Values
- RBRACK
```
public static final int RBRACK
```
  See Also:
  
  Constant Field Values
- SEMI
```
public static final int SEMI
```
  See Also:
  
  Constant Field Values
- COMMA
```
public static final int COMMA
```
  See Also:
  
  Constant Field Values
- DOT
```
public static final int DOT
```
  See Also:
  
  Constant Field Values
- COLON
```
public static final int COLON
```
  See Also:
  
  Constant Field Values
- TRAVERSAL_ROOT
```
public static final int TRAVERSAL_ROOT
```
  See Also:
  
  Constant Field Values
- ANON_TRAVERSAL_ROOT
```
public static final int ANON_TRAVERSAL_ROOT
```
  See Also:
  
  Constant Field Values
- WS
```
public static final int WS
```
  See Also:
  
  Constant Field Values
- LINE_COMMENT
```
public static final int LINE_COMMENT
```
  See Also:
  
  Constant Field Values
- Identifier
```
public static final int Identifier
```
  See Also:
  
  Constant Field Values
- RULE_queryList
```
public static final int RULE_queryList
```
  See Also:
  
  Constant Field Values
- RULE_query
```
public static final int RULE_query
```
  See Also:
  
  Constant Field Values
- RULE_emptyQuery
```
public static final int RULE_emptyQuery
```
  See Also:
  
  Constant Field Values
- RULE_traversalSource
```
public static final int RULE_traversalSource
```
  See Also:
  
  Constant Field Values
- RULE_transactionPart
```
public static final int RULE_transactionPart
```
  See Also:
  
  Constant Field Values
- RULE_rootTraversal
```
public static final int RULE_rootTraversal
```
  See Also:
  
  Constant Field Values
- RULE_traversalSourceSelfMethod
```
public static final int RULE_traversalSourceSelfMethod
```
  See Also:
  
  Constant Field Values
- RULE_traversalSourceSelfMethod_withBulk
```
public static final int RULE_traversalSourceSelfMethod_withBulk
```
  See Also:
  
  Constant Field Values
- RULE_traversalSourceSelfMethod_withPath
```
public static final int RULE_traversalSourceSelfMethod_withPath
```
  See Also:
  
  Constant Field Values
- RULE_traversalSourceSelfMethod_withSack
```
public static final int RULE_traversalSourceSelfMethod_withSack
```
  See Also:
  
  Constant Field Values
- RULE_traversalSourceSelfMethod_withSideEffect
```
public static final int RULE_traversalSourceSelfMethod_withSideEffect
```
  See Also:
  
  Constant Field Values
- RULE_traversalSourceSelfMethod_withStrategies
```
public static final int RULE_traversalSourceSelfMethod_withStrategies
```
  See Also:
  
  Constant Field Values
- RULE_traversalSourceSelfMethod_withoutStrategies
```
public static final int RULE_traversalSourceSelfMethod_withoutStrategies
```
  See Also:
  
  Constant Field Values
- RULE_traversalSourceSelfMethod_with
```
public static final int RULE_traversalSourceSelfMethod_with
```
  See Also:
  
  Constant Field Values
- RULE_traversalSourceSpawnMethod
```
public static final int RULE_traversalSourceSpawnMethod
```
  See Also:
  
  Constant Field Values
- RULE_traversalSourceSpawnMethod_addE
```
public static final int RULE_traversalSourceSpawnMethod_addE
```
  See Also:
  
  Constant Field Values
- RULE_traversalSourceSpawnMethod_addV
```
public static final int RULE_traversalSourceSpawnMethod_addV
```
  See Also:
  
  Constant Field Values
- RULE_traversalSourceSpawnMethod_E
```
public static final int RULE_traversalSourceSpawnMethod_E
```
  See Also:
  
  Constant Field Values
- RULE_traversalSourceSpawnMethod_V
```
public static final int RULE_traversalSourceSpawnMethod_V
```
  See Also:
  
  Constant Field Values
- RULE_traversalSourceSpawnMethod_inject
```
public static final int RULE_traversalSourceSpawnMethod_inject
```
  See Also:
  
  Constant Field Values
- RULE_traversalSourceSpawnMethod_io
```
public static final int RULE_traversalSourceSpawnMethod_io
```
  See Also:
  
  Constant Field Values
- RULE_traversalSourceSpawnMethod_mergeV
```
public static final int RULE_traversalSourceSpawnMethod_mergeV
```
  See Also:
  
  Constant Field Values
- RULE_traversalSourceSpawnMethod_mergeE
```
public static final int RULE_traversalSourceSpawnMethod_mergeE
```
  See Also:
  
  Constant Field Values
- RULE_traversalSourceSpawnMethod_call
```
public static final int RULE_traversalSourceSpawnMethod_call
```
  See Also:
  
  Constant Field Values
- RULE_traversalSourceSpawnMethod_union
```
public static final int RULE_traversalSourceSpawnMethod_union
```
  See Also:
  
  Constant Field Values
- RULE_chainedTraversal
```
public static final int RULE_chainedTraversal
```
  See Also:
  
  Constant Field Values
- RULE_nestedTraversal
```
public static final int RULE_nestedTraversal
```
  See Also:
  
  Constant Field Values
- RULE_terminatedTraversal
```
public static final int RULE_terminatedTraversal
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod
```
public static final int RULE_traversalMethod
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_V
```
public static final int RULE_traversalMethod_V
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_E
```
public static final int RULE_traversalMethod_E
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_addE
```
public static final int RULE_traversalMethod_addE
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_addV
```
public static final int RULE_traversalMethod_addV
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_aggregate
```
public static final int RULE_traversalMethod_aggregate
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_all
```
public static final int RULE_traversalMethod_all
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_and
```
public static final int RULE_traversalMethod_and
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_any
```
public static final int RULE_traversalMethod_any
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_as
```
public static final int RULE_traversalMethod_as
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_asBool
```
public static final int RULE_traversalMethod_asBool
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_asDate
```
public static final int RULE_traversalMethod_asDate
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_asNumber
```
public static final int RULE_traversalMethod_asNumber
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_asString
```
public static final int RULE_traversalMethod_asString
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_barrier
```
public static final int RULE_traversalMethod_barrier
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_both
```
public static final int RULE_traversalMethod_both
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_bothE
```
public static final int RULE_traversalMethod_bothE
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_bothV
```
public static final int RULE_traversalMethod_bothV
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_branch
```
public static final int RULE_traversalMethod_branch
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_by
```
public static final int RULE_traversalMethod_by
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_call
```
public static final int RULE_traversalMethod_call
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_cap
```
public static final int RULE_traversalMethod_cap
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_choose
```
public static final int RULE_traversalMethod_choose
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_coalesce
```
public static final int RULE_traversalMethod_coalesce
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_coin
```
public static final int RULE_traversalMethod_coin
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_combine
```
public static final int RULE_traversalMethod_combine
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_concat
```
public static final int RULE_traversalMethod_concat
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_conjoin
```
public static final int RULE_traversalMethod_conjoin
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_connectedComponent
```
public static final int RULE_traversalMethod_connectedComponent
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_constant
```
public static final int RULE_traversalMethod_constant
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_count
```
public static final int RULE_traversalMethod_count
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_cyclicPath
```
public static final int RULE_traversalMethod_cyclicPath
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_dateAdd
```
public static final int RULE_traversalMethod_dateAdd
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_dateDiff
```
public static final int RULE_traversalMethod_dateDiff
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_dedup
```
public static final int RULE_traversalMethod_dedup
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_difference
```
public static final int RULE_traversalMethod_difference
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_discard
```
public static final int RULE_traversalMethod_discard
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_disjunct
```
public static final int RULE_traversalMethod_disjunct
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_drop
```
public static final int RULE_traversalMethod_drop
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_element
```
public static final int RULE_traversalMethod_element
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_elementMap
```
public static final int RULE_traversalMethod_elementMap
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_emit
```
public static final int RULE_traversalMethod_emit
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_fail
```
public static final int RULE_traversalMethod_fail
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_filter
```
public static final int RULE_traversalMethod_filter
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_flatMap
```
public static final int RULE_traversalMethod_flatMap
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_fold
```
public static final int RULE_traversalMethod_fold
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_format
```
public static final int RULE_traversalMethod_format
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_from
```
public static final int RULE_traversalMethod_from
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_group
```
public static final int RULE_traversalMethod_group
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_groupCount
```
public static final int RULE_traversalMethod_groupCount
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_has
```
public static final int RULE_traversalMethod_has
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_hasId
```
public static final int RULE_traversalMethod_hasId
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_hasKey
```
public static final int RULE_traversalMethod_hasKey
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_hasLabel
```
public static final int RULE_traversalMethod_hasLabel
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_hasNot
```
public static final int RULE_traversalMethod_hasNot
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_hasValue
```
public static final int RULE_traversalMethod_hasValue
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_id
```
public static final int RULE_traversalMethod_id
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_identity
```
public static final int RULE_traversalMethod_identity
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_in
```
public static final int RULE_traversalMethod_in
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_inE
```
public static final int RULE_traversalMethod_inE
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_intersect
```
public static final int RULE_traversalMethod_intersect
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_inV
```
public static final int RULE_traversalMethod_inV
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_index
```
public static final int RULE_traversalMethod_index
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_inject
```
public static final int RULE_traversalMethod_inject
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_is
```
public static final int RULE_traversalMethod_is
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_key
```
public static final int RULE_traversalMethod_key
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_label
```
public static final int RULE_traversalMethod_label
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_length
```
public static final int RULE_traversalMethod_length
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_limit
```
public static final int RULE_traversalMethod_limit
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_local
```
public static final int RULE_traversalMethod_local
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_loops
```
public static final int RULE_traversalMethod_loops
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_lTrim
```
public static final int RULE_traversalMethod_lTrim
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_map
```
public static final int RULE_traversalMethod_map
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_match
```
public static final int RULE_traversalMethod_match
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_math
```
public static final int RULE_traversalMethod_math
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_max
```
public static final int RULE_traversalMethod_max
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_mean
```
public static final int RULE_traversalMethod_mean
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_merge
```
public static final int RULE_traversalMethod_merge
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_mergeV
```
public static final int RULE_traversalMethod_mergeV
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_mergeE
```
public static final int RULE_traversalMethod_mergeE
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_min
```
public static final int RULE_traversalMethod_min
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_none
```
public static final int RULE_traversalMethod_none
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_not
```
public static final int RULE_traversalMethod_not
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_option
```
public static final int RULE_traversalMethod_option
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_optional
```
public static final int RULE_traversalMethod_optional
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_or
```
public static final int RULE_traversalMethod_or
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_order
```
public static final int RULE_traversalMethod_order
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_otherV
```
public static final int RULE_traversalMethod_otherV
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_out
```
public static final int RULE_traversalMethod_out
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_outE
```
public static final int RULE_traversalMethod_outE
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_outV
```
public static final int RULE_traversalMethod_outV
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_pageRank
```
public static final int RULE_traversalMethod_pageRank
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_path
```
public static final int RULE_traversalMethod_path
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_peerPressure
```
public static final int RULE_traversalMethod_peerPressure
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_product
```
public static final int RULE_traversalMethod_product
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_profile
```
public static final int RULE_traversalMethod_profile
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_project
```
public static final int RULE_traversalMethod_project
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_properties
```
public static final int RULE_traversalMethod_properties
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_property
```
public static final int RULE_traversalMethod_property
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_propertyMap
```
public static final int RULE_traversalMethod_propertyMap
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_range
```
public static final int RULE_traversalMethod_range
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_read
```
public static final int RULE_traversalMethod_read
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_repeat
```
public static final int RULE_traversalMethod_repeat
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_replace
```
public static final int RULE_traversalMethod_replace
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_reverse
```
public static final int RULE_traversalMethod_reverse
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_rTrim
```
public static final int RULE_traversalMethod_rTrim
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_sack
```
public static final int RULE_traversalMethod_sack
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_sample
```
public static final int RULE_traversalMethod_sample
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_select
```
public static final int RULE_traversalMethod_select
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_shortestPath
```
public static final int RULE_traversalMethod_shortestPath
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_sideEffect
```
public static final int RULE_traversalMethod_sideEffect
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_simplePath
```
public static final int RULE_traversalMethod_simplePath
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_skip
```
public static final int RULE_traversalMethod_skip
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_split
```
public static final int RULE_traversalMethod_split
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_store
```
public static final int RULE_traversalMethod_store
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_subgraph
```
public static final int RULE_traversalMethod_subgraph
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_substring
```
public static final int RULE_traversalMethod_substring
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_sum
```
public static final int RULE_traversalMethod_sum
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_tail
```
public static final int RULE_traversalMethod_tail
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_timeLimit
```
public static final int RULE_traversalMethod_timeLimit
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_times
```
public static final int RULE_traversalMethod_times
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_to
```
public static final int RULE_traversalMethod_to
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_toE
```
public static final int RULE_traversalMethod_toE
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_toLower
```
public static final int RULE_traversalMethod_toLower
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_toUpper
```
public static final int RULE_traversalMethod_toUpper
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_toV
```
public static final int RULE_traversalMethod_toV
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_tree
```
public static final int RULE_traversalMethod_tree
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_trim
```
public static final int RULE_traversalMethod_trim
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_unfold
```
public static final int RULE_traversalMethod_unfold
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_union
```
public static final int RULE_traversalMethod_union
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_until
```
public static final int RULE_traversalMethod_until
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_value
```
public static final int RULE_traversalMethod_value
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_valueMap
```
public static final int RULE_traversalMethod_valueMap
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_values
```
public static final int RULE_traversalMethod_values
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_where
```
public static final int RULE_traversalMethod_where
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_with
```
public static final int RULE_traversalMethod_with
```
  See Also:
  
  Constant Field Values
- RULE_traversalMethod_write
```
public static final int RULE_traversalMethod_write
```
  See Also:
  
  Constant Field Values
- RULE_traversalStrategy
```
public static final int RULE_traversalStrategy
```
  See Also:
  
  Constant Field Values
- RULE_configuration
```
public static final int RULE_configuration
```
  See Also:
  
  Constant Field Values
- RULE_traversalScope
```
public static final int RULE_traversalScope
```
  See Also:
  
  Constant Field Values
- RULE_traversalBarrier
```
public static final int RULE_traversalBarrier
```
  See Also:
  
  Constant Field Values
- RULE_traversalT
```
public static final int RULE_traversalT
```
  See Also:
  
  Constant Field Values
- RULE_traversalTShort
```
public static final int RULE_traversalTShort
```
  See Also:
  
  Constant Field Values
- RULE_traversalTLong
```
public static final int RULE_traversalTLong
```
  See Also:
  
  Constant Field Values
- RULE_traversalMerge
```
public static final int RULE_traversalMerge
```
  See Also:
  
  Constant Field Values
- RULE_traversalOrder
```
public static final int RULE_traversalOrder
```
  See Also:
  
  Constant Field Values
- RULE_traversalDirection
```
public static final int RULE_traversalDirection
```
  See Also:
  
  Constant Field Values
- RULE_traversalDirectionShort
```
public static final int RULE_traversalDirectionShort
```
  See Also:
  
  Constant Field Values
- RULE_traversalDirectionLong
```
public static final int RULE_traversalDirectionLong
```
  See Also:
  
  Constant Field Values
- RULE_traversalCardinality
```
public static final int RULE_traversalCardinality
```
  See Also:
  
  Constant Field Values
- RULE_traversalColumn
```
public static final int RULE_traversalColumn
```
  See Also:
  
  Constant Field Values
- RULE_traversalPop
```
public static final int RULE_traversalPop
```
  See Also:
  
  Constant Field Values
- RULE_traversalOperator
```
public static final int RULE_traversalOperator
```
  See Also:
  
  Constant Field Values
- RULE_traversalPick
```
public static final int RULE_traversalPick
```
  See Also:
  
  Constant Field Values
- RULE_traversalDT
```
public static final int RULE_traversalDT
```
  See Also:
  
  Constant Field Values
- RULE_traversalGType
```
public static final int RULE_traversalGType
```
  See Also:
  
  Constant Field Values
- RULE_traversalPredicate
```
public static final int RULE_traversalPredicate
```
  See Also:
  
  Constant Field Values
- RULE_traversalTerminalMethod
```
public static final int RULE_traversalTerminalMethod
```
  See Also:
  
  Constant Field Values
- RULE_traversalSackMethod
```
public static final int RULE_traversalSackMethod
```
  See Also:
  
  Constant Field Values
- RULE_traversalComparator
```
public static final int RULE_traversalComparator
```
  See Also:
  
  Constant Field Values
- RULE_traversalFunction
```
public static final int RULE_traversalFunction
```
  See Also:
  
  Constant Field Values
- RULE_traversalBiFunction
```
public static final int RULE_traversalBiFunction
```
  See Also:
  
  Constant Field Values
- RULE_traversalPredicate_eq
```
public static final int RULE_traversalPredicate_eq
```
  See Also:
  
  Constant Field Values
- RULE_traversalPredicate_neq
```
public static final int RULE_traversalPredicate_neq
```
  See Also:
  
  Constant Field Values
- RULE_traversalPredicate_typeOf
```
public static final int RULE_traversalPredicate_typeOf
```
  See Also:
  
  Constant Field Values
- RULE_traversalPredicate_lt
```
public static final int RULE_traversalPredicate_lt
```
  See Also:
  
  Constant Field Values
- RULE_traversalPredicate_lte
```
public static final int RULE_traversalPredicate_lte
```
  See Also:
  
  Constant Field Values
- RULE_traversalPredicate_gt
```
public static final int RULE_traversalPredicate_gt
```
  See Also:
  
  Constant Field Values
- RULE_traversalPredicate_gte
```
public static final int RULE_traversalPredicate_gte
```
  See Also:
  
  Constant Field Values
- RULE_traversalPredicate_inside
```
public static final int RULE_traversalPredicate_inside
```
  See Also:
  
  Constant Field Values
- RULE_traversalPredicate_outside
```
public static final int RULE_traversalPredicate_outside
```
  See Also:
  
  Constant Field Values
- RULE_traversalPredicate_between
```
public static final int RULE_traversalPredicate_between
```
  See Also:
  
  Constant Field Values
- RULE_traversalPredicate_within
```
public static final int RULE_traversalPredicate_within
```
  See Also:
  
  Constant Field Values
- RULE_traversalPredicate_without
```
public static final int RULE_traversalPredicate_without
```
  See Also:
  
  Constant Field Values
- RULE_traversalPredicate_not
```
public static final int RULE_traversalPredicate_not
```
  See Also:
  
  Constant Field Values
- RULE_traversalPredicate_containing
```
public static final int RULE_traversalPredicate_containing
```
  See Also:
  
  Constant Field Values
- RULE_traversalPredicate_notContaining
```
public static final int RULE_traversalPredicate_notContaining
```
  See Also:
  
  Constant Field Values
- RULE_traversalPredicate_startingWith
```
public static final int RULE_traversalPredicate_startingWith
```
  See Also:
  
  Constant Field Values
- RULE_traversalPredicate_notStartingWith
```
public static final int RULE_traversalPredicate_notStartingWith
```
  See Also:
  
  Constant Field Values
- RULE_traversalPredicate_endingWith
```
public static final int RULE_traversalPredicate_endingWith
```
  See Also:
  
  Constant Field Values
- RULE_traversalPredicate_notEndingWith
```
public static final int RULE_traversalPredicate_notEndingWith
```
  See Also:
  
  Constant Field Values
- RULE_traversalPredicate_regex
```
public static final int RULE_traversalPredicate_regex
```
  See Also:
  
  Constant Field Values
- RULE_traversalPredicate_notRegex
```
public static final int RULE_traversalPredicate_notRegex
```
  See Also:
  
  Constant Field Values
- RULE_traversalTerminalMethod_explain
```
public static final int RULE_traversalTerminalMethod_explain
```
  See Also:
  
  Constant Field Values
- RULE_traversalTerminalMethod_hasNext
```
public static final int RULE_traversalTerminalMethod_hasNext
```
  See Also:
  
  Constant Field Values
- RULE_traversalTerminalMethod_iterate
```
public static final int RULE_traversalTerminalMethod_iterate
```
  See Also:
  
  Constant Field Values
- RULE_traversalTerminalMethod_tryNext
```
public static final int RULE_traversalTerminalMethod_tryNext
```
  See Also:
  
  Constant Field Values
- RULE_traversalTerminalMethod_next
```
public static final int RULE_traversalTerminalMethod_next
```
  See Also:
  
  Constant Field Values
- RULE_traversalTerminalMethod_toList
```
public static final int RULE_traversalTerminalMethod_toList
```
  See Also:
  
  Constant Field Values
- RULE_traversalTerminalMethod_toSet
```
public static final int RULE_traversalTerminalMethod_toSet
```
  See Also:
  
  Constant Field Values
- RULE_traversalTerminalMethod_toBulkSet
```
public static final int RULE_traversalTerminalMethod_toBulkSet
```
  See Also:
  
  Constant Field Values
- RULE_withOptionKeys
```
public static final int RULE_withOptionKeys
```
  See Also:
  
  Constant Field Values
- RULE_connectedComponentConstants
```
public static final int RULE_connectedComponentConstants
```
  See Also:
  
  Constant Field Values
- RULE_pageRankConstants
```
public static final int RULE_pageRankConstants
```
  See Also:
  
  Constant Field Values
- RULE_peerPressureConstants
```
public static final int RULE_peerPressureConstants
```
  See Also:
  
  Constant Field Values
- RULE_shortestPathConstants
```
public static final int RULE_shortestPathConstants
```
  See Also:
  
  Constant Field Values
- RULE_withOptionsValues
```
public static final int RULE_withOptionsValues
```
  See Also:
  
  Constant Field Values
- RULE_ioOptionsKeys
```
public static final int RULE_ioOptionsKeys
```
  See Also:
  
  Constant Field Values
- RULE_ioOptionsValues
```
public static final int RULE_ioOptionsValues
```
  See Also:
  
  Constant Field Values
- RULE_connectedComponentConstants_component
```
public static final int RULE_connectedComponentConstants_component
```
  See Also:
  
  Constant Field Values
- RULE_connectedComponentConstants_edges
```
public static final int RULE_connectedComponentConstants_edges
```
  See Also:
  
  Constant Field Values
- RULE_connectedComponentConstants_propertyName
```
public static final int RULE_connectedComponentConstants_propertyName
```
  See Also:
  
  Constant Field Values
- RULE_pageRankConstants_edges
```
public static final int RULE_pageRankConstants_edges
```
  See Also:
  
  Constant Field Values
- RULE_pageRankConstants_times
```
public static final int RULE_pageRankConstants_times
```
  See Also:
  
  Constant Field Values
- RULE_pageRankConstants_propertyName
```
public static final int RULE_pageRankConstants_propertyName
```
  See Also:
  
  Constant Field Values
- RULE_peerPressureConstants_edges
```
public static final int RULE_peerPressureConstants_edges
```
  See Also:
  
  Constant Field Values
- RULE_peerPressureConstants_times
```
public static final int RULE_peerPressureConstants_times
```
  See Also:
  
  Constant Field Values
- RULE_peerPressureConstants_propertyName
```
public static final int RULE_peerPressureConstants_propertyName
```
  See Also:
  
  Constant Field Values
- RULE_shortestPathConstants_target
```
public static final int RULE_shortestPathConstants_target
```
  See Also:
  
  Constant Field Values
- RULE_shortestPathConstants_edges
```
public static final int RULE_shortestPathConstants_edges
```
  See Also:
  
  Constant Field Values
- RULE_shortestPathConstants_distance
```
public static final int RULE_shortestPathConstants_distance
```
  See Also:
  
  Constant Field Values
- RULE_shortestPathConstants_maxDistance
```
public static final int RULE_shortestPathConstants_maxDistance
```
  See Also:
  
  Constant Field Values
- RULE_shortestPathConstants_includeEdges
```
public static final int RULE_shortestPathConstants_includeEdges
```
  See Also:
  
  Constant Field Values
- RULE_withOptionsConstants_tokens
```
public static final int RULE_withOptionsConstants_tokens
```
  See Also:
  
  Constant Field Values
- RULE_withOptionsConstants_none
```
public static final int RULE_withOptionsConstants_none
```
  See Also:
  
  Constant Field Values
- RULE_withOptionsConstants_ids
```
public static final int RULE_withOptionsConstants_ids
```
  See Also:
  
  Constant Field Values
- RULE_withOptionsConstants_labels
```
public static final int RULE_withOptionsConstants_labels
```
  See Also:
  
  Constant Field Values
- RULE_withOptionsConstants_keys
```
public static final int RULE_withOptionsConstants_keys
```
  See Also:
  
  Constant Field Values
- RULE_withOptionsConstants_values
```
public static final int RULE_withOptionsConstants_values
```
  See Also:
  
  Constant Field Values
- RULE_withOptionsConstants_all
```
public static final int RULE_withOptionsConstants_all
```
  See Also:
  
  Constant Field Values
- RULE_withOptionsConstants_indexer
```
public static final int RULE_withOptionsConstants_indexer
```
  See Also:
  
  Constant Field Values
- RULE_withOptionsConstants_list
```
public static final int RULE_withOptionsConstants_list
```
  See Also:
  
  Constant Field Values
- RULE_withOptionsConstants_map
```
public static final int RULE_withOptionsConstants_map
```
  See Also:
  
  Constant Field Values
- RULE_ioOptionsConstants_reader
```
public static final int RULE_ioOptionsConstants_reader
```
  See Also:
  
  Constant Field Values
- RULE_ioOptionsConstants_writer
```
public static final int RULE_ioOptionsConstants_writer
```
  See Also:
  
  Constant Field Values
- RULE_ioOptionsConstants_gryo
```
public static final int RULE_ioOptionsConstants_gryo
```
  See Also:
  
  Constant Field Values
- RULE_ioOptionsConstants_graphson
```
public static final int RULE_ioOptionsConstants_graphson
```
  See Also:
  
  Constant Field Values
- RULE_ioOptionsConstants_graphml
```
public static final int RULE_ioOptionsConstants_graphml
```
  See Also:
  
  Constant Field Values
- RULE_connectedComponentStringConstant
```
public static final int RULE_connectedComponentStringConstant
```
  See Also:
  
  Constant Field Values
- RULE_pageRankStringConstant
```
public static final int RULE_pageRankStringConstant
```
  See Also:
  
  Constant Field Values
- RULE_peerPressureStringConstant
```
public static final int RULE_peerPressureStringConstant
```
  See Also:
  
  Constant Field Values
- RULE_shortestPathStringConstant
```
public static final int RULE_shortestPathStringConstant
```
  See Also:
  
  Constant Field Values
- RULE_withOptionsStringConstant
```
public static final int RULE_withOptionsStringConstant
```
  See Also:
  
  Constant Field Values
- RULE_ioOptionsStringConstant
```
public static final int RULE_ioOptionsStringConstant
```
  See Also:
  
  Constant Field Values
- RULE_booleanArgument
```
public static final int RULE_booleanArgument
```
  See Also:
  
  Constant Field Values
- RULE_integerArgument
```
public static final int RULE_integerArgument
```
  See Also:
  
  Constant Field Values
- RULE_floatArgument
```
public static final int RULE_floatArgument
```
  See Also:
  
  Constant Field Values
- RULE_stringArgument
```
public static final int RULE_stringArgument
```
  See Also:
  
  Constant Field Values
- RULE_stringNullableArgument
```
public static final int RULE_stringNullableArgument
```
  See Also:
  
  Constant Field Values
- RULE_stringNullableArgumentVarargs
```
public static final int RULE_stringNullableArgumentVarargs
```
  See Also:
  
  Constant Field Values
- RULE_dateArgument
```
public static final int RULE_dateArgument
```
  See Also:
  
  Constant Field Values
- RULE_genericArgument
```
public static final int RULE_genericArgument
```
  See Also:
  
  Constant Field Values
- RULE_genericArgumentVarargs
```
public static final int RULE_genericArgumentVarargs
```
  See Also:
  
  Constant Field Values
- RULE_genericMapArgument
```
public static final int RULE_genericMapArgument
```
  See Also:
  
  Constant Field Values
- RULE_genericMapNullableArgument
```
public static final int RULE_genericMapNullableArgument
```
  See Also:
  
  Constant Field Values
- RULE_traversalStrategyVarargs
```
public static final int RULE_traversalStrategyVarargs
```
  See Also:
  
  Constant Field Values
- RULE_traversalStrategyExpr
```
public static final int RULE_traversalStrategyExpr
```
  See Also:
  
  Constant Field Values
- RULE_classTypeList
```
public static final int RULE_classTypeList
```
  See Also:
  
  Constant Field Values
- RULE_classTypeExpr
```
public static final int RULE_classTypeExpr
```
  See Also:
  
  Constant Field Values
- RULE_nestedTraversalList
```
public static final int RULE_nestedTraversalList
```
  See Also:
  
  Constant Field Values
- RULE_nestedTraversalExpr
```
public static final int RULE_nestedTraversalExpr
```
  See Also:
  
  Constant Field Values
- RULE_genericCollectionLiteral
```
public static final int RULE_genericCollectionLiteral
```
  See Also:
  
  Constant Field Values
- RULE_genericLiteralVarargs
```
public static final int RULE_genericLiteralVarargs
```
  See Also:
  
  Constant Field Values
- RULE_genericLiteralExpr
```
public static final int RULE_genericLiteralExpr
```
  See Also:
  
  Constant Field Values
- RULE_genericMapNullableLiteral
```
public static final int RULE_genericMapNullableLiteral
```
  See Also:
  
  Constant Field Values
- RULE_genericRangeLiteral
```
public static final int RULE_genericRangeLiteral
```
  See Also:
  
  Constant Field Values
- RULE_genericSetLiteral
```
public static final int RULE_genericSetLiteral
```
  See Also:
  
  Constant Field Values
- RULE_stringNullableLiteralVarargs
```
public static final int RULE_stringNullableLiteralVarargs
```
  See Also:
  
  Constant Field Values
- RULE_genericLiteral
```
public static final int RULE_genericLiteral
```
  See Also:
  
  Constant Field Values
- RULE_genericMapLiteral
```
public static final int RULE_genericMapLiteral
```
  See Also:
  
  Constant Field Values
- RULE_mapKey
```
public static final int RULE_mapKey
```
  See Also:
  
  Constant Field Values
- RULE_mapEntry
```
public static final int RULE_mapEntry
```
  See Also:
  
  Constant Field Values
- RULE_stringLiteral
```
public static final int RULE_stringLiteral
```
  See Also:
  
  Constant Field Values
- RULE_stringNullableLiteral
```
public static final int RULE_stringNullableLiteral
```
  See Also:
  
  Constant Field Values
- RULE_integerLiteral
```
public static final int RULE_integerLiteral
```
  See Also:
  
  Constant Field Values
- RULE_floatLiteral
```
public static final int RULE_floatLiteral
```
  See Also:
  
  Constant Field Values
- RULE_numericLiteral
```
public static final int RULE_numericLiteral
```
  See Also:
  
  Constant Field Values
- RULE_booleanLiteral
```
public static final int RULE_booleanLiteral
```
  See Also:
  
  Constant Field Values
- RULE_dateLiteral
```
public static final int RULE_dateLiteral
```
  See Also:
  
  Constant Field Values
- RULE_nullLiteral
```
public static final int RULE_nullLiteral
```
  See Also:
  
  Constant Field Values
- RULE_nanLiteral
```
public static final int RULE_nanLiteral
```
  See Also:
  
  Constant Field Values
- RULE_infLiteral
```
public static final int RULE_infLiteral
```
  See Also:
  
  Constant Field Values
- RULE_uuidLiteral
```
public static final int RULE_uuidLiteral
```
  See Also:
  
  Constant Field Values
- RULE_nakedKey
```
public static final int RULE_nakedKey
```
  See Also:
  
  Constant Field Values
- RULE_classType
```
public static final int RULE_classType
```
  See Also:
  
  Constant Field Values
- RULE_variable
```
public static final int RULE_variable
```
  See Also:
  
  Constant Field Values
- RULE_keyword
```
public static final int RULE_keyword
```
  See Also:
  
  Constant Field Values
- ruleNames
```
public static final String[] ruleNames
```
- VOCABULARY
```
public static final org.antlr.v4.runtime.Vocabulary VOCABULARY
```
- tokenNames
```
@Deprecated
public static final String[] tokenNames
```
  Deprecated.
  Use VOCABULARY instead.
- _serializedATN
```
public static final String _serializedATN
```
- _ATN
```
public static final org.antlr.v4.runtime.atn.ATN _ATN
```

Constructor Detail

GremlinParser

public GremlinParser(org.antlr.v4.runtime.TokenStream input)

Method Detail

getTokenNames
```
@Deprecated
public String[] getTokenNames()
```
Deprecated.

Specified by:

getTokenNames in class org.antlr.v4.runtime.Recognizer<org.antlr.v4.runtime.Token,org.antlr.v4.runtime.atn.ParserATNSimulator>

getVocabulary
```
public org.antlr.v4.runtime.Vocabulary getVocabulary()
```
Overrides:

getVocabulary in class org.antlr.v4.runtime.Recognizer<org.antlr.v4.runtime.Token,org.antlr.v4.runtime.atn.ParserATNSimulator>

getGrammarFileName
```
public String getGrammarFileName()
```
Specified by:

getGrammarFileName in class org.antlr.v4.runtime.Recognizer<org.antlr.v4.runtime.Token,org.antlr.v4.runtime.atn.ParserATNSimulator>

getRuleNames
```
public String[] getRuleNames()
```
Specified by:

getRuleNames in class org.antlr.v4.runtime.Recognizer<org.antlr.v4.runtime.Token,org.antlr.v4.runtime.atn.ParserATNSimulator>

getSerializedATN
```
public String getSerializedATN()
```
Overrides:

getSerializedATN in class org.antlr.v4.runtime.Recognizer<org.antlr.v4.runtime.Token,org.antlr.v4.runtime.atn.ParserATNSimulator>

getATN
```
public org.antlr.v4.runtime.atn.ATN getATN()
```
Specified by:

getATN in class org.antlr.v4.runtime.Recognizer<org.antlr.v4.runtime.Token,org.antlr.v4.runtime.atn.ParserATNSimulator>

queryList

public final GremlinParser.QueryListContext queryList()
                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

query

public final GremlinParser.QueryContext query()
                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

emptyQuery

public final GremlinParser.EmptyQueryContext emptyQuery()
                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalSource

public final GremlinParser.TraversalSourceContext traversalSource()
                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

transactionPart

public final GremlinParser.TransactionPartContext transactionPart()
                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

rootTraversal

public final GremlinParser.RootTraversalContext rootTraversal()
                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalSourceSelfMethod

public final GremlinParser.TraversalSourceSelfMethodContext traversalSourceSelfMethod()
                                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalSourceSelfMethod_withBulk

public final GremlinParser.TraversalSourceSelfMethod_withBulkContext traversalSourceSelfMethod_withBulk()
                                                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalSourceSelfMethod_withPath

public final GremlinParser.TraversalSourceSelfMethod_withPathContext traversalSourceSelfMethod_withPath()
                                                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalSourceSelfMethod_withSack

public final GremlinParser.TraversalSourceSelfMethod_withSackContext traversalSourceSelfMethod_withSack()
                                                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalSourceSelfMethod_withSideEffect

public final GremlinParser.TraversalSourceSelfMethod_withSideEffectContext traversalSourceSelfMethod_withSideEffect()
                                                                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalSourceSelfMethod_withStrategies

public final GremlinParser.TraversalSourceSelfMethod_withStrategiesContext traversalSourceSelfMethod_withStrategies()
                                                                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalSourceSelfMethod_withoutStrategies

public final GremlinParser.TraversalSourceSelfMethod_withoutStrategiesContext traversalSourceSelfMethod_withoutStrategies()
                                                                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalSourceSelfMethod_with

public final GremlinParser.TraversalSourceSelfMethod_withContext traversalSourceSelfMethod_with()
                                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalSourceSpawnMethod

public final GremlinParser.TraversalSourceSpawnMethodContext traversalSourceSpawnMethod()
                                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalSourceSpawnMethod_addE

public final GremlinParser.TraversalSourceSpawnMethod_addEContext traversalSourceSpawnMethod_addE()
                                                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalSourceSpawnMethod_addV

public final GremlinParser.TraversalSourceSpawnMethod_addVContext traversalSourceSpawnMethod_addV()
                                                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalSourceSpawnMethod_E

public final GremlinParser.TraversalSourceSpawnMethod_EContext traversalSourceSpawnMethod_E()
                                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalSourceSpawnMethod_V

public final GremlinParser.TraversalSourceSpawnMethod_VContext traversalSourceSpawnMethod_V()
                                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalSourceSpawnMethod_inject

public final GremlinParser.TraversalSourceSpawnMethod_injectContext traversalSourceSpawnMethod_inject()
                                                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalSourceSpawnMethod_io

public final GremlinParser.TraversalSourceSpawnMethod_ioContext traversalSourceSpawnMethod_io()
                                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalSourceSpawnMethod_mergeV

public final GremlinParser.TraversalSourceSpawnMethod_mergeVContext traversalSourceSpawnMethod_mergeV()
                                                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalSourceSpawnMethod_mergeE

public final GremlinParser.TraversalSourceSpawnMethod_mergeEContext traversalSourceSpawnMethod_mergeE()
                                                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalSourceSpawnMethod_call

public final GremlinParser.TraversalSourceSpawnMethod_callContext traversalSourceSpawnMethod_call()
                                                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalSourceSpawnMethod_union

public final GremlinParser.TraversalSourceSpawnMethod_unionContext traversalSourceSpawnMethod_union()
                                                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

chainedTraversal

public final GremlinParser.ChainedTraversalContext chainedTraversal()
                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

nestedTraversal

public final GremlinParser.NestedTraversalContext nestedTraversal()
                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

terminatedTraversal

public final GremlinParser.TerminatedTraversalContext terminatedTraversal()
                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod

public final GremlinParser.TraversalMethodContext traversalMethod()
                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_V

public final GremlinParser.TraversalMethod_VContext traversalMethod_V()
                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_E

public final GremlinParser.TraversalMethod_EContext traversalMethod_E()
                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_addE

public final GremlinParser.TraversalMethod_addEContext traversalMethod_addE()
                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_addV

public final GremlinParser.TraversalMethod_addVContext traversalMethod_addV()
                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_aggregate

public final GremlinParser.TraversalMethod_aggregateContext traversalMethod_aggregate()
                                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_all

public final GremlinParser.TraversalMethod_allContext traversalMethod_all()
                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_and

public final GremlinParser.TraversalMethod_andContext traversalMethod_and()
                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_any

public final GremlinParser.TraversalMethod_anyContext traversalMethod_any()
                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_as

public final GremlinParser.TraversalMethod_asContext traversalMethod_as()
                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_asBool

public final GremlinParser.TraversalMethod_asBoolContext traversalMethod_asBool()
                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_asDate

public final GremlinParser.TraversalMethod_asDateContext traversalMethod_asDate()
                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_asNumber

public final GremlinParser.TraversalMethod_asNumberContext traversalMethod_asNumber()
                                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_asString

public final GremlinParser.TraversalMethod_asStringContext traversalMethod_asString()
                                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_barrier

public final GremlinParser.TraversalMethod_barrierContext traversalMethod_barrier()
                                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_both

public final GremlinParser.TraversalMethod_bothContext traversalMethod_both()
                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_bothE

public final GremlinParser.TraversalMethod_bothEContext traversalMethod_bothE()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_bothV

public final GremlinParser.TraversalMethod_bothVContext traversalMethod_bothV()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_branch

public final GremlinParser.TraversalMethod_branchContext traversalMethod_branch()
                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_by

public final GremlinParser.TraversalMethod_byContext traversalMethod_by()
                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_call

public final GremlinParser.TraversalMethod_callContext traversalMethod_call()
                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_cap

public final GremlinParser.TraversalMethod_capContext traversalMethod_cap()
                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_choose

public final GremlinParser.TraversalMethod_chooseContext traversalMethod_choose()
                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_coalesce

public final GremlinParser.TraversalMethod_coalesceContext traversalMethod_coalesce()
                                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_coin

public final GremlinParser.TraversalMethod_coinContext traversalMethod_coin()
                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_combine

public final GremlinParser.TraversalMethod_combineContext traversalMethod_combine()
                                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_concat

public final GremlinParser.TraversalMethod_concatContext traversalMethod_concat()
                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_conjoin

public final GremlinParser.TraversalMethod_conjoinContext traversalMethod_conjoin()
                                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_connectedComponent

public final GremlinParser.TraversalMethod_connectedComponentContext traversalMethod_connectedComponent()
                                                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_constant

public final GremlinParser.TraversalMethod_constantContext traversalMethod_constant()
                                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_count

public final GremlinParser.TraversalMethod_countContext traversalMethod_count()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_cyclicPath

public final GremlinParser.TraversalMethod_cyclicPathContext traversalMethod_cyclicPath()
                                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_dateAdd

public final GremlinParser.TraversalMethod_dateAddContext traversalMethod_dateAdd()
                                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_dateDiff

public final GremlinParser.TraversalMethod_dateDiffContext traversalMethod_dateDiff()
                                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_dedup

public final GremlinParser.TraversalMethod_dedupContext traversalMethod_dedup()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_difference

public final GremlinParser.TraversalMethod_differenceContext traversalMethod_difference()
                                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_discard

public final GremlinParser.TraversalMethod_discardContext traversalMethod_discard()
                                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_disjunct

public final GremlinParser.TraversalMethod_disjunctContext traversalMethod_disjunct()
                                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_drop

public final GremlinParser.TraversalMethod_dropContext traversalMethod_drop()
                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_element

public final GremlinParser.TraversalMethod_elementContext traversalMethod_element()
                                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_elementMap

public final GremlinParser.TraversalMethod_elementMapContext traversalMethod_elementMap()
                                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_emit

public final GremlinParser.TraversalMethod_emitContext traversalMethod_emit()
                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_fail

public final GremlinParser.TraversalMethod_failContext traversalMethod_fail()
                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_filter

public final GremlinParser.TraversalMethod_filterContext traversalMethod_filter()
                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_flatMap

public final GremlinParser.TraversalMethod_flatMapContext traversalMethod_flatMap()
                                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_fold

public final GremlinParser.TraversalMethod_foldContext traversalMethod_fold()
                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_format

public final GremlinParser.TraversalMethod_formatContext traversalMethod_format()
                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_from

public final GremlinParser.TraversalMethod_fromContext traversalMethod_from()
                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_group

public final GremlinParser.TraversalMethod_groupContext traversalMethod_group()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_groupCount

public final GremlinParser.TraversalMethod_groupCountContext traversalMethod_groupCount()
                                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_has

public final GremlinParser.TraversalMethod_hasContext traversalMethod_has()
                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_hasId

public final GremlinParser.TraversalMethod_hasIdContext traversalMethod_hasId()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_hasKey

public final GremlinParser.TraversalMethod_hasKeyContext traversalMethod_hasKey()
                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_hasLabel

public final GremlinParser.TraversalMethod_hasLabelContext traversalMethod_hasLabel()
                                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_hasNot

public final GremlinParser.TraversalMethod_hasNotContext traversalMethod_hasNot()
                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_hasValue

public final GremlinParser.TraversalMethod_hasValueContext traversalMethod_hasValue()
                                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_id

public final GremlinParser.TraversalMethod_idContext traversalMethod_id()
                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_identity

public final GremlinParser.TraversalMethod_identityContext traversalMethod_identity()
                                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_in

public final GremlinParser.TraversalMethod_inContext traversalMethod_in()
                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_inE

public final GremlinParser.TraversalMethod_inEContext traversalMethod_inE()
                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_intersect

public final GremlinParser.TraversalMethod_intersectContext traversalMethod_intersect()
                                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_inV

public final GremlinParser.TraversalMethod_inVContext traversalMethod_inV()
                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_index

public final GremlinParser.TraversalMethod_indexContext traversalMethod_index()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_inject

public final GremlinParser.TraversalMethod_injectContext traversalMethod_inject()
                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_is

public final GremlinParser.TraversalMethod_isContext traversalMethod_is()
                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_key

public final GremlinParser.TraversalMethod_keyContext traversalMethod_key()
                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_label

public final GremlinParser.TraversalMethod_labelContext traversalMethod_label()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_length

public final GremlinParser.TraversalMethod_lengthContext traversalMethod_length()
                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_limit

public final GremlinParser.TraversalMethod_limitContext traversalMethod_limit()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_local

public final GremlinParser.TraversalMethod_localContext traversalMethod_local()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_loops

public final GremlinParser.TraversalMethod_loopsContext traversalMethod_loops()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_lTrim

public final GremlinParser.TraversalMethod_lTrimContext traversalMethod_lTrim()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_map

public final GremlinParser.TraversalMethod_mapContext traversalMethod_map()
                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_match

public final GremlinParser.TraversalMethod_matchContext traversalMethod_match()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_math

public final GremlinParser.TraversalMethod_mathContext traversalMethod_math()
                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_max

public final GremlinParser.TraversalMethod_maxContext traversalMethod_max()
                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_mean

public final GremlinParser.TraversalMethod_meanContext traversalMethod_mean()
                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_merge

public final GremlinParser.TraversalMethod_mergeContext traversalMethod_merge()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_mergeV

public final GremlinParser.TraversalMethod_mergeVContext traversalMethod_mergeV()
                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_mergeE

public final GremlinParser.TraversalMethod_mergeEContext traversalMethod_mergeE()
                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_min

public final GremlinParser.TraversalMethod_minContext traversalMethod_min()
                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_none

public final GremlinParser.TraversalMethod_noneContext traversalMethod_none()
                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_not

public final GremlinParser.TraversalMethod_notContext traversalMethod_not()
                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_option

public final GremlinParser.TraversalMethod_optionContext traversalMethod_option()
                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_optional

public final GremlinParser.TraversalMethod_optionalContext traversalMethod_optional()
                                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_or

public final GremlinParser.TraversalMethod_orContext traversalMethod_or()
                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_order

public final GremlinParser.TraversalMethod_orderContext traversalMethod_order()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_otherV

public final GremlinParser.TraversalMethod_otherVContext traversalMethod_otherV()
                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_out

public final GremlinParser.TraversalMethod_outContext traversalMethod_out()
                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_outE

public final GremlinParser.TraversalMethod_outEContext traversalMethod_outE()
                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_outV

public final GremlinParser.TraversalMethod_outVContext traversalMethod_outV()
                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_pageRank

public final GremlinParser.TraversalMethod_pageRankContext traversalMethod_pageRank()
                                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_path

public final GremlinParser.TraversalMethod_pathContext traversalMethod_path()
                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_peerPressure

public final GremlinParser.TraversalMethod_peerPressureContext traversalMethod_peerPressure()
                                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_product

public final GremlinParser.TraversalMethod_productContext traversalMethod_product()
                                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_profile

public final GremlinParser.TraversalMethod_profileContext traversalMethod_profile()
                                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_project

public final GremlinParser.TraversalMethod_projectContext traversalMethod_project()
                                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_properties

public final GremlinParser.TraversalMethod_propertiesContext traversalMethod_properties()
                                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_property

public final GremlinParser.TraversalMethod_propertyContext traversalMethod_property()
                                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_propertyMap

public final GremlinParser.TraversalMethod_propertyMapContext traversalMethod_propertyMap()
                                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_range

public final GremlinParser.TraversalMethod_rangeContext traversalMethod_range()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_read

public final GremlinParser.TraversalMethod_readContext traversalMethod_read()
                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_repeat

public final GremlinParser.TraversalMethod_repeatContext traversalMethod_repeat()
                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_replace

public final GremlinParser.TraversalMethod_replaceContext traversalMethod_replace()
                                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_reverse

public final GremlinParser.TraversalMethod_reverseContext traversalMethod_reverse()
                                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_rTrim

public final GremlinParser.TraversalMethod_rTrimContext traversalMethod_rTrim()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_sack

public final GremlinParser.TraversalMethod_sackContext traversalMethod_sack()
                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_sample

public final GremlinParser.TraversalMethod_sampleContext traversalMethod_sample()
                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_select

public final GremlinParser.TraversalMethod_selectContext traversalMethod_select()
                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_shortestPath

public final GremlinParser.TraversalMethod_shortestPathContext traversalMethod_shortestPath()
                                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_sideEffect

public final GremlinParser.TraversalMethod_sideEffectContext traversalMethod_sideEffect()
                                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_simplePath

public final GremlinParser.TraversalMethod_simplePathContext traversalMethod_simplePath()
                                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_skip

public final GremlinParser.TraversalMethod_skipContext traversalMethod_skip()
                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_split

public final GremlinParser.TraversalMethod_splitContext traversalMethod_split()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_store

public final GremlinParser.TraversalMethod_storeContext traversalMethod_store()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_subgraph

public final GremlinParser.TraversalMethod_subgraphContext traversalMethod_subgraph()
                                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_substring

public final GremlinParser.TraversalMethod_substringContext traversalMethod_substring()
                                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_sum

public final GremlinParser.TraversalMethod_sumContext traversalMethod_sum()
                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_tail

public final GremlinParser.TraversalMethod_tailContext traversalMethod_tail()
                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_timeLimit

public final GremlinParser.TraversalMethod_timeLimitContext traversalMethod_timeLimit()
                                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_times

public final GremlinParser.TraversalMethod_timesContext traversalMethod_times()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_to

public final GremlinParser.TraversalMethod_toContext traversalMethod_to()
                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_toE

public final GremlinParser.TraversalMethod_toEContext traversalMethod_toE()
                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_toLower

public final GremlinParser.TraversalMethod_toLowerContext traversalMethod_toLower()
                                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_toUpper

public final GremlinParser.TraversalMethod_toUpperContext traversalMethod_toUpper()
                                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_toV

public final GremlinParser.TraversalMethod_toVContext traversalMethod_toV()
                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_tree

public final GremlinParser.TraversalMethod_treeContext traversalMethod_tree()
                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_trim

public final GremlinParser.TraversalMethod_trimContext traversalMethod_trim()
                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_unfold

public final GremlinParser.TraversalMethod_unfoldContext traversalMethod_unfold()
                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_union

public final GremlinParser.TraversalMethod_unionContext traversalMethod_union()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_until

public final GremlinParser.TraversalMethod_untilContext traversalMethod_until()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_value

public final GremlinParser.TraversalMethod_valueContext traversalMethod_value()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_valueMap

public final GremlinParser.TraversalMethod_valueMapContext traversalMethod_valueMap()
                                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_values

public final GremlinParser.TraversalMethod_valuesContext traversalMethod_values()
                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_where

public final GremlinParser.TraversalMethod_whereContext traversalMethod_where()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_with

public final GremlinParser.TraversalMethod_withContext traversalMethod_with()
                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMethod_write

public final GremlinParser.TraversalMethod_writeContext traversalMethod_write()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalStrategy

public final GremlinParser.TraversalStrategyContext traversalStrategy()
                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

configuration

public final GremlinParser.ConfigurationContext configuration()
                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalScope

public final GremlinParser.TraversalScopeContext traversalScope()
                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalBarrier

public final GremlinParser.TraversalBarrierContext traversalBarrier()
                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalT

public final GremlinParser.TraversalTContext traversalT()
                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalTShort

public final GremlinParser.TraversalTShortContext traversalTShort()
                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalTLong

public final GremlinParser.TraversalTLongContext traversalTLong()
                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalMerge

public final GremlinParser.TraversalMergeContext traversalMerge()
                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalOrder

public final GremlinParser.TraversalOrderContext traversalOrder()
                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalDirection

public final GremlinParser.TraversalDirectionContext traversalDirection()
                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalDirectionShort

public final GremlinParser.TraversalDirectionShortContext traversalDirectionShort()
                                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalDirectionLong

public final GremlinParser.TraversalDirectionLongContext traversalDirectionLong()
                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalCardinality

public final GremlinParser.TraversalCardinalityContext traversalCardinality()
                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalColumn

public final GremlinParser.TraversalColumnContext traversalColumn()
                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalPop

public final GremlinParser.TraversalPopContext traversalPop()
                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalOperator

public final GremlinParser.TraversalOperatorContext traversalOperator()
                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalPick

public final GremlinParser.TraversalPickContext traversalPick()
                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalDT

public final GremlinParser.TraversalDTContext traversalDT()
                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalGType

public final GremlinParser.TraversalGTypeContext traversalGType()
                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalPredicate

public final GremlinParser.TraversalPredicateContext traversalPredicate()
                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalTerminalMethod

public final GremlinParser.TraversalTerminalMethodContext traversalTerminalMethod()
                                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalSackMethod

public final GremlinParser.TraversalSackMethodContext traversalSackMethod()
                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalComparator

public final GremlinParser.TraversalComparatorContext traversalComparator()
                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalFunction

public final GremlinParser.TraversalFunctionContext traversalFunction()
                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalBiFunction

public final GremlinParser.TraversalBiFunctionContext traversalBiFunction()
                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalPredicate_eq

public final GremlinParser.TraversalPredicate_eqContext traversalPredicate_eq()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalPredicate_neq

public final GremlinParser.TraversalPredicate_neqContext traversalPredicate_neq()
                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalPredicate_typeOf

public final GremlinParser.TraversalPredicate_typeOfContext traversalPredicate_typeOf()
                                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalPredicate_lt

public final GremlinParser.TraversalPredicate_ltContext traversalPredicate_lt()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalPredicate_lte

public final GremlinParser.TraversalPredicate_lteContext traversalPredicate_lte()
                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalPredicate_gt

public final GremlinParser.TraversalPredicate_gtContext traversalPredicate_gt()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalPredicate_gte

public final GremlinParser.TraversalPredicate_gteContext traversalPredicate_gte()
                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalPredicate_inside

public final GremlinParser.TraversalPredicate_insideContext traversalPredicate_inside()
                                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalPredicate_outside

public final GremlinParser.TraversalPredicate_outsideContext traversalPredicate_outside()
                                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalPredicate_between

public final GremlinParser.TraversalPredicate_betweenContext traversalPredicate_between()
                                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalPredicate_within

public final GremlinParser.TraversalPredicate_withinContext traversalPredicate_within()
                                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalPredicate_without

public final GremlinParser.TraversalPredicate_withoutContext traversalPredicate_without()
                                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalPredicate_not

public final GremlinParser.TraversalPredicate_notContext traversalPredicate_not()
                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalPredicate_containing

public final GremlinParser.TraversalPredicate_containingContext traversalPredicate_containing()
                                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalPredicate_notContaining

public final GremlinParser.TraversalPredicate_notContainingContext traversalPredicate_notContaining()
                                                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalPredicate_startingWith

public final GremlinParser.TraversalPredicate_startingWithContext traversalPredicate_startingWith()
                                                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalPredicate_notStartingWith

public final GremlinParser.TraversalPredicate_notStartingWithContext traversalPredicate_notStartingWith()
                                                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalPredicate_endingWith

public final GremlinParser.TraversalPredicate_endingWithContext traversalPredicate_endingWith()
                                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalPredicate_notEndingWith

public final GremlinParser.TraversalPredicate_notEndingWithContext traversalPredicate_notEndingWith()
                                                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalPredicate_regex

public final GremlinParser.TraversalPredicate_regexContext traversalPredicate_regex()
                                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalPredicate_notRegex

public final GremlinParser.TraversalPredicate_notRegexContext traversalPredicate_notRegex()
                                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalTerminalMethod_explain

public final GremlinParser.TraversalTerminalMethod_explainContext traversalTerminalMethod_explain()
                                                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalTerminalMethod_hasNext

public final GremlinParser.TraversalTerminalMethod_hasNextContext traversalTerminalMethod_hasNext()
                                                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalTerminalMethod_iterate

public final GremlinParser.TraversalTerminalMethod_iterateContext traversalTerminalMethod_iterate()
                                                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalTerminalMethod_tryNext

public final GremlinParser.TraversalTerminalMethod_tryNextContext traversalTerminalMethod_tryNext()
                                                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalTerminalMethod_next

public final GremlinParser.TraversalTerminalMethod_nextContext traversalTerminalMethod_next()
                                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalTerminalMethod_toList

public final GremlinParser.TraversalTerminalMethod_toListContext traversalTerminalMethod_toList()
                                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalTerminalMethod_toSet

public final GremlinParser.TraversalTerminalMethod_toSetContext traversalTerminalMethod_toSet()
                                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalTerminalMethod_toBulkSet

public final GremlinParser.TraversalTerminalMethod_toBulkSetContext traversalTerminalMethod_toBulkSet()
                                                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

withOptionKeys

public final GremlinParser.WithOptionKeysContext withOptionKeys()
                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

connectedComponentConstants

public final GremlinParser.ConnectedComponentConstantsContext connectedComponentConstants()
                                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

pageRankConstants

public final GremlinParser.PageRankConstantsContext pageRankConstants()
                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

peerPressureConstants

public final GremlinParser.PeerPressureConstantsContext peerPressureConstants()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

shortestPathConstants

public final GremlinParser.ShortestPathConstantsContext shortestPathConstants()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

withOptionsValues

public final GremlinParser.WithOptionsValuesContext withOptionsValues()
                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

ioOptionsKeys

public final GremlinParser.IoOptionsKeysContext ioOptionsKeys()
                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

ioOptionsValues

public final GremlinParser.IoOptionsValuesContext ioOptionsValues()
                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

connectedComponentConstants_component

public final GremlinParser.ConnectedComponentConstants_componentContext connectedComponentConstants_component()
                                                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

connectedComponentConstants_edges

public final GremlinParser.ConnectedComponentConstants_edgesContext connectedComponentConstants_edges()
                                                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

connectedComponentConstants_propertyName

public final GremlinParser.ConnectedComponentConstants_propertyNameContext connectedComponentConstants_propertyName()
                                                                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

pageRankConstants_edges

public final GremlinParser.PageRankConstants_edgesContext pageRankConstants_edges()
                                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

pageRankConstants_times

public final GremlinParser.PageRankConstants_timesContext pageRankConstants_times()
                                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

pageRankConstants_propertyName

public final GremlinParser.PageRankConstants_propertyNameContext pageRankConstants_propertyName()
                                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

peerPressureConstants_edges

public final GremlinParser.PeerPressureConstants_edgesContext peerPressureConstants_edges()
                                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

peerPressureConstants_times

public final GremlinParser.PeerPressureConstants_timesContext peerPressureConstants_times()
                                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

peerPressureConstants_propertyName

public final GremlinParser.PeerPressureConstants_propertyNameContext peerPressureConstants_propertyName()
                                                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

shortestPathConstants_target

public final GremlinParser.ShortestPathConstants_targetContext shortestPathConstants_target()
                                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

shortestPathConstants_edges

public final GremlinParser.ShortestPathConstants_edgesContext shortestPathConstants_edges()
                                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

shortestPathConstants_distance

public final GremlinParser.ShortestPathConstants_distanceContext shortestPathConstants_distance()
                                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

shortestPathConstants_maxDistance

public final GremlinParser.ShortestPathConstants_maxDistanceContext shortestPathConstants_maxDistance()
                                                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

shortestPathConstants_includeEdges

public final GremlinParser.ShortestPathConstants_includeEdgesContext shortestPathConstants_includeEdges()
                                                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

withOptionsConstants_tokens

public final GremlinParser.WithOptionsConstants_tokensContext withOptionsConstants_tokens()
                                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

withOptionsConstants_none

public final GremlinParser.WithOptionsConstants_noneContext withOptionsConstants_none()
                                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

withOptionsConstants_ids

public final GremlinParser.WithOptionsConstants_idsContext withOptionsConstants_ids()
                                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

withOptionsConstants_labels

public final GremlinParser.WithOptionsConstants_labelsContext withOptionsConstants_labels()
                                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

withOptionsConstants_keys

public final GremlinParser.WithOptionsConstants_keysContext withOptionsConstants_keys()
                                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

withOptionsConstants_values

public final GremlinParser.WithOptionsConstants_valuesContext withOptionsConstants_values()
                                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

withOptionsConstants_all

public final GremlinParser.WithOptionsConstants_allContext withOptionsConstants_all()
                                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

withOptionsConstants_indexer

public final GremlinParser.WithOptionsConstants_indexerContext withOptionsConstants_indexer()
                                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

withOptionsConstants_list

public final GremlinParser.WithOptionsConstants_listContext withOptionsConstants_list()
                                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

withOptionsConstants_map

public final GremlinParser.WithOptionsConstants_mapContext withOptionsConstants_map()
                                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

ioOptionsConstants_reader

public final GremlinParser.IoOptionsConstants_readerContext ioOptionsConstants_reader()
                                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

ioOptionsConstants_writer

public final GremlinParser.IoOptionsConstants_writerContext ioOptionsConstants_writer()
                                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

ioOptionsConstants_gryo

public final GremlinParser.IoOptionsConstants_gryoContext ioOptionsConstants_gryo()
                                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

ioOptionsConstants_graphson

public final GremlinParser.IoOptionsConstants_graphsonContext ioOptionsConstants_graphson()
                                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

ioOptionsConstants_graphml

public final GremlinParser.IoOptionsConstants_graphmlContext ioOptionsConstants_graphml()
                                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

connectedComponentStringConstant

public final GremlinParser.ConnectedComponentStringConstantContext connectedComponentStringConstant()
                                                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

pageRankStringConstant

public final GremlinParser.PageRankStringConstantContext pageRankStringConstant()
                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

peerPressureStringConstant

public final GremlinParser.PeerPressureStringConstantContext peerPressureStringConstant()
                                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

shortestPathStringConstant

public final GremlinParser.ShortestPathStringConstantContext shortestPathStringConstant()
                                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

withOptionsStringConstant

public final GremlinParser.WithOptionsStringConstantContext withOptionsStringConstant()
                                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

ioOptionsStringConstant

public final GremlinParser.IoOptionsStringConstantContext ioOptionsStringConstant()
                                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

booleanArgument

public final GremlinParser.BooleanArgumentContext booleanArgument()
                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

integerArgument

public final GremlinParser.IntegerArgumentContext integerArgument()
                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

floatArgument

public final GremlinParser.FloatArgumentContext floatArgument()
                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

stringArgument

public final GremlinParser.StringArgumentContext stringArgument()
                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

stringNullableArgument

public final GremlinParser.StringNullableArgumentContext stringNullableArgument()
                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

stringNullableArgumentVarargs

public final GremlinParser.StringNullableArgumentVarargsContext stringNullableArgumentVarargs()
                                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

dateArgument

public final GremlinParser.DateArgumentContext dateArgument()
                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

genericArgument

public final GremlinParser.GenericArgumentContext genericArgument()
                                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

genericArgumentVarargs

public final GremlinParser.GenericArgumentVarargsContext genericArgumentVarargs()
                                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

genericMapArgument

public final GremlinParser.GenericMapArgumentContext genericMapArgument()
                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

genericMapNullableArgument

public final GremlinParser.GenericMapNullableArgumentContext genericMapNullableArgument()
                                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalStrategyVarargs

public final GremlinParser.TraversalStrategyVarargsContext traversalStrategyVarargs()
                                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

traversalStrategyExpr

public final GremlinParser.TraversalStrategyExprContext traversalStrategyExpr()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

classTypeList

public final GremlinParser.ClassTypeListContext classTypeList()
                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

classTypeExpr

public final GremlinParser.ClassTypeExprContext classTypeExpr()
                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

nestedTraversalList

public final GremlinParser.NestedTraversalListContext nestedTraversalList()
                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

nestedTraversalExpr

public final GremlinParser.NestedTraversalExprContext nestedTraversalExpr()
                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

genericCollectionLiteral

public final GremlinParser.GenericCollectionLiteralContext genericCollectionLiteral()
                                                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

genericLiteralVarargs

public final GremlinParser.GenericLiteralVarargsContext genericLiteralVarargs()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

genericLiteralExpr

public final GremlinParser.GenericLiteralExprContext genericLiteralExpr()
                                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

genericMapNullableLiteral

public final GremlinParser.GenericMapNullableLiteralContext genericMapNullableLiteral()
                                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

genericRangeLiteral

public final GremlinParser.GenericRangeLiteralContext genericRangeLiteral()
                                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

genericSetLiteral

public final GremlinParser.GenericSetLiteralContext genericSetLiteral()
                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

stringNullableLiteralVarargs

public final GremlinParser.StringNullableLiteralVarargsContext stringNullableLiteralVarargs()
                                                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

genericLiteral

public final GremlinParser.GenericLiteralContext genericLiteral()
                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

genericMapLiteral

public final GremlinParser.GenericMapLiteralContext genericMapLiteral()
                                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

mapKey

public final GremlinParser.MapKeyContext mapKey()
                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

mapEntry

public final GremlinParser.MapEntryContext mapEntry()
                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

stringLiteral

public final GremlinParser.StringLiteralContext stringLiteral()
                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

stringNullableLiteral

public final GremlinParser.StringNullableLiteralContext stringNullableLiteral()
                                                                       throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

integerLiteral

public final GremlinParser.IntegerLiteralContext integerLiteral()
                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

floatLiteral

public final GremlinParser.FloatLiteralContext floatLiteral()
                                                     throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

numericLiteral

public final GremlinParser.NumericLiteralContext numericLiteral()
                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

booleanLiteral

public final GremlinParser.BooleanLiteralContext booleanLiteral()
                                                         throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

dateLiteral

public final GremlinParser.DateLiteralContext dateLiteral()
                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

nullLiteral

public final GremlinParser.NullLiteralContext nullLiteral()
                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

nanLiteral

public final GremlinParser.NanLiteralContext nanLiteral()
                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

infLiteral

public final GremlinParser.InfLiteralContext infLiteral()
                                                 throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

uuidLiteral

public final GremlinParser.UuidLiteralContext uuidLiteral()
                                                   throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

nakedKey

public final GremlinParser.NakedKeyContext nakedKey()
                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

classType

public final GremlinParser.ClassTypeContext classType()
                                               throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

variable

public final GremlinParser.VariableContext variable()
                                             throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

keyword

public final GremlinParser.KeywordContext keyword()
                                           throws org.antlr.v4.runtime.RecognitionException

Throws:: org.antlr.v4.runtime.RecognitionException

sempred

public boolean sempred(org.antlr.v4.runtime.RuleContext _localctx,
                       int ruleIndex,
                       int predIndex)

Overrides:: sempred in class org.antlr.v4.runtime.Recognizer<org.antlr.v4.runtime.Token,org.antlr.v4.runtime.atn.ParserATNSimulator>

Class GremlinParser

Nested Class Summary

Nested classes/interfaces inherited from class org.antlr.v4.runtime.Parser

Field Summary

Fields inherited from class org.antlr.v4.runtime.Parser

Fields inherited from class org.antlr.v4.runtime.Recognizer

Constructor Summary

Method Summary

Methods inherited from class org.antlr.v4.runtime.Parser

Methods inherited from class org.antlr.v4.runtime.Recognizer

Methods inherited from class java.lang.Object

Field Detail

_decisionToDFA

_sharedContextCache

K_ADDALL

K_ADDE

K_ADDV

K_AGGREGATE

K_ALL

K_AND

K_ANY

K_AS

K_ASBOOL

K_ASC

K_ASDATE

K_ASNUMBER

K_ASSTRING

K_ASSIGN

K_BARRIER

K_BARRIERU

K_BEGIN

K_BETWEEN

K_BIGDECIMAL

K_BIGDECIMALU

K_BIGINT

K_BIGINTU

K_BINARY

K_BINARYU

K_BOOLEAN

K_BOOLEANU

K_BOTH

K_BOTHU

K_BOTHE

K_BOTHV

K_BRANCH

K_BY

K_BYTE

K_BYTEU

K_CALL

K_CAP

K_CARDINALITY

K_CHAR

K_CHARU

K_CHOOSE

K_COALESCE

K_COIN

K_COLUMN

K_COMBINE

K_COMMIT

K_COMPONENT

K_CONCAT

K_CONJOIN

K_CONNECTEDCOMPONENT

K_CONNECTEDCOMPONENTU

K_CONSTANT

K_CONTAINING

K_COUNT

K_CYCLICPATH

K_DAY

K_DATEADD

K_DATEDIFF

K_DATETIME

K_DATETIMEC

K_DATETIMEU

K_DECR

K_DEDUP

K_DESC

K_DIFFERENCE

K_DISCARD

K_DIRECTION