All Classes Interface Summary Class Summary Enum Summary Exception Summary
| Class |
Description |
| Adapter<S1,S2,T1,T2,V1,V2> |
A two-level bidirectional encoder which adapts types to types and terms to terms
|
| AdapterContext |
An evaluation context together with a source language and a target language
|
| Adapters |
Convenience functions for working with Hydra coders.
|
| Add |
|
| AdditionalBound |
|
| AdditiveExpression |
|
| AdditiveExpression_Binary |
|
| AdditiveExpression.Minus |
|
| AdditiveExpression.PartialVisitor<R> |
|
| AdditiveExpression.Plus |
|
| AdditiveExpression.Unary |
|
| AdditiveExpression.Visitor<R> |
|
| AddOrSubtractExpression |
|
| AddOrSubtractOperator |
|
| AddOrSubtractOperator.Add |
|
| AddOrSubtractOperator.PartialVisitor<R> |
|
| AddOrSubtractOperator.Subtract |
|
| AddOrSubtractOperator.Visitor<R> |
|
| AddOrSubtractRightHandSide |
|
| AggregateFunctionFeatures |
Aggregate functions
|
| AggregationQuery |
|
| AggregationQuery.Count |
|
| AggregationQuery.PartialVisitor<R> |
|
| AggregationQuery.Visitor<R> |
|
| Alias |
|
| Alias.Colon |
|
| Alias.Name |
|
| Alias.PartialVisitor<R> |
|
| Alias.Visitor<R> |
|
| Alternative |
A pattern-matching alternative
|
| AmbiguousName |
|
| And |
|
| AndExpression |
|
| AndExpression |
|
| AnnotatedIdentifier |
|
| AnnotatedTerm |
A term together with an annotation
|
| AnnotatedType |
A type together with an annotation
|
| Annotation |
|
| Annotation.Marker |
|
| Annotation.Normal |
|
| Annotation.PartialVisitor<R> |
|
| Annotation.SingleElement |
|
| Annotation.Visitor<R> |
|
| Annotations |
Annotations which can be applied to record fields, aliased union members, enum symbols, or named schemas
|
| AnnotationSchema |
Configurable annotation keys for property graph mapping specifications
|
| AnnotationTypeBody |
|
| AnnotationTypeDeclaration |
|
| AnnotationTypeElementDeclaration |
|
| AnnotationTypeElementModifier |
|
| AnnotationTypeElementModifier.Abstract |
|
| AnnotationTypeElementModifier.PartialVisitor<R> |
|
| AnnotationTypeElementModifier.Public |
|
| AnnotationTypeElementModifier.Visitor<R> |
|
| AnnotationTypeMemberDeclaration |
|
| AnnotationTypeMemberDeclaration.AnnotationType |
|
| AnnotationTypeMemberDeclaration.Class_ |
|
| AnnotationTypeMemberDeclaration.Constant |
|
| AnnotationTypeMemberDeclaration.Interface |
|
| AnnotationTypeMemberDeclaration.PartialVisitor<R> |
|
| AnnotationTypeMemberDeclaration.Visitor<R> |
|
| AnonymousPatternPart |
|
| AntlrReaderBase |
A base class for utilities which convert ANTLR parse trees into domain-specific objects
|
| Any |
`Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message.
|
| Application |
A term which applies a function to an argument
|
| ApplicationQuery |
|
| ApplicationType |
The type-level analog of an application term
|
| Apply |
|
| Apply |
|
| Apply |
|
| Argument |
|
| Arguments |
|
| ArgumentsDefinition |
|
| ArithmeticFeatures |
Arithmetic operations
|
| Array |
|
| ArrayAccess |
|
| ArrayAccess_Variant |
|
| ArrayAccess_Variant.Name |
|
| ArrayAccess_Variant.PartialVisitor<R> |
|
| ArrayAccess_Variant.Primary |
|
| ArrayAccess_Variant.Visitor<R> |
|
| ArrayCreationExpression |
|
| ArrayCreationExpression_ClassOrInterface |
|
| ArrayCreationExpression_ClassOrInterfaceArray |
|
| ArrayCreationExpression_Primitive |
|
| ArrayCreationExpression_PrimitiveArray |
|
| ArrayCreationExpression.ClassOrInterface |
|
| ArrayCreationExpression.ClassOrInterfaceArray |
|
| ArrayCreationExpression.PartialVisitor<R> |
|
| ArrayCreationExpression.Primitive |
|
| ArrayCreationExpression.PrimitiveArray |
|
| ArrayCreationExpression.Visitor<R> |
|
| ArrayInitializer |
|
| ArrayType |
|
| ArrayType_Variant |
|
| ArrayType_Variant.ClassOrInterface |
|
| ArrayType_Variant.PartialVisitor<R> |
|
| ArrayType_Variant.Primitive |
|
| ArrayType_Variant.Variable |
|
| ArrayType_Variant.Visitor<R> |
|
| Assertion |
A type assertion
|
| Assertion_Class |
|
| Assertion.Class_ |
|
| Assertion.PartialVisitor<R> |
|
| Assertion.Tuple |
|
| Assertion.Visitor<R> |
|
| AssertStatement |
|
| AssertStatement_Pair |
|
| AssertStatement.Pair |
|
| AssertStatement.PartialVisitor<R> |
|
| AssertStatement.Single |
|
| AssertStatement.Visitor<R> |
|
| Assignment |
|
| AssignmentExpression |
|
| AssignmentExpression.Assignment |
|
| AssignmentExpression.Conditional |
|
| AssignmentExpression.PartialVisitor<R> |
|
| AssignmentExpression.Visitor<R> |
|
| AssignmentOperator |
|
| AssignmentOperator.And |
|
| AssignmentOperator.Div |
|
| AssignmentOperator.Minus |
|
| AssignmentOperator.Mod |
|
| AssignmentOperator.Or |
|
| AssignmentOperator.PartialVisitor<R> |
|
| AssignmentOperator.Plus |
|
| AssignmentOperator.ShiftLeft |
|
| AssignmentOperator.ShiftRight |
|
| AssignmentOperator.ShiftRightZeroFill |
|
| AssignmentOperator.Simple |
|
| AssignmentOperator.Times |
|
| AssignmentOperator.Visitor<R> |
|
| AssignmentOperator.Xor |
|
| AssociativeExpression |
|
| Associativity |
Operator associativity
|
| Associativity.Both |
|
| Associativity.Left |
|
| Associativity.None |
|
| Associativity.PartialVisitor<R> |
|
| Associativity.Right |
|
| Associativity.Visitor<R> |
|
| At |
|
| Atom |
|
| Atom.Case |
|
| Atom.CountStar |
|
| Atom.ExistentialSubquery |
|
| Atom.FunctionInvocation |
|
| Atom.ListComprehension |
|
| Atom.Literal |
|
| Atom.Parameter |
|
| Atom.Parenthesized |
|
| Atom.PartialVisitor<R> |
|
| Atom.PatternComprehension |
|
| Atom.PatternPredicate |
|
| Atom.Quantifier |
|
| Atom.Variable |
|
| Atom.Visitor<R> |
|
| AtomFeatures |
Various kinds of atomic expressions
|
| BasicForStatement |
|
| BasicForStatementNoShortIf |
|
| Basics |
A tier-2 module of basic functions for working with types and terms.
|
| Bicoder<S1,S2,T1,T2,V1,V2> |
A two-level encoder and decoder, operating both at a type level and an instance (data) level
|
| BigfloatToBigint |
|
| BigfloatToFloat32 |
|
| BigfloatToFloat64 |
|
| BigintToBigfloat |
|
| BigintToInt16 |
|
| BigintToInt32 |
|
| BigintToInt64 |
|
| BigintToInt8 |
|
| BigintToUint16 |
|
| BigintToUint32 |
|
| BigintToUint64 |
|
| BigintToUint8 |
|
| BinaryBooleanOperator |
|
| BinaryBooleanOperator.And |
|
| BinaryBooleanOperator.Or |
|
| BinaryBooleanOperator.PartialVisitor<R> |
|
| BinaryBooleanOperator.Visitor<R> |
|
| BinaryBooleanOperator.Xor |
|
| BinaryExpression |
|
| BinaryOperator |
|
| BinaryOperator.Boolean_ |
|
| BinaryOperator.Comparison |
|
| BinaryOperator.PartialVisitor<R> |
|
| BinaryOperator.Power |
|
| BinaryOperator.Visitor<R> |
|
| Bind |
|
| Bind |
|
| Bind |
|
| Binding |
|
| BlankNode |
|
| Block |
|
| BlockStatement |
|
| BlockStatement.Class_ |
|
| BlockStatement.LocalVariableDeclaration |
|
| BlockStatement.PartialVisitor<R> |
|
| BlockStatement.Statement |
|
| BlockStatement.Visitor<R> |
|
| BlockStyle |
Formatting option for code blocks
|
| BooleanArray |
|
| BooleanArray.Array |
|
| BooleanArray.PartialVisitor<R> |
|
| BooleanArray.Simple |
|
| BooleanArray.Visitor<R> |
|
| BooleanValue |
|
| BooleanValue.False |
|
| BooleanValue.PartialVisitor<R> |
|
| BooleanValue.True |
|
| BooleanValue.Visitor<R> |
|
| BracketExpr |
An expression enclosed by brackets
|
| Brackets |
Matching open and close bracket symbols
|
| BreakStatement |
|
| Cardinality |
Whether a field is optional, required, or repeated.
|
| Cardinality.Optional |
For optional fields.
|
| Cardinality.PartialVisitor<R> |
|
| Cardinality.Repeated |
For repeated fields.
|
| Cardinality.Required |
For required fields.
|
| Cardinality.Unknown |
For fields with unknown cardinality.
|
| Cardinality.Visitor<R> |
|
| Case |
|
| CaseAlternative |
|
| CaseExpression |
|
| CaseRhs |
The right-hand side of a pattern-matching alternative
|
| CaseStatement |
A union elimination; a case statement
|
| CaseTree |
|
| CaseTree.Case |
|
| CaseTree.PartialVisitor<R> |
|
| CaseTree.TypeCase |
|
| CaseTree.Visitor<R> |
|
| CastExpression |
|
| CastExpression_Lambda |
|
| CastExpression_NotPlusMinus |
|
| CastExpression_Primitive |
|
| CastExpression_RefAndBounds |
|
| CastExpression.Lambda |
|
| CastExpression.NotPlusMinus |
|
| CastExpression.PartialVisitor<R> |
|
| CastExpression.Primitive |
|
| CastExpression.Visitor<R> |
|
| Cat |
|
| Cat |
|
| Cat2 |
|
| CatchClause |
|
| Catches |
|
| CatchFormalParameter |
|
| CatchType |
|
| ClassBody |
|
| ClassBodyDeclaration |
|
| ClassBodyDeclaration.ClassMember |
|
| ClassBodyDeclaration.ConstructorDeclaration |
|
| ClassBodyDeclaration.InstanceInitializer |
|
| ClassBodyDeclaration.PartialVisitor<R> |
|
| ClassBodyDeclaration.StaticInitializer |
|
| ClassBodyDeclaration.Visitor<R> |
|
| ClassBodyDeclarationWithComments |
|
| ClassDeclaration |
|
| ClassDeclaration.Enum_ |
|
| ClassDeclaration.Normal |
|
| ClassDeclaration.PartialVisitor<R> |
|
| ClassDeclaration.Visitor<R> |
|
| ClassInstanceCreationExpression |
|
| ClassInstanceCreationExpression_Qualifier |
|
| ClassInstanceCreationExpression_Qualifier.Expression |
|
| ClassInstanceCreationExpression_Qualifier.PartialVisitor<R> |
|
| ClassInstanceCreationExpression_Qualifier.Primary |
|
| ClassInstanceCreationExpression_Qualifier.Visitor<R> |
|
| ClassLiteral |
|
| ClassLiteral.Boolean_ |
|
| ClassLiteral.NumericType |
|
| ClassLiteral.PartialVisitor<R> |
|
| ClassLiteral.Type |
|
| ClassLiteral.Visitor<R> |
|
| ClassLiteral.Void_ |
|
| ClassMemberDeclaration |
|
| ClassMemberDeclaration.Class_ |
|
| ClassMemberDeclaration.Field |
|
| ClassMemberDeclaration.Interface |
|
| ClassMemberDeclaration.Method |
|
| ClassMemberDeclaration.None |
|
| ClassMemberDeclaration.PartialVisitor<R> |
|
| ClassMemberDeclaration.Visitor<R> |
|
| ClassModifier |
|
| ClassModifier.Abstract |
|
| ClassModifier.Annotation |
|
| ClassModifier.Final |
|
| ClassModifier.PartialVisitor<R> |
|
| ClassModifier.Private |
|
| ClassModifier.Protected |
|
| ClassModifier.Public |
|
| ClassModifier.Static |
|
| ClassModifier.Strictfp |
|
| ClassModifier.Visitor<R> |
|
| ClassOrInterfaceType |
|
| ClassOrInterfaceType.Class_ |
|
| ClassOrInterfaceType.Interface |
|
| ClassOrInterfaceType.PartialVisitor<R> |
|
| ClassOrInterfaceType.Visitor<R> |
|
| ClassOrInterfaceTypeToInstantiate |
|
| ClassType |
|
| ClassTypeQualifier |
|
| ClassTypeQualifier.None |
|
| ClassTypeQualifier.Package_ |
|
| ClassTypeQualifier.Parent |
|
| ClassTypeQualifier.PartialVisitor<R> |
|
| ClassTypeQualifier.Visitor<R> |
|
| Closed |
See https://www.w3.org/TR/shacl/#ClosedPatterConstraintComponent
|
| Coder<S1,S2,V1,V2> |
An encoder and decoder; a bidirectional flow between two types
|
| CoderDirection |
Indicates either the 'out' or the 'in' direction of a coder
|
| CoderDirection.Decode |
|
| CoderDirection.Encode |
|
| CoderDirection.PartialVisitor<R> |
|
| CoderDirection.Visitor<R> |
|
| Coders |
Convenience functions for working with Hydra coders.
|
| ColumnName |
A name for a domain which serves to identify the role played by that domain in the given relation; a 'role name' in Codd
|
| ColumnSchema<T> |
An abstract specification of the domain represented by a column in a relation; a role
|
| CommonConstraint |
Any of a number of constraint parameters which can be applied either to node or property shapes
|
| CommonConstraint.And |
See https://www.w3.org/TR/shacl/#AndConstraintComponent
|
| CommonConstraint.Class_ |
See https://www.w3.org/TR/shacl/#ClassConstraintComponent
|
| CommonConstraint.Closed |
See https://www.w3.org/TR/shacl/#ClosedConstraintComponent
|
| CommonConstraint.Datatype |
See https://www.w3.org/TR/shacl/#DatatypeConstraintComponent
|
| CommonConstraint.Disjoint |
See https://www.w3.org/TR/shacl/#DisjointConstraintComponent
|
| CommonConstraint.Equals |
See https://www.w3.org/TR/shacl/#EqualsConstraintComponent
|
| CommonConstraint.HasValue |
Specifies the condition that at least one value node is equal to the given RDF term.
|
| CommonConstraint.In |
Specifies the condition that each value node is a member of a provided SHACL list.
|
| CommonConstraint.LanguageIn |
See https://www.w3.org/TR/shacl/#LanguageInConstraintComponent
|
| CommonConstraint.MaxExclusive |
See https://www.w3.org/TR/shacl/#MaxExclusiveConstraintComponent
|
| CommonConstraint.MaxInclusive |
See https://www.w3.org/TR/shacl/#MaxInclusiveConstraintComponent
|
| CommonConstraint.MaxLength |
See https://www.w3.org/TR/shacl/#MaxLengthConstraintComponent
|
| CommonConstraint.MinExclusive |
See https://www.w3.org/TR/shacl/#MinExclusiveConstraintComponent
|
| CommonConstraint.MinInclusive |
See https://www.w3.org/TR/shacl/#MinInclusiveConstraintComponent
|
| CommonConstraint.MinLength |
See https://www.w3.org/TR/shacl/#MinLengthConstraintComponent
|
| CommonConstraint.Node |
See https://www.w3.org/TR/shacl/#NodeConstraintComponent
|
| CommonConstraint.NodeKind |
See https://www.w3.org/TR/shacl/#NodeKindConstraintComponent
|
| CommonConstraint.Not |
See https://www.w3.org/TR/shacl/#NotConstraintComponent
|
| CommonConstraint.Or |
See https://www.w3.org/TR/shacl/#OrConstraintComponent
|
| CommonConstraint.PartialVisitor<R> |
|
| CommonConstraint.Pattern |
See https://www.w3.org/TR/shacl/#PatternConstraintComponent
|
| CommonConstraint.Property |
See https://www.w3.org/TR/shacl/#PropertyConstraintComponent
|
| CommonConstraint.Visitor<R> |
|
| CommonConstraint.Xone |
See https://www.w3.org/TR/shacl/#XoneConstraintComponent
|
| CommonProperties |
Common constraint parameters and other properties for SHACL shapes
|
| Comparison |
An equality judgement: less than, equal to, or greater than
|
| Comparison.EqualTo |
|
| Comparison.GreaterThan |
|
| Comparison.LessThan |
|
| Comparison.PartialVisitor<R> |
|
| Comparison.Visitor<R> |
|
| ComparisonConstraint |
One of several comparison operators
|
| ComparisonConstraint.Equal |
|
| ComparisonConstraint.GreaterThan |
|
| ComparisonConstraint.GreaterThanOrEqual |
|
| ComparisonConstraint.LessThan |
|
| ComparisonConstraint.LessThanOrEqual |
|
| ComparisonConstraint.NotEqual |
|
| ComparisonConstraint.PartialVisitor<R> |
|
| ComparisonConstraint.Visitor<R> |
|
| ComparisonExpression |
|
| ComparisonFeatures |
Comparison operators and functions
|
| ComparisonOperator |
|
| ComparisonOperator |
|
| ComparisonOperator.Eq |
|
| ComparisonOperator.Eq |
|
| ComparisonOperator.Gt |
|
| ComparisonOperator.Gt |
|
| ComparisonOperator.Gte |
|
| ComparisonOperator.Gte |
|
| ComparisonOperator.Lt |
|
| ComparisonOperator.Lt |
|
| ComparisonOperator.Lte |
|
| ComparisonOperator.Lte |
|
| ComparisonOperator.Neq |
|
| ComparisonOperator.Neq |
|
| ComparisonOperator.PartialVisitor<R> |
|
| ComparisonOperator.PartialVisitor<R> |
|
| ComparisonOperator.Visitor<R> |
|
| ComparisonOperator.Visitor<R> |
|
| CompilationUnit |
|
| CompilationUnit.Modular |
|
| CompilationUnit.Ordinary |
|
| CompilationUnit.PartialVisitor<R> |
|
| CompilationUnit.Visitor<R> |
|
| Compose |
|
| Concat |
|
| Concat2 |
|
| ConditionalAndExpression |
|
| ConditionalExpression |
|
| ConditionalExpression_TernaryCond |
|
| ConditionalExpression_TernaryLambda |
|
| ConditionalExpression.PartialVisitor<R> |
|
| ConditionalExpression.Simple |
|
| ConditionalExpression.TernaryCond |
|
| ConditionalExpression.TernaryLambda |
|
| ConditionalExpression.Visitor<R> |
|
| ConditionalOrExpression |
|
| Cons |
|
| Constant |
A constant pattern
|
| ConstantDeclaration |
|
| ConstantExpression |
|
| ConstantModifier |
|
| ConstantModifier.Annotation |
|
| ConstantModifier.Final |
|
| ConstantModifier.PartialVisitor<R> |
|
| ConstantModifier.Public |
|
| ConstantModifier.Static |
|
| ConstantModifier.Visitor<R> |
|
| Constants |
A module for tier-0 constants.
|
| Constructor |
A data constructor
|
| Constructor_Ordinary |
An ordinary (positional) data constructor
|
| Constructor_Record |
A record-style data constructor
|
| Constructor.Ordinary |
|
| Constructor.PartialVisitor<R> |
|
| Constructor.Record |
|
| Constructor.Visitor<R> |
|
| ConstructorBody |
|
| ConstructorDeclaration |
|
| ConstructorDeclarator |
|
| ConstructorModifier |
|
| ConstructorModifier.Annotation |
|
| ConstructorModifier.PartialVisitor<R> |
|
| ConstructorModifier.Private |
|
| ConstructorModifier.Protected |
|
| ConstructorModifier.Public |
|
| ConstructorModifier.Visitor<R> |
|
| ConstructorWithComments |
A data constructor together with any comments
|
| Contains |
|
| ContinueStatement |
|
| Core |
|
| CoreEncoding |
Mapping of hydra/core constructs in a host language like Haskell or Java to their native Hydra counterparts as terms.
|
| CoreLanguage |
Language constraints for Hydra Core
|
| Create |
|
| Ctor |
|
| Ctor_Primary |
|
| Ctor_Secondary |
|
| Ctor.PartialVisitor<R> |
|
| Ctor.Primary |
|
| Ctor.Secondary |
|
| Ctor.Visitor<R> |
|
| CypherBaseVisitor<T> |
This class provides an empty implementation of CypherVisitor,
which can be extended to create a visitor which only needs to handle a subset
of the available methods. |
| CypherFeatures |
A set of features which characterize an OpenCypher query or implementation.
|
| CypherLexer |
|
| CypherParser |
|
| CypherParser.OC_AddOrSubtractExpression_OperatorContext |
|
| CypherParser.OC_AddOrSubtractExpression_RHSContext |
|
| CypherParser.OC_AddOrSubtractExpressionContext |
|
| CypherParser.OC_AndExpressionContext |
|
| CypherParser.OC_AnonymousPatternPartContext |
|
| CypherParser.OC_AtomContext |
|
| CypherParser.OC_BooleanLiteralContext |
|
| CypherParser.OC_CaseAlternativeContext |
|
| CypherParser.Oc_CaseElseContext |
|
| CypherParser.OC_CaseExpressionContext |
|
| CypherParser.OC_ComparisonExpressionContext |
|
| CypherParser.OC_ComparisonOperatorContext |
|
| CypherParser.OC_CreateContext |
|
| CypherParser.OC_CypherContext |
|
| CypherParser.OC_DashContext |
|
| CypherParser.OC_DeleteContext |
|
| CypherParser.OC_DoubleLiteralContext |
|
| CypherParser.OC_ExistentialSubqueryContext |
|
| CypherParser.OC_ExplicitProcedureInvocationContext |
|
| CypherParser.OC_ExpressionContext |
|
| CypherParser.OC_FilterExpressionContext |
|
| CypherParser.OC_FunctionInvocationContext |
|
| CypherParser.OC_FunctionNameContext |
|
| CypherParser.OC_IdInCollContext |
|
| CypherParser.OC_ImplicitProcedureInvocationContext |
|
| CypherParser.OC_InQueryCallContext |
|
| CypherParser.OC_IntegerLiteralContext |
|
| CypherParser.Oc_KeyValuePairContext |
|
| CypherParser.OC_LabelNameContext |
|
| CypherParser.OC_LeftArrowHeadContext |
|
| CypherParser.OC_LimitContext |
|
| CypherParser.OC_ListComprehensionContext |
|
| CypherParser.OC_ListLiteralContext |
|
| CypherParser.OC_ListOperatorExpressionContext |
|
| CypherParser.OC_ListOperatorExpressionOrPropertyLookupContext |
|
| CypherParser.OC_ListOperatorExpressionRangeContext |
|
| CypherParser.OC_ListOperatorExpressionRangeLHSContext |
|
| CypherParser.OC_ListOperatorExpressionRangeRHSContext |
|
| CypherParser.OC_ListOperatorExpressionSingleContext |
|
| CypherParser.OC_ListPredicateExpressionContext |
|
| CypherParser.OC_LiteralContext |
|
| CypherParser.OC_MapLiteralContext |
|
| CypherParser.OC_MatchContext |
|
| CypherParser.OC_MatchOrCreateContext |
|
| CypherParser.OC_MergeActionContext |
|
| CypherParser.OC_MergeContext |
|
| CypherParser.OC_MultiPartQueryContext |
|
| CypherParser.OC_MultiplyDivideModuloExpression_OperatorContext |
|
| CypherParser.OC_MultiplyDivideModuloExpression_RHSContext |
|
| CypherParser.OC_MultiplyDivideModuloExpressionContext |
|
| CypherParser.OC_NamespaceContext |
|
| CypherParser.OC_NodeLabelContext |
|
| CypherParser.OC_NodeLabelsContext |
|
| CypherParser.OC_NodePatternContext |
|
| CypherParser.OC_NonArithmeticOperatorExpressionContext |
|
| CypherParser.OC_NotExpressionContext |
|
| CypherParser.OC_NullPredicateExpressionContext |
|
| CypherParser.OC_NumberLiteralContext |
|
| CypherParser.OC_OrderContext |
|
| CypherParser.OC_OrExpressionContext |
|
| CypherParser.OC_ParameterContext |
|
| CypherParser.OC_ParenthesizedExpressionContext |
|
| CypherParser.OC_PartialComparisonExpressionContext |
|
| CypherParser.OC_PatternComprehensionContext |
|
| CypherParser.OC_PatternContext |
|
| CypherParser.OC_PatternElementChainContext |
|
| CypherParser.OC_PatternElementContext |
|
| CypherParser.OC_PatternPartContext |
|
| CypherParser.OC_PatternPredicateContext |
|
| CypherParser.OC_PatternWhereContext |
|
| CypherParser.OC_PowerOfExpressionContext |
|
| CypherParser.OC_ProcedureInvocationContext |
|
| CypherParser.OC_ProcedureNameContext |
|
| CypherParser.OC_ProcedureResultFieldContext |
|
| CypherParser.OC_ProjectionBodyContext |
|
| CypherParser.OC_ProjectionItemContext |
|
| CypherParser.OC_ProjectionItemsContext |
|
| CypherParser.OC_PropertiesContext |
|
| CypherParser.OC_PropertyExpressionContext |
|
| CypherParser.OC_PropertyKeyNameContext |
|
| CypherParser.OC_PropertyLookupContext |
|
| CypherParser.OC_QuantifierContext |
|
| CypherParser.OC_QuantifierOperatorContext |
|
| CypherParser.OC_QueryContext |
|
| CypherParser.OC_RangeLiteralContext |
|
| CypherParser.OC_RangeLiteralUpperBoundContext |
|
| CypherParser.OC_ReadingClauseContext |
|
| CypherParser.OC_RegularQueryContext |
|
| CypherParser.OC_RelationshipDetailContext |
|
| CypherParser.OC_RelationshipPatternContext |
|
| CypherParser.OC_RelationshipsPatternContext |
|
| CypherParser.OC_RelationshipTypesContext |
|
| CypherParser.OC_RelTypeNameContext |
|
| CypherParser.OC_RemoveContext |
|
| CypherParser.OC_RemoveItemContext |
|
| CypherParser.OC_ReservedWordContext |
|
| CypherParser.OC_ReturnContext |
|
| CypherParser.OC_RightArrowHeadContext |
|
| CypherParser.OC_SchemaNameContext |
|
| CypherParser.OC_SetContext |
|
| CypherParser.OC_SetItem_EqualContext |
|
| CypherParser.OC_SetItem_NodeLabelsContext |
|
| CypherParser.OC_SetItem_PlusEqualContext |
|
| CypherParser.OC_SetItem_PropertyContext |
|
| CypherParser.OC_SetItemContext |
|
| CypherParser.OC_SinglePartQueryContext |
|
| CypherParser.OC_SingleQueryContext |
|
| CypherParser.OC_SkipContext |
|
| CypherParser.OC_SortItemContext |
|
| CypherParser.OC_SortOrder_AscendingContext |
|
| CypherParser.OC_SortOrder_DescendingContext |
|
| CypherParser.OC_SortOrderContext |
|
| CypherParser.OC_StandaloneCallContext |
|
| CypherParser.OC_StarOrYieldItemsContext |
|
| CypherParser.OC_StatementContext |
|
| CypherParser.OC_StringListNullPredicateExpression_RHSContext |
|
| CypherParser.OC_StringListNullPredicateExpressionContext |
|
| CypherParser.OC_StringPredicateExpressionContext |
|
| CypherParser.OC_StringPredicateOperatorContext |
|
| CypherParser.OC_SymbolicNameContext |
|
| CypherParser.OC_UnaryAddOrSubtractExpression_OperatorContext |
|
| CypherParser.OC_UnaryAddOrSubtractExpressionContext |
|
| CypherParser.OC_UnionContext |
|
| CypherParser.OC_UnwindContext |
|
| CypherParser.OC_UpdatingClauseContext |
|
| CypherParser.OC_VariableAndNodeLabelsContext |
|
| CypherParser.OC_VariableContext |
|
| CypherParser.OC_WhereContext |
|
| CypherParser.Oc_WithClauseContext |
|
| CypherParser.OC_WithContext |
|
| CypherParser.OC_XorExpressionContext |
|
| CypherParser.OC_YieldItemContext |
|
| CypherParser.OC_YieldItemsContext |
|
| CypherReader |
A parser which constructs Cypher queries using the hydra/ext/cypher/openCypher model.
|
| CypherVisitor<T> |
This interface defines a complete generic visitor for a parse tree produced
by CypherParser. |
| Data |
|
| Data_Annotate |
|
| Data_Anonymous |
|
| Data_Apply |
|
| Data_ApplyInfix |
|
| Data_ApplyType |
|
| Data_ApplyUnary |
|
| Data_ApplyUsing |
|
| Data_Ascribe |
|
| Data_Assign |
|
| Data_Block |
|
| Data_ContextFunction |
|
| Data_Do |
|
| Data_EndMarker |
|
| Data_Eta |
|
| Data_For |
|
| Data_ForYield |
|
| Data_Function |
|
| Data_FunctionData |
|
| Data_FunctionData.ContextFunction |
|
| Data_FunctionData.Function |
|
| Data_FunctionData.PartialVisitor<R> |
|
| Data_FunctionData.Visitor<R> |
|
| Data_If |
|
| Data_Interpolate |
|
| Data_Match |
|
| Data_Name |
|
| Data_New |
|
| Data_NewAnonymous |
|
| Data_Param |
|
| Data_PartialFunction |
|
| Data_Placeholder |
|
| Data_PolyFunction |
|
| Data_QuotedMacroExpr |
|
| Data_QuotedMacroType |
|
| Data_Ref |
|
| Data_Ref.Anonymous |
|
| Data_Ref.ApplyUnary |
|
| Data_Ref.Name |
|
| Data_Ref.PartialVisitor<R> |
|
| Data_Ref.Select |
|
| Data_Ref.Super |
|
| Data_Ref.This |
|
| Data_Ref.Visitor<R> |
|
| Data_Repeated |
|
| Data_Return |
|
| Data_Select |
|
| Data_SplicedMacroExpr |
|
| Data_Super |
|
| Data_This |
|
| Data_Throw |
|
| Data_Try |
|
| Data_TryWithHandler |
|
| Data_Tuple |
|
| Data_While |
|
| Data_Xml |
|
| Data.Annotate |
|
| Data.Apply |
|
| Data.ApplyType |
|
| Data.ApplyUsing |
|
| Data.Ascribe |
|
| Data.Assign |
|
| Data.Block |
|
| Data.Do |
|
| Data.EndMarker |
|
| Data.Eta |
|
| Data.For |
|
| Data.ForYield |
|
| Data.FunctionData |
|
| Data.If |
|
| Data.Interpolate |
|
| Data.Lit |
|
| Data.Match |
|
| Data.New |
|
| Data.NewAnonymous |
|
| Data.Param |
|
| Data.PartialFunction |
|
| Data.PartialVisitor<R> |
|
| Data.Placeholder |
|
| Data.PolyFunction |
|
| Data.QuotedMacroExpr |
|
| Data.QuotedMacroType |
|
| Data.Ref |
|
| Data.Repeated |
|
| Data.Return |
|
| Data.SplicedMacroExpr |
|
| Data.Throw |
|
| Data.Try |
|
| Data.TryWithHandler |
|
| Data.Tuple |
|
| Data.Visitor<R> |
|
| Data.While |
|
| Data.Xml |
|
| DatabaseFunctionFeatures |
Database functions
|
| DataDeclaration |
A data type declaration
|
| DataDeclaration_Keyword |
The 'data' versus 'newtype keyword
|
| DataDeclaration_Keyword.Data |
|
| DataDeclaration_Keyword.Newtype |
|
| DataDeclaration_Keyword.PartialVisitor<R> |
|
| DataDeclaration_Keyword.Visitor<R> |
|
| DataRow<V> |
A data row, containing optional-valued cells; one per column
|
| Dataset |
|
| Decl |
|
| Decl_Def |
|
| Decl_Given |
|
| Decl_Type |
|
| Decl_Val |
|
| Decl_Var |
|
| Decl.Def |
|
| Decl.Given |
|
| Decl.PartialVisitor<R> |
|
| Decl.Type |
|
| Decl.Val |
|
| Decl.Var |
|
| Decl.Visitor<R> |
|
| Declaration |
A data or value declaration
|
| Declaration.Data |
|
| Declaration.PartialVisitor<R> |
|
| Declaration.Type |
|
| Declaration.TypedBinding |
|
| Declaration.ValueBinding |
|
| Declaration.Visitor<R> |
|
| DeclarationHead |
The left-hand side of a declaration
|
| DeclarationHead_Application |
An application-style declaration head
|
| DeclarationHead.Application |
|
| DeclarationHead.Parens |
|
| DeclarationHead.PartialVisitor<R> |
|
| DeclarationHead.Simple |
|
| DeclarationHead.Visitor<R> |
|
| DeclarationWithComments |
A data declaration together with any comments
|
| Decoding |
Decoding functions for JSON data
|
| DefaultValue |
|
| DefaultValue |
|
| Definition |
|
| Definition<A> |
An instance of a type like sh:Shape or sh:NodeShape, together with a unique IRI for that instance
|
| Definition |
|
| Definition.Enum_ |
|
| Definition.Executable |
|
| Definition.Message |
|
| Definition.PartialVisitor<R> |
|
| Definition.PartialVisitor<R> |
|
| Definition.TypeSystem |
|
| Definition.Visitor<R> |
|
| Definition.Visitor<R> |
|
| Defn |
|
| Defn_Class |
|
| Defn_Def |
|
| Defn_Enum |
|
| Defn_EnumCase |
|
| Defn_ExtensionGroup |
|
| Defn_Given |
|
| Defn_GivenAlias |
|
| Defn_Macro |
|
| Defn_Object |
|
| Defn_RepeatedEnumCase |
|
| Defn_Trait |
|
| Defn_Type |
|
| Defn_Val |
|
| Defn_Var |
|
| Defn.Class_ |
|
| Defn.Def |
|
| Defn.Enum_ |
|
| Defn.EnumCase |
|
| Defn.ExtensionGroup |
|
| Defn.Given |
|
| Defn.GivenAlias |
|
| Defn.Macro |
|
| Defn.Object_ |
|
| Defn.PartialVisitor<R> |
|
| Defn.RepeatedEnumCase |
|
| Defn.Trait |
|
| Defn.Type |
|
| Defn.Val |
|
| Defn.Var |
|
| Defn.Visitor<R> |
|
| Delete |
|
| DeleteFeatures |
Delete operations
|
| Deriving |
A 'deriving' statement
|
| Description |
|
| Description |
A graph of RDF statements together with a distinguished subject and/or object node
|
| Difference |
|
| DimExpr |
|
| Dims |
|
| Direction |
The direction of an edge or edge pattern
|
| Direction.Both |
|
| Direction.In |
|
| Direction.Out |
|
| Direction.PartialVisitor<R> |
|
| Direction.Undirected |
|
| Direction.Visitor<R> |
|
| Directive |
|
| DirectiveDefinition |
|
| DirectiveLocation |
|
| DirectiveLocation.Executable |
|
| DirectiveLocation.PartialVisitor<R> |
|
| DirectiveLocation.TypeSystem |
|
| DirectiveLocation.Visitor<R> |
|
| DirectiveLocations |
|
| DirectiveLocations_Sequence |
|
| DirectiveLocations_Sequence2 |
|
| DirectiveLocations.PartialVisitor<R> |
|
| DirectiveLocations.Sequence |
|
| DirectiveLocations.Sequence2 |
|
| DirectiveLocations.Visitor<R> |
|
| Directives |
|
| Div |
|
| Document |
|
| DoStatement |
|
| Edge<V> |
An edge
|
| Edge |
An abstract edge based on a record type
|
| EdgeBuilder<V> |
A builder object for property graph edges.
|
| EdgeLabel |
The label of an edge
|
| EdgeProjectionPattern |
|
| EdgeSpec |
A mapping specification producing edges of a specified label.
|
| EdgeType<T> |
The type of an edge
|
| EdgeTypeBuilder<T> |
A builder object for property graph edge types.
|
| Either<A,B> |
A disjoint union between a 'left' type and a 'right' type
|
| Either.Left<A,B> |
|
| Either.PartialVisitor<A,B,R> |
|
| Either.Right<A,B> |
|
| Either.Visitor<A,B,R> |
|
| Element |
A graph element, having a name, data term (value), and schema term (type)
|
| Element<V> |
Either a vertex or an edge
|
| Element.Edge<V> |
|
| Element.PartialVisitor<V,R> |
|
| Element.Vertex<V> |
|
| Element.Visitor<V,R> |
|
| ElementBuilder<V,S,B extends ElementBuilder<V,S,B>> |
|
| ElementKind |
The kind of an element: vertex or edge
|
| ElementKind.Edge |
|
| ElementKind.PartialVisitor<R> |
|
| ElementKind.Vertex |
|
| ElementKind.Visitor<R> |
|
| ElementSpec |
Either a vertex specification or an edge specification
|
| ElementSpec.Edge |
|
| ElementSpec.PartialVisitor<R> |
|
| ElementSpec.Vertex |
|
| ElementSpec.Visitor<R> |
|
| ElementTree<V> |
An element together with its dependencies in some context
|
| ElementType<T> |
The type of a vertex or edge
|
| ElementType.Edge<T> |
|
| ElementType.PartialVisitor<T,R> |
|
| ElementType.Vertex<T> |
|
| ElementType.Visitor<T,R> |
|
| ElementTypeBuilder<T,S,B extends ElementTypeBuilder<T,S,B>> |
|
| ElementTypeTree<T> |
An element type together with its dependencies in some context
|
| ElementValue |
|
| ElementValue.Annotation |
|
| ElementValue.ConditionalExpression |
|
| ElementValue.ElementValueArrayInitializer |
|
| ElementValue.PartialVisitor<R> |
|
| ElementValue.Visitor<R> |
|
| ElementValueArrayInitializer |
|
| ElementValuePair |
|
| Elimination |
A corresponding elimination for an introduction term
|
| Elimination.List |
Eliminates a list using a fold function; this function has the signature b -> [a] -> b
|
| Elimination.Optional |
Eliminates an optional term by matching over the two possible cases
|
| Elimination.PartialVisitor<R> |
|
| Elimination.Product |
Eliminates a tuple by projecting the component at a given 0-indexed offset
|
| Elimination.Record |
Eliminates a record by projecting a given field
|
| Elimination.Union |
Eliminates a union term by matching over the fields of the union.
|
| Elimination.Visitor<R> |
|
| Elimination.Wrap |
Unwrap a wrapped term
|
| EliminationVariant |
The identifier of an elimination constructor
|
| EliminationVariant.List |
|
| EliminationVariant.Optional |
|
| EliminationVariant.PartialVisitor<R> |
|
| EliminationVariant.Product |
|
| EliminationVariant.Record |
|
| EliminationVariant.Union |
|
| EliminationVariant.Visitor<R> |
|
| EliminationVariant.Wrap |
|
| Empty |
|
| Empty |
|
| EmptyStatement |
|
| EnhancedForCond |
|
| EnhancedForStatement |
|
| EnhancedForStatementNoShortIf |
|
| Enum_ |
|
| Enum_ |
Enum type definition.
|
| EnumBody |
|
| EnumBody_Element |
|
| EnumConstant |
|
| EnumConstantModifier |
|
| EnumConstantName |
|
| EnumDeclaration |
|
| EnumDefinition |
Enum type definition
|
| Enumerator |
|
| Enumerator_CaseGenerator |
|
| Enumerator_Generator |
|
| Enumerator_Guard |
|
| Enumerator_Val |
|
| Enumerator.CaseGenerator |
|
| Enumerator.Generator |
|
| Enumerator.Guard |
|
| Enumerator.PartialVisitor<R> |
|
| Enumerator.Val |
|
| Enumerator.Visitor<R> |
|
| EnumField |
|
| EnumFieldName |
|
| EnumSchema |
|
| EnumTypeDefinition |
|
| EnumTypeExtension |
|
| EnumTypeExtension_Sequence |
|
| EnumTypeExtension_Sequence2 |
|
| EnumTypeExtension.PartialVisitor<R> |
|
| EnumTypeExtension.Sequence |
|
| EnumTypeExtension.Sequence2 |
|
| EnumTypeExtension.Visitor<R> |
|
| EnumValue |
|
| EnumValue |
Enum value definition
|
| EnumValue |
Enum value definition.
|
| EnumValueDefinition |
|
| EnumValueName |
|
| EnumValuesDefinition |
|
| Equal |
|
| EqualBigfloat |
|
| EqualBigint |
|
| EqualBinary |
|
| EqualBoolean |
|
| EqualFloat32 |
|
| EqualFloat64 |
|
| EqualInt16 |
|
| EqualInt32 |
|
| EqualInt64 |
|
| EqualInt8 |
|
| Equality |
|
| EqualityExpression |
|
| EqualityExpression_Binary |
|
| EqualityExpression.Equal |
|
| EqualityExpression.NotEqual |
|
| EqualityExpression.PartialVisitor<R> |
|
| EqualityExpression.Unary |
|
| EqualityExpression.Visitor<R> |
|
| EqualityFunction<T> |
|
| EqualityFunction.Relation |
|
| EqualString |
|
| EqualTerm |
|
| EqualType |
|
| EqualUint16 |
|
| EqualUint32 |
|
| EqualUint64 |
|
| EqualUint8 |
|
| EvaluationStyle |
One of two evaluation styles: eager or lazy
|
| EvaluationStyle.Eager |
|
| EvaluationStyle.Lazy |
|
| EvaluationStyle.PartialVisitor<R> |
|
| EvaluationStyle.Visitor<R> |
|
| ExceptionType |
|
| ExceptionType.Class_ |
|
| ExceptionType.PartialVisitor<R> |
|
| ExceptionType.Variable |
|
| ExceptionType.Visitor<R> |
|
| ExclusiveOrExpression |
|
| ExecutableDefinition |
|
| ExecutableDefinition.Fragment |
|
| ExecutableDefinition.Operation |
|
| ExecutableDefinition.PartialVisitor<R> |
|
| ExecutableDefinition.Visitor<R> |
|
| ExecutableDirectiveLocation |
|
| ExecutableDirectiveLocation.FIELD |
|
| ExecutableDirectiveLocation.FRAGMENTLowbarDEFINITION |
|
| ExecutableDirectiveLocation.FRAGMENTLowbarSPREAD |
|
| ExecutableDirectiveLocation.INLINELowbarFRAGMENT |
|
| ExecutableDirectiveLocation.MUTATION |
|
| ExecutableDirectiveLocation.PartialVisitor<R> |
|
| ExecutableDirectiveLocation.QUERY |
|
| ExecutableDirectiveLocation.SUBSCRIPTION |
|
| ExecutableDirectiveLocation.VARIABLELowbarDEFINITION |
|
| ExecutableDirectiveLocation.Visitor<R> |
|
| ExecutableDocument |
|
| ExistentialSubquery |
|
| ExistentialSubquery.PartialVisitor<R> |
|
| ExistentialSubquery.Pattern |
|
| ExistentialSubquery.Regular |
|
| ExistentialSubquery.Visitor<R> |
|
| Expect |
Functions for decoding of native Java values from Hydra terms.
|
| ExplicitConstructorInvocation |
|
| ExplicitConstructorInvocation_Variant |
|
| ExplicitConstructorInvocation_Variant.PartialVisitor<R> |
|
| ExplicitConstructorInvocation_Variant.Primary |
|
| ExplicitConstructorInvocation_Variant.Super |
|
| ExplicitConstructorInvocation_Variant.This |
|
| ExplicitConstructorInvocation_Variant.Visitor<R> |
|
| ExplicitProcedureInvocation |
|
| Export |
An export statement
|
| Export |
|
| Export.Declaration |
|
| Export.Module |
|
| Export.PartialVisitor<R> |
|
| Export.Visitor<R> |
|
| Expr |
An abstract expression
|
| Expr.Brackets |
|
| Expr.Const |
|
| Expr.Indent |
|
| Expr.Op |
|
| Expr.PartialVisitor<R> |
|
| Expr.Visitor<R> |
|
| Expression |
|
| Expression |
A data expression
|
| Expression |
|
| Expression |
|
| Expression_Application |
An application expression
|
| Expression_Case |
A case expression
|
| Expression_ConstructRecord |
A record constructor expression
|
| Expression_If |
An 'if' expression
|
| Expression_InfixApplication |
An infix application expression
|
| Expression_Lambda |
A lambda expression
|
| Expression_Let |
A 'let' expression
|
| Expression_PrefixApplication |
A prefix expression
|
| Expression_Section |
A section expression
|
| Expression_TypeSignature |
A type signature expression
|
| Expression_UpdateRecord |
An update record expression
|
| Expression.Application |
|
| Expression.Assignment |
|
| Expression.Associative |
|
| Expression.Binary |
|
| Expression.Case |
|
| Expression.ConstructRecord |
|
| Expression.Do |
|
| Expression.If |
|
| Expression.InfixApplication |
|
| Expression.Lambda |
|
| Expression.Lambda |
|
| Expression.LeftSection |
|
| Expression.Let |
|
| Expression.List |
|
| Expression.Literal |
|
| Expression.Parens |
|
| Expression.PartialVisitor<R> |
|
| Expression.PartialVisitor<R> |
|
| Expression.PartialVisitor<R> |
|
| Expression.PrefixApplication |
|
| Expression.Property |
|
| Expression.RightSection |
|
| Expression.Tuple |
|
| Expression.TypeSignature |
|
| Expression.Unary |
|
| Expression.UpdateRecord |
|
| Expression.Variable |
|
| Expression.Variable |
|
| Expression.Vertex |
|
| Expression.Visitor<R> |
|
| Expression.Visitor<R> |
|
| Expression.Visitor<R> |
|
| ExpressionName |
|
| ExpressionStatement |
|
| Extras |
Basic functions which depend on primitive functions
|
| Fail |
|
| Field |
A name/term pair
|
| Field |
|
| Field |
A field (name/type pair)
|
| Field |
|
| Field |
A single field of a message type
|
| Field |
A single field of a message type.
|
| Field.Cardinality |
The field cardinality.
|
| Field.DefaultValue |
The string value of the default value of this field.
|
| Field.JsonName |
The field JSON name.
|
| Field.Kind |
The field type.
|
| Field.Name |
The field name.
|
| Field.Number_ |
The field number.
|
| Field.OneofIndex |
The index of the field type in `Type.oneofs`, for message or enumeration types.
|
| Field.Options |
The protocol buffer options.
|
| Field.Packed |
Whether to use alternative packed wire representation.
|
| Field.PartialVisitor<R> |
|
| Field.TypeUrl |
The field type URL, without the scheme, for message or enumeration types.
|
| Field.Visitor<R> |
|
| FieldAccess |
|
| FieldAccess_Qualifier |
|
| FieldAccess_Qualifier.PartialVisitor<R> |
|
| FieldAccess_Qualifier.Primary |
|
| FieldAccess_Qualifier.Super |
|
| FieldAccess_Qualifier.Typed |
|
| FieldAccess_Qualifier.Visitor<R> |
|
| FieldDeclaration |
|
| FieldDefinition |
|
| FieldModifier |
|
| FieldModifier.Annotation |
|
| FieldModifier.Final |
|
| FieldModifier.PartialVisitor<R> |
|
| FieldModifier.Private |
|
| FieldModifier.Protected |
|
| FieldModifier.Public |
|
| FieldModifier.Static |
|
| FieldModifier.Transient |
|
| FieldModifier.Visitor<R> |
|
| FieldModifier.Volatile |
|
| FieldName |
|
| FieldName |
The name of a field
|
| FieldsDefinition |
|
| FieldType |
A name/type pair
|
| FieldType |
|
| FieldType.Map |
|
| FieldType.Oneof |
|
| FieldType.PartialVisitor<R> |
|
| FieldType.Repeated |
|
| FieldType.Simple |
|
| FieldType.Visitor<R> |
|
| FieldUpdate |
A field name and value
|
| FieldWithComments |
A field together with any comments
|
| FileExtension |
|
| FileReference |
|
| FilterExpression |
|
| Finally |
|
| Fixed |
|
| Float32ToBigfloat |
|
| Float64ToBigfloat |
|
| FloatingPointLiteral |
Note: this is an approximation which ignores encoding
|
| FloatingPointType |
|
| FloatingPointType.Double_ |
|
| FloatingPointType.Float_ |
|
| FloatingPointType.PartialVisitor<R> |
|
| FloatingPointType.Visitor<R> |
|
| FloatType |
A floating-point type
|
| FloatType.Bigfloat |
|
| FloatType.Float32 |
|
| FloatType.Float64 |
|
| FloatType.PartialVisitor<R> |
|
| FloatType.Visitor<R> |
|
| FloatValue |
A floating-point literal value
|
| FloatValue |
|
| FloatValue.Bigfloat |
An arbitrary-precision floating-point value
|
| FloatValue.Float32 |
A 32-bit floating-point value
|
| FloatValue.Float64 |
A 64-bit floating-point value
|
| FloatValue.PartialVisitor<R> |
|
| FloatValue.Visitor<R> |
|
| Flow<S,X> |
A variant of the State monad with built-in logging and error handling
|
| FlowException |
|
| Flows |
|
| Flows |
A collection of convenience methods for constructing and composing flows, or stateful computations.
|
| FlowState<S,X> |
The result of evaluating a Flow
|
| Foldl |
|
| ForCond |
|
| ForeignKey |
A mapping from certain columns of a source relation to primary key columns of a target relation
|
| ForInit |
|
| ForInit.LocalVariable |
|
| ForInit.PartialVisitor<R> |
|
| ForInit.Statements |
|
| ForInit.Visitor<R> |
|
| FormalParameter |
|
| FormalParameter_Simple |
|
| FormalParameter.PartialVisitor<R> |
|
| FormalParameter.Simple |
|
| FormalParameter.VariableArity |
|
| FormalParameter.Visitor<R> |
|
| ForStatement |
|
| ForStatement.Basic |
|
| ForStatement.Enhanced |
|
| ForStatement.PartialVisitor<R> |
|
| ForStatement.Visitor<R> |
|
| ForStatementNoShortIf |
|
| ForStatementNoShortIf.Basic |
|
| ForStatementNoShortIf.Enhanced |
|
| ForStatementNoShortIf.PartialVisitor<R> |
|
| ForStatementNoShortIf.Visitor<R> |
|
| ForUpdate |
|
| FragmentDefinition |
|
| FragmentName |
|
| FragmentSpread |
|
| FromCypher |
|
| FromList |
|
| FromList |
|
| FromList |
|
| Function |
A function
|
| Function.Elimination |
An elimination for any of a few term variants
|
| Function.Lambda |
A function abstraction (lambda)
|
| Function.PartialVisitor<R> |
|
| Function.Primitive |
A reference to a built-in (primitive) function
|
| Function.Visitor<R> |
|
| Function3<A,B,C,R> |
|
| Function4<A,B,C,D,R> |
|
| FunctionFeatures |
Standard Cypher functions
|
| FunctionInvocation |
|
| FunctionType |
A function type, also known as an arrow type
|
| FunctionVariant |
The identifier of a function constructor
|
| FunctionVariant.Elimination |
|
| FunctionVariant.Lambda |
|
| FunctionVariant.PartialVisitor<R> |
|
| FunctionVariant.Primitive |
|
| FunctionVariant.Visitor<R> |
|
| GenAIFunctionFeatures |
GenAI functions
|
| Grammar |
An enhanced Backus-Naur form (BNF) grammar
|
| Graph |
|
| Graph |
A graph, or set of name/term bindings together with parameters (annotations, primitives) and a schema graph
|
| Graph<V> |
A graph; a self-contained collection of vertices and edges
|
| GraphFunctionFeatures |
Graph functions
|
| GraphPattern |
A query pattern which matches within a designated component subgraph
|
| Graphs |
DSL for constructing property graph types (vertex and edge types, property types)
and values (vertices, edges, and properties).
|
| GraphSchema<T> |
A graph schema; a vertex and edge types for the vertices and edges of a graph conforming to the schema
|
| GteInt32 |
|
| GtInt32 |
|
| Head |
|
| HeaderRow |
A header row, containing column names (but no types or data)
|
| HydraSchemaSpec |
The specification of a Hydra schema, provided as a set of modules and a distinguished type
|
| HydraTestBase |
|
| Identifier |
|
| Identity |
|
| IdInColl |
|
| IfElse |
|
| IfThenElseStatement |
|
| IfThenElseStatementNoShortIf |
|
| IfThenStatement |
|
| ImplementsInterfaces |
|
| ImplementsInterfaces_Sequence |
|
| ImplementsInterfaces_Sequence2 |
|
| ImplementsInterfaces.PartialVisitor<R> |
|
| ImplementsInterfaces.Sequence |
|
| ImplementsInterfaces.Sequence2 |
|
| ImplementsInterfaces.Visitor<R> |
|
| ImplicitProcedureInvocation |
|
| Import |
An import statement
|
| Import |
|
| Import_Spec |
An import specification
|
| Import_Spec.Hiding |
|
| Import_Spec.List |
|
| Import_Spec.PartialVisitor<R> |
|
| Import_Spec.Visitor<R> |
|
| ImportDeclaration |
|
| ImportDeclaration.PartialVisitor<R> |
|
| ImportDeclaration.SingleStaticImport |
|
| ImportDeclaration.SingleType |
|
| ImportDeclaration.StaticImportOnDemand |
|
| ImportDeclaration.TypeImportOnDemand |
|
| ImportDeclaration.Visitor<R> |
|
| Importee |
|
| Importee_Given |
|
| Importee_Name |
|
| Importee_Rename |
|
| Importee_Unimport |
|
| Importee.Given |
|
| Importee.GivenAll |
|
| Importee.Name |
|
| Importee.PartialVisitor<R> |
|
| Importee.Rename |
|
| Importee.Unimport |
|
| Importee.Visitor<R> |
|
| Importee.Wildcard |
|
| Importer |
|
| ImportExportSpec |
An import or export specification
|
| ImportExportSpec_Subspec |
|
| ImportExportSpec_Subspec.All |
|
| ImportExportSpec_Subspec.List |
|
| ImportExportSpec_Subspec.PartialVisitor<R> |
|
| ImportExportSpec_Subspec.Visitor<R> |
|
| ImportExportStat |
|
| ImportExportStat.Export |
|
| ImportExportStat.Import |
|
| ImportExportStat.PartialVisitor<R> |
|
| ImportExportStat.Visitor<R> |
|
| ImportModifier |
An import modifier ('pattern' or 'type')
|
| ImportModifier.PartialVisitor<R> |
|
| ImportModifier.Pattern |
|
| ImportModifier.Type |
|
| ImportModifier.Visitor<R> |
|
| InclusiveOrExpression |
|
| IndentedExpression |
An expression indented in a certain style
|
| IndentStyle |
Any of several indentation styles
|
| IndentStyle.AllLines |
|
| IndentStyle.PartialVisitor<R> |
|
| IndentStyle.SubsequentLines |
|
| IndentStyle.Visitor<R> |
|
| Init |
|
| Injection |
An instance of a union type; i.e.
|
| InlineFragment |
|
| InputFieldsDefinition |
|
| InputObjectTypeDefinition |
|
| InputObjectTypeDefinition_Sequence |
|
| InputObjectTypeDefinition_Sequence2 |
|
| InputObjectTypeDefinition.PartialVisitor<R> |
|
| InputObjectTypeDefinition.Sequence |
|
| InputObjectTypeDefinition.Sequence2 |
|
| InputObjectTypeDefinition.Visitor<R> |
|
| InputObjectTypeExtension |
|
| InputObjectTypeExtension_Sequence |
|
| InputObjectTypeExtension_Sequence2 |
|
| InputObjectTypeExtension.PartialVisitor<R> |
|
| InputObjectTypeExtension.Sequence |
|
| InputObjectTypeExtension.Sequence2 |
|
| InputObjectTypeExtension.Visitor<R> |
|
| InputValueDefinition |
|
| InQueryCall |
|
| Insert |
|
| Insert |
|
| InstanceInitializer |
|
| Int16ToBigint |
|
| Int32ToBigint |
|
| Int64ToBigint |
|
| Int8ToBigint |
|
| IntegerLiteral |
Note: this is an approximation which ignores encoding
|
| IntegerType |
An integer type
|
| IntegerType.Bigint |
|
| IntegerType.Int16 |
|
| IntegerType.Int32 |
|
| IntegerType.Int64 |
|
| IntegerType.Int8 |
|
| IntegerType.PartialVisitor<R> |
|
| IntegerType.Uint16 |
|
| IntegerType.Uint32 |
|
| IntegerType.Uint64 |
|
| IntegerType.Uint8 |
|
| IntegerType.Visitor<R> |
|
| IntegerValue |
An integer literal value
|
| IntegerValue.Bigint |
An arbitrary-precision integer value
|
| IntegerValue.Int16 |
A 16-bit signed integer value (short value)
|
| IntegerValue.Int32 |
A 32-bit signed integer value (int value)
|
| IntegerValue.Int64 |
A 64-bit signed integer value (long value)
|
| IntegerValue.Int8 |
An 8-bit signed integer value
|
| IntegerValue.PartialVisitor<R> |
|
| IntegerValue.Uint16 |
A 16-bit unsigned integer value
|
| IntegerValue.Uint32 |
A 32-bit unsigned integer value (unsigned int)
|
| IntegerValue.Uint64 |
A 64-bit unsigned integer value (unsigned long)
|
| IntegerValue.Uint8 |
An 8-bit unsigned integer value (byte)
|
| IntegerValue.Visitor<R> |
|
| IntegralType |
|
| IntegralType.Byte_ |
|
| IntegralType.Char |
|
| IntegralType.Int |
|
| IntegralType.Long_ |
|
| IntegralType.PartialVisitor<R> |
|
| IntegralType.Short_ |
|
| IntegralType.Visitor<R> |
|
| Intercalate |
|
| Intercalate |
|
| InterfaceBody |
|
| InterfaceDeclaration |
|
| InterfaceDeclaration.AnnotationType |
|
| InterfaceDeclaration.NormalInterface |
|
| InterfaceDeclaration.PartialVisitor<R> |
|
| InterfaceDeclaration.Visitor<R> |
|
| InterfaceMemberDeclaration |
|
| InterfaceMemberDeclaration.Class_ |
|
| InterfaceMemberDeclaration.Constant |
|
| InterfaceMemberDeclaration.Interface |
|
| InterfaceMemberDeclaration.InterfaceMethod |
|
| InterfaceMemberDeclaration.PartialVisitor<R> |
|
| InterfaceMemberDeclaration.Visitor<R> |
|
| InterfaceMethodDeclaration |
|
| InterfaceMethodModifier |
|
| InterfaceMethodModifier.Abstract |
|
| InterfaceMethodModifier.Annotation |
|
| InterfaceMethodModifier.Default |
|
| InterfaceMethodModifier.PartialVisitor<R> |
|
| InterfaceMethodModifier.Private |
|
| InterfaceMethodModifier.Public |
|
| InterfaceMethodModifier.Static |
|
| InterfaceMethodModifier.Strictfp |
|
| InterfaceMethodModifier.Visitor<R> |
|
| InterfaceModifier |
|
| InterfaceModifier.Abstract |
|
| InterfaceModifier.Annotation |
|
| InterfaceModifier.PartialVisitor<R> |
|
| InterfaceModifier.Private |
|
| InterfaceModifier.Protected |
|
| InterfaceModifier.Public |
|
| InterfaceModifier.Static |
|
| InterfaceModifier.Strictfb |
|
| InterfaceModifier.Visitor<R> |
|
| InterfaceType |
|
| InterfaceTypeDefinition |
|
| InterfaceTypeDefinition_Sequence |
|
| InterfaceTypeDefinition_Sequence2 |
|
| InterfaceTypeDefinition.PartialVisitor<R> |
|
| InterfaceTypeDefinition.Sequence |
|
| InterfaceTypeDefinition.Sequence2 |
|
| InterfaceTypeDefinition.Visitor<R> |
|
| InterfaceTypeExtension |
|
| InterfaceTypeExtension_Sequence |
|
| InterfaceTypeExtension_Sequence2 |
|
| InterfaceTypeExtension_Sequence3 |
|
| InterfaceTypeExtension.PartialVisitor<R> |
|
| InterfaceTypeExtension.Sequence |
|
| InterfaceTypeExtension.Sequence2 |
|
| InterfaceTypeExtension.Sequence3 |
|
| InterfaceTypeExtension.Visitor<R> |
|
| Intersection |
|
| Intersperse |
|
| IntValue |
|
| Iri |
An Internationalized Resource Identifier
|
| IriOrLiteral |
An IRI or a literal; this type is a convenience for downstream models like SHACL which may exclude blank nodes
|
| IriOrLiteral.Iri |
|
| IriOrLiteral.Literal |
|
| IriOrLiteral.PartialVisitor<R> |
|
| IriOrLiteral.Visitor<R> |
|
| IsEmpty |
|
| IsEmpty |
|
| IsEmpty |
|
| IsJust |
|
| IsNothing |
|
| JsonDecoding |
Decoding functions for Hydra's native JSON values which are intended for use in Java.
|
| JsonDecoding.JsonDecodingException |
|
| JsonEncoding |
Encoding functions for Hydra's native JSON values
|
| JsonEncoding.ObjectBuilder |
|
| JsonIoCoder<S1,S2> |
A bidirectional coder between Hydra's native JSON values and the JSON objects supported by json-io.
|
| JsonSerde<S1,S2> |
A bidirectional coder between Hydra's native JSON values and strings (via json-io).
|
| Keys |
|
| KeyValuePair |
|
| Kind |
Basic field types.
|
| Kind.Bool |
Field type bool.
|
| Kind.Bytes |
Field type bytes.
|
| Kind.Double_ |
Field type double.
|
| Kind.Enum_ |
Field type enum.
|
| Kind.Fixed32 |
Field type fixed32.
|
| Kind.Fixed64 |
Field type fixed64.
|
| Kind.Float_ |
Field type float.
|
| Kind.Group |
Field type group.
|
| Kind.Int32 |
Field type int32.
|
| Kind.Int64 |
Field type int64.
|
| Kind.Message |
Field type message.
|
| Kind.PartialVisitor<R> |
|
| Kind.Sfixed32 |
Field type sfixed32.
|
| Kind.Sfixed64 |
Field type sfixed64.
|
| Kind.Sint32 |
Field type sint32.
|
| Kind.Sint64 |
Field type sint64.
|
| Kind.String_ |
Field type string.
|
| Kind.Uint32 |
Field type uint32.
|
| Kind.Uint64 |
Field type uint64.
|
| Kind.Unknown |
Field type unknown.
|
| Kind.Visitor<R> |
|
| Label |
A name for a pattern
|
| Label |
Either a vertex or edge label
|
| Label.Edge |
|
| Label.PartialVisitor<R> |
|
| Label.Vertex |
|
| Label.Visitor<R> |
|
| LabeledPattern |
A pattern together with a name (label)
|
| LabeledStatement |
|
| LabeledStatementNoShortIf |
|
| Lambda |
A function abstraction (lambda)
|
| LambdaBody |
|
| LambdaBody.Block |
|
| LambdaBody.Expression |
|
| LambdaBody.PartialVisitor<R> |
|
| LambdaBody.Visitor<R> |
|
| LambdaExpression |
|
| LambdaParameter |
|
| LambdaParameter_Normal |
|
| LambdaParameter.Normal |
|
| LambdaParameter.PartialVisitor<R> |
|
| LambdaParameter.VariableArity |
|
| LambdaParameter.Visitor<R> |
|
| LambdaParameters |
|
| LambdaParameters.PartialVisitor<R> |
|
| LambdaParameters.Single |
|
| LambdaParameters.Tuple |
|
| LambdaParameters.Visitor<R> |
|
| LambdaParameterType |
|
| LambdaParameterType.PartialVisitor<R> |
|
| LambdaParameterType.Type |
|
| LambdaParameterType.Var |
|
| LambdaParameterType.Visitor<R> |
|
| LambdaType |
A type abstraction; the type-level analog of a lambda term
|
| LangStrings |
A convenience type which provides at most one string value per language, and optionally a value without a language
|
| Language |
A named language together with language-specific constraints
|
| Language |
Language constraints for Java
|
| Language |
Language constraints for Protobuf v3
|
| LanguageConstraints |
A set of constraints on valid type and term expressions, characterizing a language
|
| LanguageName |
The unique name of a language
|
| LanguageTag |
A BCP47 language tag
|
| Last |
|
| LastMile<S,A> |
The last mile of a transformation, which encodes and serializes terms to a file
|
| LeftHandSide |
|
| LeftHandSide.ArrayAccess |
|
| LeftHandSide.ExpressionName |
|
| LeftHandSide.FieldAccess |
|
| LeftHandSide.PartialVisitor<R> |
|
| LeftHandSide.Visitor<R> |
|
| Length |
|
| Length |
|
| Let |
A set of (possibly recursive) 'let' bindings together with an environment in which they are bound
|
| LetBinding |
A field with an optional type scheme, used to bind variables to terms in a 'let' expression
|
| LetQuery |
|
| Lexical |
Lexical functions (which deal with named elements and primitives within graphs).
|
| Libraries |
A registry of all of the primitive functions available in Hydra-Java.
|
| Library |
A library of primitive functions
|
| Limit |
|
| ListComprehension |
|
| ListFeatures |
List functionality
|
| ListFunctionFeatures |
List functions
|
| ListLiteral |
|
| ListOperatorExpression |
|
| ListOperatorExpression.PartialVisitor<R> |
|
| ListOperatorExpression.Range |
|
| ListOperatorExpression.Single |
|
| ListOperatorExpression.Visitor<R> |
|
| ListOperatorExpressionOrPropertyLookup |
|
| ListOperatorExpressionOrPropertyLookup.List |
|
| ListOperatorExpressionOrPropertyLookup.PartialVisitor<R> |
|
| ListOperatorExpressionOrPropertyLookup.Property |
|
| ListOperatorExpressionOrPropertyLookup.Visitor<R> |
|
| ListPredicateExpression |
|
| Lists |
|
| ListType |
|
| ListValue |
|
| ListValue_Sequence |
|
| ListValue.PartialVisitor<R> |
|
| ListValue.Sequence |
|
| ListValue.Sequence2 |
|
| ListValue.Visitor<R> |
|
| Lit |
|
| Lit.Boolean_ |
|
| Lit.Byte_ |
|
| Lit.Char |
|
| Lit.Double_ |
|
| Lit.Float_ |
|
| Lit.Int |
|
| Lit.Long_ |
|
| Lit.Null |
|
| Lit.PartialVisitor<R> |
|
| Lit.Short_ |
|
| Lit.String_ |
|
| Lit.Symbol |
|
| Lit.Unit |
|
| Lit.Visitor<R> |
|
| Literal |
A term constant; an instance of a literal type
|
| Literal |
|
| Literal |
A literal value
|
| Literal |
|
| Literal |
A value such as a string, number, or date
|
| Literal.Binary |
A binary literal
|
| Literal.Boolean_ |
A boolean literal
|
| Literal.Boolean_ |
|
| Literal.Boolean_ |
|
| Literal.Char |
|
| Literal.Character_ |
|
| Literal.Double_ |
|
| Literal.Float_ |
A floating-point literal
|
| Literal.Float_ |
|
| Literal.FloatingPoint |
|
| Literal.Int |
|
| Literal.Integer_ |
An integer literal
|
| Literal.Integer_ |
|
| Literal.Integer_ |
|
| Literal.List |
|
| Literal.Map |
|
| Literal.Null |
|
| Literal.Null |
|
| Literal.Number_ |
|
| Literal.PartialVisitor<R> |
|
| Literal.PartialVisitor<R> |
|
| Literal.PartialVisitor<R> |
|
| Literal.PartialVisitor<R> |
|
| Literal.String_ |
A string literal
|
| Literal.String_ |
|
| Literal.String_ |
|
| Literal.String_ |
|
| Literal.Visitor<R> |
|
| Literal.Visitor<R> |
|
| Literal.Visitor<R> |
|
| Literal.Visitor<R> |
|
| LiteralFeatures |
Various types of literal values
|
| Literals |
DSL functions for working with literal values.
|
| Literals |
|
| LiteralType |
Any of a fixed set of literal types, also called atomic types, base types, primitive types, or type constants
|
| LiteralType.Binary |
|
| LiteralType.Boolean_ |
|
| LiteralType.Float_ |
|
| LiteralType.Integer_ |
|
| LiteralType.PartialVisitor<R> |
|
| LiteralType.String_ |
|
| LiteralType.Visitor<R> |
|
| LiteralTypes |
DSL utilities for working with literal types.
|
| LiteralVariant |
The identifier of a literal constructor
|
| LiteralVariant.Binary |
|
| LiteralVariant.Boolean_ |
|
| LiteralVariant.Float_ |
|
| LiteralVariant.Integer_ |
|
| LiteralVariant.PartialVisitor<R> |
|
| LiteralVariant.String_ |
|
| LiteralVariant.Visitor<R> |
|
| LList<X> |
A simple tail-sharing linked list.
|
| LoadCSVFunctionFeatures |
Load CSV functions
|
| LocalBinding |
|
| LocalBinding.PartialVisitor<R> |
|
| LocalBinding.Signature |
|
| LocalBinding.Value |
|
| LocalBinding.Visitor<R> |
|
| LocalBindings |
|
| LocalVariableDeclaration |
|
| LocalVariableDeclarationStatement |
|
| LocalVariableType |
|
| LocalVariableType.PartialVisitor<R> |
|
| LocalVariableType.Type |
|
| LocalVariableType.Var |
|
| LocalVariableType.Visitor<R> |
|
| LogarithmicFunctionFeatures |
Logarithmic functions
|
| LogicalFeatures |
Logical operations
|
| Lookup |
|
| LteInt32 |
|
| LtInt32 |
|
| Map |
|
| Map |
|
| Map |
|
| Map |
|
| Map |
|
| Map |
|
| MapKeys |
|
| MapList |
|
| MapLiteral |
|
| MapperBase |
A base class for simple functional mappers with exceptions (specific to Java)
|
| MapperBase.MapperException |
|
| Maps |
|
| MapType |
A map type
|
| MarkerAnnotation |
|
| Match |
|
| MatchFeatures |
Match queries
|
| MatchOrCreate |
|
| MatchOrCreate.Create |
|
| MatchOrCreate.Match |
|
| MatchOrCreate.PartialVisitor<R> |
|
| MatchOrCreate.Visitor<R> |
|
| MatchQuery |
|
| Math |
|
| Member |
|
| Member_Data |
|
| Member_Data.Object_ |
|
| Member_Data.PartialVisitor<R> |
|
| Member_Data.Pkg |
|
| Member_Data.Visitor<R> |
|
| Member_Type |
|
| Member.PartialVisitor<R> |
|
| Member.Self |
|
| Member.Term |
|
| Member.TermParam |
|
| Member.Type |
|
| Member.TypeParam |
|
| Member.Visitor<R> |
|
| Merge |
|
| MergeAction |
|
| MergeFeatures |
Merge operations
|
| Merging |
Utilities for combining multiple vertex or edge types into a single "merged" vertex or edge type,
and correspondingly encoding and decoding vertices and edges of these types.
|
| Merging.IdAdapters<T,V> |
A helper object which defines merged vertex and edge id types, and a value coder for each vertex and edge label.
|
| MessageDefinition |
A protocol buffer message type
|
| Messages |
A collection of standard error and warning messages
|
| MethodBody |
|
| MethodBody.Block |
|
| MethodBody.None |
|
| MethodBody.PartialVisitor<R> |
|
| MethodBody.Visitor<R> |
|
| MethodDeclaration |
|
| MethodDeclarator |
|
| MethodHeader |
|
| MethodInvocation |
|
| MethodInvocation_Complex |
|
| MethodInvocation_Header |
|
| MethodInvocation_Header.Complex |
|
| MethodInvocation_Header.PartialVisitor<R> |
|
| MethodInvocation_Header.Simple |
|
| MethodInvocation_Header.Visitor<R> |
|
| MethodInvocation_Variant |
|
| MethodInvocation_Variant.Expression |
|
| MethodInvocation_Variant.PartialVisitor<R> |
|
| MethodInvocation_Variant.Primary |
|
| MethodInvocation_Variant.Super |
|
| MethodInvocation_Variant.Type |
|
| MethodInvocation_Variant.TypeSuper |
|
| MethodInvocation_Variant.Visitor<R> |
|
| MethodModifier |
|
| MethodModifier.Abstract |
|
| MethodModifier.Annotation |
|
| MethodModifier.Final |
|
| MethodModifier.Native |
|
| MethodModifier.PartialVisitor<R> |
|
| MethodModifier.Private |
|
| MethodModifier.Protected |
|
| MethodModifier.Public |
|
| MethodModifier.Static |
|
| MethodModifier.Strictfb |
|
| MethodModifier.Synchronized |
|
| MethodModifier.Visitor<R> |
|
| MethodName |
|
| MethodReference |
|
| MethodReference_Array |
|
| MethodReference_Expression |
|
| MethodReference_New |
|
| MethodReference_Primary |
|
| MethodReference_ReferenceType |
|
| MethodReference_Super |
|
| MethodReference.Array |
|
| MethodReference.Expression |
|
| MethodReference.New |
|
| MethodReference.PartialVisitor<R> |
|
| MethodReference.Primary |
|
| MethodReference.ReferenceType |
|
| MethodReference.Super |
|
| MethodReference.Visitor<R> |
|
| Mod |
|
| Mod |
|
| Mod_Annot |
|
| Mod_Private |
|
| Mod_Protected |
|
| Mod.Abstract |
|
| Mod.Annot |
|
| Mod.Case |
|
| Mod.Contravariant |
|
| Mod.Covariant |
|
| Mod.Final |
|
| Mod.Implicit |
|
| Mod.Infix |
|
| Mod.Inline |
|
| Mod.Lazy |
|
| Mod.Opaque |
|
| Mod.Open |
|
| Mod.Override_ |
|
| Mod.PartialVisitor<R> |
|
| Mod.Private |
|
| Mod.Protected |
|
| Mod.Sealed |
|
| Mod.Super |
|
| Mod.Transparent |
|
| Mod.Using |
|
| Mod.ValParam |
|
| Mod.VarParam |
|
| Mod.Visitor<R> |
|
| ModularCompilationUnit |
|
| Module |
|
| Module |
A logical collection of elements in the same namespace, having dependencies on zero or more other modules
|
| ModuleBuilder |
|
| ModuleDeclaration |
|
| ModuleDirective |
|
| ModuleDirective_ExportsOrOpens |
|
| ModuleDirective_Provides |
|
| ModuleDirective_Requires |
|
| ModuleDirective.Exports |
|
| ModuleDirective.Opens |
|
| ModuleDirective.PartialVisitor<R> |
|
| ModuleDirective.Provides |
|
| ModuleDirective.Requires |
|
| ModuleDirective.Uses |
|
| ModuleDirective.Visitor<R> |
|
| ModuleHead |
|
| ModuleName |
|
| ModuleName |
|
| Modules |
|
| Mul |
|
| MultiPartQuery |
|
| MultiplicativeExpression |
|
| MultiplicativeExpression_Binary |
|
| MultiplicativeExpression.Divide |
|
| MultiplicativeExpression.Mod |
|
| MultiplicativeExpression.PartialVisitor<R> |
|
| MultiplicativeExpression.Times |
|
| MultiplicativeExpression.Unary |
|
| MultiplicativeExpression.Visitor<R> |
|
| MultiplyDivideModuloExpression |
|
| MultiplyDivideModuloOperator |
|
| MultiplyDivideModuloOperator.Divide |
|
| MultiplyDivideModuloOperator.Modulo |
|
| MultiplyDivideModuloOperator.Multiply |
|
| MultiplyDivideModuloOperator.PartialVisitor<R> |
|
| MultiplyDivideModuloOperator.Visitor<R> |
|
| MultiplyDivideModuloRightHandSide |
|
| Name |
A unique identifier in some context; a string-valued key
|
| Name |
|
| Name |
|
| Name |
|
| Name |
|
| Name.Anonymous |
|
| Name.Implicit |
|
| Name.Indeterminate |
|
| Name.Normal |
|
| Name.Parens |
|
| Name.PartialVisitor<R> |
|
| Name.PartialVisitor<R> |
|
| Name.Value |
|
| Name.Visitor<R> |
|
| Name.Visitor<R> |
|
| Named |
|
| NamedSchema |
|
| NamedSchema_Type |
|
| NamedSchema_Type.Enum_ |
|
| NamedSchema_Type.PartialVisitor<R> |
|
| NamedSchema_Type.Record |
|
| NamedSchema_Type.Typeref |
|
| NamedSchema_Type.Visitor<R> |
|
| NamedType |
|
| NamedType |
|
| NamedType.Enum_ |
|
| NamedType.Fixed |
|
| NamedType.PartialVisitor<R> |
|
| NamedType.Record |
|
| NamedType.Visitor<R> |
|
| NamePart |
|
| Namespace |
|
| Namespace |
A prefix for element names
|
| Neg |
|
| Node |
|
| Node |
A YAML node (value)
|
| Node |
A node in a query expression; it may be a term, a variable, or a wildcard
|
| Node.Bnode |
|
| Node.Iri |
|
| Node.Literal |
|
| Node.Mapping |
|
| Node.PartialVisitor<R> |
|
| Node.PartialVisitor<R> |
|
| Node.PartialVisitor<R> |
|
| Node.Scalar |
|
| Node.Sequence |
|
| Node.Term |
A graph term; an expression which is valid in the graph being matched
|
| Node.Variable |
A query variable, not to be confused with a variable term
|
| Node.Visitor<R> |
|
| Node.Visitor<R> |
|
| Node.Visitor<R> |
|
| Node.Wildcard |
An anonymous variable which we do not care to join across patterns
|
| NodeKind |
|
| NodeKind.BlankNode |
A blank node
|
| NodeKind.BlankNodeOrIri |
A blank node or an IRI
|
| NodeKind.BlankNodeOrLiteral |
A blank node or a literal
|
| NodeKind.Iri |
An IRI
|
| NodeKind.IriOrLiteral |
An IRI or a literal
|
| NodeKind.Literal |
A literal
|
| NodeKind.PartialVisitor<R> |
|
| NodeKind.Visitor<R> |
|
| NodeLabel |
|
| NodeLabels |
|
| NodePattern |
|
| NodePatternChain |
|
| NodePatternFeatures |
Node patterns
|
| NodeShape |
A SHACL node shape.
|
| NonArithmeticOperatorExpression |
|
| NonNullType |
|
| NonNullType.List |
|
| NonNullType.Named |
|
| NonNullType.PartialVisitor<R> |
|
| NonNullType.Visitor<R> |
|
| NormalAnnotation |
|
| NormalClassDeclaration |
|
| NormalInterfaceDeclaration |
|
| Not |
|
| NotExpression |
|
| Nub |
|
| Null |
|
| NullFeatures |
IS NULL / IS NOT NULL checks
|
| NullPredicateExpression |
|
| NullValue |
|
| NumberLiteral |
|
| NumberLiteral.Double_ |
|
| NumberLiteral.Integer_ |
|
| NumberLiteral.PartialVisitor<R> |
|
| NumberLiteral.Visitor<R> |
|
| NumericFunctionFeatures |
Numeric functions
|
| NumericType |
|
| NumericType.FloatingPoint |
|
| NumericType.Integral |
|
| NumericType.PartialVisitor<R> |
|
| NumericType.Visitor<R> |
|
| NumericTypeArray |
|
| NumericTypeArray.Array |
|
| NumericTypeArray.PartialVisitor<R> |
|
| NumericTypeArray.Simple |
|
| NumericTypeArray.Visitor<R> |
|
| ObjectField |
|
| ObjectTypeDefinition |
|
| ObjectTypeExtension |
|
| ObjectTypeExtension_Sequence |
|
| ObjectTypeExtension_Sequence2 |
|
| ObjectTypeExtension_Sequence3 |
|
| ObjectTypeExtension.PartialVisitor<R> |
|
| ObjectTypeExtension.Sequence |
|
| ObjectTypeExtension.Sequence2 |
|
| ObjectTypeExtension.Sequence3 |
|
| ObjectTypeExtension.Visitor<R> |
|
| ObjectValue |
|
| ObjectValue_Sequence |
|
| ObjectValue.PartialVisitor<R> |
|
| ObjectValue.Sequence |
|
| ObjectValue.Sequence2 |
|
| ObjectValue.Visitor<R> |
|
| Op |
An operator symbol
|
| OperationDefinition |
|
| OperationDefinition_Sequence |
|
| OperationDefinition.PartialVisitor<R> |
|
| OperationDefinition.SelectionSet |
|
| OperationDefinition.Sequence |
|
| OperationDefinition.Visitor<R> |
|
| OperationType |
|
| OperationType.Mutation |
|
| OperationType.PartialVisitor<R> |
|
| OperationType.Query |
|
| OperationType.Subscription |
|
| OperationType.Visitor<R> |
|
| Operator |
|
| Operator.Backtick |
|
| Operator.Normal |
|
| Operator.PartialVisitor<R> |
|
| Operator.Visitor<R> |
|
| OpExpr |
An operator expression
|
| Opt<T> |
A clone of java.util.Optional which implements Serializable and can therefore be used with frameworks
including Spark which require serializable objects.
|
| Option |
A protocol buffer option, which can be attached to a message, field, enumeration, etc
|
| Option |
A protocol buffer option, which can be attached to a message, field, enumeration, etc.
|
| OptionalCases |
A case statement for matching optional terms
|
| Optionals |
|
| Or |
|
| Order |
|
| Order |
|
| Order.Ascending |
|
| Order.Descending |
|
| Order.Ignore |
|
| Order.PartialVisitor<R> |
|
| Order.Visitor<R> |
|
| OrdinaryCompilationUnit |
|
| OrExpression |
|
| Package_ |
|
| PackageDeclaration |
|
| PackageModifier |
|
| PackageName |
|
| PackageName |
|
| PackageOrTypeName |
|
| Padding |
Left and right padding for an operator
|
| Parameter |
|
| Parameter.Integer_ |
|
| Parameter.PartialVisitor<R> |
|
| Parameter.Symbolic |
|
| Parameter.Visitor<R> |
|
| ParenthesizedExpression |
|
| PartialComparisonExpression |
|
| Pat |
|
| Pat_Alternative |
|
| Pat_Bind |
|
| Pat_Extract |
|
| Pat_ExtractInfix |
|
| Pat_Given |
|
| Pat_Interpolate |
|
| Pat_Macro |
|
| Pat_Repeated |
|
| Pat_Tuple |
|
| Pat_Typed |
|
| Pat_Var |
|
| Pat_Xml |
|
| Pat.Alternative |
|
| Pat.Bind |
|
| Pat.Extract |
|
| Pat.ExtractInfix |
|
| Pat.Given |
|
| Pat.Interpolate |
|
| Pat.Macro |
|
| Pat.PartialVisitor<R> |
|
| Pat.Repeated |
|
| Pat.SeqWildcard |
|
| Pat.Tuple |
|
| Pat.Typed |
|
| Pat.Var |
|
| Pat.Visitor<R> |
|
| Pat.Wildcard |
|
| Pat.Xml |
|
| Path |
A query path
|
| Path.Inverse |
A path given by the inverse of another path
|
| Path.PartialVisitor<R> |
|
| Path.Regex |
A path given by a regular expression quantifier applied to another path
|
| Path.Step |
A path given by a single step
|
| Path.Visitor<R> |
|
| PathEquation |
A declared equivalence between two abstract paths in a graph
|
| PathFeatures |
Path functions only found in OpenCypher
|
| Pattern |
|
| Pattern |
|
| Pattern |
A SHACL pattern.
|
| Pattern |
A pattern which matches valid expressions in the language
|
| Pattern |
A query pattern
|
| Pattern_Application |
|
| Pattern_As |
|
| Pattern_Record |
|
| Pattern_Typed |
|
| Pattern.Alternatives |
|
| Pattern.Application |
|
| Pattern.As |
|
| Pattern.Conjunction |
The conjunction ('and') of several other patterns
|
| Pattern.Constant |
|
| Pattern.Disjunction |
The disjunction (inclusive 'or') of several other patterns
|
| Pattern.Graph |
A pattern which matches within a named subgraph
|
| Pattern.Ignored |
|
| Pattern.Labeled |
|
| Pattern.List |
|
| Pattern.Literal |
|
| Pattern.Name |
|
| Pattern.Negation |
The negation of another pattern
|
| Pattern.Nil |
|
| Pattern.Nonterminal |
|
| Pattern.Option |
|
| Pattern.Parens |
|
| Pattern.PartialVisitor<R> |
|
| Pattern.PartialVisitor<R> |
|
| Pattern.PartialVisitor<R> |
|
| Pattern.Plus |
|
| Pattern.Record |
|
| Pattern.Regex |
|
| Pattern.Sequence |
|
| Pattern.Star |
|
| Pattern.Triple |
A subject/predicate/object pattern
|
| Pattern.Tuple |
|
| Pattern.Typed |
|
| Pattern.Visitor<R> |
|
| Pattern.Visitor<R> |
|
| Pattern.Visitor<R> |
|
| Pattern.Wildcard |
|
| PatternComprehension |
|
| PatternElement |
|
| PatternElement.Chained |
|
| PatternElement.Parenthesized |
|
| PatternElement.PartialVisitor<R> |
|
| PatternElement.Visitor<R> |
|
| PatternElementChain |
|
| PatternField |
|
| PatternImplication |
A pattern which, if it matches in a given graph, implies that another pattern must also match.
|
| PatternPart |
|
| PatternPredicate |
|
| PatternWhere |
|
| Pkg |
|
| Pkg_Object |
|
| PostDecrementExpression |
|
| PostfixExpression |
|
| PostfixExpression.Name |
|
| PostfixExpression.PartialVisitor<R> |
|
| PostfixExpression.PostDecrement |
|
| PostfixExpression.PostIncrement |
|
| PostfixExpression.Primary |
|
| PostfixExpression.Visitor<R> |
|
| PostIncrementExpression |
|
| PowerOfExpression |
|
| Precedence |
Operator precedence
|
| Precision |
Numeric precision: arbitrary precision, or precision to a specified number of bits
|
| Precision.Arbitrary |
|
| Precision.Bits |
|
| Precision.PartialVisitor<R> |
|
| Precision.Visitor<R> |
|
| PreDecrementExpression |
|
| PredefString |
|
| PredicateFunctionFeatures |
Predicate functions
|
| PreIncrementExpression |
|
| PrettyPrinter |
A temporary pretty-printer for terms, for the sake of tests and debugging.
|
| Primary |
|
| Primary.ArrayCreation |
|
| Primary.NoNewArray |
|
| Primary.PartialVisitor<R> |
|
| Primary.Visitor<R> |
|
| PrimaryKey |
A primary key of a relation, specified either as a single column, or as a list of columns
|
| PrimaryNoNewArray |
|
| PrimaryNoNewArray.ArrayAccess |
|
| PrimaryNoNewArray.ClassInstance |
|
| PrimaryNoNewArray.ClassLiteral |
|
| PrimaryNoNewArray.DotThis |
|
| PrimaryNoNewArray.FieldAccess |
|
| PrimaryNoNewArray.Literal |
|
| PrimaryNoNewArray.MethodInvocation |
|
| PrimaryNoNewArray.MethodReference |
|
| PrimaryNoNewArray.Parens |
|
| PrimaryNoNewArray.PartialVisitor<R> |
|
| PrimaryNoNewArray.This |
|
| PrimaryNoNewArray.Visitor<R> |
|
| Primitive |
|
| Primitive |
A built-in function
|
| Primitive.Boolean_ |
A binary value
|
| Primitive.Bytes |
sequence of 8-bit unsigned bytes
|
| Primitive.Double_ |
double precision (64-bit) IEEE 754 floating-point number
|
| Primitive.Float_ |
single precision (32-bit) IEEE 754 floating-point number
|
| Primitive.Int |
32-bit signed integer
|
| Primitive.Long_ |
64-bit signed integer
|
| Primitive.Null |
no value
|
| Primitive.PartialVisitor<R> |
|
| Primitive.String_ |
unicode character sequence
|
| Primitive.Visitor<R> |
|
| PrimitiveFunction |
Any of Hydra's primitive functions, implemented in Java
|
| PrimitiveType |
|
| PrimitiveType |
|
| PrimitiveType<T> |
A wrapper for a type which can be used as the basis of equality and comparison primitives.
|
| PrimitiveType.Boolean_ |
|
| PrimitiveType.Boolean_ |
|
| PrimitiveType.Bytes |
|
| PrimitiveType.Double_ |
|
| PrimitiveType.Float_ |
|
| PrimitiveType.Int |
|
| PrimitiveType.Long_ |
|
| PrimitiveType.Numeric |
|
| PrimitiveType.PartialVisitor<R> |
|
| PrimitiveType.PartialVisitor<R> |
|
| PrimitiveType.String_ |
|
| PrimitiveType.Visitor<R> |
|
| PrimitiveType.Visitor<R> |
|
| PrimitiveTypeWithAnnotations |
|
| Printing |
Utilities for use in transformations
|
| ProcedureCallFeatures |
Procedure calls
|
| ProcedureInvocation |
|
| ProcedureInvocation.Explicit |
|
| ProcedureInvocation.Implicit |
|
| ProcedureInvocation.PartialVisitor<R> |
|
| ProcedureInvocation.Visitor<R> |
|
| ProcedureResultField |
|
| Production |
A BNF production
|
| Projection |
A record elimination; a projection
|
| Projection |
|
| ProjectionBody |
|
| ProjectionFeatures |
Projections
|
| ProjectionItem |
|
| ProjectionItems |
|
| Projections |
|
| Properties |
|
| Properties.Map |
|
| Properties.Parameter |
|
| Properties.PartialVisitor<R> |
|
| Properties.Visitor<R> |
|
| Property |
A type representing an RDF property, and encapsulating its domain, range, and subclass relationships
|
| Property |
|
| Property<V> |
A key/value property
|
| PropertyEquals |
|
| PropertyExpression |
|
| PropertyKey |
|
| PropertyKey |
A property key
|
| PropertyKeyName |
|
| PropertyLookup |
|
| PropertyPattern |
|
| PropertyProjection |
|
| PropertyShape |
A SHACL property shape.
|
| PropertyShapeConstraint |
A number of constraint parameters which are specific to property shapes, and cannot be applied to node shapes
|
| PropertyShapeConstraint.LessThan |
See https://www.w3.org/TR/shacl/#LessThanConstraintComponent
|
| PropertyShapeConstraint.LessThanOrEquals |
See https://www.w3.org/TR/shacl/#LessThanOrEqualsConstraintComponent
|
| PropertyShapeConstraint.MaxCount |
The maximum cardinality.
|
| PropertyShapeConstraint.MinCount |
The minimum cardinality.
|
| PropertyShapeConstraint.PartialVisitor<R> |
|
| PropertyShapeConstraint.QualifiedValueShape |
See https://www.w3.org/TR/shacl/#QualifiedValueShapeConstraintComponent
|
| PropertyShapeConstraint.UniqueLang |
See https://www.w3.org/TR/shacl/#UniqueLangConstraintComponent
|
| PropertyShapeConstraint.Visitor<R> |
|
| PropertySpec |
A mapping specification producing properties of a specified key, and values of the appropriate type.
|
| PropertyType<T> |
The type of a property
|
| PropertyValue |
|
| PropertyValuePattern |
|
| PropertyValuePattern.PartialVisitor<R> |
|
| PropertyValuePattern.Value |
|
| PropertyValuePattern.Variable |
|
| PropertyValuePattern.Visitor<R> |
|
| ProtoFile |
A .proto file, usually containing one or more enum or message type definitions
|
| Pure |
|
| Pure |
|
| Pure |
|
| Quad |
An RDF triple with an optional named graph component
|
| QualifiedName |
|
| QualifiedName |
|
| QualifiedName |
|
| QualifiedName |
A qualified name consisting of an optional namespace together with a mandatory local name
|
| QualifiedValueShape |
See https://www.w3.org/TR/shacl/#QualifiedValueShapeConstraintComponent
|
| Quantifier |
|
| QuantifierFeatures |
Quantifier expressions
|
| QuantifierOperator |
|
| QuantifierOperator.All |
|
| QuantifierOperator.Any |
|
| QuantifierOperator.None |
|
| QuantifierOperator.PartialVisitor<R> |
|
| QuantifierOperator.Single |
|
| QuantifierOperator.Visitor<R> |
|
| Quasi |
|
| Queries |
|
| Query |
|
| Query |
|
| Query |
A SELECT-style graph pattern matching query
|
| Query.Aggregate |
|
| Query.Application |
|
| Query.LetQuery |
|
| Query.Match |
|
| Query.PartialVisitor<R> |
|
| Query.PartialVisitor<R> |
|
| Query.Regular |
|
| Query.Select |
|
| Query.Standalone |
|
| Query.Value |
|
| Query.Visitor<R> |
|
| Query.Visitor<R> |
|
| Range |
A range from min to max, inclusive
|
| RangeExpression |
|
| RangeLiteral |
|
| RangeLiteralFeatures |
Range literals within relationship patterns
|
| RdfsClass |
Stand-in for rdfs:Class
|
| ReadingClause |
|
| ReadingClause.InQueryCall |
|
| ReadingClause.Match |
|
| ReadingClause.PartialVisitor<R> |
|
| ReadingClause.Unwind |
|
| ReadingClause.Visitor<R> |
|
| ReadingFeatures |
Specific syntax related to reading data from the graph.
|
| ReceiverParameter |
|
| Record |
A record, or labeled tuple; a map of field names to terms
|
| Record |
|
| RecordField |
|
| RecordSchema |
|
| Reduction |
|
| Ref |
|
| Ref.Init |
|
| Ref.Name |
|
| Ref.PartialVisitor<R> |
|
| Ref.Visitor<R> |
|
| Reference<A> |
Either an instance of a type like sh:Shape or sh:NodeShape, or an IRI which refers to an instance of that type
|
| Reference.Anonymous<A> |
An anonymous instance
|
| Reference.Definition<A> |
An inline definition
|
| Reference.Named<A> |
|
| Reference.PartialVisitor<A,R> |
|
| Reference.Visitor<A,R> |
|
| ReferenceType |
|
| ReferenceType.Array |
|
| ReferenceType.ClassOrInterface |
|
| ReferenceType.PartialVisitor<R> |
|
| ReferenceType.Variable |
|
| ReferenceType.Visitor<R> |
|
| Regex |
A regular expression
|
| RegexQuantifier |
A regular expression quantifier
|
| RegexQuantifier.AtLeast |
The {n,} quantifier; matches at least n occurrences
|
| RegexQuantifier.Exactly |
The {n} quantifier; matches exactly n occurrences
|
| RegexQuantifier.One |
No quantifier; matches a single occurrence
|
| RegexQuantifier.OneOrMore |
The + quantifier; matches one or more occurrences
|
| RegexQuantifier.PartialVisitor<R> |
|
| RegexQuantifier.Range |
The {n, m} quantifier; matches between n and m (inclusive) occurrences
|
| RegexQuantifier.Visitor<R> |
|
| RegexQuantifier.ZeroOrMore |
The * quantifier; matches any number of occurrences
|
| RegexQuantifier.ZeroOrOne |
The ? quanifier; matches zero or one occurrence
|
| RegexSequence |
A path with a regex quantifier
|
| RegularQuery |
|
| Relation<V> |
A set of distinct n-tuples; a table
|
| RelationalExpression |
|
| RelationalExpression_GreaterThan |
|
| RelationalExpression_GreaterThanEqual |
|
| RelationalExpression_InstanceOf |
|
| RelationalExpression_LessThan |
|
| RelationalExpression_LessThanEqual |
|
| RelationalExpression.GreaterThan |
|
| RelationalExpression.GreaterThanEqual |
|
| RelationalExpression.Instanceof |
|
| RelationalExpression.LessThan |
|
| RelationalExpression.LessThanEqual |
|
| RelationalExpression.PartialVisitor<R> |
|
| RelationalExpression.Simple |
|
| RelationalExpression.Visitor<R> |
|
| RelationName |
A unique relation (table) name
|
| RelationSchema<T> |
An abstract relation; the name and columns of a relation without its actual data
|
| Relationship<V> |
A domain-unordered (string-indexed, rather than position-indexed) relation
|
| RelationshipDetail |
|
| RelationshipDirectionFeatures |
Relationship directions / arrow patterns
|
| RelationshipPattern |
|
| RelationshipPatternFeatures |
Relationship patterns
|
| RelationshipsPattern |
|
| RelationshipTypes |
|
| RelTypeName |
|
| Rem |
|
| Remove |
|
| Remove |
|
| Remove |
|
| RemoveFeatures |
REMOVE operations
|
| RemoveItem |
|
| RemoveItem.PartialVisitor<R> |
|
| RemoveItem.Property |
|
| RemoveItem.VariableLabels |
|
| RemoveItem.Visitor<R> |
|
| RequiresModifier |
|
| RequiresModifier.PartialVisitor<R> |
|
| RequiresModifier.Static |
|
| RequiresModifier.Transitive |
|
| RequiresModifier.Visitor<R> |
|
| Resource |
|
| Resource |
|
| Resource_Local |
|
| Resource.Bnode |
|
| Resource.Iri |
|
| Resource.Local |
|
| Resource.PartialVisitor<R> |
|
| Resource.PartialVisitor<R> |
|
| Resource.Variable |
|
| Resource.Visitor<R> |
|
| Resource.Visitor<R> |
|
| ResourceSpecification |
|
| Result |
|
| Result.PartialVisitor<R> |
|
| Result.Type |
|
| Result.Visitor<R> |
|
| Result.Void_ |
|
| Return |
|
| ReturnStatement |
|
| Reverse |
|
| Rewriting |
Utility functions for rewriting terms, types, and other recursive data structures.
|
| RightHandSide |
|
| RootOperationTypeDefinition |
|
| Row<V> |
An n-tuple which is an element of a given relation
|
| RowType |
A labeled record or union type
|
| SafeHead |
|
| Scalar |
A union of scalars supported in the YAML failsafe and JSON schemas.
|
| Scalar.Bool |
Represents a true/false value
|
| Scalar.Float_ |
Represents an approximation to real numbers
|
| Scalar.Int |
Represents arbitrary sized finite mathematical integers
|
| Scalar.Null |
Represents the lack of a value
|
| Scalar.PartialVisitor<R> |
|
| Scalar.Str |
A string value
|
| Scalar.Visitor<R> |
|
| ScalarFunctionFeatures |
Scalar functions
|
| ScalarType |
One of several Proto3 scalar types
|
| ScalarType.Bool |
|
| ScalarType.Bytes |
|
| ScalarType.Double_ |
|
| ScalarType.Fixed32 |
|
| ScalarType.Fixed64 |
|
| ScalarType.Float_ |
|
| ScalarType.Int32 |
|
| ScalarType.Int64 |
|
| ScalarType.PartialVisitor<R> |
|
| ScalarType.Sfixed32 |
|
| ScalarType.Sfixed64 |
|
| ScalarType.Sint32 |
|
| ScalarType.Sint64 |
|
| ScalarType.String_ |
|
| ScalarType.Uint32 |
|
| ScalarType.Uint64 |
|
| ScalarType.Visitor<R> |
|
| ScalarTypeDefinition |
|
| ScalarTypeExtension |
|
| ScalaSymbol |
|
| Schema |
|
| Schema |
|
| Schema<S,T,V> |
A set of mappings which translates between Hydra terms and annotations, and application-specific property graph types
|
| Schema.Array |
|
| Schema.Array |
|
| Schema.Fixed |
|
| Schema.Inline |
|
| Schema.Map |
|
| Schema.Map |
|
| Schema.Named |
|
| Schema.Named |
|
| Schema.Null |
|
| Schema.PartialVisitor<R> |
|
| Schema.PartialVisitor<R> |
|
| Schema.Primitive |
|
| Schema.Primitive |
|
| Schema.Reference |
A reference by name to a previously defined type
|
| Schema.Union |
|
| Schema.Union |
|
| Schema.Visitor<R> |
|
| Schema.Visitor<R> |
|
| SchemaDefinition |
|
| SchemaExtension |
|
| SchemaExtension_Sequence |
|
| SchemaExtension.PartialVisitor<R> |
|
| SchemaExtension.Sequence |
|
| SchemaExtension.Sequence2 |
|
| SchemaExtension.Visitor<R> |
|
| SchemaFile |
|
| SchemaSpec |
The specification of a schema at the source end of a workflow
|
| SchemaSpec.File |
A schema provided as a file, available at the given file path
|
| SchemaSpec.Hydra |
A native Hydra schema
|
| SchemaSpec.PartialVisitor<R> |
|
| SchemaSpec.Provided |
A schema which will be provided within the workflow
|
| SchemaSpec.Visitor<R> |
|
| Selection |
|
| Selection.Field |
|
| Selection.FragmentSpread |
|
| Selection.InlineFragment |
|
| Selection.PartialVisitor<R> |
|
| Selection.Visitor<R> |
|
| SelectionSet |
|
| SelectQuery |
|
| Self |
|
| Serde |
RDF4j-based serialization for Hydra RDF graphs.
|
| Set |
|
| SetFeatures |
Set definitions
|
| SetItem |
|
| SetItem.PartialVisitor<R> |
|
| SetItem.Property |
|
| SetItem.VariableEqual |
|
| SetItem.VariableLabels |
|
| SetItem.VariablePlusEqual |
|
| SetItem.Visitor<R> |
|
| Sets |
|
| Severity |
|
| Severity.Info |
A non-critical constraint violation indicating an informative message
|
| Severity.PartialVisitor<R> |
|
| Severity.Violation |
A constraint violation
|
| Severity.Visitor<R> |
|
| Severity.Warning |
A non-critical constraint violation indicating a warning
|
| Shape |
A SHACL node or property shape.
|
| Shape.Node |
|
| Shape.PartialVisitor<R> |
|
| Shape.Property |
|
| Shape.Visitor<R> |
|
| ShapesGraph |
An RDF graph containing zero or more shapes that is passed into a SHACL validation process so that a data graph can be validated against the shapes
|
| ShiftExpression |
|
| ShiftExpression_Binary |
|
| ShiftExpression.PartialVisitor<R> |
|
| ShiftExpression.ShiftLeft |
|
| ShiftExpression.ShiftRight |
|
| ShiftExpression.ShiftRightZeroFill |
|
| ShiftExpression.Unary |
|
| ShiftExpression.Visitor<R> |
|
| ShowInt32 |
|
| ShowString |
|
| ShowTerm |
|
| SimpleType |
A scalar type or a reference to an enum type or message type
|
| SimpleType.PartialVisitor<R> |
|
| SimpleType.Reference |
|
| SimpleType.Scalar |
|
| SimpleType.Visitor<R> |
|
| SimpleTypeName |
|
| SingleElementAnnotation |
|
| SinglePartQuery |
|
| SingleQuery |
|
| SingleQuery.MultiPart |
|
| SingleQuery.PartialVisitor<R> |
|
| SingleQuery.SinglePart |
|
| SingleQuery.Visitor<R> |
|
| SingleStaticImportDeclaration |
|
| Singleton |
|
| SingleTypeImportDeclaration |
|
| Size |
|
| Skip |
|
| SortItem |
|
| SortOrder |
|
| SortOrder.Ascending |
|
| SortOrder.Descending |
|
| SortOrder.PartialVisitor<R> |
|
| SortOrder.Visitor<R> |
|
| Source |
|
| SourceContext |
`SourceContext` represents information about the source of a protobuf element, like the file in which it is defined.
|
| SpatialFunctionFeatures |
Spatial functions
|
| SplitOn |
|
| StandaloneCall |
|
| StarOrYieldItems |
|
| StarOrYieldItems.Items |
|
| StarOrYieldItems.PartialVisitor<R> |
|
| StarOrYieldItems.Star |
|
| StarOrYieldItems.Visitor<R> |
|
| Stat |
|
| Stat.Decl |
|
| Stat.Defn |
|
| Stat.ImportExport |
|
| Stat.PartialVisitor<R> |
|
| Stat.Term |
|
| Stat.Visitor<R> |
|
| StatelessAdapter<T1,T2,V1,V2> |
A convenience class for stateless adapters; we use Hydra's Unit as the state type.
|
| StatelessCoder<V1,V2> |
A convenience class for stateless coders; we use Hydra's Unit as the state type.
|
| Statement |
|
| Statement |
|
| Statement.For |
|
| Statement.IfThen |
|
| Statement.IfThenElse |
|
| Statement.Labeled |
|
| Statement.PartialVisitor<R> |
|
| Statement.Visitor<R> |
|
| Statement.While |
|
| Statement.WithoutTrailing |
|
| StatementExpression |
|
| StatementExpression.Assignment |
|
| StatementExpression.ClassInstanceCreation |
|
| StatementExpression.MethodInvocation |
|
| StatementExpression.PartialVisitor<R> |
|
| StatementExpression.PostDecrement |
|
| StatementExpression.PostIncrement |
|
| StatementExpression.PreDecrement |
|
| StatementExpression.PreIncrement |
|
| StatementExpression.Visitor<R> |
|
| StatementNoShortIf |
|
| StatementNoShortIf.For |
|
| StatementNoShortIf.IfThenElse |
|
| StatementNoShortIf.Labeled |
|
| StatementNoShortIf.PartialVisitor<R> |
|
| StatementNoShortIf.Visitor<R> |
|
| StatementNoShortIf.While |
|
| StatementNoShortIf.WithoutTrailing |
|
| StatementWithoutTrailingSubstatement |
|
| StatementWithoutTrailingSubstatement.Assert |
|
| StatementWithoutTrailingSubstatement.Block |
|
| StatementWithoutTrailingSubstatement.Break |
|
| StatementWithoutTrailingSubstatement.Continue |
|
| StatementWithoutTrailingSubstatement.Do |
|
| StatementWithoutTrailingSubstatement.Empty |
|
| StatementWithoutTrailingSubstatement.Expression |
|
| StatementWithoutTrailingSubstatement.PartialVisitor<R> |
|
| StatementWithoutTrailingSubstatement.Return |
|
| StatementWithoutTrailingSubstatement.Switch |
|
| StatementWithoutTrailingSubstatement.Synchronized |
|
| StatementWithoutTrailingSubstatement.Throw |
|
| StatementWithoutTrailingSubstatement.Try |
|
| StatementWithoutTrailingSubstatement.Visitor<R> |
|
| StaticImportOnDemandDeclaration |
|
| StaticInitializer |
|
| Step |
An atomic function as part of a query.
|
| Step.Compare |
A comparison of two terms
|
| Step.Edge |
An out-to-in traversal of an abstract edge
|
| Step.PartialVisitor<R> |
|
| Step.Project |
A projection from a record through one of its fields
|
| Step.Visitor<R> |
|
| StringFeatures |
String functions/keywords only found in OpenCypher
|
| StringFunctionFeatures |
String functions
|
| StringListNullPredicateExpression |
|
| StringListNullPredicateRightHandSide |
|
| StringListNullPredicateRightHandSide.List |
|
| StringListNullPredicateRightHandSide.Null |
|
| StringListNullPredicateRightHandSide.PartialVisitor<R> |
|
| StringListNullPredicateRightHandSide.String_ |
|
| StringListNullPredicateRightHandSide.Visitor<R> |
|
| StringLiteral |
|
| StringLiteral |
Note: this is an approximation which ignores encoding
|
| StringPredicateExpression |
|
| StringPredicateOperator |
|
| StringPredicateOperator.Contains |
|
| StringPredicateOperator.EndsWith |
|
| StringPredicateOperator.PartialVisitor<R> |
|
| StringPredicateOperator.StartsWith |
|
| StringPredicateOperator.Visitor<R> |
|
| Strings |
|
| StringValue |
|
| Strip |
Several functions for stripping annotations from types and terms.
|
| Sub |
|
| Sum |
The unlabeled equivalent of an Injection term
|
| SwitchBlock |
|
| SwitchBlock_Pair |
|
| SwitchBlockStatementGroup |
|
| SwitchLabel |
|
| SwitchLabel.Constant |
|
| SwitchLabel.Default |
|
| SwitchLabel.EnumConstant |
|
| SwitchLabel.PartialVisitor<R> |
|
| SwitchLabel.Visitor<R> |
|
| SwitchStatement |
|
| Symbol |
Any symbol
|
| Symbol |
A nonterminal symbol
|
| SynchronizedStatement |
|
| Syntax |
The syntax in which a protocol buffer element is defined.
|
| Syntax.PartialVisitor<R> |
|
| Syntax.Proto2 |
Syntax `proto2`.
|
| Syntax.Proto3 |
Syntax `proto3`.
|
| Syntax.Visitor<R> |
|
| Table<V> |
A simple table as in a CSV file, having an optional header row and any number of data rows
|
| Tail |
|
| TCase<A> |
An association of a field name (as in a case statement) with a phantom type
|
| TElement<A> |
An association with a named term (element) with a phantom type
|
| Template |
|
| TemporalDurationFunctionFeatures |
Temporal duration functions
|
| TemporalInstantFunctionFeatures |
Temporal instant functions
|
| Term |
A data term
|
| Term.Annotated |
A term annotated with metadata
|
| Term.Application |
A function application
|
| Term.Function |
A function term
|
| Term.Let |
|
| Term.List |
A list
|
| Term.Literal |
A literal value
|
| Term.Map |
A map of keys to values
|
| Term.Optional |
An optional value
|
| Term.PartialVisitor<R> |
|
| Term.Product |
A tuple
|
| Term.Record |
A record term
|
| Term.Set |
A set of values
|
| Term.Sum |
A variant tuple
|
| Term.TypeAbstraction |
A System F type abstraction term
|
| Term.TypeApplication |
A System F type application term
|
| Term.Typed |
A term annotated with its type
|
| Term.Union |
An injection; an instance of a union type
|
| Term.Variable |
A variable reference
|
| Term.Visitor<R> |
|
| Term.Wrap |
|
| TermAccessor |
A function which maps from a term to a particular immediate subterm
|
| TermAccessor.AnnotatedSubject |
|
| TermAccessor.ApplicationArgument |
|
| TermAccessor.ApplicationFunction |
|
| TermAccessor.InjectionTerm |
|
| TermAccessor.LambdaBody |
|
| TermAccessor.LetBinding |
|
| TermAccessor.LetEnvironment |
|
| TermAccessor.ListElement |
|
| TermAccessor.ListFold |
|
| TermAccessor.MapKey |
|
| TermAccessor.MapValue |
|
| TermAccessor.OptionalCasesJust |
|
| TermAccessor.OptionalCasesNothing |
|
| TermAccessor.OptionalTerm |
|
| TermAccessor.PartialVisitor<R> |
|
| TermAccessor.ProductTerm |
|
| TermAccessor.RecordField |
|
| TermAccessor.SetElement |
|
| TermAccessor.SumTerm |
|
| TermAccessor.TypeAbstractionBody |
|
| TermAccessor.TypeApplicationTerm |
|
| TermAccessor.TypedTerm |
|
| TermAccessor.UnionCasesBranch |
|
| TermAccessor.UnionCasesDefault |
|
| TermAccessor.Visitor<R> |
|
| TermAccessor.WrappedTerm |
|
| TermCoder<X> |
A type together with a coder for mapping terms into arguments for primitive functions, and mapping computed results into terms
|
| Terms |
DSL utilities for constructing Hydra terms based on native Java objects.
|
| TermVariant |
The identifier of a term expression constructor
|
| TermVariant.Annotated |
|
| TermVariant.Application |
|
| TermVariant.Function |
|
| TermVariant.Let |
|
| TermVariant.List |
|
| TermVariant.Literal |
|
| TermVariant.Map |
|
| TermVariant.Optional |
|
| TermVariant.PartialVisitor<R> |
|
| TermVariant.Product |
|
| TermVariant.Record |
|
| TermVariant.Set |
|
| TermVariant.Sum |
|
| TermVariant.TypeAbstraction |
|
| TermVariant.TypeApplication |
|
| TermVariant.Typed |
|
| TermVariant.Union |
|
| TermVariant.Variable |
|
| TermVariant.Visitor<R> |
|
| TermVariant.Wrap |
|
| TestCase |
A simple test case with an input and an expected output
|
| TestGroup |
A collection of test cases with a name and optional description
|
| TField<A> |
An association with a term-level field with a phantom type
|
| Throws |
|
| ThrowStatement |
|
| Tier1 |
A module for miscellaneous tier-1 functions and constants.
|
| Tier2 |
A module for miscellaneous tier-2 functions and constants.
|
| Tier3 |
A module for miscellaneous tier-3 functions and constants.
|
| ToList |
|
| ToList |
|
| ToList |
|
| ToLower |
|
| ToUpper |
|
| Trace |
A container for logging and error information
|
| TransformWorkflow |
The specification of a workflow which takes a schema specification, reads data from a directory, and writes data to another directory
|
| TraversalOrder |
Specifies either a pre-order or post-order traversal
|
| TraversalOrder.PartialVisitor<R> |
|
| TraversalOrder.Post |
Post-order traversal
|
| TraversalOrder.Pre |
Pre-order traversal
|
| TraversalOrder.Visitor<R> |
|
| Tree |
|
| Tree.Bounds |
|
| Tree.CaseTree |
|
| Tree.Ctor |
|
| Tree.Enumerator |
|
| Tree.Importee |
|
| Tree.Importer |
|
| Tree.Member |
|
| Tree.Mod |
|
| Tree.PartialVisitor<R> |
|
| Tree.Pat |
|
| Tree.Quasi |
|
| Tree.Ref |
|
| Tree.Source |
|
| Tree.Stat |
|
| Tree.Template |
|
| Tree.Type |
|
| Tree.Visitor<R> |
|
| TrigonometricFunctionFeatures |
Trigonometric functions
|
| Triple |
An RDF triple defined by a subject, predicate, and object
|
| TriplePattern |
A subject/predicate/object pattern
|
| TryMe |
|
| TryStatement |
|
| TryStatement_Simple |
|
| TryStatement_WithFinally |
|
| TryStatement.PartialVisitor<R> |
|
| TryStatement.Simple |
|
| TryStatement.Visitor<R> |
|
| TryStatement.WithFinally |
|
| TryStatement.WithResources |
|
| TryWithResourcesStatement |
|
| TTerm<A> |
An association of a term with a phantom type
|
| Tuple |
A simple class for tuples (instances of product types) in Java.
|
| Tuple.Tuple0 |
A zero-tuple, i.e.
|
| Tuple.Tuple1<T1> |
A one-tuple.
|
| Tuple.Tuple2<T1,T2> |
A two-tuple, i.e.
|
| Tuple.Tuple3<T1,T2,T3> |
A three-tuple, i.e.
|
| Tuple.Tuple4<T1,T2,T3,T4> |
A four-tuple, i.e.
|
| Tuple.Tuple5<T1,T2,T3,T4,T5> |
A five-tuple.
|
| Tuple.Tuple6<T1,T2,T3,T4,T5,T6> |
A six-tuple.
|
| Tuple.Tuple7<T1,T2,T3,T4,T5,T6,T7> |
A seven-tuple.
|
| Tuple.Tuple8<T1,T2,T3,T4,T5,T6,T7,T8> |
An eight-tuple.
|
| Tuple.Tuple9<T1,T2,T3,T4,T5,T6,T7,T8,T9> |
A nine-tuple.
|
| TupleProjection |
A tuple elimination; a projection from an integer-indexed product
|
| Type |
A data type
|
| Type |
|
| Type |
|
| Type |
|
| Type |
A protocol buffer message type.
|
| Type |
|
| Type_And |
|
| Type_Annotate |
|
| Type_AnonymousName |
|
| Type_Application |
|
| Type_Apply |
|
| Type_ApplyInfix |
|
| Type_Bounds |
|
| Type_ByName |
|
| Type_Context |
|
| Type_ContextFunction |
|
| Type_Existential |
|
| Type_Function |
|
| Type_Function |
|
| Type_FunctionType |
|
| Type_FunctionType.ContextFunction |
|
| Type_FunctionType.Function |
|
| Type_FunctionType.PartialVisitor<R> |
|
| Type_FunctionType.Visitor<R> |
|
| Type_ImplicitFunction |
|
| Type_Infix |
|
| Type_Lambda |
|
| Type_Macro |
|
| Type_Match |
|
| Type_Method |
|
| Type_Name |
|
| Type_Or |
|
| Type_Param |
|
| Type_Placeholder |
|
| Type_PolyFunction |
|
| Type_Project |
|
| Type_Ref |
|
| Type_Ref.Name |
|
| Type_Ref.PartialVisitor<R> |
|
| Type_Ref.Project |
|
| Type_Ref.Select |
|
| Type_Ref.Singleton |
|
| Type_Ref.Visitor<R> |
|
| Type_Refine |
|
| Type_Repeated |
|
| Type_Select |
|
| Type_Singleton |
|
| Type_Tuple |
|
| Type_TypedParam |
|
| Type_Var |
|
| Type_With |
|
| Type.And |
|
| Type.Annotate |
|
| Type.Annotated |
|
| Type.AnonymousName |
|
| Type.Application |
|
| Type.Application |
|
| Type.Apply |
|
| Type.ApplyInfix |
|
| Type.ByName |
|
| Type.Ctx |
|
| Type.Existential |
|
| Type.Function |
|
| Type.Function |
|
| Type.FunctionType |
|
| Type.ImplicitFunction |
|
| Type.Infix |
|
| Type.Lambda |
|
| Type.Lambda |
|
| Type.List |
|
| Type.List |
|
| Type.List |
|
| Type.Literal |
|
| Type.Macro |
|
| Type.Map |
|
| Type.Match |
|
| Type.Method |
|
| Type.Named |
|
| Type.NonNull |
|
| Type.Optional |
|
| Type.Or |
|
| Type.Parens |
|
| Type.PartialVisitor<R> |
|
| Type.PartialVisitor<R> |
|
| Type.PartialVisitor<R> |
|
| Type.PartialVisitor<R> |
|
| Type.PartialVisitor<R> |
|
| Type.Placeholder |
|
| Type.PolyFunction |
|
| Type.Primitive |
|
| Type.Product |
|
| Type.Record |
|
| Type.Ref |
|
| Type.Reference |
|
| Type.Refine |
|
| Type.Repeated |
|
| Type.Set |
|
| Type.Sum |
|
| Type.Tuple |
|
| Type.Tuple |
|
| Type.TypedParam |
|
| Type.Union |
|
| Type.Var |
|
| Type.Variable |
|
| Type.Variable |
|
| Type.Visitor<R> |
|
| Type.Visitor<R> |
|
| Type.Visitor<R> |
|
| Type.Visitor<R> |
|
| Type.Visitor<R> |
|
| Type.With |
|
| Type.Wrap |
|
| TypeAbstraction |
A System F type abstraction term
|
| TypeArgument |
|
| TypeArgument.PartialVisitor<R> |
|
| TypeArgument.Reference |
|
| TypeArgument.Visitor<R> |
|
| TypeArgument.Wildcard |
|
| TypeArgumentsOrDiamond |
|
| TypeArgumentsOrDiamond.Arguments |
|
| TypeArgumentsOrDiamond.Diamond |
|
| TypeArgumentsOrDiamond.PartialVisitor<R> |
|
| TypeArgumentsOrDiamond.Visitor<R> |
|
| TypeBound |
|
| TypeBound_ClassOrInterface |
|
| TypeBound.ClassOrInterface |
|
| TypeBound.PartialVisitor<R> |
|
| TypeBound.Variable |
|
| TypeBound.Visitor<R> |
|
| TypeCase |
|
| TypeClass |
Any of a small number of built-in type classes
|
| TypeClass.Equality |
|
| TypeClass.Ordering |
|
| TypeClass.PartialVisitor<R> |
|
| TypeClass.Visitor<R> |
|
| TypeCondition |
|
| TypeCondition.NamedType |
|
| TypeCondition.On |
|
| TypeCondition.PartialVisitor<R> |
|
| TypeCondition.Visitor<R> |
|
| TypeConstraint |
An assertion that two types can be unified into a single type
|
| TypedBinding |
|
| TypeDeclaration |
|
| TypeDeclaration |
|
| TypeDeclaration.Class_ |
|
| TypeDeclaration.Interface |
|
| TypeDeclaration.None |
|
| TypeDeclaration.PartialVisitor<R> |
|
| TypeDeclaration.Visitor<R> |
|
| TypeDeclarationWithComments |
|
| TypeDefinition |
|
| TypeDefinition.Enum_ |
|
| TypeDefinition.InputObject |
|
| TypeDefinition.Interface |
|
| TypeDefinition.Object_ |
|
| TypeDefinition.PartialVisitor<R> |
|
| TypeDefinition.Scalar |
|
| TypeDefinition.Union |
|
| TypeDefinition.Visitor<R> |
|
| TypedTerm |
A term together with its type
|
| TypeExtension |
|
| TypeExtension.Enum_ |
|
| TypeExtension.InputObject |
|
| TypeExtension.Interface |
|
| TypeExtension.Object_ |
|
| TypeExtension.PartialVisitor<R> |
|
| TypeExtension.Scalar |
|
| TypeExtension.Union |
|
| TypeExtension.Visitor<R> |
|
| TypeIdentifier |
|
| TypeImportOnDemandDeclaration |
|
| TypeName |
|
| TypeName |
The local name of an enum type or message type
|
| TypeNameArray |
|
| TypeNameArray.Array |
|
| TypeNameArray.PartialVisitor<R> |
|
| TypeNameArray.Simple |
|
| TypeNameArray.Visitor<R> |
|
| TypeParameter |
|
| TypeParameterModifier |
|
| TypeReference |
A reference to an enum type or message type
|
| Types |
DSL utilities for constructing Hydra types.
|
| TypeScheme |
A type expression together with free type variables occurring in the expression
|
| TypeSignature |
|
| TypeSystemDefinition |
|
| TypeSystemDefinition.Directive |
|
| TypeSystemDefinition.PartialVisitor<R> |
|
| TypeSystemDefinition.Schema |
|
| TypeSystemDefinition.Type |
|
| TypeSystemDefinition.Visitor<R> |
|
| TypeSystemDefinitionOrExtension |
|
| TypeSystemDefinitionOrExtension.Definition |
|
| TypeSystemDefinitionOrExtension.Extension |
|
| TypeSystemDefinitionOrExtension.PartialVisitor<R> |
|
| TypeSystemDefinitionOrExtension.Visitor<R> |
|
| TypeSystemDirectiveLocation |
|
| TypeSystemDirectiveLocation.ARGUMENTLowbarDEFINITION |
|
| TypeSystemDirectiveLocation.ENUM |
|
| TypeSystemDirectiveLocation.ENUMLowbarVALUE |
|
| TypeSystemDirectiveLocation.FIELDLowbarDEFINITION |
|
| TypeSystemDirectiveLocation.INPUTLowbarFIELDLowbarDEFINITION |
|
| TypeSystemDirectiveLocation.INPUTLowbarOBJECT |
|
| TypeSystemDirectiveLocation.INTERFACE |
|
| TypeSystemDirectiveLocation.OBJECT |
|
| TypeSystemDirectiveLocation.PartialVisitor<R> |
|
| TypeSystemDirectiveLocation.SCALAR |
|
| TypeSystemDirectiveLocation.SCHEMA |
|
| TypeSystemDirectiveLocation.UNION |
|
| TypeSystemDirectiveLocation.Visitor<R> |
|
| TypeSystemDocment |
|
| TypeSystemExtension |
|
| TypeSystemExtension.PartialVisitor<R> |
|
| TypeSystemExtension.Schema |
|
| TypeSystemExtension.Type |
|
| TypeSystemExtension.Visitor<R> |
|
| TypeSystemExtensionDocument |
|
| TypeVariable |
|
| TypeVariant |
The identifier of a type constructor
|
| TypeVariant.Annotated |
|
| TypeVariant.Application |
|
| TypeVariant.Function |
|
| TypeVariant.Lambda |
|
| TypeVariant.List |
|
| TypeVariant.Literal |
|
| TypeVariant.Map |
|
| TypeVariant.Optional |
|
| TypeVariant.PartialVisitor<R> |
|
| TypeVariant.Product |
|
| TypeVariant.Record |
|
| TypeVariant.Set |
|
| TypeVariant.Sum |
|
| TypeVariant.Union |
|
| TypeVariant.Variable |
|
| TypeVariant.Visitor<R> |
|
| TypeVariant.Wrap |
|
| Uint16ToBigint |
|
| Uint32ToBigint |
|
| Uint64ToBigint |
|
| Uint8ToBigint |
|
| UnannClassType |
A ClassType which does not allow annotations
|
| UnannType |
A Type which does not allow annotations
|
| UnaryAddOrSubtractExpression |
|
| UnaryExpression |
|
| UnaryExpression |
|
| UnaryExpression.Minus |
|
| UnaryExpression.Other |
|
| UnaryExpression.PartialVisitor<R> |
|
| UnaryExpression.Plus |
|
| UnaryExpression.PreDecrement |
|
| UnaryExpression.PreIncrement |
|
| UnaryExpression.Visitor<R> |
|
| UnaryExpressionNotPlusMinus |
|
| UnaryExpressionNotPlusMinus.Cast |
|
| UnaryExpressionNotPlusMinus.Not |
|
| UnaryExpressionNotPlusMinus.PartialVisitor<R> |
|
| UnaryExpressionNotPlusMinus.Postfix |
|
| UnaryExpressionNotPlusMinus.Tilde |
|
| UnaryExpressionNotPlusMinus.Visitor<R> |
|
| UnaryOperator |
|
| UnaryOperator.Negate |
|
| UnaryOperator.PartialVisitor<R> |
|
| UnaryOperator.Visitor<R> |
|
| Union |
|
| Union |
|
| Union |
|
| UnionMember |
|
| UnionMemberTypes |
|
| UnionMemberTypes_Sequence |
|
| UnionMemberTypes_Sequence2 |
|
| UnionMemberTypes.PartialVisitor<R> |
|
| UnionMemberTypes.Sequence |
|
| UnionMemberTypes.Sequence2 |
|
| UnionMemberTypes.Visitor<R> |
|
| UnionSchema |
|
| UnionTypeDefinition |
|
| UnionTypeExtension |
|
| UnionTypeExtension_Sequence |
|
| UnionTypeExtension_Sequence2 |
|
| UnionTypeExtension.PartialVisitor<R> |
|
| UnionTypeExtension.Sequence |
|
| UnionTypeExtension.Sequence2 |
|
| UnionTypeExtension.Visitor<R> |
|
| Unit |
An empty record as a canonical unit value
|
| UnqualifiedClassInstanceCreationExpression |
|
| Unwind |
|
| UpdatingClause |
|
| UpdatingClause.Create |
|
| UpdatingClause.Delete |
|
| UpdatingClause.Merge |
|
| UpdatingClause.PartialVisitor<R> |
|
| UpdatingClause.Remove |
|
| UpdatingClause.Set |
|
| UpdatingClause.Visitor<R> |
|
| UpdatingFeatures |
Specific syntax related to updating data in the graph
|
| Validation |
Utilities for validating property graphs against property graph schemas
|
| Value |
|
| Value |
A scalar value
|
| Value |
A JSON value
|
| Value.Array |
A JSON array
|
| Value.Boolean_ |
|
| Value.Boolean_ |
|
| Value.Boolean_ |
A boolean value
|
| Value.Enum_ |
|
| Value.Float_ |
|
| Value.Int |
|
| Value.List |
|
| Value.Null |
|
| Value.Null |
JSON's null value
|
| Value.Number_ |
A numeric value
|
| Value.Object_ |
|
| Value.Object_ |
A JSON object as a set of key/value pairs
|
| Value.PartialVisitor<R> |
|
| Value.PartialVisitor<R> |
|
| Value.PartialVisitor<R> |
|
| Value.String_ |
|
| Value.String_ |
|
| Value.String_ |
A string value
|
| Value.Variable |
|
| Value.Visitor<R> |
|
| Value.Visitor<R> |
|
| Value.Visitor<R> |
|
| ValueBinding |
|
| ValueBinding_Simple |
|
| ValueBinding.PartialVisitor<R> |
|
| ValueBinding.Simple |
|
| ValueBinding.Visitor<R> |
|
| Values |
|
| ValueSpec |
A mapping specification producing values (usually literal values) whose type is understood in context
|
| ValueSpec.PartialVisitor<R> |
|
| ValueSpec.Pattern |
A compact path representing the function, e.g.
|
| ValueSpec.Value |
A trivial no-op specification which passes the entire value
|
| ValueSpec.Visitor<R> |
|
| Variable |
|
| Variable |
|
| Variable |
|
| Variable |
|
| Variable |
A query variable
|
| VariableAccess |
|
| VariableAccess.ExpressionName |
|
| VariableAccess.FieldAccess |
|
| VariableAccess.PartialVisitor<R> |
|
| VariableAccess.Visitor<R> |
|
| VariableAndNodeLabels |
|
| VariableArityParameter |
|
| VariableDeclarator |
|
| VariableDeclaratorId |
|
| VariableEquals |
|
| VariableInitializer |
|
| VariableInitializer.ArrayInitializer |
|
| VariableInitializer.Expression |
|
| VariableInitializer.PartialVisitor<R> |
|
| VariableInitializer.Visitor<R> |
|
| VariableModifier |
|
| VariableModifier.Annotation |
|
| VariableModifier.Final |
|
| VariableModifier.PartialVisitor<R> |
|
| VariableModifier.Visitor<R> |
|
| VariablePlusEquals |
|
| VariablesDefinition |
|
| VectorFunctionFeatures |
Vector functions
|
| Vertex<V> |
A vertex
|
| VertexBuilder<V> |
A builder object for property graph vertices.
|
| VertexLabel |
The label of a vertex.
|
| VertexPattern |
|
| VertexSpec |
A mapping specification producing vertices of a specified label
|
| VertexType<T> |
The type of a vertex
|
| VertexTypeBuilder<T> |
A builder object for property graph vertex types.
|
| Where |
|
| WhileStatement |
|
| WhileStatementNoShortIf |
|
| Wildcard |
|
| WildcardBounds |
|
| WildcardBounds.Extends |
|
| WildcardBounds.PartialVisitor<R> |
|
| WildcardBounds.Super |
|
| WildcardBounds.Visitor<R> |
|
| With |
|
| WithClause |
|
| WrappedTerm |
A term wrapped in a type name
|
| WrappedType |
A type wrapped in a type name
|
| Ws |
One of several classes of whitespace
|
| Ws.Break |
|
| Ws.BreakAndIndent |
|
| Ws.DoubleBreak |
|
| Ws.None |
|
| Ws.PartialVisitor<R> |
|
| Ws.Space |
|
| Ws.Visitor<R> |
|
| XorExpression |
|
| YieldItem |
|
| YieldItems |
|