fql

package
v0.12.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 22, 2020 License: Apache-2.0 Imports: 5 Imported by: 10

Documentation

Index

Constants

View Source 
const (
	FqlLexerMultiLineComment  = 1
	FqlLexerSingleLineComment = 2
	FqlLexerWhiteSpaces       = 3
	FqlLexerLineTerminator    = 4
	FqlLexerColon             = 5
	FqlLexerSemiColon         = 6
	FqlLexerDot               = 7
	FqlLexerComma             = 8
	FqlLexerOpenBracket       = 9
	FqlLexerCloseBracket      = 10
	FqlLexerOpenParen         = 11
	FqlLexerCloseParen        = 12
	FqlLexerOpenBrace         = 13
	FqlLexerCloseBrace        = 14
	FqlLexerGt                = 15
	FqlLexerLt                = 16
	FqlLexerEq                = 17
	FqlLexerGte               = 18
	FqlLexerLte               = 19
	FqlLexerNeq               = 20
	FqlLexerMulti             = 21
	FqlLexerDiv               = 22
	FqlLexerMod               = 23
	FqlLexerPlus              = 24
	FqlLexerMinus             = 25
	FqlLexerMinusMinus        = 26
	FqlLexerPlusPlus          = 27
	FqlLexerAnd               = 28
	FqlLexerOr                = 29
	FqlLexerRange             = 30
	FqlLexerAssign            = 31
	FqlLexerQuestionMark      = 32
	FqlLexerRegexNotMatch     = 33
	FqlLexerRegexMatch        = 34
	FqlLexerFor               = 35
	FqlLexerReturn            = 36
	FqlLexerDistinct          = 37
	FqlLexerFilter            = 38
	FqlLexerSort              = 39
	FqlLexerLimit             = 40
	FqlLexerLet               = 41
	FqlLexerCollect           = 42
	FqlLexerSortDirection     = 43
	FqlLexerNone              = 44
	FqlLexerNull              = 45
	FqlLexerBooleanLiteral    = 46
	FqlLexerUse               = 47
	FqlLexerInto              = 48
	FqlLexerKeep              = 49
	FqlLexerWith              = 50
	FqlLexerCount             = 51
	FqlLexerAll               = 52
	FqlLexerAny               = 53
	FqlLexerAggregate         = 54
	FqlLexerLike              = 55
	FqlLexerNot               = 56
	FqlLexerIn                = 57
	FqlLexerParam             = 58
	FqlLexerIdentifier        = 59
	FqlLexerStringLiteral     = 60
	FqlLexerIntegerLiteral    = 61
	FqlLexerFloatLiteral      = 62
	FqlLexerNamespaceSegment  = 63
)

FqlLexer tokens.

View Source 
const (
	FqlParserEOF               = antlr.TokenEOF
	FqlParserMultiLineComment  = 1
	FqlParserSingleLineComment = 2
	FqlParserWhiteSpaces       = 3
	FqlParserLineTerminator    = 4
	FqlParserColon             = 5
	FqlParserSemiColon         = 6
	FqlParserDot               = 7
	FqlParserComma             = 8
	FqlParserOpenBracket       = 9
	FqlParserCloseBracket      = 10
	FqlParserOpenParen         = 11
	FqlParserCloseParen        = 12
	FqlParserOpenBrace         = 13
	FqlParserCloseBrace        = 14
	FqlParserGt                = 15
	FqlParserLt                = 16
	FqlParserEq                = 17
	FqlParserGte               = 18
	FqlParserLte               = 19
	FqlParserNeq               = 20
	FqlParserMulti             = 21
	FqlParserDiv               = 22
	FqlParserMod               = 23
	FqlParserPlus              = 24
	FqlParserMinus             = 25
	FqlParserMinusMinus        = 26
	FqlParserPlusPlus          = 27
	FqlParserAnd               = 28
	FqlParserOr                = 29
	FqlParserRange             = 30
	FqlParserAssign            = 31
	FqlParserQuestionMark      = 32
	FqlParserRegexNotMatch     = 33
	FqlParserRegexMatch        = 34
	FqlParserFor               = 35
	FqlParserReturn            = 36
	FqlParserDistinct          = 37
	FqlParserFilter            = 38
	FqlParserSort              = 39
	FqlParserLimit             = 40
	FqlParserLet               = 41
	FqlParserCollect           = 42
	FqlParserSortDirection     = 43
	FqlParserNone              = 44
	FqlParserNull              = 45
	FqlParserBooleanLiteral    = 46
	FqlParserUse               = 47
	FqlParserInto              = 48
	FqlParserKeep              = 49
	FqlParserWith              = 50
	FqlParserCount             = 51
	FqlParserAll               = 52
	FqlParserAny               = 53
	FqlParserAggregate         = 54
	FqlParserLike              = 55
	FqlParserNot               = 56
	FqlParserIn                = 57
	FqlParserParam             = 58
	FqlParserIdentifier        = 59
	FqlParserStringLiteral     = 60
	FqlParserIntegerLiteral    = 61
	FqlParserFloatLiteral      = 62
	FqlParserNamespaceSegment  = 63
)

FqlParser tokens.

View Source 
const (
	FqlParserRULE_program                    = 0
	FqlParserRULE_head                       = 1
	FqlParserRULE_useExpression              = 2
	FqlParserRULE_use                        = 3
	FqlParserRULE_body                       = 4
	FqlParserRULE_bodyStatement              = 5
	FqlParserRULE_bodyExpression             = 6
	FqlParserRULE_returnExpression           = 7
	FqlParserRULE_forExpression              = 8
	FqlParserRULE_forExpressionValueVariable = 9
	FqlParserRULE_forExpressionKeyVariable   = 10
	FqlParserRULE_forExpressionSource        = 11
	FqlParserRULE_forExpressionClause        = 12
	FqlParserRULE_forExpressionStatement     = 13
	FqlParserRULE_forExpressionBody          = 14
	FqlParserRULE_forExpressionReturn        = 15
	FqlParserRULE_filterClause               = 16
	FqlParserRULE_limitClause                = 17
	FqlParserRULE_limitClauseValue           = 18
	FqlParserRULE_sortClause                 = 19
	FqlParserRULE_sortClauseExpression       = 20
	FqlParserRULE_collectClause              = 21
	FqlParserRULE_collectSelector            = 22
	FqlParserRULE_collectGrouping            = 23
	FqlParserRULE_collectAggregator          = 24
	FqlParserRULE_collectAggregateSelector   = 25
	FqlParserRULE_collectGroupVariable       = 26
	FqlParserRULE_collectCounter             = 27
	FqlParserRULE_variableDeclaration        = 28
	FqlParserRULE_param                      = 29
	FqlParserRULE_variable                   = 30
	FqlParserRULE_rangeOperator              = 31
	FqlParserRULE_arrayLiteral               = 32
	FqlParserRULE_objectLiteral              = 33
	FqlParserRULE_booleanLiteral             = 34
	FqlParserRULE_stringLiteral              = 35
	FqlParserRULE_integerLiteral             = 36
	FqlParserRULE_floatLiteral               = 37
	FqlParserRULE_noneLiteral                = 38
	FqlParserRULE_arrayElementList           = 39
	FqlParserRULE_propertyAssignment         = 40
	FqlParserRULE_shorthandPropertyName      = 41
	FqlParserRULE_computedPropertyName       = 42
	FqlParserRULE_propertyName               = 43
	FqlParserRULE_expressionGroup            = 44
	FqlParserRULE_namespaceIdentifier        = 45
	FqlParserRULE_namespace                  = 46
	FqlParserRULE_functionIdentifier         = 47
	FqlParserRULE_functionCallExpression     = 48
	FqlParserRULE_member                     = 49
	FqlParserRULE_memberPath                 = 50
	FqlParserRULE_memberExpression           = 51
	FqlParserRULE_arguments                  = 52
	FqlParserRULE_expression                 = 53
	FqlParserRULE_forTernaryExpression       = 54
	FqlParserRULE_arrayOperator              = 55
	FqlParserRULE_inOperator                 = 56
	FqlParserRULE_equalityOperator           = 57
	FqlParserRULE_regexpOperator             = 58
	FqlParserRULE_logicalAndOperator         = 59
	FqlParserRULE_logicalOrOperator          = 60
	FqlParserRULE_multiplicativeOperator     = 61
	FqlParserRULE_additiveOperator           = 62
	FqlParserRULE_unaryOperator              = 63
)

FqlParser rules.

Variables

This section is empty.

Functions

This section is empty.

Types

type AdditiveOperatorContext added in v0.6.0 

type AdditiveOperatorContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewAdditiveOperatorContext added in v0.6.0 

func NewAdditiveOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AdditiveOperatorContext

func NewEmptyAdditiveOperatorContext added in v0.6.0 

func NewEmptyAdditiveOperatorContext() *AdditiveOperatorContext

func (*AdditiveOperatorContext) Accept added in v0.6.0 

func (s *AdditiveOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*AdditiveOperatorContext) EnterRule added in v0.6.0 

func (s *AdditiveOperatorContext) EnterRule(listener antlr.ParseTreeListener)

func (*AdditiveOperatorContext) ExitRule added in v0.6.0 

func (s *AdditiveOperatorContext) ExitRule(listener antlr.ParseTreeListener)

func (*AdditiveOperatorContext) GetParser added in v0.6.0 

func (s *AdditiveOperatorContext) GetParser() antlr.Parser

func (*AdditiveOperatorContext) GetRuleContext added in v0.6.0 

func (s *AdditiveOperatorContext) GetRuleContext() antlr.RuleContext

func (*AdditiveOperatorContext) IsAdditiveOperatorContext added in v0.6.0 

func (*AdditiveOperatorContext) IsAdditiveOperatorContext()

func (*AdditiveOperatorContext) Minus added in v0.6.0 

func (s *AdditiveOperatorContext) Minus() antlr.TerminalNode

func (*AdditiveOperatorContext) Plus added in v0.6.0 

func (s *AdditiveOperatorContext) Plus() antlr.TerminalNode

func (*AdditiveOperatorContext) ToStringTree added in v0.6.0 

func (s *AdditiveOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ArgumentsContext 

type ArgumentsContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewArgumentsContext 

func NewArgumentsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArgumentsContext

func NewEmptyArgumentsContext 

func NewEmptyArgumentsContext() *ArgumentsContext

func (*ArgumentsContext) Accept 

func (s *ArgumentsContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ArgumentsContext) AllComma 

func (s *ArgumentsContext) AllComma() []antlr.TerminalNode

func (*ArgumentsContext) AllExpression 

func (s *ArgumentsContext) AllExpression() []IExpressionContext

func (*ArgumentsContext) CloseParen 

func (s *ArgumentsContext) CloseParen() antlr.TerminalNode

func (*ArgumentsContext) Comma 

func (s *ArgumentsContext) Comma(i int) antlr.TerminalNode

func (*ArgumentsContext) EnterRule 

func (s *ArgumentsContext) EnterRule(listener antlr.ParseTreeListener)

func (*ArgumentsContext) ExitRule 

func (s *ArgumentsContext) ExitRule(listener antlr.ParseTreeListener)

func (*ArgumentsContext) Expression 

func (s *ArgumentsContext) Expression(i int) IExpressionContext

func (*ArgumentsContext) GetParser 

func (s *ArgumentsContext) GetParser() antlr.Parser

func (*ArgumentsContext) GetRuleContext 

func (s *ArgumentsContext) GetRuleContext() antlr.RuleContext

func (*ArgumentsContext) IsArgumentsContext 

func (*ArgumentsContext) IsArgumentsContext()

func (*ArgumentsContext) OpenParen 

func (s *ArgumentsContext) OpenParen() antlr.TerminalNode

func (*ArgumentsContext) ToStringTree 

func (s *ArgumentsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ArrayElementListContext 

type ArrayElementListContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewArrayElementListContext 

func NewArrayElementListContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayElementListContext

func NewEmptyArrayElementListContext 

func NewEmptyArrayElementListContext() *ArrayElementListContext

func (*ArrayElementListContext) Accept 

func (s *ArrayElementListContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ArrayElementListContext) AllComma 

func (s *ArrayElementListContext) AllComma() []antlr.TerminalNode

func (*ArrayElementListContext) AllExpression 

func (s *ArrayElementListContext) AllExpression() []IExpressionContext

func (*ArrayElementListContext) Comma 

func (s *ArrayElementListContext) Comma(i int) antlr.TerminalNode

func (*ArrayElementListContext) EnterRule 

func (s *ArrayElementListContext) EnterRule(listener antlr.ParseTreeListener)

func (*ArrayElementListContext) ExitRule 

func (s *ArrayElementListContext) ExitRule(listener antlr.ParseTreeListener)

func (*ArrayElementListContext) Expression 

func (s *ArrayElementListContext) Expression(i int) IExpressionContext

func (*ArrayElementListContext) GetParser 

func (s *ArrayElementListContext) GetParser() antlr.Parser

func (*ArrayElementListContext) GetRuleContext 

func (s *ArrayElementListContext) GetRuleContext() antlr.RuleContext

func (*ArrayElementListContext) IsArrayElementListContext 

func (*ArrayElementListContext) IsArrayElementListContext()

func (*ArrayElementListContext) ToStringTree 

func (s *ArrayElementListContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ArrayLiteralContext 

type ArrayLiteralContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewArrayLiteralContext 

func NewArrayLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayLiteralContext

func NewEmptyArrayLiteralContext 

func NewEmptyArrayLiteralContext() *ArrayLiteralContext

func (*ArrayLiteralContext) Accept 

func (s *ArrayLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ArrayLiteralContext) ArrayElementList 

func (s *ArrayLiteralContext) ArrayElementList() IArrayElementListContext

func (*ArrayLiteralContext) CloseBracket 

func (s *ArrayLiteralContext) CloseBracket() antlr.TerminalNode

func (*ArrayLiteralContext) EnterRule 

func (s *ArrayLiteralContext) EnterRule(listener antlr.ParseTreeListener)

func (*ArrayLiteralContext) ExitRule 

func (s *ArrayLiteralContext) ExitRule(listener antlr.ParseTreeListener)

func (*ArrayLiteralContext) GetParser 

func (s *ArrayLiteralContext) GetParser() antlr.Parser

func (*ArrayLiteralContext) GetRuleContext 

func (s *ArrayLiteralContext) GetRuleContext() antlr.RuleContext

func (*ArrayLiteralContext) IsArrayLiteralContext 

func (*ArrayLiteralContext) IsArrayLiteralContext()

func (*ArrayLiteralContext) OpenBracket 

func (s *ArrayLiteralContext) OpenBracket() antlr.TerminalNode

func (*ArrayLiteralContext) ToStringTree 

func (s *ArrayLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ArrayOperatorContext 

type ArrayOperatorContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewArrayOperatorContext 

func NewArrayOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArrayOperatorContext

func NewEmptyArrayOperatorContext 

func NewEmptyArrayOperatorContext() *ArrayOperatorContext

func (*ArrayOperatorContext) Accept 

func (s *ArrayOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ArrayOperatorContext) All 

func (s *ArrayOperatorContext) All() antlr.TerminalNode

func (*ArrayOperatorContext) Any 

func (s *ArrayOperatorContext) Any() antlr.TerminalNode

func (*ArrayOperatorContext) EnterRule 

func (s *ArrayOperatorContext) EnterRule(listener antlr.ParseTreeListener)

func (*ArrayOperatorContext) ExitRule 

func (s *ArrayOperatorContext) ExitRule(listener antlr.ParseTreeListener)

func (*ArrayOperatorContext) GetParser 

func (s *ArrayOperatorContext) GetParser() antlr.Parser

func (*ArrayOperatorContext) GetRuleContext 

func (s *ArrayOperatorContext) GetRuleContext() antlr.RuleContext

func (*ArrayOperatorContext) IsArrayOperatorContext 

func (*ArrayOperatorContext) IsArrayOperatorContext()

func (*ArrayOperatorContext) None 

func (s *ArrayOperatorContext) None() antlr.TerminalNode

func (*ArrayOperatorContext) ToStringTree 

func (s *ArrayOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type BaseFqlParserListener 

type BaseFqlParserListener struct{}

BaseFqlParserListener is a complete listener for a parse tree produced by FqlParser.

func (*BaseFqlParserListener) EnterAdditiveOperator added in v0.6.0 

func (s *BaseFqlParserListener) EnterAdditiveOperator(ctx *AdditiveOperatorContext)

EnterAdditiveOperator is called when production additiveOperator is entered.

func (*BaseFqlParserListener) EnterArguments 

func (s *BaseFqlParserListener) EnterArguments(ctx *ArgumentsContext)

EnterArguments is called when production arguments is entered.

func (*BaseFqlParserListener) EnterArrayElementList 

func (s *BaseFqlParserListener) EnterArrayElementList(ctx *ArrayElementListContext)

EnterArrayElementList is called when production arrayElementList is entered.

func (*BaseFqlParserListener) EnterArrayLiteral 

func (s *BaseFqlParserListener) EnterArrayLiteral(ctx *ArrayLiteralContext)

EnterArrayLiteral is called when production arrayLiteral is entered.

func (*BaseFqlParserListener) EnterArrayOperator 

func (s *BaseFqlParserListener) EnterArrayOperator(ctx *ArrayOperatorContext)

EnterArrayOperator is called when production arrayOperator is entered.

func (*BaseFqlParserListener) EnterBody 

func (s *BaseFqlParserListener) EnterBody(ctx *BodyContext)

EnterBody is called when production body is entered.

func (*BaseFqlParserListener) EnterBodyExpression 

func (s *BaseFqlParserListener) EnterBodyExpression(ctx *BodyExpressionContext)

EnterBodyExpression is called when production bodyExpression is entered.

func (*BaseFqlParserListener) EnterBodyStatement 

func (s *BaseFqlParserListener) EnterBodyStatement(ctx *BodyStatementContext)

EnterBodyStatement is called when production bodyStatement is entered.

func (*BaseFqlParserListener) EnterBooleanLiteral 

func (s *BaseFqlParserListener) EnterBooleanLiteral(ctx *BooleanLiteralContext)

EnterBooleanLiteral is called when production booleanLiteral is entered.

func (*BaseFqlParserListener) EnterCollectAggregateSelector added in v0.4.0 

func (s *BaseFqlParserListener) EnterCollectAggregateSelector(ctx *CollectAggregateSelectorContext)

EnterCollectAggregateSelector is called when production collectAggregateSelector is entered.

func (*BaseFqlParserListener) EnterCollectAggregator added in v0.4.0 

func (s *BaseFqlParserListener) EnterCollectAggregator(ctx *CollectAggregatorContext)

EnterCollectAggregator is called when production collectAggregator is entered.

func (*BaseFqlParserListener) EnterCollectClause 

func (s *BaseFqlParserListener) EnterCollectClause(ctx *CollectClauseContext)

EnterCollectClause is called when production collectClause is entered.

func (*BaseFqlParserListener) EnterCollectCounter added in v0.4.0 

func (s *BaseFqlParserListener) EnterCollectCounter(ctx *CollectCounterContext)

EnterCollectCounter is called when production collectCounter is entered.

func (*BaseFqlParserListener) EnterCollectGroupVariable 

func (s *BaseFqlParserListener) EnterCollectGroupVariable(ctx *CollectGroupVariableContext)

EnterCollectGroupVariable is called when production collectGroupVariable is entered.

func (*BaseFqlParserListener) EnterCollectGrouping added in v0.4.0 

func (s *BaseFqlParserListener) EnterCollectGrouping(ctx *CollectGroupingContext)

EnterCollectGrouping is called when production collectGrouping is entered.

func (*BaseFqlParserListener) EnterCollectSelector added in v0.4.0 

func (s *BaseFqlParserListener) EnterCollectSelector(ctx *CollectSelectorContext)

EnterCollectSelector is called when production collectSelector is entered.

func (*BaseFqlParserListener) EnterComputedPropertyName 

func (s *BaseFqlParserListener) EnterComputedPropertyName(ctx *ComputedPropertyNameContext)

EnterComputedPropertyName is called when production computedPropertyName is entered.

func (*BaseFqlParserListener) EnterEqualityOperator 

func (s *BaseFqlParserListener) EnterEqualityOperator(ctx *EqualityOperatorContext)

EnterEqualityOperator is called when production equalityOperator is entered.

func (*BaseFqlParserListener) EnterEveryRule 

func (s *BaseFqlParserListener) EnterEveryRule(ctx antlr.ParserRuleContext)

EnterEveryRule is called when any rule is entered.

func (*BaseFqlParserListener) EnterExpression 

func (s *BaseFqlParserListener) EnterExpression(ctx *ExpressionContext)

EnterExpression is called when production expression is entered.

func (*BaseFqlParserListener) EnterExpressionGroup added in v0.6.0 

func (s *BaseFqlParserListener) EnterExpressionGroup(ctx *ExpressionGroupContext)

EnterExpressionGroup is called when production expressionGroup is entered.

func (*BaseFqlParserListener) EnterFilterClause 

func (s *BaseFqlParserListener) EnterFilterClause(ctx *FilterClauseContext)

EnterFilterClause is called when production filterClause is entered.

func (*BaseFqlParserListener) EnterFloatLiteral 

func (s *BaseFqlParserListener) EnterFloatLiteral(ctx *FloatLiteralContext)

EnterFloatLiteral is called when production floatLiteral is entered.

func (*BaseFqlParserListener) EnterForExpression 

func (s *BaseFqlParserListener) EnterForExpression(ctx *ForExpressionContext)

EnterForExpression is called when production forExpression is entered.

func (*BaseFqlParserListener) EnterForExpressionBody 

func (s *BaseFqlParserListener) EnterForExpressionBody(ctx *ForExpressionBodyContext)

EnterForExpressionBody is called when production forExpressionBody is entered.

func (*BaseFqlParserListener) EnterForExpressionClause 

func (s *BaseFqlParserListener) EnterForExpressionClause(ctx *ForExpressionClauseContext)

EnterForExpressionClause is called when production forExpressionClause is entered.

func (*BaseFqlParserListener) EnterForExpressionKeyVariable 

func (s *BaseFqlParserListener) EnterForExpressionKeyVariable(ctx *ForExpressionKeyVariableContext)

EnterForExpressionKeyVariable is called when production forExpressionKeyVariable is entered.

func (*BaseFqlParserListener) EnterForExpressionReturn 

func (s *BaseFqlParserListener) EnterForExpressionReturn(ctx *ForExpressionReturnContext)

EnterForExpressionReturn is called when production forExpressionReturn is entered.

func (*BaseFqlParserListener) EnterForExpressionSource 

func (s *BaseFqlParserListener) EnterForExpressionSource(ctx *ForExpressionSourceContext)

EnterForExpressionSource is called when production forExpressionSource is entered.

func (*BaseFqlParserListener) EnterForExpressionStatement added in v0.5.0 

func (s *BaseFqlParserListener) EnterForExpressionStatement(ctx *ForExpressionStatementContext)

EnterForExpressionStatement is called when production forExpressionStatement is entered.

func (*BaseFqlParserListener) EnterForExpressionValueVariable 

func (s *BaseFqlParserListener) EnterForExpressionValueVariable(ctx *ForExpressionValueVariableContext)

EnterForExpressionValueVariable is called when production forExpressionValueVariable is entered.

func (*BaseFqlParserListener) EnterForTernaryExpression 

func (s *BaseFqlParserListener) EnterForTernaryExpression(ctx *ForTernaryExpressionContext)

EnterForTernaryExpression is called when production forTernaryExpression is entered.

func (*BaseFqlParserListener) EnterFunctionCallExpression 

func (s *BaseFqlParserListener) EnterFunctionCallExpression(ctx *FunctionCallExpressionContext)

EnterFunctionCallExpression is called when production functionCallExpression is entered.

func (*BaseFqlParserListener) EnterFunctionIdentifier added in v0.11.0 

func (s *BaseFqlParserListener) EnterFunctionIdentifier(ctx *FunctionIdentifierContext)

EnterFunctionIdentifier is called when production functionIdentifier is entered.

func (*BaseFqlParserListener) EnterHead added in v0.11.0 

func (s *BaseFqlParserListener) EnterHead(ctx *HeadContext)

EnterHead is called when production head is entered.

func (*BaseFqlParserListener) EnterInOperator 

func (s *BaseFqlParserListener) EnterInOperator(ctx *InOperatorContext)

EnterInOperator is called when production inOperator is entered.

func (*BaseFqlParserListener) EnterIntegerLiteral 

func (s *BaseFqlParserListener) EnterIntegerLiteral(ctx *IntegerLiteralContext)

EnterIntegerLiteral is called when production integerLiteral is entered.

func (*BaseFqlParserListener) EnterLimitClause 

func (s *BaseFqlParserListener) EnterLimitClause(ctx *LimitClauseContext)

EnterLimitClause is called when production limitClause is entered.

func (*BaseFqlParserListener) EnterLimitClauseValue added in v0.5.0 

func (s *BaseFqlParserListener) EnterLimitClauseValue(ctx *LimitClauseValueContext)

EnterLimitClauseValue is called when production limitClauseValue is entered.

func (*BaseFqlParserListener) EnterLogicalAndOperator added in v0.6.0 

func (s *BaseFqlParserListener) EnterLogicalAndOperator(ctx *LogicalAndOperatorContext)

EnterLogicalAndOperator is called when production logicalAndOperator is entered.

func (*BaseFqlParserListener) EnterLogicalOrOperator added in v0.6.0 

func (s *BaseFqlParserListener) EnterLogicalOrOperator(ctx *LogicalOrOperatorContext)

EnterLogicalOrOperator is called when production logicalOrOperator is entered.

func (*BaseFqlParserListener) EnterMember added in v0.9.0 

func (s *BaseFqlParserListener) EnterMember(ctx *MemberContext)

EnterMember is called when production member is entered.

func (*BaseFqlParserListener) EnterMemberExpression 

func (s *BaseFqlParserListener) EnterMemberExpression(ctx *MemberExpressionContext)

EnterMemberExpression is called when production memberExpression is entered.

func (*BaseFqlParserListener) EnterMemberPath added in v0.9.0 

func (s *BaseFqlParserListener) EnterMemberPath(ctx *MemberPathContext)

EnterMemberPath is called when production memberPath is entered.

func (*BaseFqlParserListener) EnterMultiplicativeOperator added in v0.6.0 

func (s *BaseFqlParserListener) EnterMultiplicativeOperator(ctx *MultiplicativeOperatorContext)

EnterMultiplicativeOperator is called when production multiplicativeOperator is entered.

func (*BaseFqlParserListener) EnterNamespace added in v0.8.0 

func (s *BaseFqlParserListener) EnterNamespace(ctx *NamespaceContext)

EnterNamespace is called when production namespace is entered.

func (*BaseFqlParserListener) EnterNamespaceIdentifier added in v0.11.0 

func (s *BaseFqlParserListener) EnterNamespaceIdentifier(ctx *NamespaceIdentifierContext)

EnterNamespaceIdentifier is called when production namespaceIdentifier is entered.

func (*BaseFqlParserListener) EnterNoneLiteral 

func (s *BaseFqlParserListener) EnterNoneLiteral(ctx *NoneLiteralContext)

EnterNoneLiteral is called when production noneLiteral is entered.

func (*BaseFqlParserListener) EnterObjectLiteral 

func (s *BaseFqlParserListener) EnterObjectLiteral(ctx *ObjectLiteralContext)

EnterObjectLiteral is called when production objectLiteral is entered.

func (*BaseFqlParserListener) EnterParam 

func (s *BaseFqlParserListener) EnterParam(ctx *ParamContext)

EnterParam is called when production param is entered.

func (*BaseFqlParserListener) EnterProgram 

func (s *BaseFqlParserListener) EnterProgram(ctx *ProgramContext)

EnterProgram is called when production program is entered.

func (*BaseFqlParserListener) EnterPropertyAssignment 

func (s *BaseFqlParserListener) EnterPropertyAssignment(ctx *PropertyAssignmentContext)

EnterPropertyAssignment is called when production propertyAssignment is entered.

func (*BaseFqlParserListener) EnterPropertyName 

func (s *BaseFqlParserListener) EnterPropertyName(ctx *PropertyNameContext)

EnterPropertyName is called when production propertyName is entered.

func (*BaseFqlParserListener) EnterRangeOperator 

func (s *BaseFqlParserListener) EnterRangeOperator(ctx *RangeOperatorContext)

EnterRangeOperator is called when production rangeOperator is entered.

func (*BaseFqlParserListener) EnterRegexpOperator added in v0.8.0 

func (s *BaseFqlParserListener) EnterRegexpOperator(ctx *RegexpOperatorContext)

EnterRegexpOperator is called when production regexpOperator is entered.

func (*BaseFqlParserListener) EnterReturnExpression 

func (s *BaseFqlParserListener) EnterReturnExpression(ctx *ReturnExpressionContext)

EnterReturnExpression is called when production returnExpression is entered.

func (*BaseFqlParserListener) EnterShorthandPropertyName 

func (s *BaseFqlParserListener) EnterShorthandPropertyName(ctx *ShorthandPropertyNameContext)

EnterShorthandPropertyName is called when production shorthandPropertyName is entered.

func (*BaseFqlParserListener) EnterSortClause 

func (s *BaseFqlParserListener) EnterSortClause(ctx *SortClauseContext)

EnterSortClause is called when production sortClause is entered.

func (*BaseFqlParserListener) EnterSortClauseExpression 

func (s *BaseFqlParserListener) EnterSortClauseExpression(ctx *SortClauseExpressionContext)

EnterSortClauseExpression is called when production sortClauseExpression is entered.

func (*BaseFqlParserListener) EnterStringLiteral 

func (s *BaseFqlParserListener) EnterStringLiteral(ctx *StringLiteralContext)

EnterStringLiteral is called when production stringLiteral is entered.

func (*BaseFqlParserListener) EnterUnaryOperator 

func (s *BaseFqlParserListener) EnterUnaryOperator(ctx *UnaryOperatorContext)

EnterUnaryOperator is called when production unaryOperator is entered.

func (*BaseFqlParserListener) EnterUse added in v0.11.0 

func (s *BaseFqlParserListener) EnterUse(ctx *UseContext)

EnterUse is called when production use is entered.

func (*BaseFqlParserListener) EnterUseExpression added in v0.11.0 

func (s *BaseFqlParserListener) EnterUseExpression(ctx *UseExpressionContext)

EnterUseExpression is called when production useExpression is entered.

func (*BaseFqlParserListener) EnterVariable 

func (s *BaseFqlParserListener) EnterVariable(ctx *VariableContext)

EnterVariable is called when production variable is entered.

func (*BaseFqlParserListener) EnterVariableDeclaration 

func (s *BaseFqlParserListener) EnterVariableDeclaration(ctx *VariableDeclarationContext)

EnterVariableDeclaration is called when production variableDeclaration is entered.

func (*BaseFqlParserListener) ExitAdditiveOperator added in v0.6.0 

func (s *BaseFqlParserListener) ExitAdditiveOperator(ctx *AdditiveOperatorContext)

ExitAdditiveOperator is called when production additiveOperator is exited.

func (*BaseFqlParserListener) ExitArguments 

func (s *BaseFqlParserListener) ExitArguments(ctx *ArgumentsContext)

ExitArguments is called when production arguments is exited.

func (*BaseFqlParserListener) ExitArrayElementList 

func (s *BaseFqlParserListener) ExitArrayElementList(ctx *ArrayElementListContext)

ExitArrayElementList is called when production arrayElementList is exited.

func (*BaseFqlParserListener) ExitArrayLiteral 

func (s *BaseFqlParserListener) ExitArrayLiteral(ctx *ArrayLiteralContext)

ExitArrayLiteral is called when production arrayLiteral is exited.

func (*BaseFqlParserListener) ExitArrayOperator 

func (s *BaseFqlParserListener) ExitArrayOperator(ctx *ArrayOperatorContext)

ExitArrayOperator is called when production arrayOperator is exited.

func (*BaseFqlParserListener) ExitBody 

func (s *BaseFqlParserListener) ExitBody(ctx *BodyContext)

ExitBody is called when production body is exited.

func (*BaseFqlParserListener) ExitBodyExpression 

func (s *BaseFqlParserListener) ExitBodyExpression(ctx *BodyExpressionContext)

ExitBodyExpression is called when production bodyExpression is exited.

func (*BaseFqlParserListener) ExitBodyStatement 

func (s *BaseFqlParserListener) ExitBodyStatement(ctx *BodyStatementContext)

ExitBodyStatement is called when production bodyStatement is exited.

func (*BaseFqlParserListener) ExitBooleanLiteral 

func (s *BaseFqlParserListener) ExitBooleanLiteral(ctx *BooleanLiteralContext)

ExitBooleanLiteral is called when production booleanLiteral is exited.

func (*BaseFqlParserListener) ExitCollectAggregateSelector added in v0.4.0 

func (s *BaseFqlParserListener) ExitCollectAggregateSelector(ctx *CollectAggregateSelectorContext)

ExitCollectAggregateSelector is called when production collectAggregateSelector is exited.

func (*BaseFqlParserListener) ExitCollectAggregator added in v0.4.0 

func (s *BaseFqlParserListener) ExitCollectAggregator(ctx *CollectAggregatorContext)

ExitCollectAggregator is called when production collectAggregator is exited.

func (*BaseFqlParserListener) ExitCollectClause 

func (s *BaseFqlParserListener) ExitCollectClause(ctx *CollectClauseContext)

ExitCollectClause is called when production collectClause is exited.

func (*BaseFqlParserListener) ExitCollectCounter added in v0.4.0 

func (s *BaseFqlParserListener) ExitCollectCounter(ctx *CollectCounterContext)

ExitCollectCounter is called when production collectCounter is exited.

func (*BaseFqlParserListener) ExitCollectGroupVariable 

func (s *BaseFqlParserListener) ExitCollectGroupVariable(ctx *CollectGroupVariableContext)

ExitCollectGroupVariable is called when production collectGroupVariable is exited.

func (*BaseFqlParserListener) ExitCollectGrouping added in v0.4.0 

func (s *BaseFqlParserListener) ExitCollectGrouping(ctx *CollectGroupingContext)

ExitCollectGrouping is called when production collectGrouping is exited.

func (*BaseFqlParserListener) ExitCollectSelector added in v0.4.0 

func (s *BaseFqlParserListener) ExitCollectSelector(ctx *CollectSelectorContext)

ExitCollectSelector is called when production collectSelector is exited.

func (*BaseFqlParserListener) ExitComputedPropertyName 

func (s *BaseFqlParserListener) ExitComputedPropertyName(ctx *ComputedPropertyNameContext)

ExitComputedPropertyName is called when production computedPropertyName is exited.

func (*BaseFqlParserListener) ExitEqualityOperator 

func (s *BaseFqlParserListener) ExitEqualityOperator(ctx *EqualityOperatorContext)

ExitEqualityOperator is called when production equalityOperator is exited.

func (*BaseFqlParserListener) ExitEveryRule 

func (s *BaseFqlParserListener) ExitEveryRule(ctx antlr.ParserRuleContext)

ExitEveryRule is called when any rule is exited.

func (*BaseFqlParserListener) ExitExpression 

func (s *BaseFqlParserListener) ExitExpression(ctx *ExpressionContext)

ExitExpression is called when production expression is exited.

func (*BaseFqlParserListener) ExitExpressionGroup added in v0.6.0 

func (s *BaseFqlParserListener) ExitExpressionGroup(ctx *ExpressionGroupContext)

ExitExpressionGroup is called when production expressionGroup is exited.

func (*BaseFqlParserListener) ExitFilterClause 

func (s *BaseFqlParserListener) ExitFilterClause(ctx *FilterClauseContext)

ExitFilterClause is called when production filterClause is exited.

func (*BaseFqlParserListener) ExitFloatLiteral 

func (s *BaseFqlParserListener) ExitFloatLiteral(ctx *FloatLiteralContext)

ExitFloatLiteral is called when production floatLiteral is exited.

func (*BaseFqlParserListener) ExitForExpression 

func (s *BaseFqlParserListener) ExitForExpression(ctx *ForExpressionContext)

ExitForExpression is called when production forExpression is exited.

func (*BaseFqlParserListener) ExitForExpressionBody 

func (s *BaseFqlParserListener) ExitForExpressionBody(ctx *ForExpressionBodyContext)

ExitForExpressionBody is called when production forExpressionBody is exited.

func (*BaseFqlParserListener) ExitForExpressionClause 

func (s *BaseFqlParserListener) ExitForExpressionClause(ctx *ForExpressionClauseContext)

ExitForExpressionClause is called when production forExpressionClause is exited.

func (*BaseFqlParserListener) ExitForExpressionKeyVariable 

func (s *BaseFqlParserListener) ExitForExpressionKeyVariable(ctx *ForExpressionKeyVariableContext)

ExitForExpressionKeyVariable is called when production forExpressionKeyVariable is exited.

func (*BaseFqlParserListener) ExitForExpressionReturn 

func (s *BaseFqlParserListener) ExitForExpressionReturn(ctx *ForExpressionReturnContext)

ExitForExpressionReturn is called when production forExpressionReturn is exited.

func (*BaseFqlParserListener) ExitForExpressionSource 

func (s *BaseFqlParserListener) ExitForExpressionSource(ctx *ForExpressionSourceContext)

ExitForExpressionSource is called when production forExpressionSource is exited.

func (*BaseFqlParserListener) ExitForExpressionStatement added in v0.5.0 

func (s *BaseFqlParserListener) ExitForExpressionStatement(ctx *ForExpressionStatementContext)

ExitForExpressionStatement is called when production forExpressionStatement is exited.

func (*BaseFqlParserListener) ExitForExpressionValueVariable 

func (s *BaseFqlParserListener) ExitForExpressionValueVariable(ctx *ForExpressionValueVariableContext)

ExitForExpressionValueVariable is called when production forExpressionValueVariable is exited.

func (*BaseFqlParserListener) ExitForTernaryExpression 

func (s *BaseFqlParserListener) ExitForTernaryExpression(ctx *ForTernaryExpressionContext)

ExitForTernaryExpression is called when production forTernaryExpression is exited.

func (*BaseFqlParserListener) ExitFunctionCallExpression 

func (s *BaseFqlParserListener) ExitFunctionCallExpression(ctx *FunctionCallExpressionContext)

ExitFunctionCallExpression is called when production functionCallExpression is exited.

func (*BaseFqlParserListener) ExitFunctionIdentifier added in v0.11.0 

func (s *BaseFqlParserListener) ExitFunctionIdentifier(ctx *FunctionIdentifierContext)

ExitFunctionIdentifier is called when production functionIdentifier is exited.

func (*BaseFqlParserListener) ExitHead added in v0.11.0 

func (s *BaseFqlParserListener) ExitHead(ctx *HeadContext)

ExitHead is called when production head is exited.

func (*BaseFqlParserListener) ExitInOperator 

func (s *BaseFqlParserListener) ExitInOperator(ctx *InOperatorContext)

ExitInOperator is called when production inOperator is exited.

func (*BaseFqlParserListener) ExitIntegerLiteral 

func (s *BaseFqlParserListener) ExitIntegerLiteral(ctx *IntegerLiteralContext)

ExitIntegerLiteral is called when production integerLiteral is exited.

func (*BaseFqlParserListener) ExitLimitClause 

func (s *BaseFqlParserListener) ExitLimitClause(ctx *LimitClauseContext)

ExitLimitClause is called when production limitClause is exited.

func (*BaseFqlParserListener) ExitLimitClauseValue added in v0.5.0 

func (s *BaseFqlParserListener) ExitLimitClauseValue(ctx *LimitClauseValueContext)

ExitLimitClauseValue is called when production limitClauseValue is exited.

func (*BaseFqlParserListener) ExitLogicalAndOperator added in v0.6.0 

func (s *BaseFqlParserListener) ExitLogicalAndOperator(ctx *LogicalAndOperatorContext)

ExitLogicalAndOperator is called when production logicalAndOperator is exited.

func (*BaseFqlParserListener) ExitLogicalOrOperator added in v0.6.0 

func (s *BaseFqlParserListener) ExitLogicalOrOperator(ctx *LogicalOrOperatorContext)

ExitLogicalOrOperator is called when production logicalOrOperator is exited.

func (*BaseFqlParserListener) ExitMember added in v0.9.0 

func (s *BaseFqlParserListener) ExitMember(ctx *MemberContext)

ExitMember is called when production member is exited.

func (*BaseFqlParserListener) ExitMemberExpression 

func (s *BaseFqlParserListener) ExitMemberExpression(ctx *MemberExpressionContext)

ExitMemberExpression is called when production memberExpression is exited.

func (*BaseFqlParserListener) ExitMemberPath added in v0.9.0 

func (s *BaseFqlParserListener) ExitMemberPath(ctx *MemberPathContext)

ExitMemberPath is called when production memberPath is exited.

func (*BaseFqlParserListener) ExitMultiplicativeOperator added in v0.6.0 

func (s *BaseFqlParserListener) ExitMultiplicativeOperator(ctx *MultiplicativeOperatorContext)

ExitMultiplicativeOperator is called when production multiplicativeOperator is exited.

func (*BaseFqlParserListener) ExitNamespace added in v0.8.0 

func (s *BaseFqlParserListener) ExitNamespace(ctx *NamespaceContext)

ExitNamespace is called when production namespace is exited.

func (*BaseFqlParserListener) ExitNamespaceIdentifier added in v0.11.0 

func (s *BaseFqlParserListener) ExitNamespaceIdentifier(ctx *NamespaceIdentifierContext)

ExitNamespaceIdentifier is called when production namespaceIdentifier is exited.

func (*BaseFqlParserListener) ExitNoneLiteral 

func (s *BaseFqlParserListener) ExitNoneLiteral(ctx *NoneLiteralContext)

ExitNoneLiteral is called when production noneLiteral is exited.

func (*BaseFqlParserListener) ExitObjectLiteral 

func (s *BaseFqlParserListener) ExitObjectLiteral(ctx *ObjectLiteralContext)

ExitObjectLiteral is called when production objectLiteral is exited.

func (*BaseFqlParserListener) ExitParam 

func (s *BaseFqlParserListener) ExitParam(ctx *ParamContext)

ExitParam is called when production param is exited.

func (*BaseFqlParserListener) ExitProgram 

func (s *BaseFqlParserListener) ExitProgram(ctx *ProgramContext)

ExitProgram is called when production program is exited.

func (*BaseFqlParserListener) ExitPropertyAssignment 

func (s *BaseFqlParserListener) ExitPropertyAssignment(ctx *PropertyAssignmentContext)

ExitPropertyAssignment is called when production propertyAssignment is exited.

func (*BaseFqlParserListener) ExitPropertyName 

func (s *BaseFqlParserListener) ExitPropertyName(ctx *PropertyNameContext)

ExitPropertyName is called when production propertyName is exited.

func (*BaseFqlParserListener) ExitRangeOperator 

func (s *BaseFqlParserListener) ExitRangeOperator(ctx *RangeOperatorContext)

ExitRangeOperator is called when production rangeOperator is exited.

func (*BaseFqlParserListener) ExitRegexpOperator added in v0.8.0 

func (s *BaseFqlParserListener) ExitRegexpOperator(ctx *RegexpOperatorContext)

ExitRegexpOperator is called when production regexpOperator is exited.

func (*BaseFqlParserListener) ExitReturnExpression 

func (s *BaseFqlParserListener) ExitReturnExpression(ctx *ReturnExpressionContext)

ExitReturnExpression is called when production returnExpression is exited.

func (*BaseFqlParserListener) ExitShorthandPropertyName 

func (s *BaseFqlParserListener) ExitShorthandPropertyName(ctx *ShorthandPropertyNameContext)

ExitShorthandPropertyName is called when production shorthandPropertyName is exited.

func (*BaseFqlParserListener) ExitSortClause 

func (s *BaseFqlParserListener) ExitSortClause(ctx *SortClauseContext)

ExitSortClause is called when production sortClause is exited.

func (*BaseFqlParserListener) ExitSortClauseExpression 

func (s *BaseFqlParserListener) ExitSortClauseExpression(ctx *SortClauseExpressionContext)

ExitSortClauseExpression is called when production sortClauseExpression is exited.

func (*BaseFqlParserListener) ExitStringLiteral 

func (s *BaseFqlParserListener) ExitStringLiteral(ctx *StringLiteralContext)

ExitStringLiteral is called when production stringLiteral is exited.

func (*BaseFqlParserListener) ExitUnaryOperator 

func (s *BaseFqlParserListener) ExitUnaryOperator(ctx *UnaryOperatorContext)

ExitUnaryOperator is called when production unaryOperator is exited.

func (*BaseFqlParserListener) ExitUse added in v0.11.0 

func (s *BaseFqlParserListener) ExitUse(ctx *UseContext)

ExitUse is called when production use is exited.

func (*BaseFqlParserListener) ExitUseExpression added in v0.11.0 

func (s *BaseFqlParserListener) ExitUseExpression(ctx *UseExpressionContext)

ExitUseExpression is called when production useExpression is exited.

func (*BaseFqlParserListener) ExitVariable 

func (s *BaseFqlParserListener) ExitVariable(ctx *VariableContext)

ExitVariable is called when production variable is exited.

func (*BaseFqlParserListener) ExitVariableDeclaration 

func (s *BaseFqlParserListener) ExitVariableDeclaration(ctx *VariableDeclarationContext)

ExitVariableDeclaration is called when production variableDeclaration is exited.

func (*BaseFqlParserListener) VisitErrorNode 

func (s *BaseFqlParserListener) VisitErrorNode(node antlr.ErrorNode)

VisitErrorNode is called when an error node is visited.

func (*BaseFqlParserListener) VisitTerminal 

func (s *BaseFqlParserListener) VisitTerminal(node antlr.TerminalNode)

VisitTerminal is called when a terminal node is visited.

type BaseFqlParserVisitor 

type BaseFqlParserVisitor struct {
	*antlr.BaseParseTreeVisitor
}

func (*BaseFqlParserVisitor) VisitAdditiveOperator added in v0.6.0 

func (v *BaseFqlParserVisitor) VisitAdditiveOperator(ctx *AdditiveOperatorContext) interface{}

func (*BaseFqlParserVisitor) VisitArguments 

func (v *BaseFqlParserVisitor) VisitArguments(ctx *ArgumentsContext) interface{}

func (*BaseFqlParserVisitor) VisitArrayElementList 

func (v *BaseFqlParserVisitor) VisitArrayElementList(ctx *ArrayElementListContext) interface{}

func (*BaseFqlParserVisitor) VisitArrayLiteral 

func (v *BaseFqlParserVisitor) VisitArrayLiteral(ctx *ArrayLiteralContext) interface{}

func (*BaseFqlParserVisitor) VisitArrayOperator 

func (v *BaseFqlParserVisitor) VisitArrayOperator(ctx *ArrayOperatorContext) interface{}

func (*BaseFqlParserVisitor) VisitBody 

func (v *BaseFqlParserVisitor) VisitBody(ctx *BodyContext) interface{}

func (*BaseFqlParserVisitor) VisitBodyExpression 

func (v *BaseFqlParserVisitor) VisitBodyExpression(ctx *BodyExpressionContext) interface{}

func (*BaseFqlParserVisitor) VisitBodyStatement 

func (v *BaseFqlParserVisitor) VisitBodyStatement(ctx *BodyStatementContext) interface{}

func (*BaseFqlParserVisitor) VisitBooleanLiteral 

func (v *BaseFqlParserVisitor) VisitBooleanLiteral(ctx *BooleanLiteralContext) interface{}

func (*BaseFqlParserVisitor) VisitCollectAggregateSelector added in v0.4.0 

func (v *BaseFqlParserVisitor) VisitCollectAggregateSelector(ctx *CollectAggregateSelectorContext) interface{}

func (*BaseFqlParserVisitor) VisitCollectAggregator added in v0.4.0 

func (v *BaseFqlParserVisitor) VisitCollectAggregator(ctx *CollectAggregatorContext) interface{}

func (*BaseFqlParserVisitor) VisitCollectClause 

func (v *BaseFqlParserVisitor) VisitCollectClause(ctx *CollectClauseContext) interface{}

func (*BaseFqlParserVisitor) VisitCollectCounter added in v0.4.0 

func (v *BaseFqlParserVisitor) VisitCollectCounter(ctx *CollectCounterContext) interface{}

func (*BaseFqlParserVisitor) VisitCollectGroupVariable 

func (v *BaseFqlParserVisitor) VisitCollectGroupVariable(ctx *CollectGroupVariableContext) interface{}

func (*BaseFqlParserVisitor) VisitCollectGrouping added in v0.4.0 

func (v *BaseFqlParserVisitor) VisitCollectGrouping(ctx *CollectGroupingContext) interface{}

func (*BaseFqlParserVisitor) VisitCollectSelector added in v0.4.0 

func (v *BaseFqlParserVisitor) VisitCollectSelector(ctx *CollectSelectorContext) interface{}

func (*BaseFqlParserVisitor) VisitComputedPropertyName 

func (v *BaseFqlParserVisitor) VisitComputedPropertyName(ctx *ComputedPropertyNameContext) interface{}

func (*BaseFqlParserVisitor) VisitEqualityOperator 

func (v *BaseFqlParserVisitor) VisitEqualityOperator(ctx *EqualityOperatorContext) interface{}

func (*BaseFqlParserVisitor) VisitExpression 

func (v *BaseFqlParserVisitor) VisitExpression(ctx *ExpressionContext) interface{}

func (*BaseFqlParserVisitor) VisitExpressionGroup added in v0.6.0 

func (v *BaseFqlParserVisitor) VisitExpressionGroup(ctx *ExpressionGroupContext) interface{}

func (*BaseFqlParserVisitor) VisitFilterClause 

func (v *BaseFqlParserVisitor) VisitFilterClause(ctx *FilterClauseContext) interface{}

func (*BaseFqlParserVisitor) VisitFloatLiteral 

func (v *BaseFqlParserVisitor) VisitFloatLiteral(ctx *FloatLiteralContext) interface{}

func (*BaseFqlParserVisitor) VisitForExpression 

func (v *BaseFqlParserVisitor) VisitForExpression(ctx *ForExpressionContext) interface{}

func (*BaseFqlParserVisitor) VisitForExpressionBody 

func (v *BaseFqlParserVisitor) VisitForExpressionBody(ctx *ForExpressionBodyContext) interface{}

func (*BaseFqlParserVisitor) VisitForExpressionClause 

func (v *BaseFqlParserVisitor) VisitForExpressionClause(ctx *ForExpressionClauseContext) interface{}

func (*BaseFqlParserVisitor) VisitForExpressionKeyVariable 

func (v *BaseFqlParserVisitor) VisitForExpressionKeyVariable(ctx *ForExpressionKeyVariableContext) interface{}

func (*BaseFqlParserVisitor) VisitForExpressionReturn 

func (v *BaseFqlParserVisitor) VisitForExpressionReturn(ctx *ForExpressionReturnContext) interface{}

func (*BaseFqlParserVisitor) VisitForExpressionSource 

func (v *BaseFqlParserVisitor) VisitForExpressionSource(ctx *ForExpressionSourceContext) interface{}

func (*BaseFqlParserVisitor) VisitForExpressionStatement added in v0.5.0 

func (v *BaseFqlParserVisitor) VisitForExpressionStatement(ctx *ForExpressionStatementContext) interface{}

func (*BaseFqlParserVisitor) VisitForExpressionValueVariable 

func (v *BaseFqlParserVisitor) VisitForExpressionValueVariable(ctx *ForExpressionValueVariableContext) interface{}

func (*BaseFqlParserVisitor) VisitForTernaryExpression 

func (v *BaseFqlParserVisitor) VisitForTernaryExpression(ctx *ForTernaryExpressionContext) interface{}

func (*BaseFqlParserVisitor) VisitFunctionCallExpression 

func (v *BaseFqlParserVisitor) VisitFunctionCallExpression(ctx *FunctionCallExpressionContext) interface{}

func (*BaseFqlParserVisitor) VisitFunctionIdentifier added in v0.11.0 

func (v *BaseFqlParserVisitor) VisitFunctionIdentifier(ctx *FunctionIdentifierContext) interface{}

func (*BaseFqlParserVisitor) VisitHead added in v0.11.0 

func (v *BaseFqlParserVisitor) VisitHead(ctx *HeadContext) interface{}

func (*BaseFqlParserVisitor) VisitInOperator 

func (v *BaseFqlParserVisitor) VisitInOperator(ctx *InOperatorContext) interface{}

func (*BaseFqlParserVisitor) VisitIntegerLiteral 

func (v *BaseFqlParserVisitor) VisitIntegerLiteral(ctx *IntegerLiteralContext) interface{}

func (*BaseFqlParserVisitor) VisitLimitClause 

func (v *BaseFqlParserVisitor) VisitLimitClause(ctx *LimitClauseContext) interface{}

func (*BaseFqlParserVisitor) VisitLimitClauseValue added in v0.5.0 

func (v *BaseFqlParserVisitor) VisitLimitClauseValue(ctx *LimitClauseValueContext) interface{}

func (*BaseFqlParserVisitor) VisitLogicalAndOperator added in v0.6.0 

func (v *BaseFqlParserVisitor) VisitLogicalAndOperator(ctx *LogicalAndOperatorContext) interface{}

func (*BaseFqlParserVisitor) VisitLogicalOrOperator added in v0.6.0 

func (v *BaseFqlParserVisitor) VisitLogicalOrOperator(ctx *LogicalOrOperatorContext) interface{}

func (*BaseFqlParserVisitor) VisitMember added in v0.9.0 

func (v *BaseFqlParserVisitor) VisitMember(ctx *MemberContext) interface{}

func (*BaseFqlParserVisitor) VisitMemberExpression 

func (v *BaseFqlParserVisitor) VisitMemberExpression(ctx *MemberExpressionContext) interface{}

func (*BaseFqlParserVisitor) VisitMemberPath added in v0.9.0 

func (v *BaseFqlParserVisitor) VisitMemberPath(ctx *MemberPathContext) interface{}

func (*BaseFqlParserVisitor) VisitMultiplicativeOperator added in v0.6.0 

func (v *BaseFqlParserVisitor) VisitMultiplicativeOperator(ctx *MultiplicativeOperatorContext) interface{}

func (*BaseFqlParserVisitor) VisitNamespace added in v0.8.0 

func (v *BaseFqlParserVisitor) VisitNamespace(ctx *NamespaceContext) interface{}

func (*BaseFqlParserVisitor) VisitNamespaceIdentifier added in v0.11.0 

func (v *BaseFqlParserVisitor) VisitNamespaceIdentifier(ctx *NamespaceIdentifierContext) interface{}

func (*BaseFqlParserVisitor) VisitNoneLiteral 

func (v *BaseFqlParserVisitor) VisitNoneLiteral(ctx *NoneLiteralContext) interface{}

func (*BaseFqlParserVisitor) VisitObjectLiteral 

func (v *BaseFqlParserVisitor) VisitObjectLiteral(ctx *ObjectLiteralContext) interface{}

func (*BaseFqlParserVisitor) VisitParam 

func (v *BaseFqlParserVisitor) VisitParam(ctx *ParamContext) interface{}

func (*BaseFqlParserVisitor) VisitProgram 

func (v *BaseFqlParserVisitor) VisitProgram(ctx *ProgramContext) interface{}

func (*BaseFqlParserVisitor) VisitPropertyAssignment 

func (v *BaseFqlParserVisitor) VisitPropertyAssignment(ctx *PropertyAssignmentContext) interface{}

func (*BaseFqlParserVisitor) VisitPropertyName 

func (v *BaseFqlParserVisitor) VisitPropertyName(ctx *PropertyNameContext) interface{}

func (*BaseFqlParserVisitor) VisitRangeOperator 

func (v *BaseFqlParserVisitor) VisitRangeOperator(ctx *RangeOperatorContext) interface{}

func (*BaseFqlParserVisitor) VisitRegexpOperator added in v0.8.0 

func (v *BaseFqlParserVisitor) VisitRegexpOperator(ctx *RegexpOperatorContext) interface{}

func (*BaseFqlParserVisitor) VisitReturnExpression 

func (v *BaseFqlParserVisitor) VisitReturnExpression(ctx *ReturnExpressionContext) interface{}

func (*BaseFqlParserVisitor) VisitShorthandPropertyName 

func (v *BaseFqlParserVisitor) VisitShorthandPropertyName(ctx *ShorthandPropertyNameContext) interface{}

func (*BaseFqlParserVisitor) VisitSortClause 

func (v *BaseFqlParserVisitor) VisitSortClause(ctx *SortClauseContext) interface{}

func (*BaseFqlParserVisitor) VisitSortClauseExpression 

func (v *BaseFqlParserVisitor) VisitSortClauseExpression(ctx *SortClauseExpressionContext) interface{}

func (*BaseFqlParserVisitor) VisitStringLiteral 

func (v *BaseFqlParserVisitor) VisitStringLiteral(ctx *StringLiteralContext) interface{}

func (*BaseFqlParserVisitor) VisitUnaryOperator 

func (v *BaseFqlParserVisitor) VisitUnaryOperator(ctx *UnaryOperatorContext) interface{}

func (*BaseFqlParserVisitor) VisitUse added in v0.11.0 

func (v *BaseFqlParserVisitor) VisitUse(ctx *UseContext) interface{}

func (*BaseFqlParserVisitor) VisitUseExpression added in v0.11.0 

func (v *BaseFqlParserVisitor) VisitUseExpression(ctx *UseExpressionContext) interface{}

func (*BaseFqlParserVisitor) VisitVariable 

func (v *BaseFqlParserVisitor) VisitVariable(ctx *VariableContext) interface{}

func (*BaseFqlParserVisitor) VisitVariableDeclaration 

func (v *BaseFqlParserVisitor) VisitVariableDeclaration(ctx *VariableDeclarationContext) interface{}

type BodyContext 

type BodyContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewBodyContext 

func NewBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BodyContext

func NewEmptyBodyContext 

func NewEmptyBodyContext() *BodyContext

func (*BodyContext) Accept 

func (s *BodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*BodyContext) AllBodyStatement 

func (s *BodyContext) AllBodyStatement() []IBodyStatementContext

func (*BodyContext) BodyExpression 

func (s *BodyContext) BodyExpression() IBodyExpressionContext

func (*BodyContext) BodyStatement 

func (s *BodyContext) BodyStatement(i int) IBodyStatementContext

func (*BodyContext) EnterRule 

func (s *BodyContext) EnterRule(listener antlr.ParseTreeListener)

func (*BodyContext) ExitRule 

func (s *BodyContext) ExitRule(listener antlr.ParseTreeListener)

func (*BodyContext) GetParser 

func (s *BodyContext) GetParser() antlr.Parser

func (*BodyContext) GetRuleContext 

func (s *BodyContext) GetRuleContext() antlr.RuleContext

func (*BodyContext) IsBodyContext 

func (*BodyContext) IsBodyContext()

func (*BodyContext) ToStringTree 

func (s *BodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type BodyExpressionContext 

type BodyExpressionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewBodyExpressionContext 

func NewBodyExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BodyExpressionContext

func NewEmptyBodyExpressionContext 

func NewEmptyBodyExpressionContext() *BodyExpressionContext

func (*BodyExpressionContext) Accept 

func (s *BodyExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*BodyExpressionContext) EnterRule 

func (s *BodyExpressionContext) EnterRule(listener antlr.ParseTreeListener)

func (*BodyExpressionContext) ExitRule 

func (s *BodyExpressionContext) ExitRule(listener antlr.ParseTreeListener)

func (*BodyExpressionContext) ForExpression 

func (s *BodyExpressionContext) ForExpression() IForExpressionContext

func (*BodyExpressionContext) GetParser 

func (s *BodyExpressionContext) GetParser() antlr.Parser

func (*BodyExpressionContext) GetRuleContext 

func (s *BodyExpressionContext) GetRuleContext() antlr.RuleContext

func (*BodyExpressionContext) IsBodyExpressionContext 

func (*BodyExpressionContext) IsBodyExpressionContext()

func (*BodyExpressionContext) ReturnExpression 

func (s *BodyExpressionContext) ReturnExpression() IReturnExpressionContext

func (*BodyExpressionContext) ToStringTree 

func (s *BodyExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type BodyStatementContext 

type BodyStatementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewBodyStatementContext 

func NewBodyStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BodyStatementContext

func NewEmptyBodyStatementContext 

func NewEmptyBodyStatementContext() *BodyStatementContext

func (*BodyStatementContext) Accept 

func (s *BodyStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*BodyStatementContext) EnterRule 

func (s *BodyStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*BodyStatementContext) ExitRule 

func (s *BodyStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*BodyStatementContext) FunctionCallExpression 

func (s *BodyStatementContext) FunctionCallExpression() IFunctionCallExpressionContext

func (*BodyStatementContext) GetParser 

func (s *BodyStatementContext) GetParser() antlr.Parser

func (*BodyStatementContext) GetRuleContext 

func (s *BodyStatementContext) GetRuleContext() antlr.RuleContext

func (*BodyStatementContext) IsBodyStatementContext 

func (*BodyStatementContext) IsBodyStatementContext()

func (*BodyStatementContext) ToStringTree 

func (s *BodyStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*BodyStatementContext) VariableDeclaration 

func (s *BodyStatementContext) VariableDeclaration() IVariableDeclarationContext

type BooleanLiteralContext 

type BooleanLiteralContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewBooleanLiteralContext 

func NewBooleanLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BooleanLiteralContext

func NewEmptyBooleanLiteralContext 

func NewEmptyBooleanLiteralContext() *BooleanLiteralContext

func (*BooleanLiteralContext) Accept 

func (s *BooleanLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*BooleanLiteralContext) BooleanLiteral 

func (s *BooleanLiteralContext) BooleanLiteral() antlr.TerminalNode

func (*BooleanLiteralContext) EnterRule 

func (s *BooleanLiteralContext) EnterRule(listener antlr.ParseTreeListener)

func (*BooleanLiteralContext) ExitRule 

func (s *BooleanLiteralContext) ExitRule(listener antlr.ParseTreeListener)

func (*BooleanLiteralContext) GetParser 

func (s *BooleanLiteralContext) GetParser() antlr.Parser

func (*BooleanLiteralContext) GetRuleContext 

func (s *BooleanLiteralContext) GetRuleContext() antlr.RuleContext

func (*BooleanLiteralContext) IsBooleanLiteralContext 

func (*BooleanLiteralContext) IsBooleanLiteralContext()

func (*BooleanLiteralContext) ToStringTree 

func (s *BooleanLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type CollectAggregateSelectorContext added in v0.4.0 

type CollectAggregateSelectorContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCollectAggregateSelectorContext added in v0.4.0 

func NewCollectAggregateSelectorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectAggregateSelectorContext

func NewEmptyCollectAggregateSelectorContext added in v0.4.0 

func NewEmptyCollectAggregateSelectorContext() *CollectAggregateSelectorContext

func (*CollectAggregateSelectorContext) Accept added in v0.4.0 

func (s *CollectAggregateSelectorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CollectAggregateSelectorContext) Assign added in v0.4.0 

func (s *CollectAggregateSelectorContext) Assign() antlr.TerminalNode

func (*CollectAggregateSelectorContext) EnterRule added in v0.4.0 

func (s *CollectAggregateSelectorContext) EnterRule(listener antlr.ParseTreeListener)

func (*CollectAggregateSelectorContext) ExitRule added in v0.4.0 

func (s *CollectAggregateSelectorContext) ExitRule(listener antlr.ParseTreeListener)

func (*CollectAggregateSelectorContext) FunctionCallExpression added in v0.4.0 

func (s *CollectAggregateSelectorContext) FunctionCallExpression() IFunctionCallExpressionContext

func (*CollectAggregateSelectorContext) GetParser added in v0.4.0 

func (s *CollectAggregateSelectorContext) GetParser() antlr.Parser

func (*CollectAggregateSelectorContext) GetRuleContext added in v0.4.0 

func (s *CollectAggregateSelectorContext) GetRuleContext() antlr.RuleContext

func (*CollectAggregateSelectorContext) Identifier added in v0.4.0 

func (s *CollectAggregateSelectorContext) Identifier() antlr.TerminalNode

func (*CollectAggregateSelectorContext) IsCollectAggregateSelectorContext added in v0.4.0 

func (*CollectAggregateSelectorContext) IsCollectAggregateSelectorContext()

func (*CollectAggregateSelectorContext) ToStringTree added in v0.4.0 

func (s *CollectAggregateSelectorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type CollectAggregatorContext added in v0.4.0 

type CollectAggregatorContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCollectAggregatorContext added in v0.4.0 

func NewCollectAggregatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectAggregatorContext

func NewEmptyCollectAggregatorContext added in v0.4.0 

func NewEmptyCollectAggregatorContext() *CollectAggregatorContext

func (*CollectAggregatorContext) Accept added in v0.4.0 

func (s *CollectAggregatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CollectAggregatorContext) Aggregate added in v0.4.0 

func (s *CollectAggregatorContext) Aggregate() antlr.TerminalNode

func (*CollectAggregatorContext) AllCollectAggregateSelector added in v0.4.0 

func (s *CollectAggregatorContext) AllCollectAggregateSelector() []ICollectAggregateSelectorContext

func (*CollectAggregatorContext) AllComma added in v0.4.0 

func (s *CollectAggregatorContext) AllComma() []antlr.TerminalNode

func (*CollectAggregatorContext) CollectAggregateSelector added in v0.4.0 

func (s *CollectAggregatorContext) CollectAggregateSelector(i int) ICollectAggregateSelectorContext

func (*CollectAggregatorContext) Comma added in v0.4.0 

func (s *CollectAggregatorContext) Comma(i int) antlr.TerminalNode

func (*CollectAggregatorContext) EnterRule added in v0.4.0 

func (s *CollectAggregatorContext) EnterRule(listener antlr.ParseTreeListener)

func (*CollectAggregatorContext) ExitRule added in v0.4.0 

func (s *CollectAggregatorContext) ExitRule(listener antlr.ParseTreeListener)

func (*CollectAggregatorContext) GetParser added in v0.4.0 

func (s *CollectAggregatorContext) GetParser() antlr.Parser

func (*CollectAggregatorContext) GetRuleContext added in v0.4.0 

func (s *CollectAggregatorContext) GetRuleContext() antlr.RuleContext

func (*CollectAggregatorContext) IsCollectAggregatorContext added in v0.4.0 

func (*CollectAggregatorContext) IsCollectAggregatorContext()

func (*CollectAggregatorContext) ToStringTree added in v0.4.0 

func (s *CollectAggregatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type CollectClauseContext 

type CollectClauseContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCollectClauseContext 

func NewCollectClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectClauseContext

func NewEmptyCollectClauseContext 

func NewEmptyCollectClauseContext() *CollectClauseContext

func (*CollectClauseContext) Accept 

func (s *CollectClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CollectClauseContext) Collect 

func (s *CollectClauseContext) Collect() antlr.TerminalNode

func (*CollectClauseContext) CollectAggregator added in v0.4.0 

func (s *CollectClauseContext) CollectAggregator() ICollectAggregatorContext

func (*CollectClauseContext) CollectCounter added in v0.4.0 

func (s *CollectClauseContext) CollectCounter() ICollectCounterContext

func (*CollectClauseContext) CollectGroupVariable 

func (s *CollectClauseContext) CollectGroupVariable() ICollectGroupVariableContext

func (*CollectClauseContext) CollectGrouping added in v0.4.0 

func (s *CollectClauseContext) CollectGrouping() ICollectGroupingContext

func (*CollectClauseContext) EnterRule 

func (s *CollectClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*CollectClauseContext) ExitRule 

func (s *CollectClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*CollectClauseContext) GetParser 

func (s *CollectClauseContext) GetParser() antlr.Parser

func (*CollectClauseContext) GetRuleContext 

func (s *CollectClauseContext) GetRuleContext() antlr.RuleContext

func (*CollectClauseContext) IsCollectClauseContext 

func (*CollectClauseContext) IsCollectClauseContext()

func (*CollectClauseContext) ToStringTree 

func (s *CollectClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type CollectCounterContext added in v0.4.0 

type CollectCounterContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCollectCounterContext added in v0.4.0 

func NewCollectCounterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectCounterContext

func NewEmptyCollectCounterContext added in v0.4.0 

func NewEmptyCollectCounterContext() *CollectCounterContext

func (*CollectCounterContext) Accept added in v0.4.0 

func (s *CollectCounterContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CollectCounterContext) Count added in v0.4.0 

func (s *CollectCounterContext) Count() antlr.TerminalNode

func (*CollectCounterContext) EnterRule added in v0.4.0 

func (s *CollectCounterContext) EnterRule(listener antlr.ParseTreeListener)

func (*CollectCounterContext) ExitRule added in v0.4.0 

func (s *CollectCounterContext) ExitRule(listener antlr.ParseTreeListener)

func (*CollectCounterContext) GetParser added in v0.4.0 

func (s *CollectCounterContext) GetParser() antlr.Parser

func (*CollectCounterContext) GetRuleContext added in v0.4.0 

func (s *CollectCounterContext) GetRuleContext() antlr.RuleContext

func (*CollectCounterContext) Identifier added in v0.4.0 

func (s *CollectCounterContext) Identifier() antlr.TerminalNode

func (*CollectCounterContext) Into added in v0.4.0 

func (s *CollectCounterContext) Into() antlr.TerminalNode

func (*CollectCounterContext) IsCollectCounterContext added in v0.4.0 

func (*CollectCounterContext) IsCollectCounterContext()

func (*CollectCounterContext) ToStringTree added in v0.4.0 

func (s *CollectCounterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*CollectCounterContext) With added in v0.4.0 

func (s *CollectCounterContext) With() antlr.TerminalNode

type CollectGroupVariableContext 

type CollectGroupVariableContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCollectGroupVariableContext 

func NewCollectGroupVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectGroupVariableContext

func NewEmptyCollectGroupVariableContext 

func NewEmptyCollectGroupVariableContext() *CollectGroupVariableContext

func (*CollectGroupVariableContext) Accept 

func (s *CollectGroupVariableContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CollectGroupVariableContext) AllIdentifier added in v0.4.0 

func (s *CollectGroupVariableContext) AllIdentifier() []antlr.TerminalNode

func (*CollectGroupVariableContext) CollectSelector added in v0.4.0 

func (s *CollectGroupVariableContext) CollectSelector() ICollectSelectorContext

func (*CollectGroupVariableContext) EnterRule 

func (s *CollectGroupVariableContext) EnterRule(listener antlr.ParseTreeListener)

func (*CollectGroupVariableContext) ExitRule 

func (s *CollectGroupVariableContext) ExitRule(listener antlr.ParseTreeListener)

func (*CollectGroupVariableContext) GetParser 

func (s *CollectGroupVariableContext) GetParser() antlr.Parser

func (*CollectGroupVariableContext) GetRuleContext 

func (s *CollectGroupVariableContext) GetRuleContext() antlr.RuleContext

func (*CollectGroupVariableContext) Identifier 

func (s *CollectGroupVariableContext) Identifier(i int) antlr.TerminalNode

func (*CollectGroupVariableContext) Into added in v0.4.0 

func (s *CollectGroupVariableContext) Into() antlr.TerminalNode

func (*CollectGroupVariableContext) IsCollectGroupVariableContext 

func (*CollectGroupVariableContext) IsCollectGroupVariableContext()

func (*CollectGroupVariableContext) Keep added in v0.4.0 

func (s *CollectGroupVariableContext) Keep() antlr.TerminalNode

func (*CollectGroupVariableContext) ToStringTree 

func (s *CollectGroupVariableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type CollectGroupingContext added in v0.4.0 

type CollectGroupingContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCollectGroupingContext added in v0.4.0 

func NewCollectGroupingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectGroupingContext

func NewEmptyCollectGroupingContext added in v0.4.0 

func NewEmptyCollectGroupingContext() *CollectGroupingContext

func (*CollectGroupingContext) Accept added in v0.4.0 

func (s *CollectGroupingContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CollectGroupingContext) AllCollectSelector added in v0.4.0 

func (s *CollectGroupingContext) AllCollectSelector() []ICollectSelectorContext

func (*CollectGroupingContext) AllComma added in v0.4.0 

func (s *CollectGroupingContext) AllComma() []antlr.TerminalNode

func (*CollectGroupingContext) CollectSelector added in v0.4.0 

func (s *CollectGroupingContext) CollectSelector(i int) ICollectSelectorContext

func (*CollectGroupingContext) Comma added in v0.4.0 

func (s *CollectGroupingContext) Comma(i int) antlr.TerminalNode

func (*CollectGroupingContext) EnterRule added in v0.4.0 

func (s *CollectGroupingContext) EnterRule(listener antlr.ParseTreeListener)

func (*CollectGroupingContext) ExitRule added in v0.4.0 

func (s *CollectGroupingContext) ExitRule(listener antlr.ParseTreeListener)

func (*CollectGroupingContext) GetParser added in v0.4.0 

func (s *CollectGroupingContext) GetParser() antlr.Parser

func (*CollectGroupingContext) GetRuleContext added in v0.4.0 

func (s *CollectGroupingContext) GetRuleContext() antlr.RuleContext

func (*CollectGroupingContext) IsCollectGroupingContext added in v0.4.0 

func (*CollectGroupingContext) IsCollectGroupingContext()

func (*CollectGroupingContext) ToStringTree added in v0.4.0 

func (s *CollectGroupingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type CollectSelectorContext added in v0.4.0 

type CollectSelectorContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewCollectSelectorContext added in v0.4.0 

func NewCollectSelectorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *CollectSelectorContext

func NewEmptyCollectSelectorContext added in v0.4.0 

func NewEmptyCollectSelectorContext() *CollectSelectorContext

func (*CollectSelectorContext) Accept added in v0.4.0 

func (s *CollectSelectorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*CollectSelectorContext) Assign added in v0.4.0 

func (s *CollectSelectorContext) Assign() antlr.TerminalNode

func (*CollectSelectorContext) EnterRule added in v0.4.0 

func (s *CollectSelectorContext) EnterRule(listener antlr.ParseTreeListener)

func (*CollectSelectorContext) ExitRule added in v0.4.0 

func (s *CollectSelectorContext) ExitRule(listener antlr.ParseTreeListener)

func (*CollectSelectorContext) Expression added in v0.4.0 

func (s *CollectSelectorContext) Expression() IExpressionContext

func (*CollectSelectorContext) GetParser added in v0.4.0 

func (s *CollectSelectorContext) GetParser() antlr.Parser

func (*CollectSelectorContext) GetRuleContext added in v0.4.0 

func (s *CollectSelectorContext) GetRuleContext() antlr.RuleContext

func (*CollectSelectorContext) Identifier added in v0.4.0 

func (s *CollectSelectorContext) Identifier() antlr.TerminalNode

func (*CollectSelectorContext) IsCollectSelectorContext added in v0.4.0 

func (*CollectSelectorContext) IsCollectSelectorContext()

func (*CollectSelectorContext) ToStringTree added in v0.4.0 

func (s *CollectSelectorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ComputedPropertyNameContext 

type ComputedPropertyNameContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewComputedPropertyNameContext 

func NewComputedPropertyNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ComputedPropertyNameContext

func NewEmptyComputedPropertyNameContext 

func NewEmptyComputedPropertyNameContext() *ComputedPropertyNameContext

func (*ComputedPropertyNameContext) Accept 

func (s *ComputedPropertyNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ComputedPropertyNameContext) CloseBracket 

func (s *ComputedPropertyNameContext) CloseBracket() antlr.TerminalNode

func (*ComputedPropertyNameContext) EnterRule 

func (s *ComputedPropertyNameContext) EnterRule(listener antlr.ParseTreeListener)

func (*ComputedPropertyNameContext) ExitRule 

func (s *ComputedPropertyNameContext) ExitRule(listener antlr.ParseTreeListener)

func (*ComputedPropertyNameContext) Expression 

func (s *ComputedPropertyNameContext) Expression() IExpressionContext

func (*ComputedPropertyNameContext) GetParser 

func (s *ComputedPropertyNameContext) GetParser() antlr.Parser

func (*ComputedPropertyNameContext) GetRuleContext 

func (s *ComputedPropertyNameContext) GetRuleContext() antlr.RuleContext

func (*ComputedPropertyNameContext) IsComputedPropertyNameContext 

func (*ComputedPropertyNameContext) IsComputedPropertyNameContext()

func (*ComputedPropertyNameContext) OpenBracket 

func (s *ComputedPropertyNameContext) OpenBracket() antlr.TerminalNode

func (*ComputedPropertyNameContext) ToStringTree 

func (s *ComputedPropertyNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type EqualityOperatorContext 

type EqualityOperatorContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyEqualityOperatorContext 

func NewEmptyEqualityOperatorContext() *EqualityOperatorContext

func NewEqualityOperatorContext 

func NewEqualityOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *EqualityOperatorContext

func (*EqualityOperatorContext) Accept 

func (s *EqualityOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*EqualityOperatorContext) EnterRule 

func (s *EqualityOperatorContext) EnterRule(listener antlr.ParseTreeListener)

func (*EqualityOperatorContext) Eq 

func (s *EqualityOperatorContext) Eq() antlr.TerminalNode

func (*EqualityOperatorContext) ExitRule 

func (s *EqualityOperatorContext) ExitRule(listener antlr.ParseTreeListener)

func (*EqualityOperatorContext) GetParser 

func (s *EqualityOperatorContext) GetParser() antlr.Parser

func (*EqualityOperatorContext) GetRuleContext 

func (s *EqualityOperatorContext) GetRuleContext() antlr.RuleContext

func (*EqualityOperatorContext) Gt 

func (s *EqualityOperatorContext) Gt() antlr.TerminalNode

func (*EqualityOperatorContext) Gte 

func (s *EqualityOperatorContext) Gte() antlr.TerminalNode

func (*EqualityOperatorContext) IsEqualityOperatorContext 

func (*EqualityOperatorContext) IsEqualityOperatorContext()

func (*EqualityOperatorContext) Lt 

func (s *EqualityOperatorContext) Lt() antlr.TerminalNode

func (*EqualityOperatorContext) Lte 

func (s *EqualityOperatorContext) Lte() antlr.TerminalNode

func (*EqualityOperatorContext) Neq 

func (s *EqualityOperatorContext) Neq() antlr.TerminalNode

func (*EqualityOperatorContext) ToStringTree 

func (s *EqualityOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ExpressionContext 

type ExpressionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExpressionContext 

func NewEmptyExpressionContext() *ExpressionContext

func NewExpressionContext 

func NewExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionContext

func (*ExpressionContext) Accept 

func (s *ExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExpressionContext) AdditiveOperator added in v0.6.0 

func (s *ExpressionContext) AdditiveOperator() IAdditiveOperatorContext

func (*ExpressionContext) AllExpression 

func (s *ExpressionContext) AllExpression() []IExpressionContext

func (*ExpressionContext) ArrayLiteral 

func (s *ExpressionContext) ArrayLiteral() IArrayLiteralContext

func (*ExpressionContext) ArrayOperator 

func (s *ExpressionContext) ArrayOperator() IArrayOperatorContext

func (*ExpressionContext) BooleanLiteral 

func (s *ExpressionContext) BooleanLiteral() IBooleanLiteralContext

func (*ExpressionContext) Colon 

func (s *ExpressionContext) Colon() antlr.TerminalNode

func (*ExpressionContext) EnterRule 

func (s *ExpressionContext) EnterRule(listener antlr.ParseTreeListener)

func (*ExpressionContext) EqualityOperator 

func (s *ExpressionContext) EqualityOperator() IEqualityOperatorContext

func (*ExpressionContext) ExitRule 

func (s *ExpressionContext) ExitRule(listener antlr.ParseTreeListener)

func (*ExpressionContext) Expression 

func (s *ExpressionContext) Expression(i int) IExpressionContext

func (*ExpressionContext) ExpressionGroup added in v0.6.0 

func (s *ExpressionContext) ExpressionGroup() IExpressionGroupContext

func (*ExpressionContext) FloatLiteral 

func (s *ExpressionContext) FloatLiteral() IFloatLiteralContext

func (*ExpressionContext) FunctionCallExpression 

func (s *ExpressionContext) FunctionCallExpression() IFunctionCallExpressionContext

func (*ExpressionContext) GetParser 

func (s *ExpressionContext) GetParser() antlr.Parser

func (*ExpressionContext) GetRuleContext 

func (s *ExpressionContext) GetRuleContext() antlr.RuleContext

func (*ExpressionContext) InOperator 

func (s *ExpressionContext) InOperator() IInOperatorContext

func (*ExpressionContext) IntegerLiteral 

func (s *ExpressionContext) IntegerLiteral() IIntegerLiteralContext

func (*ExpressionContext) IsExpressionContext 

func (*ExpressionContext) IsExpressionContext()

func (*ExpressionContext) LogicalAndOperator added in v0.6.0 

func (s *ExpressionContext) LogicalAndOperator() ILogicalAndOperatorContext

func (*ExpressionContext) LogicalOrOperator added in v0.6.0 

func (s *ExpressionContext) LogicalOrOperator() ILogicalOrOperatorContext

func (*ExpressionContext) MemberExpression 

func (s *ExpressionContext) MemberExpression() IMemberExpressionContext

func (*ExpressionContext) MultiplicativeOperator added in v0.6.0 

func (s *ExpressionContext) MultiplicativeOperator() IMultiplicativeOperatorContext

func (*ExpressionContext) NoneLiteral 

func (s *ExpressionContext) NoneLiteral() INoneLiteralContext

func (*ExpressionContext) ObjectLiteral 

func (s *ExpressionContext) ObjectLiteral() IObjectLiteralContext

func (*ExpressionContext) Param 

func (s *ExpressionContext) Param() IParamContext

func (*ExpressionContext) QuestionMark 

func (s *ExpressionContext) QuestionMark() antlr.TerminalNode

func (*ExpressionContext) RangeOperator 

func (s *ExpressionContext) RangeOperator() IRangeOperatorContext

func (*ExpressionContext) RegexpOperator added in v0.8.0 

func (s *ExpressionContext) RegexpOperator() IRegexpOperatorContext

func (*ExpressionContext) StringLiteral 

func (s *ExpressionContext) StringLiteral() IStringLiteralContext

func (*ExpressionContext) ToStringTree 

func (s *ExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*ExpressionContext) UnaryOperator added in v0.3.0 

func (s *ExpressionContext) UnaryOperator() IUnaryOperatorContext

func (*ExpressionContext) Variable 

func (s *ExpressionContext) Variable() IVariableContext

type ExpressionGroupContext added in v0.6.0 

type ExpressionGroupContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyExpressionGroupContext added in v0.6.0 

func NewEmptyExpressionGroupContext() *ExpressionGroupContext

func NewExpressionGroupContext added in v0.6.0 

func NewExpressionGroupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionGroupContext

func (*ExpressionGroupContext) Accept added in v0.6.0 

func (s *ExpressionGroupContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ExpressionGroupContext) CloseParen added in v0.6.0 

func (s *ExpressionGroupContext) CloseParen() antlr.TerminalNode

func (*ExpressionGroupContext) EnterRule added in v0.6.0 

func (s *ExpressionGroupContext) EnterRule(listener antlr.ParseTreeListener)

func (*ExpressionGroupContext) ExitRule added in v0.6.0 

func (s *ExpressionGroupContext) ExitRule(listener antlr.ParseTreeListener)

func (*ExpressionGroupContext) Expression added in v0.6.0 

func (s *ExpressionGroupContext) Expression() IExpressionContext

func (*ExpressionGroupContext) GetParser added in v0.6.0 

func (s *ExpressionGroupContext) GetParser() antlr.Parser

func (*ExpressionGroupContext) GetRuleContext added in v0.6.0 

func (s *ExpressionGroupContext) GetRuleContext() antlr.RuleContext

func (*ExpressionGroupContext) IsExpressionGroupContext added in v0.6.0 

func (*ExpressionGroupContext) IsExpressionGroupContext()

func (*ExpressionGroupContext) OpenParen added in v0.6.0 

func (s *ExpressionGroupContext) OpenParen() antlr.TerminalNode

func (*ExpressionGroupContext) ToStringTree added in v0.6.0 

func (s *ExpressionGroupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type FilterClauseContext 

type FilterClauseContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFilterClauseContext 

func NewEmptyFilterClauseContext() *FilterClauseContext

func NewFilterClauseContext 

func NewFilterClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FilterClauseContext

func (*FilterClauseContext) Accept 

func (s *FilterClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FilterClauseContext) EnterRule 

func (s *FilterClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*FilterClauseContext) ExitRule 

func (s *FilterClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*FilterClauseContext) Expression 

func (s *FilterClauseContext) Expression() IExpressionContext

func (*FilterClauseContext) Filter 

func (s *FilterClauseContext) Filter() antlr.TerminalNode

func (*FilterClauseContext) GetParser 

func (s *FilterClauseContext) GetParser() antlr.Parser

func (*FilterClauseContext) GetRuleContext 

func (s *FilterClauseContext) GetRuleContext() antlr.RuleContext

func (*FilterClauseContext) IsFilterClauseContext 

func (*FilterClauseContext) IsFilterClauseContext()

func (*FilterClauseContext) ToStringTree 

func (s *FilterClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type FloatLiteralContext 

type FloatLiteralContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFloatLiteralContext 

func NewEmptyFloatLiteralContext() *FloatLiteralContext

func NewFloatLiteralContext 

func NewFloatLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FloatLiteralContext

func (*FloatLiteralContext) Accept 

func (s *FloatLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FloatLiteralContext) EnterRule 

func (s *FloatLiteralContext) EnterRule(listener antlr.ParseTreeListener)

func (*FloatLiteralContext) ExitRule 

func (s *FloatLiteralContext) ExitRule(listener antlr.ParseTreeListener)

func (*FloatLiteralContext) FloatLiteral 

func (s *FloatLiteralContext) FloatLiteral() antlr.TerminalNode

func (*FloatLiteralContext) GetParser 

func (s *FloatLiteralContext) GetParser() antlr.Parser

func (*FloatLiteralContext) GetRuleContext 

func (s *FloatLiteralContext) GetRuleContext() antlr.RuleContext

func (*FloatLiteralContext) IsFloatLiteralContext 

func (*FloatLiteralContext) IsFloatLiteralContext()

func (*FloatLiteralContext) ToStringTree 

func (s *FloatLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ForExpressionBodyContext 

type ForExpressionBodyContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyForExpressionBodyContext 

func NewEmptyForExpressionBodyContext() *ForExpressionBodyContext

func NewForExpressionBodyContext 

func NewForExpressionBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionBodyContext

func (*ForExpressionBodyContext) Accept 

func (s *ForExpressionBodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ForExpressionBodyContext) EnterRule 

func (s *ForExpressionBodyContext) EnterRule(listener antlr.ParseTreeListener)

func (*ForExpressionBodyContext) ExitRule 

func (s *ForExpressionBodyContext) ExitRule(listener antlr.ParseTreeListener)

func (*ForExpressionBodyContext) ForExpressionClause added in v0.5.0 

func (s *ForExpressionBodyContext) ForExpressionClause() IForExpressionClauseContext

func (*ForExpressionBodyContext) ForExpressionStatement added in v0.5.0 

func (s *ForExpressionBodyContext) ForExpressionStatement() IForExpressionStatementContext

func (*ForExpressionBodyContext) GetParser 

func (s *ForExpressionBodyContext) GetParser() antlr.Parser

func (*ForExpressionBodyContext) GetRuleContext 

func (s *ForExpressionBodyContext) GetRuleContext() antlr.RuleContext

func (*ForExpressionBodyContext) IsForExpressionBodyContext 

func (*ForExpressionBodyContext) IsForExpressionBodyContext()

func (*ForExpressionBodyContext) ToStringTree 

func (s *ForExpressionBodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ForExpressionClauseContext 

type ForExpressionClauseContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyForExpressionClauseContext 

func NewEmptyForExpressionClauseContext() *ForExpressionClauseContext

func NewForExpressionClauseContext 

func NewForExpressionClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionClauseContext

func (*ForExpressionClauseContext) Accept 

func (s *ForExpressionClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ForExpressionClauseContext) CollectClause 

func (s *ForExpressionClauseContext) CollectClause() ICollectClauseContext

func (*ForExpressionClauseContext) EnterRule 

func (s *ForExpressionClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*ForExpressionClauseContext) ExitRule 

func (s *ForExpressionClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*ForExpressionClauseContext) FilterClause 

func (s *ForExpressionClauseContext) FilterClause() IFilterClauseContext

func (*ForExpressionClauseContext) GetParser 

func (s *ForExpressionClauseContext) GetParser() antlr.Parser

func (*ForExpressionClauseContext) GetRuleContext 

func (s *ForExpressionClauseContext) GetRuleContext() antlr.RuleContext

func (*ForExpressionClauseContext) IsForExpressionClauseContext 

func (*ForExpressionClauseContext) IsForExpressionClauseContext()

func (*ForExpressionClauseContext) LimitClause 

func (s *ForExpressionClauseContext) LimitClause() ILimitClauseContext

func (*ForExpressionClauseContext) SortClause 

func (s *ForExpressionClauseContext) SortClause() ISortClauseContext

func (*ForExpressionClauseContext) ToStringTree 

func (s *ForExpressionClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ForExpressionContext 

type ForExpressionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyForExpressionContext 

func NewEmptyForExpressionContext() *ForExpressionContext

func NewForExpressionContext 

func NewForExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionContext

func (*ForExpressionContext) Accept 

func (s *ForExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ForExpressionContext) AllForExpressionBody 

func (s *ForExpressionContext) AllForExpressionBody() []IForExpressionBodyContext

func (*ForExpressionContext) Comma 

func (s *ForExpressionContext) Comma() antlr.TerminalNode

func (*ForExpressionContext) EnterRule 

func (s *ForExpressionContext) EnterRule(listener antlr.ParseTreeListener)

func (*ForExpressionContext) ExitRule 

func (s *ForExpressionContext) ExitRule(listener antlr.ParseTreeListener)

func (*ForExpressionContext) For 

func (s *ForExpressionContext) For() antlr.TerminalNode

func (*ForExpressionContext) ForExpressionBody 

func (s *ForExpressionContext) ForExpressionBody(i int) IForExpressionBodyContext

func (*ForExpressionContext) ForExpressionKeyVariable 

func (s *ForExpressionContext) ForExpressionKeyVariable() IForExpressionKeyVariableContext

func (*ForExpressionContext) ForExpressionReturn 

func (s *ForExpressionContext) ForExpressionReturn() IForExpressionReturnContext

func (*ForExpressionContext) ForExpressionSource 

func (s *ForExpressionContext) ForExpressionSource() IForExpressionSourceContext

func (*ForExpressionContext) ForExpressionValueVariable 

func (s *ForExpressionContext) ForExpressionValueVariable() IForExpressionValueVariableContext

func (*ForExpressionContext) GetParser 

func (s *ForExpressionContext) GetParser() antlr.Parser

func (*ForExpressionContext) GetRuleContext 

func (s *ForExpressionContext) GetRuleContext() antlr.RuleContext

func (*ForExpressionContext) In 

func (s *ForExpressionContext) In() antlr.TerminalNode

func (*ForExpressionContext) IsForExpressionContext 

func (*ForExpressionContext) IsForExpressionContext()

func (*ForExpressionContext) ToStringTree 

func (s *ForExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ForExpressionKeyVariableContext 

type ForExpressionKeyVariableContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyForExpressionKeyVariableContext 

func NewEmptyForExpressionKeyVariableContext() *ForExpressionKeyVariableContext

func NewForExpressionKeyVariableContext 

func NewForExpressionKeyVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionKeyVariableContext

func (*ForExpressionKeyVariableContext) Accept 

func (s *ForExpressionKeyVariableContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ForExpressionKeyVariableContext) EnterRule 

func (s *ForExpressionKeyVariableContext) EnterRule(listener antlr.ParseTreeListener)

func (*ForExpressionKeyVariableContext) ExitRule 

func (s *ForExpressionKeyVariableContext) ExitRule(listener antlr.ParseTreeListener)

func (*ForExpressionKeyVariableContext) GetParser 

func (s *ForExpressionKeyVariableContext) GetParser() antlr.Parser

func (*ForExpressionKeyVariableContext) GetRuleContext 

func (s *ForExpressionKeyVariableContext) GetRuleContext() antlr.RuleContext

func (*ForExpressionKeyVariableContext) Identifier 

func (s *ForExpressionKeyVariableContext) Identifier() antlr.TerminalNode

func (*ForExpressionKeyVariableContext) IsForExpressionKeyVariableContext 

func (*ForExpressionKeyVariableContext) IsForExpressionKeyVariableContext()

func (*ForExpressionKeyVariableContext) ToStringTree 

func (s *ForExpressionKeyVariableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ForExpressionReturnContext 

type ForExpressionReturnContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyForExpressionReturnContext 

func NewEmptyForExpressionReturnContext() *ForExpressionReturnContext

func NewForExpressionReturnContext 

func NewForExpressionReturnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionReturnContext

func (*ForExpressionReturnContext) Accept 

func (s *ForExpressionReturnContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ForExpressionReturnContext) EnterRule 

func (s *ForExpressionReturnContext) EnterRule(listener antlr.ParseTreeListener)

func (*ForExpressionReturnContext) ExitRule 

func (s *ForExpressionReturnContext) ExitRule(listener antlr.ParseTreeListener)

func (*ForExpressionReturnContext) ForExpression 

func (s *ForExpressionReturnContext) ForExpression() IForExpressionContext

func (*ForExpressionReturnContext) GetParser 

func (s *ForExpressionReturnContext) GetParser() antlr.Parser

func (*ForExpressionReturnContext) GetRuleContext 

func (s *ForExpressionReturnContext) GetRuleContext() antlr.RuleContext

func (*ForExpressionReturnContext) IsForExpressionReturnContext 

func (*ForExpressionReturnContext) IsForExpressionReturnContext()

func (*ForExpressionReturnContext) ReturnExpression 

func (s *ForExpressionReturnContext) ReturnExpression() IReturnExpressionContext

func (*ForExpressionReturnContext) ToStringTree 

func (s *ForExpressionReturnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ForExpressionSourceContext 

type ForExpressionSourceContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyForExpressionSourceContext 

func NewEmptyForExpressionSourceContext() *ForExpressionSourceContext

func NewForExpressionSourceContext 

func NewForExpressionSourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionSourceContext

func (*ForExpressionSourceContext) Accept 

func (s *ForExpressionSourceContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ForExpressionSourceContext) ArrayLiteral 

func (s *ForExpressionSourceContext) ArrayLiteral() IArrayLiteralContext

func (*ForExpressionSourceContext) EnterRule 

func (s *ForExpressionSourceContext) EnterRule(listener antlr.ParseTreeListener)

func (*ForExpressionSourceContext) ExitRule 

func (s *ForExpressionSourceContext) ExitRule(listener antlr.ParseTreeListener)

func (*ForExpressionSourceContext) FunctionCallExpression 

func (s *ForExpressionSourceContext) FunctionCallExpression() IFunctionCallExpressionContext

func (*ForExpressionSourceContext) GetParser 

func (s *ForExpressionSourceContext) GetParser() antlr.Parser

func (*ForExpressionSourceContext) GetRuleContext 

func (s *ForExpressionSourceContext) GetRuleContext() antlr.RuleContext

func (*ForExpressionSourceContext) IsForExpressionSourceContext 

func (*ForExpressionSourceContext) IsForExpressionSourceContext()

func (*ForExpressionSourceContext) MemberExpression 

func (s *ForExpressionSourceContext) MemberExpression() IMemberExpressionContext

func (*ForExpressionSourceContext) ObjectLiteral 

func (s *ForExpressionSourceContext) ObjectLiteral() IObjectLiteralContext

func (*ForExpressionSourceContext) Param 

func (s *ForExpressionSourceContext) Param() IParamContext

func (*ForExpressionSourceContext) RangeOperator 

func (s *ForExpressionSourceContext) RangeOperator() IRangeOperatorContext

func (*ForExpressionSourceContext) ToStringTree 

func (s *ForExpressionSourceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*ForExpressionSourceContext) Variable 

func (s *ForExpressionSourceContext) Variable() IVariableContext

type ForExpressionStatementContext added in v0.5.0 

type ForExpressionStatementContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyForExpressionStatementContext added in v0.5.0 

func NewEmptyForExpressionStatementContext() *ForExpressionStatementContext

func NewForExpressionStatementContext added in v0.5.0 

func NewForExpressionStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionStatementContext

func (*ForExpressionStatementContext) Accept added in v0.5.0 

func (s *ForExpressionStatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ForExpressionStatementContext) EnterRule added in v0.5.0 

func (s *ForExpressionStatementContext) EnterRule(listener antlr.ParseTreeListener)

func (*ForExpressionStatementContext) ExitRule added in v0.5.0 

func (s *ForExpressionStatementContext) ExitRule(listener antlr.ParseTreeListener)

func (*ForExpressionStatementContext) FunctionCallExpression added in v0.5.0 

func (s *ForExpressionStatementContext) FunctionCallExpression() IFunctionCallExpressionContext

func (*ForExpressionStatementContext) GetParser added in v0.5.0 

func (s *ForExpressionStatementContext) GetParser() antlr.Parser

func (*ForExpressionStatementContext) GetRuleContext added in v0.5.0 

func (s *ForExpressionStatementContext) GetRuleContext() antlr.RuleContext

func (*ForExpressionStatementContext) IsForExpressionStatementContext added in v0.5.0 

func (*ForExpressionStatementContext) IsForExpressionStatementContext()

func (*ForExpressionStatementContext) ToStringTree added in v0.5.0 

func (s *ForExpressionStatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*ForExpressionStatementContext) VariableDeclaration added in v0.5.0 

func (s *ForExpressionStatementContext) VariableDeclaration() IVariableDeclarationContext

type ForExpressionValueVariableContext 

type ForExpressionValueVariableContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyForExpressionValueVariableContext 

func NewEmptyForExpressionValueVariableContext() *ForExpressionValueVariableContext

func NewForExpressionValueVariableContext 

func NewForExpressionValueVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForExpressionValueVariableContext

func (*ForExpressionValueVariableContext) Accept 

func (s *ForExpressionValueVariableContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ForExpressionValueVariableContext) EnterRule 

func (s *ForExpressionValueVariableContext) EnterRule(listener antlr.ParseTreeListener)

func (*ForExpressionValueVariableContext) ExitRule 

func (s *ForExpressionValueVariableContext) ExitRule(listener antlr.ParseTreeListener)

func (*ForExpressionValueVariableContext) GetParser 

func (s *ForExpressionValueVariableContext) GetParser() antlr.Parser

func (*ForExpressionValueVariableContext) GetRuleContext 

func (s *ForExpressionValueVariableContext) GetRuleContext() antlr.RuleContext

func (*ForExpressionValueVariableContext) Identifier 

func (s *ForExpressionValueVariableContext) Identifier() antlr.TerminalNode

func (*ForExpressionValueVariableContext) IsForExpressionValueVariableContext 

func (*ForExpressionValueVariableContext) IsForExpressionValueVariableContext()

func (*ForExpressionValueVariableContext) ToStringTree 

func (s *ForExpressionValueVariableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ForTernaryExpressionContext 

type ForTernaryExpressionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyForTernaryExpressionContext 

func NewEmptyForTernaryExpressionContext() *ForTernaryExpressionContext

func NewForTernaryExpressionContext 

func NewForTernaryExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ForTernaryExpressionContext

func (*ForTernaryExpressionContext) Accept 

func (s *ForTernaryExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ForTernaryExpressionContext) AllCloseParen 

func (s *ForTernaryExpressionContext) AllCloseParen() []antlr.TerminalNode

func (*ForTernaryExpressionContext) AllExpression 

func (s *ForTernaryExpressionContext) AllExpression() []IExpressionContext

func (*ForTernaryExpressionContext) AllForExpression 

func (s *ForTernaryExpressionContext) AllForExpression() []IForExpressionContext

func (*ForTernaryExpressionContext) AllOpenParen 

func (s *ForTernaryExpressionContext) AllOpenParen() []antlr.TerminalNode

func (*ForTernaryExpressionContext) CloseParen 

func (s *ForTernaryExpressionContext) CloseParen(i int) antlr.TerminalNode

func (*ForTernaryExpressionContext) Colon 

func (s *ForTernaryExpressionContext) Colon() antlr.TerminalNode

func (*ForTernaryExpressionContext) EnterRule 

func (s *ForTernaryExpressionContext) EnterRule(listener antlr.ParseTreeListener)

func (*ForTernaryExpressionContext) ExitRule 

func (s *ForTernaryExpressionContext) ExitRule(listener antlr.ParseTreeListener)

func (*ForTernaryExpressionContext) Expression 

func (s *ForTernaryExpressionContext) Expression(i int) IExpressionContext

func (*ForTernaryExpressionContext) ForExpression 

func (s *ForTernaryExpressionContext) ForExpression(i int) IForExpressionContext

func (*ForTernaryExpressionContext) GetParser 

func (s *ForTernaryExpressionContext) GetParser() antlr.Parser

func (*ForTernaryExpressionContext) GetRuleContext 

func (s *ForTernaryExpressionContext) GetRuleContext() antlr.RuleContext

func (*ForTernaryExpressionContext) IsForTernaryExpressionContext 

func (*ForTernaryExpressionContext) IsForTernaryExpressionContext()

func (*ForTernaryExpressionContext) OpenParen 

func (s *ForTernaryExpressionContext) OpenParen(i int) antlr.TerminalNode

func (*ForTernaryExpressionContext) QuestionMark 

func (s *ForTernaryExpressionContext) QuestionMark() antlr.TerminalNode

func (*ForTernaryExpressionContext) ToStringTree 

func (s *ForTernaryExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type FqlLexer 

type FqlLexer struct {
	*antlr.BaseLexer
	// contains filtered or unexported fields
}

func NewFqlLexer 

func NewFqlLexer(input antlr.CharStream) *FqlLexer

type FqlParser 

type FqlParser struct {
	*antlr.BaseParser
}

func NewFqlParser 

func NewFqlParser(input antlr.TokenStream) *FqlParser

func (*FqlParser) AdditiveOperator added in v0.6.0 

func (p *FqlParser) AdditiveOperator() (localctx IAdditiveOperatorContext)

func (*FqlParser) Arguments 

func (p *FqlParser) Arguments() (localctx IArgumentsContext)

func (*FqlParser) ArrayElementList 

func (p *FqlParser) ArrayElementList() (localctx IArrayElementListContext)

func (*FqlParser) ArrayLiteral 

func (p *FqlParser) ArrayLiteral() (localctx IArrayLiteralContext)

func (*FqlParser) ArrayOperator 

func (p *FqlParser) ArrayOperator() (localctx IArrayOperatorContext)

func (*FqlParser) Body 

func (p *FqlParser) Body() (localctx IBodyContext)

func (*FqlParser) BodyExpression 

func (p *FqlParser) BodyExpression() (localctx IBodyExpressionContext)

func (*FqlParser) BodyStatement 

func (p *FqlParser) BodyStatement() (localctx IBodyStatementContext)

func (*FqlParser) BooleanLiteral 

func (p *FqlParser) BooleanLiteral() (localctx IBooleanLiteralContext)

func (*FqlParser) CollectAggregateSelector added in v0.4.0 

func (p *FqlParser) CollectAggregateSelector() (localctx ICollectAggregateSelectorContext)

func (*FqlParser) CollectAggregator added in v0.4.0 

func (p *FqlParser) CollectAggregator() (localctx ICollectAggregatorContext)

func (*FqlParser) CollectClause 

func (p *FqlParser) CollectClause() (localctx ICollectClauseContext)

func (*FqlParser) CollectCounter added in v0.4.0 

func (p *FqlParser) CollectCounter() (localctx ICollectCounterContext)

func (*FqlParser) CollectGroupVariable 

func (p *FqlParser) CollectGroupVariable() (localctx ICollectGroupVariableContext)

func (*FqlParser) CollectGrouping added in v0.4.0 

func (p *FqlParser) CollectGrouping() (localctx ICollectGroupingContext)

func (*FqlParser) CollectSelector added in v0.4.0 

func (p *FqlParser) CollectSelector() (localctx ICollectSelectorContext)

func (*FqlParser) ComputedPropertyName 

func (p *FqlParser) ComputedPropertyName() (localctx IComputedPropertyNameContext)

func (*FqlParser) EqualityOperator 

func (p *FqlParser) EqualityOperator() (localctx IEqualityOperatorContext)

func (*FqlParser) Expression 

func (p *FqlParser) Expression() (localctx IExpressionContext)

func (*FqlParser) ExpressionGroup added in v0.6.0 

func (p *FqlParser) ExpressionGroup() (localctx IExpressionGroupContext)

func (*FqlParser) Expression_Sempred 

func (p *FqlParser) Expression_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*FqlParser) FilterClause 

func (p *FqlParser) FilterClause() (localctx IFilterClauseContext)

func (*FqlParser) FloatLiteral 

func (p *FqlParser) FloatLiteral() (localctx IFloatLiteralContext)

func (*FqlParser) ForExpression 

func (p *FqlParser) ForExpression() (localctx IForExpressionContext)

func (*FqlParser) ForExpressionBody 

func (p *FqlParser) ForExpressionBody() (localctx IForExpressionBodyContext)

func (*FqlParser) ForExpressionClause 

func (p *FqlParser) ForExpressionClause() (localctx IForExpressionClauseContext)

func (*FqlParser) ForExpressionKeyVariable 

func (p *FqlParser) ForExpressionKeyVariable() (localctx IForExpressionKeyVariableContext)

func (*FqlParser) ForExpressionReturn 

func (p *FqlParser) ForExpressionReturn() (localctx IForExpressionReturnContext)

func (*FqlParser) ForExpressionSource 

func (p *FqlParser) ForExpressionSource() (localctx IForExpressionSourceContext)

func (*FqlParser) ForExpressionStatement added in v0.5.0 

func (p *FqlParser) ForExpressionStatement() (localctx IForExpressionStatementContext)

func (*FqlParser) ForExpressionValueVariable 

func (p *FqlParser) ForExpressionValueVariable() (localctx IForExpressionValueVariableContext)

func (*FqlParser) ForTernaryExpression 

func (p *FqlParser) ForTernaryExpression() (localctx IForTernaryExpressionContext)

func (*FqlParser) FunctionCallExpression 

func (p *FqlParser) FunctionCallExpression() (localctx IFunctionCallExpressionContext)

func (*FqlParser) FunctionIdentifier added in v0.11.0 

func (p *FqlParser) FunctionIdentifier() (localctx IFunctionIdentifierContext)

func (*FqlParser) Head added in v0.11.0 

func (p *FqlParser) Head() (localctx IHeadContext)

func (*FqlParser) InOperator 

func (p *FqlParser) InOperator() (localctx IInOperatorContext)

func (*FqlParser) IntegerLiteral 

func (p *FqlParser) IntegerLiteral() (localctx IIntegerLiteralContext)

func (*FqlParser) LimitClause 

func (p *FqlParser) LimitClause() (localctx ILimitClauseContext)

func (*FqlParser) LimitClauseValue added in v0.5.0 

func (p *FqlParser) LimitClauseValue() (localctx ILimitClauseValueContext)

func (*FqlParser) LogicalAndOperator added in v0.6.0 

func (p *FqlParser) LogicalAndOperator() (localctx ILogicalAndOperatorContext)

func (*FqlParser) LogicalOrOperator added in v0.6.0 

func (p *FqlParser) LogicalOrOperator() (localctx ILogicalOrOperatorContext)

func (*FqlParser) Member added in v0.9.0 

func (p *FqlParser) Member() (localctx IMemberContext)

func (*FqlParser) MemberExpression 

func (p *FqlParser) MemberExpression() (localctx IMemberExpressionContext)

func (*FqlParser) MemberPath added in v0.9.0 

func (p *FqlParser) MemberPath() (localctx IMemberPathContext)

func (*FqlParser) MultiplicativeOperator added in v0.6.0 

func (p *FqlParser) MultiplicativeOperator() (localctx IMultiplicativeOperatorContext)

func (*FqlParser) Namespace added in v0.8.0 

func (p *FqlParser) Namespace() (localctx INamespaceContext)

func (*FqlParser) NamespaceIdentifier added in v0.11.0 

func (p *FqlParser) NamespaceIdentifier() (localctx INamespaceIdentifierContext)

func (*FqlParser) NoneLiteral 

func (p *FqlParser) NoneLiteral() (localctx INoneLiteralContext)

func (*FqlParser) ObjectLiteral 

func (p *FqlParser) ObjectLiteral() (localctx IObjectLiteralContext)

func (*FqlParser) Param 

func (p *FqlParser) Param() (localctx IParamContext)

func (*FqlParser) Program 

func (p *FqlParser) Program() (localctx IProgramContext)

func (*FqlParser) PropertyAssignment 

func (p *FqlParser) PropertyAssignment() (localctx IPropertyAssignmentContext)

func (*FqlParser) PropertyName 

func (p *FqlParser) PropertyName() (localctx IPropertyNameContext)

func (*FqlParser) RangeOperator 

func (p *FqlParser) RangeOperator() (localctx IRangeOperatorContext)

func (*FqlParser) RegexpOperator added in v0.8.0 

func (p *FqlParser) RegexpOperator() (localctx IRegexpOperatorContext)

func (*FqlParser) ReturnExpression 

func (p *FqlParser) ReturnExpression() (localctx IReturnExpressionContext)

func (*FqlParser) Sempred 

func (p *FqlParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool

func (*FqlParser) ShorthandPropertyName 

func (p *FqlParser) ShorthandPropertyName() (localctx IShorthandPropertyNameContext)

func (*FqlParser) SortClause 

func (p *FqlParser) SortClause() (localctx ISortClauseContext)

func (*FqlParser) SortClauseExpression 

func (p *FqlParser) SortClauseExpression() (localctx ISortClauseExpressionContext)

func (*FqlParser) StringLiteral 

func (p *FqlParser) StringLiteral() (localctx IStringLiteralContext)

func (*FqlParser) UnaryOperator 

func (p *FqlParser) UnaryOperator() (localctx IUnaryOperatorContext)

func (*FqlParser) Use added in v0.11.0 

func (p *FqlParser) Use() (localctx IUseContext)

func (*FqlParser) UseExpression added in v0.11.0 

func (p *FqlParser) UseExpression() (localctx IUseExpressionContext)

func (*FqlParser) Variable 

func (p *FqlParser) Variable() (localctx IVariableContext)

func (*FqlParser) VariableDeclaration 

func (p *FqlParser) VariableDeclaration() (localctx IVariableDeclarationContext)

type FqlParserListener 

type FqlParserListener interface {
	antlr.ParseTreeListener

	// EnterProgram is called when entering the program production.
	EnterProgram(c *ProgramContext)

	// EnterHead is called when entering the head production.
	EnterHead(c *HeadContext)

	// EnterUseExpression is called when entering the useExpression production.
	EnterUseExpression(c *UseExpressionContext)

	// EnterUse is called when entering the use production.
	EnterUse(c *UseContext)

	// EnterBody is called when entering the body production.
	EnterBody(c *BodyContext)

	// EnterBodyStatement is called when entering the bodyStatement production.
	EnterBodyStatement(c *BodyStatementContext)

	// EnterBodyExpression is called when entering the bodyExpression production.
	EnterBodyExpression(c *BodyExpressionContext)

	// EnterReturnExpression is called when entering the returnExpression production.
	EnterReturnExpression(c *ReturnExpressionContext)

	// EnterForExpression is called when entering the forExpression production.
	EnterForExpression(c *ForExpressionContext)

	// EnterForExpressionValueVariable is called when entering the forExpressionValueVariable production.
	EnterForExpressionValueVariable(c *ForExpressionValueVariableContext)

	// EnterForExpressionKeyVariable is called when entering the forExpressionKeyVariable production.
	EnterForExpressionKeyVariable(c *ForExpressionKeyVariableContext)

	// EnterForExpressionSource is called when entering the forExpressionSource production.
	EnterForExpressionSource(c *ForExpressionSourceContext)

	// EnterForExpressionClause is called when entering the forExpressionClause production.
	EnterForExpressionClause(c *ForExpressionClauseContext)

	// EnterForExpressionStatement is called when entering the forExpressionStatement production.
	EnterForExpressionStatement(c *ForExpressionStatementContext)

	// EnterForExpressionBody is called when entering the forExpressionBody production.
	EnterForExpressionBody(c *ForExpressionBodyContext)

	// EnterForExpressionReturn is called when entering the forExpressionReturn production.
	EnterForExpressionReturn(c *ForExpressionReturnContext)

	// EnterFilterClause is called when entering the filterClause production.
	EnterFilterClause(c *FilterClauseContext)

	// EnterLimitClause is called when entering the limitClause production.
	EnterLimitClause(c *LimitClauseContext)

	// EnterLimitClauseValue is called when entering the limitClauseValue production.
	EnterLimitClauseValue(c *LimitClauseValueContext)

	// EnterSortClause is called when entering the sortClause production.
	EnterSortClause(c *SortClauseContext)

	// EnterSortClauseExpression is called when entering the sortClauseExpression production.
	EnterSortClauseExpression(c *SortClauseExpressionContext)

	// EnterCollectClause is called when entering the collectClause production.
	EnterCollectClause(c *CollectClauseContext)

	// EnterCollectSelector is called when entering the collectSelector production.
	EnterCollectSelector(c *CollectSelectorContext)

	// EnterCollectGrouping is called when entering the collectGrouping production.
	EnterCollectGrouping(c *CollectGroupingContext)

	// EnterCollectAggregator is called when entering the collectAggregator production.
	EnterCollectAggregator(c *CollectAggregatorContext)

	// EnterCollectAggregateSelector is called when entering the collectAggregateSelector production.
	EnterCollectAggregateSelector(c *CollectAggregateSelectorContext)

	// EnterCollectGroupVariable is called when entering the collectGroupVariable production.
	EnterCollectGroupVariable(c *CollectGroupVariableContext)

	// EnterCollectCounter is called when entering the collectCounter production.
	EnterCollectCounter(c *CollectCounterContext)

	// EnterVariableDeclaration is called when entering the variableDeclaration production.
	EnterVariableDeclaration(c *VariableDeclarationContext)

	// EnterParam is called when entering the param production.
	EnterParam(c *ParamContext)

	// EnterVariable is called when entering the variable production.
	EnterVariable(c *VariableContext)

	// EnterRangeOperator is called when entering the rangeOperator production.
	EnterRangeOperator(c *RangeOperatorContext)

	// EnterArrayLiteral is called when entering the arrayLiteral production.
	EnterArrayLiteral(c *ArrayLiteralContext)

	// EnterObjectLiteral is called when entering the objectLiteral production.
	EnterObjectLiteral(c *ObjectLiteralContext)

	// EnterBooleanLiteral is called when entering the booleanLiteral production.
	EnterBooleanLiteral(c *BooleanLiteralContext)

	// EnterStringLiteral is called when entering the stringLiteral production.
	EnterStringLiteral(c *StringLiteralContext)

	// EnterIntegerLiteral is called when entering the integerLiteral production.
	EnterIntegerLiteral(c *IntegerLiteralContext)

	// EnterFloatLiteral is called when entering the floatLiteral production.
	EnterFloatLiteral(c *FloatLiteralContext)

	// EnterNoneLiteral is called when entering the noneLiteral production.
	EnterNoneLiteral(c *NoneLiteralContext)

	// EnterArrayElementList is called when entering the arrayElementList production.
	EnterArrayElementList(c *ArrayElementListContext)

	// EnterPropertyAssignment is called when entering the propertyAssignment production.
	EnterPropertyAssignment(c *PropertyAssignmentContext)

	// EnterShorthandPropertyName is called when entering the shorthandPropertyName production.
	EnterShorthandPropertyName(c *ShorthandPropertyNameContext)

	// EnterComputedPropertyName is called when entering the computedPropertyName production.
	EnterComputedPropertyName(c *ComputedPropertyNameContext)

	// EnterPropertyName is called when entering the propertyName production.
	EnterPropertyName(c *PropertyNameContext)

	// EnterExpressionGroup is called when entering the expressionGroup production.
	EnterExpressionGroup(c *ExpressionGroupContext)

	// EnterNamespaceIdentifier is called when entering the namespaceIdentifier production.
	EnterNamespaceIdentifier(c *NamespaceIdentifierContext)

	// EnterNamespace is called when entering the namespace production.
	EnterNamespace(c *NamespaceContext)

	// EnterFunctionIdentifier is called when entering the functionIdentifier production.
	EnterFunctionIdentifier(c *FunctionIdentifierContext)

	// EnterFunctionCallExpression is called when entering the functionCallExpression production.
	EnterFunctionCallExpression(c *FunctionCallExpressionContext)

	// EnterMember is called when entering the member production.
	EnterMember(c *MemberContext)

	// EnterMemberPath is called when entering the memberPath production.
	EnterMemberPath(c *MemberPathContext)

	// EnterMemberExpression is called when entering the memberExpression production.
	EnterMemberExpression(c *MemberExpressionContext)

	// EnterArguments is called when entering the arguments production.
	EnterArguments(c *ArgumentsContext)

	// EnterExpression is called when entering the expression production.
	EnterExpression(c *ExpressionContext)

	// EnterForTernaryExpression is called when entering the forTernaryExpression production.
	EnterForTernaryExpression(c *ForTernaryExpressionContext)

	// EnterArrayOperator is called when entering the arrayOperator production.
	EnterArrayOperator(c *ArrayOperatorContext)

	// EnterInOperator is called when entering the inOperator production.
	EnterInOperator(c *InOperatorContext)

	// EnterEqualityOperator is called when entering the equalityOperator production.
	EnterEqualityOperator(c *EqualityOperatorContext)

	// EnterRegexpOperator is called when entering the regexpOperator production.
	EnterRegexpOperator(c *RegexpOperatorContext)

	// EnterLogicalAndOperator is called when entering the logicalAndOperator production.
	EnterLogicalAndOperator(c *LogicalAndOperatorContext)

	// EnterLogicalOrOperator is called when entering the logicalOrOperator production.
	EnterLogicalOrOperator(c *LogicalOrOperatorContext)

	// EnterMultiplicativeOperator is called when entering the multiplicativeOperator production.
	EnterMultiplicativeOperator(c *MultiplicativeOperatorContext)

	// EnterAdditiveOperator is called when entering the additiveOperator production.
	EnterAdditiveOperator(c *AdditiveOperatorContext)

	// EnterUnaryOperator is called when entering the unaryOperator production.
	EnterUnaryOperator(c *UnaryOperatorContext)

	// ExitProgram is called when exiting the program production.
	ExitProgram(c *ProgramContext)

	// ExitHead is called when exiting the head production.
	ExitHead(c *HeadContext)

	// ExitUseExpression is called when exiting the useExpression production.
	ExitUseExpression(c *UseExpressionContext)

	// ExitUse is called when exiting the use production.
	ExitUse(c *UseContext)

	// ExitBody is called when exiting the body production.
	ExitBody(c *BodyContext)

	// ExitBodyStatement is called when exiting the bodyStatement production.
	ExitBodyStatement(c *BodyStatementContext)

	// ExitBodyExpression is called when exiting the bodyExpression production.
	ExitBodyExpression(c *BodyExpressionContext)

	// ExitReturnExpression is called when exiting the returnExpression production.
	ExitReturnExpression(c *ReturnExpressionContext)

	// ExitForExpression is called when exiting the forExpression production.
	ExitForExpression(c *ForExpressionContext)

	// ExitForExpressionValueVariable is called when exiting the forExpressionValueVariable production.
	ExitForExpressionValueVariable(c *ForExpressionValueVariableContext)

	// ExitForExpressionKeyVariable is called when exiting the forExpressionKeyVariable production.
	ExitForExpressionKeyVariable(c *ForExpressionKeyVariableContext)

	// ExitForExpressionSource is called when exiting the forExpressionSource production.
	ExitForExpressionSource(c *ForExpressionSourceContext)

	// ExitForExpressionClause is called when exiting the forExpressionClause production.
	ExitForExpressionClause(c *ForExpressionClauseContext)

	// ExitForExpressionStatement is called when exiting the forExpressionStatement production.
	ExitForExpressionStatement(c *ForExpressionStatementContext)

	// ExitForExpressionBody is called when exiting the forExpressionBody production.
	ExitForExpressionBody(c *ForExpressionBodyContext)

	// ExitForExpressionReturn is called when exiting the forExpressionReturn production.
	ExitForExpressionReturn(c *ForExpressionReturnContext)

	// ExitFilterClause is called when exiting the filterClause production.
	ExitFilterClause(c *FilterClauseContext)

	// ExitLimitClause is called when exiting the limitClause production.
	ExitLimitClause(c *LimitClauseContext)

	// ExitLimitClauseValue is called when exiting the limitClauseValue production.
	ExitLimitClauseValue(c *LimitClauseValueContext)

	// ExitSortClause is called when exiting the sortClause production.
	ExitSortClause(c *SortClauseContext)

	// ExitSortClauseExpression is called when exiting the sortClauseExpression production.
	ExitSortClauseExpression(c *SortClauseExpressionContext)

	// ExitCollectClause is called when exiting the collectClause production.
	ExitCollectClause(c *CollectClauseContext)

	// ExitCollectSelector is called when exiting the collectSelector production.
	ExitCollectSelector(c *CollectSelectorContext)

	// ExitCollectGrouping is called when exiting the collectGrouping production.
	ExitCollectGrouping(c *CollectGroupingContext)

	// ExitCollectAggregator is called when exiting the collectAggregator production.
	ExitCollectAggregator(c *CollectAggregatorContext)

	// ExitCollectAggregateSelector is called when exiting the collectAggregateSelector production.
	ExitCollectAggregateSelector(c *CollectAggregateSelectorContext)

	// ExitCollectGroupVariable is called when exiting the collectGroupVariable production.
	ExitCollectGroupVariable(c *CollectGroupVariableContext)

	// ExitCollectCounter is called when exiting the collectCounter production.
	ExitCollectCounter(c *CollectCounterContext)

	// ExitVariableDeclaration is called when exiting the variableDeclaration production.
	ExitVariableDeclaration(c *VariableDeclarationContext)

	// ExitParam is called when exiting the param production.
	ExitParam(c *ParamContext)

	// ExitVariable is called when exiting the variable production.
	ExitVariable(c *VariableContext)

	// ExitRangeOperator is called when exiting the rangeOperator production.
	ExitRangeOperator(c *RangeOperatorContext)

	// ExitArrayLiteral is called when exiting the arrayLiteral production.
	ExitArrayLiteral(c *ArrayLiteralContext)

	// ExitObjectLiteral is called when exiting the objectLiteral production.
	ExitObjectLiteral(c *ObjectLiteralContext)

	// ExitBooleanLiteral is called when exiting the booleanLiteral production.
	ExitBooleanLiteral(c *BooleanLiteralContext)

	// ExitStringLiteral is called when exiting the stringLiteral production.
	ExitStringLiteral(c *StringLiteralContext)

	// ExitIntegerLiteral is called when exiting the integerLiteral production.
	ExitIntegerLiteral(c *IntegerLiteralContext)

	// ExitFloatLiteral is called when exiting the floatLiteral production.
	ExitFloatLiteral(c *FloatLiteralContext)

	// ExitNoneLiteral is called when exiting the noneLiteral production.
	ExitNoneLiteral(c *NoneLiteralContext)

	// ExitArrayElementList is called when exiting the arrayElementList production.
	ExitArrayElementList(c *ArrayElementListContext)

	// ExitPropertyAssignment is called when exiting the propertyAssignment production.
	ExitPropertyAssignment(c *PropertyAssignmentContext)

	// ExitShorthandPropertyName is called when exiting the shorthandPropertyName production.
	ExitShorthandPropertyName(c *ShorthandPropertyNameContext)

	// ExitComputedPropertyName is called when exiting the computedPropertyName production.
	ExitComputedPropertyName(c *ComputedPropertyNameContext)

	// ExitPropertyName is called when exiting the propertyName production.
	ExitPropertyName(c *PropertyNameContext)

	// ExitExpressionGroup is called when exiting the expressionGroup production.
	ExitExpressionGroup(c *ExpressionGroupContext)

	// ExitNamespaceIdentifier is called when exiting the namespaceIdentifier production.
	ExitNamespaceIdentifier(c *NamespaceIdentifierContext)

	// ExitNamespace is called when exiting the namespace production.
	ExitNamespace(c *NamespaceContext)

	// ExitFunctionIdentifier is called when exiting the functionIdentifier production.
	ExitFunctionIdentifier(c *FunctionIdentifierContext)

	// ExitFunctionCallExpression is called when exiting the functionCallExpression production.
	ExitFunctionCallExpression(c *FunctionCallExpressionContext)

	// ExitMember is called when exiting the member production.
	ExitMember(c *MemberContext)

	// ExitMemberPath is called when exiting the memberPath production.
	ExitMemberPath(c *MemberPathContext)

	// ExitMemberExpression is called when exiting the memberExpression production.
	ExitMemberExpression(c *MemberExpressionContext)

	// ExitArguments is called when exiting the arguments production.
	ExitArguments(c *ArgumentsContext)

	// ExitExpression is called when exiting the expression production.
	ExitExpression(c *ExpressionContext)

	// ExitForTernaryExpression is called when exiting the forTernaryExpression production.
	ExitForTernaryExpression(c *ForTernaryExpressionContext)

	// ExitArrayOperator is called when exiting the arrayOperator production.
	ExitArrayOperator(c *ArrayOperatorContext)

	// ExitInOperator is called when exiting the inOperator production.
	ExitInOperator(c *InOperatorContext)

	// ExitEqualityOperator is called when exiting the equalityOperator production.
	ExitEqualityOperator(c *EqualityOperatorContext)

	// ExitRegexpOperator is called when exiting the regexpOperator production.
	ExitRegexpOperator(c *RegexpOperatorContext)

	// ExitLogicalAndOperator is called when exiting the logicalAndOperator production.
	ExitLogicalAndOperator(c *LogicalAndOperatorContext)

	// ExitLogicalOrOperator is called when exiting the logicalOrOperator production.
	ExitLogicalOrOperator(c *LogicalOrOperatorContext)

	// ExitMultiplicativeOperator is called when exiting the multiplicativeOperator production.
	ExitMultiplicativeOperator(c *MultiplicativeOperatorContext)

	// ExitAdditiveOperator is called when exiting the additiveOperator production.
	ExitAdditiveOperator(c *AdditiveOperatorContext)

	// ExitUnaryOperator is called when exiting the unaryOperator production.
	ExitUnaryOperator(c *UnaryOperatorContext)
}

FqlParserListener is a complete listener for a parse tree produced by FqlParser.

type FqlParserVisitor 

type FqlParserVisitor interface {
	antlr.ParseTreeVisitor

	// Visit a parse tree produced by FqlParser#program.
	VisitProgram(ctx *ProgramContext) interface{}

	// Visit a parse tree produced by FqlParser#head.
	VisitHead(ctx *HeadContext) interface{}

	// Visit a parse tree produced by FqlParser#useExpression.
	VisitUseExpression(ctx *UseExpressionContext) interface{}

	// Visit a parse tree produced by FqlParser#use.
	VisitUse(ctx *UseContext) interface{}

	// Visit a parse tree produced by FqlParser#body.
	VisitBody(ctx *BodyContext) interface{}

	// Visit a parse tree produced by FqlParser#bodyStatement.
	VisitBodyStatement(ctx *BodyStatementContext) interface{}

	// Visit a parse tree produced by FqlParser#bodyExpression.
	VisitBodyExpression(ctx *BodyExpressionContext) interface{}

	// Visit a parse tree produced by FqlParser#returnExpression.
	VisitReturnExpression(ctx *ReturnExpressionContext) interface{}

	// Visit a parse tree produced by FqlParser#forExpression.
	VisitForExpression(ctx *ForExpressionContext) interface{}

	// Visit a parse tree produced by FqlParser#forExpressionValueVariable.
	VisitForExpressionValueVariable(ctx *ForExpressionValueVariableContext) interface{}

	// Visit a parse tree produced by FqlParser#forExpressionKeyVariable.
	VisitForExpressionKeyVariable(ctx *ForExpressionKeyVariableContext) interface{}

	// Visit a parse tree produced by FqlParser#forExpressionSource.
	VisitForExpressionSource(ctx *ForExpressionSourceContext) interface{}

	// Visit a parse tree produced by FqlParser#forExpressionClause.
	VisitForExpressionClause(ctx *ForExpressionClauseContext) interface{}

	// Visit a parse tree produced by FqlParser#forExpressionStatement.
	VisitForExpressionStatement(ctx *ForExpressionStatementContext) interface{}

	// Visit a parse tree produced by FqlParser#forExpressionBody.
	VisitForExpressionBody(ctx *ForExpressionBodyContext) interface{}

	// Visit a parse tree produced by FqlParser#forExpressionReturn.
	VisitForExpressionReturn(ctx *ForExpressionReturnContext) interface{}

	// Visit a parse tree produced by FqlParser#filterClause.
	VisitFilterClause(ctx *FilterClauseContext) interface{}

	// Visit a parse tree produced by FqlParser#limitClause.
	VisitLimitClause(ctx *LimitClauseContext) interface{}

	// Visit a parse tree produced by FqlParser#limitClauseValue.
	VisitLimitClauseValue(ctx *LimitClauseValueContext) interface{}

	// Visit a parse tree produced by FqlParser#sortClause.
	VisitSortClause(ctx *SortClauseContext) interface{}

	// Visit a parse tree produced by FqlParser#sortClauseExpression.
	VisitSortClauseExpression(ctx *SortClauseExpressionContext) interface{}

	// Visit a parse tree produced by FqlParser#collectClause.
	VisitCollectClause(ctx *CollectClauseContext) interface{}

	// Visit a parse tree produced by FqlParser#collectSelector.
	VisitCollectSelector(ctx *CollectSelectorContext) interface{}

	// Visit a parse tree produced by FqlParser#collectGrouping.
	VisitCollectGrouping(ctx *CollectGroupingContext) interface{}

	// Visit a parse tree produced by FqlParser#collectAggregator.
	VisitCollectAggregator(ctx *CollectAggregatorContext) interface{}

	// Visit a parse tree produced by FqlParser#collectAggregateSelector.
	VisitCollectAggregateSelector(ctx *CollectAggregateSelectorContext) interface{}

	// Visit a parse tree produced by FqlParser#collectGroupVariable.
	VisitCollectGroupVariable(ctx *CollectGroupVariableContext) interface{}

	// Visit a parse tree produced by FqlParser#collectCounter.
	VisitCollectCounter(ctx *CollectCounterContext) interface{}

	// Visit a parse tree produced by FqlParser#variableDeclaration.
	VisitVariableDeclaration(ctx *VariableDeclarationContext) interface{}

	// Visit a parse tree produced by FqlParser#param.
	VisitParam(ctx *ParamContext) interface{}

	// Visit a parse tree produced by FqlParser#variable.
	VisitVariable(ctx *VariableContext) interface{}

	// Visit a parse tree produced by FqlParser#rangeOperator.
	VisitRangeOperator(ctx *RangeOperatorContext) interface{}

	// Visit a parse tree produced by FqlParser#arrayLiteral.
	VisitArrayLiteral(ctx *ArrayLiteralContext) interface{}

	// Visit a parse tree produced by FqlParser#objectLiteral.
	VisitObjectLiteral(ctx *ObjectLiteralContext) interface{}

	// Visit a parse tree produced by FqlParser#booleanLiteral.
	VisitBooleanLiteral(ctx *BooleanLiteralContext) interface{}

	// Visit a parse tree produced by FqlParser#stringLiteral.
	VisitStringLiteral(ctx *StringLiteralContext) interface{}

	// Visit a parse tree produced by FqlParser#integerLiteral.
	VisitIntegerLiteral(ctx *IntegerLiteralContext) interface{}

	// Visit a parse tree produced by FqlParser#floatLiteral.
	VisitFloatLiteral(ctx *FloatLiteralContext) interface{}

	// Visit a parse tree produced by FqlParser#noneLiteral.
	VisitNoneLiteral(ctx *NoneLiteralContext) interface{}

	// Visit a parse tree produced by FqlParser#arrayElementList.
	VisitArrayElementList(ctx *ArrayElementListContext) interface{}

	// Visit a parse tree produced by FqlParser#propertyAssignment.
	VisitPropertyAssignment(ctx *PropertyAssignmentContext) interface{}

	// Visit a parse tree produced by FqlParser#shorthandPropertyName.
	VisitShorthandPropertyName(ctx *ShorthandPropertyNameContext) interface{}

	// Visit a parse tree produced by FqlParser#computedPropertyName.
	VisitComputedPropertyName(ctx *ComputedPropertyNameContext) interface{}

	// Visit a parse tree produced by FqlParser#propertyName.
	VisitPropertyName(ctx *PropertyNameContext) interface{}

	// Visit a parse tree produced by FqlParser#expressionGroup.
	VisitExpressionGroup(ctx *ExpressionGroupContext) interface{}

	// Visit a parse tree produced by FqlParser#namespaceIdentifier.
	VisitNamespaceIdentifier(ctx *NamespaceIdentifierContext) interface{}

	// Visit a parse tree produced by FqlParser#namespace.
	VisitNamespace(ctx *NamespaceContext) interface{}

	// Visit a parse tree produced by FqlParser#functionIdentifier.
	VisitFunctionIdentifier(ctx *FunctionIdentifierContext) interface{}

	// Visit a parse tree produced by FqlParser#functionCallExpression.
	VisitFunctionCallExpression(ctx *FunctionCallExpressionContext) interface{}

	// Visit a parse tree produced by FqlParser#member.
	VisitMember(ctx *MemberContext) interface{}

	// Visit a parse tree produced by FqlParser#memberPath.
	VisitMemberPath(ctx *MemberPathContext) interface{}

	// Visit a parse tree produced by FqlParser#memberExpression.
	VisitMemberExpression(ctx *MemberExpressionContext) interface{}

	// Visit a parse tree produced by FqlParser#arguments.
	VisitArguments(ctx *ArgumentsContext) interface{}

	// Visit a parse tree produced by FqlParser#expression.
	VisitExpression(ctx *ExpressionContext) interface{}

	// Visit a parse tree produced by FqlParser#forTernaryExpression.
	VisitForTernaryExpression(ctx *ForTernaryExpressionContext) interface{}

	// Visit a parse tree produced by FqlParser#arrayOperator.
	VisitArrayOperator(ctx *ArrayOperatorContext) interface{}

	// Visit a parse tree produced by FqlParser#inOperator.
	VisitInOperator(ctx *InOperatorContext) interface{}

	// Visit a parse tree produced by FqlParser#equalityOperator.
	VisitEqualityOperator(ctx *EqualityOperatorContext) interface{}

	// Visit a parse tree produced by FqlParser#regexpOperator.
	VisitRegexpOperator(ctx *RegexpOperatorContext) interface{}

	// Visit a parse tree produced by FqlParser#logicalAndOperator.
	VisitLogicalAndOperator(ctx *LogicalAndOperatorContext) interface{}

	// Visit a parse tree produced by FqlParser#logicalOrOperator.
	VisitLogicalOrOperator(ctx *LogicalOrOperatorContext) interface{}

	// Visit a parse tree produced by FqlParser#multiplicativeOperator.
	VisitMultiplicativeOperator(ctx *MultiplicativeOperatorContext) interface{}

	// Visit a parse tree produced by FqlParser#additiveOperator.
	VisitAdditiveOperator(ctx *AdditiveOperatorContext) interface{}

	// Visit a parse tree produced by FqlParser#unaryOperator.
	VisitUnaryOperator(ctx *UnaryOperatorContext) interface{}
}

A complete Visitor for a parse tree produced by FqlParser.

type FunctionCallExpressionContext 

type FunctionCallExpressionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFunctionCallExpressionContext 

func NewEmptyFunctionCallExpressionContext() *FunctionCallExpressionContext

func NewFunctionCallExpressionContext 

func NewFunctionCallExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionCallExpressionContext

func (*FunctionCallExpressionContext) Accept 

func (s *FunctionCallExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FunctionCallExpressionContext) Arguments 

func (s *FunctionCallExpressionContext) Arguments() IArgumentsContext

func (*FunctionCallExpressionContext) EnterRule 

func (s *FunctionCallExpressionContext) EnterRule(listener antlr.ParseTreeListener)

func (*FunctionCallExpressionContext) ExitRule 

func (s *FunctionCallExpressionContext) ExitRule(listener antlr.ParseTreeListener)

func (*FunctionCallExpressionContext) FunctionIdentifier added in v0.11.0 

func (s *FunctionCallExpressionContext) FunctionIdentifier() IFunctionIdentifierContext

func (*FunctionCallExpressionContext) GetParser 

func (s *FunctionCallExpressionContext) GetParser() antlr.Parser

func (*FunctionCallExpressionContext) GetRuleContext 

func (s *FunctionCallExpressionContext) GetRuleContext() antlr.RuleContext

func (*FunctionCallExpressionContext) IsFunctionCallExpressionContext 

func (*FunctionCallExpressionContext) IsFunctionCallExpressionContext()

func (*FunctionCallExpressionContext) Namespace added in v0.8.0 

func (s *FunctionCallExpressionContext) Namespace() INamespaceContext

func (*FunctionCallExpressionContext) ToStringTree 

func (s *FunctionCallExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type FunctionIdentifierContext added in v0.11.0 

type FunctionIdentifierContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFunctionIdentifierContext added in v0.11.0 

func NewEmptyFunctionIdentifierContext() *FunctionIdentifierContext

func NewFunctionIdentifierContext added in v0.11.0 

func NewFunctionIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FunctionIdentifierContext

func (*FunctionIdentifierContext) Accept added in v0.11.0 

func (s *FunctionIdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*FunctionIdentifierContext) Aggregate added in v0.11.0 

func (s *FunctionIdentifierContext) Aggregate() antlr.TerminalNode

func (*FunctionIdentifierContext) All added in v0.11.0 

func (s *FunctionIdentifierContext) All() antlr.TerminalNode

func (*FunctionIdentifierContext) And added in v0.11.0 

func (s *FunctionIdentifierContext) And() antlr.TerminalNode

func (*FunctionIdentifierContext) Any added in v0.11.0 

func (s *FunctionIdentifierContext) Any() antlr.TerminalNode

func (*FunctionIdentifierContext) BooleanLiteral added in v0.11.0 

func (s *FunctionIdentifierContext) BooleanLiteral() antlr.TerminalNode

func (*FunctionIdentifierContext) Collect added in v0.11.0 

func (s *FunctionIdentifierContext) Collect() antlr.TerminalNode

func (*FunctionIdentifierContext) Count added in v0.11.0 

func (s *FunctionIdentifierContext) Count() antlr.TerminalNode

func (*FunctionIdentifierContext) Distinct added in v0.11.0 

func (s *FunctionIdentifierContext) Distinct() antlr.TerminalNode

func (*FunctionIdentifierContext) EnterRule added in v0.11.0 

func (s *FunctionIdentifierContext) EnterRule(listener antlr.ParseTreeListener)

func (*FunctionIdentifierContext) ExitRule added in v0.11.0 

func (s *FunctionIdentifierContext) ExitRule(listener antlr.ParseTreeListener)

func (*FunctionIdentifierContext) Filter added in v0.11.0 

func (s *FunctionIdentifierContext) Filter() antlr.TerminalNode

func (*FunctionIdentifierContext) For added in v0.11.0 

func (s *FunctionIdentifierContext) For() antlr.TerminalNode

func (*FunctionIdentifierContext) GetParser added in v0.11.0 

func (s *FunctionIdentifierContext) GetParser() antlr.Parser

func (*FunctionIdentifierContext) GetRuleContext added in v0.11.0 

func (s *FunctionIdentifierContext) GetRuleContext() antlr.RuleContext

func (*FunctionIdentifierContext) Identifier added in v0.11.0 

func (s *FunctionIdentifierContext) Identifier() antlr.TerminalNode

func (*FunctionIdentifierContext) In added in v0.11.0 

func (s *FunctionIdentifierContext) In() antlr.TerminalNode

func (*FunctionIdentifierContext) Into added in v0.11.0 

func (s *FunctionIdentifierContext) Into() antlr.TerminalNode

func (*FunctionIdentifierContext) IsFunctionIdentifierContext added in v0.11.0 

func (*FunctionIdentifierContext) IsFunctionIdentifierContext()

func (*FunctionIdentifierContext) Keep added in v0.11.0 

func (s *FunctionIdentifierContext) Keep() antlr.TerminalNode

func (*FunctionIdentifierContext) Let added in v0.11.0 

func (s *FunctionIdentifierContext) Let() antlr.TerminalNode

func (*FunctionIdentifierContext) Like added in v0.11.0 

func (s *FunctionIdentifierContext) Like() antlr.TerminalNode

func (*FunctionIdentifierContext) Limit added in v0.11.0 

func (s *FunctionIdentifierContext) Limit() antlr.TerminalNode

func (*FunctionIdentifierContext) None added in v0.11.0 

func (s *FunctionIdentifierContext) None() antlr.TerminalNode

func (*FunctionIdentifierContext) Not added in v0.11.0 

func (s *FunctionIdentifierContext) Not() antlr.TerminalNode

func (*FunctionIdentifierContext) Null added in v0.11.0 

func (s *FunctionIdentifierContext) Null() antlr.TerminalNode

func (*FunctionIdentifierContext) Or added in v0.11.0 

func (s *FunctionIdentifierContext) Or() antlr.TerminalNode

func (*FunctionIdentifierContext) Return added in v0.11.0 

func (s *FunctionIdentifierContext) Return() antlr.TerminalNode

func (*FunctionIdentifierContext) Sort added in v0.11.0 

func (s *FunctionIdentifierContext) Sort() antlr.TerminalNode

func (*FunctionIdentifierContext) SortDirection added in v0.11.0 

func (s *FunctionIdentifierContext) SortDirection() antlr.TerminalNode

func (*FunctionIdentifierContext) ToStringTree added in v0.11.0 

func (s *FunctionIdentifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*FunctionIdentifierContext) Use added in v0.11.0 

func (s *FunctionIdentifierContext) Use() antlr.TerminalNode

func (*FunctionIdentifierContext) With added in v0.11.0 

func (s *FunctionIdentifierContext) With() antlr.TerminalNode

type HeadContext added in v0.11.0 

type HeadContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyHeadContext added in v0.11.0 

func NewEmptyHeadContext() *HeadContext

func NewHeadContext added in v0.11.0 

func NewHeadContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *HeadContext

func (*HeadContext) Accept added in v0.11.0 

func (s *HeadContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*HeadContext) EnterRule added in v0.11.0 

func (s *HeadContext) EnterRule(listener antlr.ParseTreeListener)

func (*HeadContext) ExitRule added in v0.11.0 

func (s *HeadContext) ExitRule(listener antlr.ParseTreeListener)

func (*HeadContext) GetParser added in v0.11.0 

func (s *HeadContext) GetParser() antlr.Parser

func (*HeadContext) GetRuleContext added in v0.11.0 

func (s *HeadContext) GetRuleContext() antlr.RuleContext

func (*HeadContext) IsHeadContext added in v0.11.0 

func (*HeadContext) IsHeadContext()

func (*HeadContext) ToStringTree added in v0.11.0 

func (s *HeadContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*HeadContext) UseExpression added in v0.11.0 

func (s *HeadContext) UseExpression() IUseExpressionContext

type IAdditiveOperatorContext added in v0.6.0 

type IAdditiveOperatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsAdditiveOperatorContext differentiates from other interfaces.
	IsAdditiveOperatorContext()
}

IAdditiveOperatorContext is an interface to support dynamic dispatch.

type IArgumentsContext 

type IArgumentsContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsArgumentsContext differentiates from other interfaces.
	IsArgumentsContext()
}

IArgumentsContext is an interface to support dynamic dispatch.

type IArrayElementListContext 

type IArrayElementListContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsArrayElementListContext differentiates from other interfaces.
	IsArrayElementListContext()
}

IArrayElementListContext is an interface to support dynamic dispatch.

type IArrayLiteralContext 

type IArrayLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsArrayLiteralContext differentiates from other interfaces.
	IsArrayLiteralContext()
}

IArrayLiteralContext is an interface to support dynamic dispatch.

type IArrayOperatorContext 

type IArrayOperatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsArrayOperatorContext differentiates from other interfaces.
	IsArrayOperatorContext()
}

IArrayOperatorContext is an interface to support dynamic dispatch.

type IBodyContext 

type IBodyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBodyContext differentiates from other interfaces.
	IsBodyContext()
}

IBodyContext is an interface to support dynamic dispatch.

type IBodyExpressionContext 

type IBodyExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBodyExpressionContext differentiates from other interfaces.
	IsBodyExpressionContext()
}

IBodyExpressionContext is an interface to support dynamic dispatch.

type IBodyStatementContext 

type IBodyStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBodyStatementContext differentiates from other interfaces.
	IsBodyStatementContext()
}

IBodyStatementContext is an interface to support dynamic dispatch.

type IBooleanLiteralContext 

type IBooleanLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsBooleanLiteralContext differentiates from other interfaces.
	IsBooleanLiteralContext()
}

IBooleanLiteralContext is an interface to support dynamic dispatch.

type ICollectAggregateSelectorContext added in v0.4.0 

type ICollectAggregateSelectorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCollectAggregateSelectorContext differentiates from other interfaces.
	IsCollectAggregateSelectorContext()
}

ICollectAggregateSelectorContext is an interface to support dynamic dispatch.

type ICollectAggregatorContext added in v0.4.0 

type ICollectAggregatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCollectAggregatorContext differentiates from other interfaces.
	IsCollectAggregatorContext()
}

ICollectAggregatorContext is an interface to support dynamic dispatch.

type ICollectClauseContext 

type ICollectClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCollectClauseContext differentiates from other interfaces.
	IsCollectClauseContext()
}

ICollectClauseContext is an interface to support dynamic dispatch.

type ICollectCounterContext added in v0.4.0 

type ICollectCounterContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCollectCounterContext differentiates from other interfaces.
	IsCollectCounterContext()
}

ICollectCounterContext is an interface to support dynamic dispatch.

type ICollectGroupVariableContext 

type ICollectGroupVariableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCollectGroupVariableContext differentiates from other interfaces.
	IsCollectGroupVariableContext()
}

ICollectGroupVariableContext is an interface to support dynamic dispatch.

type ICollectGroupingContext added in v0.4.0 

type ICollectGroupingContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCollectGroupingContext differentiates from other interfaces.
	IsCollectGroupingContext()
}

ICollectGroupingContext is an interface to support dynamic dispatch.

type ICollectSelectorContext added in v0.4.0 

type ICollectSelectorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsCollectSelectorContext differentiates from other interfaces.
	IsCollectSelectorContext()
}

ICollectSelectorContext is an interface to support dynamic dispatch.

type IComputedPropertyNameContext 

type IComputedPropertyNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsComputedPropertyNameContext differentiates from other interfaces.
	IsComputedPropertyNameContext()
}

IComputedPropertyNameContext is an interface to support dynamic dispatch.

type IEqualityOperatorContext 

type IEqualityOperatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsEqualityOperatorContext differentiates from other interfaces.
	IsEqualityOperatorContext()
}

IEqualityOperatorContext is an interface to support dynamic dispatch.

type IExpressionContext 

type IExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsExpressionContext differentiates from other interfaces.
	IsExpressionContext()
}

IExpressionContext is an interface to support dynamic dispatch.

type IExpressionGroupContext added in v0.6.0 

type IExpressionGroupContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsExpressionGroupContext differentiates from other interfaces.
	IsExpressionGroupContext()
}

IExpressionGroupContext is an interface to support dynamic dispatch.

type IFilterClauseContext 

type IFilterClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFilterClauseContext differentiates from other interfaces.
	IsFilterClauseContext()
}

IFilterClauseContext is an interface to support dynamic dispatch.

type IFloatLiteralContext 

type IFloatLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFloatLiteralContext differentiates from other interfaces.
	IsFloatLiteralContext()
}

IFloatLiteralContext is an interface to support dynamic dispatch.

type IForExpressionBodyContext 

type IForExpressionBodyContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsForExpressionBodyContext differentiates from other interfaces.
	IsForExpressionBodyContext()
}

IForExpressionBodyContext is an interface to support dynamic dispatch.

type IForExpressionClauseContext 

type IForExpressionClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsForExpressionClauseContext differentiates from other interfaces.
	IsForExpressionClauseContext()
}

IForExpressionClauseContext is an interface to support dynamic dispatch.

type IForExpressionContext 

type IForExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsForExpressionContext differentiates from other interfaces.
	IsForExpressionContext()
}

IForExpressionContext is an interface to support dynamic dispatch.

type IForExpressionKeyVariableContext 

type IForExpressionKeyVariableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsForExpressionKeyVariableContext differentiates from other interfaces.
	IsForExpressionKeyVariableContext()
}

IForExpressionKeyVariableContext is an interface to support dynamic dispatch.

type IForExpressionReturnContext 

type IForExpressionReturnContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsForExpressionReturnContext differentiates from other interfaces.
	IsForExpressionReturnContext()
}

IForExpressionReturnContext is an interface to support dynamic dispatch.

type IForExpressionSourceContext 

type IForExpressionSourceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsForExpressionSourceContext differentiates from other interfaces.
	IsForExpressionSourceContext()
}

IForExpressionSourceContext is an interface to support dynamic dispatch.

type IForExpressionStatementContext added in v0.5.0 

type IForExpressionStatementContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsForExpressionStatementContext differentiates from other interfaces.
	IsForExpressionStatementContext()
}

IForExpressionStatementContext is an interface to support dynamic dispatch.

type IForExpressionValueVariableContext 

type IForExpressionValueVariableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsForExpressionValueVariableContext differentiates from other interfaces.
	IsForExpressionValueVariableContext()
}

IForExpressionValueVariableContext is an interface to support dynamic dispatch.

type IForTernaryExpressionContext 

type IForTernaryExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsForTernaryExpressionContext differentiates from other interfaces.
	IsForTernaryExpressionContext()
}

IForTernaryExpressionContext is an interface to support dynamic dispatch.

type IFunctionCallExpressionContext 

type IFunctionCallExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFunctionCallExpressionContext differentiates from other interfaces.
	IsFunctionCallExpressionContext()
}

IFunctionCallExpressionContext is an interface to support dynamic dispatch.

type IFunctionIdentifierContext added in v0.11.0 

type IFunctionIdentifierContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFunctionIdentifierContext differentiates from other interfaces.
	IsFunctionIdentifierContext()
}

IFunctionIdentifierContext is an interface to support dynamic dispatch.

type IHeadContext added in v0.11.0 

type IHeadContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsHeadContext differentiates from other interfaces.
	IsHeadContext()
}

IHeadContext is an interface to support dynamic dispatch.

type IInOperatorContext 

type IInOperatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsInOperatorContext differentiates from other interfaces.
	IsInOperatorContext()
}

IInOperatorContext is an interface to support dynamic dispatch.

type IIntegerLiteralContext 

type IIntegerLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsIntegerLiteralContext differentiates from other interfaces.
	IsIntegerLiteralContext()
}

IIntegerLiteralContext is an interface to support dynamic dispatch.

type ILimitClauseContext 

type ILimitClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLimitClauseContext differentiates from other interfaces.
	IsLimitClauseContext()
}

ILimitClauseContext is an interface to support dynamic dispatch.

type ILimitClauseValueContext added in v0.5.0 

type ILimitClauseValueContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLimitClauseValueContext differentiates from other interfaces.
	IsLimitClauseValueContext()
}

ILimitClauseValueContext is an interface to support dynamic dispatch.

type ILogicalAndOperatorContext added in v0.6.0 

type ILogicalAndOperatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLogicalAndOperatorContext differentiates from other interfaces.
	IsLogicalAndOperatorContext()
}

ILogicalAndOperatorContext is an interface to support dynamic dispatch.

type ILogicalOrOperatorContext added in v0.6.0 

type ILogicalOrOperatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsLogicalOrOperatorContext differentiates from other interfaces.
	IsLogicalOrOperatorContext()
}

ILogicalOrOperatorContext is an interface to support dynamic dispatch.

type IMemberContext added in v0.9.0 

type IMemberContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMemberContext differentiates from other interfaces.
	IsMemberContext()
}

IMemberContext is an interface to support dynamic dispatch.

type IMemberExpressionContext 

type IMemberExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMemberExpressionContext differentiates from other interfaces.
	IsMemberExpressionContext()
}

IMemberExpressionContext is an interface to support dynamic dispatch.

type IMemberPathContext added in v0.9.0 

type IMemberPathContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMemberPathContext differentiates from other interfaces.
	IsMemberPathContext()
}

IMemberPathContext is an interface to support dynamic dispatch.

type IMultiplicativeOperatorContext added in v0.6.0 

type IMultiplicativeOperatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsMultiplicativeOperatorContext differentiates from other interfaces.
	IsMultiplicativeOperatorContext()
}

IMultiplicativeOperatorContext is an interface to support dynamic dispatch.

type INamespaceContext added in v0.8.0 

type INamespaceContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsNamespaceContext differentiates from other interfaces.
	IsNamespaceContext()
}

INamespaceContext is an interface to support dynamic dispatch.

type INamespaceIdentifierContext added in v0.11.0 

type INamespaceIdentifierContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsNamespaceIdentifierContext differentiates from other interfaces.
	IsNamespaceIdentifierContext()
}

INamespaceIdentifierContext is an interface to support dynamic dispatch.

type INoneLiteralContext 

type INoneLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsNoneLiteralContext differentiates from other interfaces.
	IsNoneLiteralContext()
}

INoneLiteralContext is an interface to support dynamic dispatch.

type IObjectLiteralContext 

type IObjectLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsObjectLiteralContext differentiates from other interfaces.
	IsObjectLiteralContext()
}

IObjectLiteralContext is an interface to support dynamic dispatch.

type IParamContext 

type IParamContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsParamContext differentiates from other interfaces.
	IsParamContext()
}

IParamContext is an interface to support dynamic dispatch.

type IProgramContext 

type IProgramContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsProgramContext differentiates from other interfaces.
	IsProgramContext()
}

IProgramContext is an interface to support dynamic dispatch.

type IPropertyAssignmentContext 

type IPropertyAssignmentContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPropertyAssignmentContext differentiates from other interfaces.
	IsPropertyAssignmentContext()
}

IPropertyAssignmentContext is an interface to support dynamic dispatch.

type IPropertyNameContext 

type IPropertyNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsPropertyNameContext differentiates from other interfaces.
	IsPropertyNameContext()
}

IPropertyNameContext is an interface to support dynamic dispatch.

type IRangeOperatorContext 

type IRangeOperatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsRangeOperatorContext differentiates from other interfaces.
	IsRangeOperatorContext()
}

IRangeOperatorContext is an interface to support dynamic dispatch.

type IRegexpOperatorContext added in v0.8.0 

type IRegexpOperatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsRegexpOperatorContext differentiates from other interfaces.
	IsRegexpOperatorContext()
}

IRegexpOperatorContext is an interface to support dynamic dispatch.

type IReturnExpressionContext 

type IReturnExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsReturnExpressionContext differentiates from other interfaces.
	IsReturnExpressionContext()
}

IReturnExpressionContext is an interface to support dynamic dispatch.

type IShorthandPropertyNameContext 

type IShorthandPropertyNameContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsShorthandPropertyNameContext differentiates from other interfaces.
	IsShorthandPropertyNameContext()
}

IShorthandPropertyNameContext is an interface to support dynamic dispatch.

type ISortClauseContext 

type ISortClauseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSortClauseContext differentiates from other interfaces.
	IsSortClauseContext()
}

ISortClauseContext is an interface to support dynamic dispatch.

type ISortClauseExpressionContext 

type ISortClauseExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsSortClauseExpressionContext differentiates from other interfaces.
	IsSortClauseExpressionContext()
}

ISortClauseExpressionContext is an interface to support dynamic dispatch.

type IStringLiteralContext 

type IStringLiteralContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsStringLiteralContext differentiates from other interfaces.
	IsStringLiteralContext()
}

IStringLiteralContext is an interface to support dynamic dispatch.

type IUnaryOperatorContext 

type IUnaryOperatorContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUnaryOperatorContext differentiates from other interfaces.
	IsUnaryOperatorContext()
}

IUnaryOperatorContext is an interface to support dynamic dispatch.

type IUseContext added in v0.11.0 

type IUseContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUseContext differentiates from other interfaces.
	IsUseContext()
}

IUseContext is an interface to support dynamic dispatch.

type IUseExpressionContext added in v0.11.0 

type IUseExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsUseExpressionContext differentiates from other interfaces.
	IsUseExpressionContext()
}

IUseExpressionContext is an interface to support dynamic dispatch.

type IVariableContext 

type IVariableContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsVariableContext differentiates from other interfaces.
	IsVariableContext()
}

IVariableContext is an interface to support dynamic dispatch.

type IVariableDeclarationContext 

type IVariableDeclarationContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsVariableDeclarationContext differentiates from other interfaces.
	IsVariableDeclarationContext()
}

IVariableDeclarationContext is an interface to support dynamic dispatch.

type InOperatorContext 

type InOperatorContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyInOperatorContext 

func NewEmptyInOperatorContext() *InOperatorContext

func NewInOperatorContext 

func NewInOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *InOperatorContext

func (*InOperatorContext) Accept 

func (s *InOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*InOperatorContext) EnterRule 

func (s *InOperatorContext) EnterRule(listener antlr.ParseTreeListener)

func (*InOperatorContext) ExitRule 

func (s *InOperatorContext) ExitRule(listener antlr.ParseTreeListener)

func (*InOperatorContext) GetParser 

func (s *InOperatorContext) GetParser() antlr.Parser

func (*InOperatorContext) GetRuleContext 

func (s *InOperatorContext) GetRuleContext() antlr.RuleContext

func (*InOperatorContext) In 

func (s *InOperatorContext) In() antlr.TerminalNode

func (*InOperatorContext) IsInOperatorContext 

func (*InOperatorContext) IsInOperatorContext()

func (*InOperatorContext) Not added in v0.3.0 

func (s *InOperatorContext) Not() antlr.TerminalNode

func (*InOperatorContext) ToStringTree 

func (s *InOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type IntegerLiteralContext 

type IntegerLiteralContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyIntegerLiteralContext 

func NewEmptyIntegerLiteralContext() *IntegerLiteralContext

func NewIntegerLiteralContext 

func NewIntegerLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IntegerLiteralContext

func (*IntegerLiteralContext) Accept 

func (s *IntegerLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*IntegerLiteralContext) EnterRule 

func (s *IntegerLiteralContext) EnterRule(listener antlr.ParseTreeListener)

func (*IntegerLiteralContext) ExitRule 

func (s *IntegerLiteralContext) ExitRule(listener antlr.ParseTreeListener)

func (*IntegerLiteralContext) GetParser 

func (s *IntegerLiteralContext) GetParser() antlr.Parser

func (*IntegerLiteralContext) GetRuleContext 

func (s *IntegerLiteralContext) GetRuleContext() antlr.RuleContext

func (*IntegerLiteralContext) IntegerLiteral 

func (s *IntegerLiteralContext) IntegerLiteral() antlr.TerminalNode

func (*IntegerLiteralContext) IsIntegerLiteralContext 

func (*IntegerLiteralContext) IsIntegerLiteralContext()

func (*IntegerLiteralContext) ToStringTree 

func (s *IntegerLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type LimitClauseContext 

type LimitClauseContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyLimitClauseContext 

func NewEmptyLimitClauseContext() *LimitClauseContext

func NewLimitClauseContext 

func NewLimitClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LimitClauseContext

func (*LimitClauseContext) Accept 

func (s *LimitClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*LimitClauseContext) AllLimitClauseValue added in v0.5.0 

func (s *LimitClauseContext) AllLimitClauseValue() []ILimitClauseValueContext

func (*LimitClauseContext) Comma 

func (s *LimitClauseContext) Comma() antlr.TerminalNode

func (*LimitClauseContext) EnterRule 

func (s *LimitClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*LimitClauseContext) ExitRule 

func (s *LimitClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*LimitClauseContext) GetParser 

func (s *LimitClauseContext) GetParser() antlr.Parser

func (*LimitClauseContext) GetRuleContext 

func (s *LimitClauseContext) GetRuleContext() antlr.RuleContext

func (*LimitClauseContext) IsLimitClauseContext 

func (*LimitClauseContext) IsLimitClauseContext()

func (*LimitClauseContext) Limit 

func (s *LimitClauseContext) Limit() antlr.TerminalNode

func (*LimitClauseContext) LimitClauseValue added in v0.5.0 

func (s *LimitClauseContext) LimitClauseValue(i int) ILimitClauseValueContext

func (*LimitClauseContext) ToStringTree 

func (s *LimitClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type LimitClauseValueContext added in v0.5.0 

type LimitClauseValueContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyLimitClauseValueContext added in v0.5.0 

func NewEmptyLimitClauseValueContext() *LimitClauseValueContext

func NewLimitClauseValueContext added in v0.5.0 

func NewLimitClauseValueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LimitClauseValueContext

func (*LimitClauseValueContext) Accept added in v0.5.0 

func (s *LimitClauseValueContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*LimitClauseValueContext) EnterRule added in v0.5.0 

func (s *LimitClauseValueContext) EnterRule(listener antlr.ParseTreeListener)

func (*LimitClauseValueContext) ExitRule added in v0.5.0 

func (s *LimitClauseValueContext) ExitRule(listener antlr.ParseTreeListener)

func (*LimitClauseValueContext) GetParser added in v0.5.0 

func (s *LimitClauseValueContext) GetParser() antlr.Parser

func (*LimitClauseValueContext) GetRuleContext added in v0.5.0 

func (s *LimitClauseValueContext) GetRuleContext() antlr.RuleContext

func (*LimitClauseValueContext) IntegerLiteral added in v0.5.0 

func (s *LimitClauseValueContext) IntegerLiteral() antlr.TerminalNode

func (*LimitClauseValueContext) IsLimitClauseValueContext added in v0.5.0 

func (*LimitClauseValueContext) IsLimitClauseValueContext()

func (*LimitClauseValueContext) Param added in v0.5.0 

func (s *LimitClauseValueContext) Param() IParamContext

func (*LimitClauseValueContext) ToStringTree added in v0.5.0 

func (s *LimitClauseValueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type LogicalAndOperatorContext added in v0.6.0 

type LogicalAndOperatorContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyLogicalAndOperatorContext added in v0.6.0 

func NewEmptyLogicalAndOperatorContext() *LogicalAndOperatorContext

func NewLogicalAndOperatorContext added in v0.6.0 

func NewLogicalAndOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LogicalAndOperatorContext

func (*LogicalAndOperatorContext) Accept added in v0.6.0 

func (s *LogicalAndOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*LogicalAndOperatorContext) And added in v0.6.0 

func (s *LogicalAndOperatorContext) And() antlr.TerminalNode

func (*LogicalAndOperatorContext) EnterRule added in v0.6.0 

func (s *LogicalAndOperatorContext) EnterRule(listener antlr.ParseTreeListener)

func (*LogicalAndOperatorContext) ExitRule added in v0.6.0 

func (s *LogicalAndOperatorContext) ExitRule(listener antlr.ParseTreeListener)

func (*LogicalAndOperatorContext) GetParser added in v0.6.0 

func (s *LogicalAndOperatorContext) GetParser() antlr.Parser

func (*LogicalAndOperatorContext) GetRuleContext added in v0.6.0 

func (s *LogicalAndOperatorContext) GetRuleContext() antlr.RuleContext

func (*LogicalAndOperatorContext) IsLogicalAndOperatorContext added in v0.6.0 

func (*LogicalAndOperatorContext) IsLogicalAndOperatorContext()

func (*LogicalAndOperatorContext) ToStringTree added in v0.6.0 

func (s *LogicalAndOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type LogicalOrOperatorContext added in v0.6.0 

type LogicalOrOperatorContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyLogicalOrOperatorContext added in v0.6.0 

func NewEmptyLogicalOrOperatorContext() *LogicalOrOperatorContext

func NewLogicalOrOperatorContext added in v0.6.0 

func NewLogicalOrOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LogicalOrOperatorContext

func (*LogicalOrOperatorContext) Accept added in v0.6.0 

func (s *LogicalOrOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*LogicalOrOperatorContext) EnterRule added in v0.6.0 

func (s *LogicalOrOperatorContext) EnterRule(listener antlr.ParseTreeListener)

func (*LogicalOrOperatorContext) ExitRule added in v0.6.0 

func (s *LogicalOrOperatorContext) ExitRule(listener antlr.ParseTreeListener)

func (*LogicalOrOperatorContext) GetParser added in v0.6.0 

func (s *LogicalOrOperatorContext) GetParser() antlr.Parser

func (*LogicalOrOperatorContext) GetRuleContext added in v0.6.0 

func (s *LogicalOrOperatorContext) GetRuleContext() antlr.RuleContext

func (*LogicalOrOperatorContext) IsLogicalOrOperatorContext added in v0.6.0 

func (*LogicalOrOperatorContext) IsLogicalOrOperatorContext()

func (*LogicalOrOperatorContext) Or added in v0.6.0 

func (s *LogicalOrOperatorContext) Or() antlr.TerminalNode

func (*LogicalOrOperatorContext) ToStringTree added in v0.6.0 

func (s *LogicalOrOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type MemberContext added in v0.9.0 

type MemberContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyMemberContext added in v0.9.0 

func NewEmptyMemberContext() *MemberContext

func NewMemberContext added in v0.9.0 

func NewMemberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MemberContext

func (*MemberContext) Accept added in v0.9.0 

func (s *MemberContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*MemberContext) EnterRule added in v0.9.0 

func (s *MemberContext) EnterRule(listener antlr.ParseTreeListener)

func (*MemberContext) ExitRule added in v0.9.0 

func (s *MemberContext) ExitRule(listener antlr.ParseTreeListener)

func (*MemberContext) FunctionCallExpression added in v0.9.0 

func (s *MemberContext) FunctionCallExpression() IFunctionCallExpressionContext

func (*MemberContext) GetParser added in v0.9.0 

func (s *MemberContext) GetParser() antlr.Parser

func (*MemberContext) GetRuleContext added in v0.9.0 

func (s *MemberContext) GetRuleContext() antlr.RuleContext

func (*MemberContext) Identifier added in v0.9.0 

func (s *MemberContext) Identifier() antlr.TerminalNode

func (*MemberContext) IsMemberContext added in v0.9.0 

func (*MemberContext) IsMemberContext()

func (*MemberContext) Param added in v0.9.0 

func (s *MemberContext) Param() IParamContext

func (*MemberContext) ToStringTree added in v0.9.0 

func (s *MemberContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type MemberExpressionContext 

type MemberExpressionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyMemberExpressionContext 

func NewEmptyMemberExpressionContext() *MemberExpressionContext

func NewMemberExpressionContext 

func NewMemberExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MemberExpressionContext

func (*MemberExpressionContext) Accept 

func (s *MemberExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*MemberExpressionContext) EnterRule 

func (s *MemberExpressionContext) EnterRule(listener antlr.ParseTreeListener)

func (*MemberExpressionContext) ExitRule 

func (s *MemberExpressionContext) ExitRule(listener antlr.ParseTreeListener)

func (*MemberExpressionContext) GetParser 

func (s *MemberExpressionContext) GetParser() antlr.Parser

func (*MemberExpressionContext) GetRuleContext 

func (s *MemberExpressionContext) GetRuleContext() antlr.RuleContext

func (*MemberExpressionContext) IsMemberExpressionContext 

func (*MemberExpressionContext) IsMemberExpressionContext()

func (*MemberExpressionContext) Member added in v0.9.0 

func (s *MemberExpressionContext) Member() IMemberContext

func (*MemberExpressionContext) MemberPath added in v0.9.0 

func (s *MemberExpressionContext) MemberPath() IMemberPathContext

func (*MemberExpressionContext) ToStringTree 

func (s *MemberExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type MemberPathContext added in v0.9.0 

type MemberPathContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyMemberPathContext added in v0.9.0 

func NewEmptyMemberPathContext() *MemberPathContext

func NewMemberPathContext added in v0.9.0 

func NewMemberPathContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MemberPathContext

func (*MemberPathContext) Accept added in v0.9.0 

func (s *MemberPathContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*MemberPathContext) AllComputedPropertyName added in v0.9.0 

func (s *MemberPathContext) AllComputedPropertyName() []IComputedPropertyNameContext

func (*MemberPathContext) AllDot added in v0.9.0 

func (s *MemberPathContext) AllDot() []antlr.TerminalNode

func (*MemberPathContext) AllPropertyName added in v0.9.0 

func (s *MemberPathContext) AllPropertyName() []IPropertyNameContext

func (*MemberPathContext) ComputedPropertyName added in v0.9.0 

func (s *MemberPathContext) ComputedPropertyName(i int) IComputedPropertyNameContext

func (*MemberPathContext) Dot added in v0.9.0 

func (s *MemberPathContext) Dot(i int) antlr.TerminalNode

func (*MemberPathContext) EnterRule added in v0.9.0 

func (s *MemberPathContext) EnterRule(listener antlr.ParseTreeListener)

func (*MemberPathContext) ExitRule added in v0.9.0 

func (s *MemberPathContext) ExitRule(listener antlr.ParseTreeListener)

func (*MemberPathContext) GetParser added in v0.9.0 

func (s *MemberPathContext) GetParser() antlr.Parser

func (*MemberPathContext) GetRuleContext added in v0.9.0 

func (s *MemberPathContext) GetRuleContext() antlr.RuleContext

func (*MemberPathContext) IsMemberPathContext added in v0.9.0 

func (*MemberPathContext) IsMemberPathContext()

func (*MemberPathContext) PropertyName added in v0.9.0 

func (s *MemberPathContext) PropertyName(i int) IPropertyNameContext

func (*MemberPathContext) ToStringTree added in v0.9.0 

func (s *MemberPathContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type MultiplicativeOperatorContext added in v0.6.0 

type MultiplicativeOperatorContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyMultiplicativeOperatorContext added in v0.6.0 

func NewEmptyMultiplicativeOperatorContext() *MultiplicativeOperatorContext

func NewMultiplicativeOperatorContext added in v0.6.0 

func NewMultiplicativeOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MultiplicativeOperatorContext

func (*MultiplicativeOperatorContext) Accept added in v0.6.0 

func (s *MultiplicativeOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*MultiplicativeOperatorContext) Div added in v0.6.0 

func (s *MultiplicativeOperatorContext) Div() antlr.TerminalNode

func (*MultiplicativeOperatorContext) EnterRule added in v0.6.0 

func (s *MultiplicativeOperatorContext) EnterRule(listener antlr.ParseTreeListener)

func (*MultiplicativeOperatorContext) ExitRule added in v0.6.0 

func (s *MultiplicativeOperatorContext) ExitRule(listener antlr.ParseTreeListener)

func (*MultiplicativeOperatorContext) GetParser added in v0.6.0 

func (s *MultiplicativeOperatorContext) GetParser() antlr.Parser

func (*MultiplicativeOperatorContext) GetRuleContext added in v0.6.0 

func (s *MultiplicativeOperatorContext) GetRuleContext() antlr.RuleContext

func (*MultiplicativeOperatorContext) IsMultiplicativeOperatorContext added in v0.6.0 

func (*MultiplicativeOperatorContext) IsMultiplicativeOperatorContext()

func (*MultiplicativeOperatorContext) Mod added in v0.6.0 

func (s *MultiplicativeOperatorContext) Mod() antlr.TerminalNode

func (*MultiplicativeOperatorContext) Multi added in v0.6.0 

func (s *MultiplicativeOperatorContext) Multi() antlr.TerminalNode

func (*MultiplicativeOperatorContext) ToStringTree added in v0.6.0 

func (s *MultiplicativeOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type NamespaceContext added in v0.8.0 

type NamespaceContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyNamespaceContext added in v0.8.0 

func NewEmptyNamespaceContext() *NamespaceContext

func NewNamespaceContext added in v0.8.0 

func NewNamespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NamespaceContext

func (*NamespaceContext) Accept added in v0.8.0 

func (s *NamespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*NamespaceContext) AllNamespaceSegment added in v0.8.0 

func (s *NamespaceContext) AllNamespaceSegment() []antlr.TerminalNode

func (*NamespaceContext) EnterRule added in v0.8.0 

func (s *NamespaceContext) EnterRule(listener antlr.ParseTreeListener)

func (*NamespaceContext) ExitRule added in v0.8.0 

func (s *NamespaceContext) ExitRule(listener antlr.ParseTreeListener)

func (*NamespaceContext) GetParser added in v0.8.0 

func (s *NamespaceContext) GetParser() antlr.Parser

func (*NamespaceContext) GetRuleContext added in v0.8.0 

func (s *NamespaceContext) GetRuleContext() antlr.RuleContext

func (*NamespaceContext) IsNamespaceContext added in v0.8.0 

func (*NamespaceContext) IsNamespaceContext()

func (*NamespaceContext) NamespaceSegment added in v0.8.0 

func (s *NamespaceContext) NamespaceSegment(i int) antlr.TerminalNode

func (*NamespaceContext) ToStringTree added in v0.8.0 

func (s *NamespaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type NamespaceIdentifierContext added in v0.11.0 

type NamespaceIdentifierContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyNamespaceIdentifierContext added in v0.11.0 

func NewEmptyNamespaceIdentifierContext() *NamespaceIdentifierContext

func NewNamespaceIdentifierContext added in v0.11.0 

func NewNamespaceIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NamespaceIdentifierContext

func (*NamespaceIdentifierContext) Accept added in v0.11.0 

func (s *NamespaceIdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*NamespaceIdentifierContext) EnterRule added in v0.11.0 

func (s *NamespaceIdentifierContext) EnterRule(listener antlr.ParseTreeListener)

func (*NamespaceIdentifierContext) ExitRule added in v0.11.0 

func (s *NamespaceIdentifierContext) ExitRule(listener antlr.ParseTreeListener)

func (*NamespaceIdentifierContext) GetParser added in v0.11.0 

func (s *NamespaceIdentifierContext) GetParser() antlr.Parser

func (*NamespaceIdentifierContext) GetRuleContext added in v0.11.0 

func (s *NamespaceIdentifierContext) GetRuleContext() antlr.RuleContext

func (*NamespaceIdentifierContext) Identifier added in v0.11.0 

func (s *NamespaceIdentifierContext) Identifier() antlr.TerminalNode

func (*NamespaceIdentifierContext) IsNamespaceIdentifierContext added in v0.11.0 

func (*NamespaceIdentifierContext) IsNamespaceIdentifierContext()

func (*NamespaceIdentifierContext) Namespace added in v0.11.0 

func (s *NamespaceIdentifierContext) Namespace() INamespaceContext

func (*NamespaceIdentifierContext) ToStringTree added in v0.11.0 

func (s *NamespaceIdentifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type NoneLiteralContext 

type NoneLiteralContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyNoneLiteralContext 

func NewEmptyNoneLiteralContext() *NoneLiteralContext

func NewNoneLiteralContext 

func NewNoneLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NoneLiteralContext

func (*NoneLiteralContext) Accept 

func (s *NoneLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*NoneLiteralContext) EnterRule 

func (s *NoneLiteralContext) EnterRule(listener antlr.ParseTreeListener)

func (*NoneLiteralContext) ExitRule 

func (s *NoneLiteralContext) ExitRule(listener antlr.ParseTreeListener)

func (*NoneLiteralContext) GetParser 

func (s *NoneLiteralContext) GetParser() antlr.Parser

func (*NoneLiteralContext) GetRuleContext 

func (s *NoneLiteralContext) GetRuleContext() antlr.RuleContext

func (*NoneLiteralContext) IsNoneLiteralContext 

func (*NoneLiteralContext) IsNoneLiteralContext()

func (*NoneLiteralContext) None 

func (s *NoneLiteralContext) None() antlr.TerminalNode

func (*NoneLiteralContext) Null 

func (s *NoneLiteralContext) Null() antlr.TerminalNode

func (*NoneLiteralContext) ToStringTree 

func (s *NoneLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ObjectLiteralContext 

type ObjectLiteralContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyObjectLiteralContext 

func NewEmptyObjectLiteralContext() *ObjectLiteralContext

func NewObjectLiteralContext 

func NewObjectLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ObjectLiteralContext

func (*ObjectLiteralContext) Accept 

func (s *ObjectLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ObjectLiteralContext) AllComma 

func (s *ObjectLiteralContext) AllComma() []antlr.TerminalNode

func (*ObjectLiteralContext) AllPropertyAssignment 

func (s *ObjectLiteralContext) AllPropertyAssignment() []IPropertyAssignmentContext

func (*ObjectLiteralContext) CloseBrace 

func (s *ObjectLiteralContext) CloseBrace() antlr.TerminalNode

func (*ObjectLiteralContext) Comma 

func (s *ObjectLiteralContext) Comma(i int) antlr.TerminalNode

func (*ObjectLiteralContext) EnterRule 

func (s *ObjectLiteralContext) EnterRule(listener antlr.ParseTreeListener)

func (*ObjectLiteralContext) ExitRule 

func (s *ObjectLiteralContext) ExitRule(listener antlr.ParseTreeListener)

func (*ObjectLiteralContext) GetParser 

func (s *ObjectLiteralContext) GetParser() antlr.Parser

func (*ObjectLiteralContext) GetRuleContext 

func (s *ObjectLiteralContext) GetRuleContext() antlr.RuleContext

func (*ObjectLiteralContext) IsObjectLiteralContext 

func (*ObjectLiteralContext) IsObjectLiteralContext()

func (*ObjectLiteralContext) OpenBrace 

func (s *ObjectLiteralContext) OpenBrace() antlr.TerminalNode

func (*ObjectLiteralContext) PropertyAssignment 

func (s *ObjectLiteralContext) PropertyAssignment(i int) IPropertyAssignmentContext

func (*ObjectLiteralContext) ToStringTree 

func (s *ObjectLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ParamContext 

type ParamContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyParamContext 

func NewEmptyParamContext() *ParamContext

func NewParamContext 

func NewParamContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParamContext

func (*ParamContext) Accept 

func (s *ParamContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ParamContext) EnterRule 

func (s *ParamContext) EnterRule(listener antlr.ParseTreeListener)

func (*ParamContext) ExitRule 

func (s *ParamContext) ExitRule(listener antlr.ParseTreeListener)

func (*ParamContext) GetParser 

func (s *ParamContext) GetParser() antlr.Parser

func (*ParamContext) GetRuleContext 

func (s *ParamContext) GetRuleContext() antlr.RuleContext

func (*ParamContext) Identifier 

func (s *ParamContext) Identifier() antlr.TerminalNode

func (*ParamContext) IsParamContext 

func (*ParamContext) IsParamContext()

func (*ParamContext) Param 

func (s *ParamContext) Param() antlr.TerminalNode

func (*ParamContext) ToStringTree 

func (s *ParamContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ProgramContext 

type ProgramContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyProgramContext 

func NewEmptyProgramContext() *ProgramContext

func NewProgramContext 

func NewProgramContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ProgramContext

func (*ProgramContext) Accept 

func (s *ProgramContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ProgramContext) AllHead added in v0.11.0 

func (s *ProgramContext) AllHead() []IHeadContext

func (*ProgramContext) Body 

func (s *ProgramContext) Body() IBodyContext

func (*ProgramContext) EnterRule 

func (s *ProgramContext) EnterRule(listener antlr.ParseTreeListener)

func (*ProgramContext) ExitRule 

func (s *ProgramContext) ExitRule(listener antlr.ParseTreeListener)

func (*ProgramContext) GetParser 

func (s *ProgramContext) GetParser() antlr.Parser

func (*ProgramContext) GetRuleContext 

func (s *ProgramContext) GetRuleContext() antlr.RuleContext

func (*ProgramContext) Head added in v0.11.0 

func (s *ProgramContext) Head(i int) IHeadContext

func (*ProgramContext) IsProgramContext 

func (*ProgramContext) IsProgramContext()

func (*ProgramContext) ToStringTree 

func (s *ProgramContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type PropertyAssignmentContext 

type PropertyAssignmentContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyPropertyAssignmentContext 

func NewEmptyPropertyAssignmentContext() *PropertyAssignmentContext

func NewPropertyAssignmentContext 

func NewPropertyAssignmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertyAssignmentContext

func (*PropertyAssignmentContext) Accept 

func (s *PropertyAssignmentContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*PropertyAssignmentContext) Colon 

func (s *PropertyAssignmentContext) Colon() antlr.TerminalNode

func (*PropertyAssignmentContext) ComputedPropertyName 

func (s *PropertyAssignmentContext) ComputedPropertyName() IComputedPropertyNameContext

func (*PropertyAssignmentContext) EnterRule 

func (s *PropertyAssignmentContext) EnterRule(listener antlr.ParseTreeListener)

func (*PropertyAssignmentContext) ExitRule 

func (s *PropertyAssignmentContext) ExitRule(listener antlr.ParseTreeListener)

func (*PropertyAssignmentContext) Expression 

func (s *PropertyAssignmentContext) Expression() IExpressionContext

func (*PropertyAssignmentContext) GetParser 

func (s *PropertyAssignmentContext) GetParser() antlr.Parser

func (*PropertyAssignmentContext) GetRuleContext 

func (s *PropertyAssignmentContext) GetRuleContext() antlr.RuleContext

func (*PropertyAssignmentContext) IsPropertyAssignmentContext 

func (*PropertyAssignmentContext) IsPropertyAssignmentContext()

func (*PropertyAssignmentContext) PropertyName 

func (s *PropertyAssignmentContext) PropertyName() IPropertyNameContext

func (*PropertyAssignmentContext) ShorthandPropertyName 

func (s *PropertyAssignmentContext) ShorthandPropertyName() IShorthandPropertyNameContext

func (*PropertyAssignmentContext) ToStringTree 

func (s *PropertyAssignmentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type PropertyNameContext 

type PropertyNameContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyPropertyNameContext 

func NewEmptyPropertyNameContext() *PropertyNameContext

func NewPropertyNameContext 

func NewPropertyNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PropertyNameContext

func (*PropertyNameContext) Accept 

func (s *PropertyNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*PropertyNameContext) EnterRule 

func (s *PropertyNameContext) EnterRule(listener antlr.ParseTreeListener)

func (*PropertyNameContext) ExitRule 

func (s *PropertyNameContext) ExitRule(listener antlr.ParseTreeListener)

func (*PropertyNameContext) GetParser 

func (s *PropertyNameContext) GetParser() antlr.Parser

func (*PropertyNameContext) GetRuleContext 

func (s *PropertyNameContext) GetRuleContext() antlr.RuleContext

func (*PropertyNameContext) Identifier 

func (s *PropertyNameContext) Identifier() antlr.TerminalNode

func (*PropertyNameContext) IsPropertyNameContext 

func (*PropertyNameContext) IsPropertyNameContext()

func (*PropertyNameContext) Param added in v0.9.0 

func (s *PropertyNameContext) Param() IParamContext

func (*PropertyNameContext) StringLiteral added in v0.4.0 

func (s *PropertyNameContext) StringLiteral() IStringLiteralContext

func (*PropertyNameContext) ToStringTree 

func (s *PropertyNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type RangeOperatorContext 

type RangeOperatorContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyRangeOperatorContext 

func NewEmptyRangeOperatorContext() *RangeOperatorContext

func NewRangeOperatorContext 

func NewRangeOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RangeOperatorContext

func (*RangeOperatorContext) Accept 

func (s *RangeOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*RangeOperatorContext) AllIntegerLiteral 

func (s *RangeOperatorContext) AllIntegerLiteral() []IIntegerLiteralContext

func (*RangeOperatorContext) AllParam 

func (s *RangeOperatorContext) AllParam() []IParamContext

func (*RangeOperatorContext) AllVariable 

func (s *RangeOperatorContext) AllVariable() []IVariableContext

func (*RangeOperatorContext) EnterRule 

func (s *RangeOperatorContext) EnterRule(listener antlr.ParseTreeListener)

func (*RangeOperatorContext) ExitRule 

func (s *RangeOperatorContext) ExitRule(listener antlr.ParseTreeListener)

func (*RangeOperatorContext) GetParser 

func (s *RangeOperatorContext) GetParser() antlr.Parser

func (*RangeOperatorContext) GetRuleContext 

func (s *RangeOperatorContext) GetRuleContext() antlr.RuleContext

func (*RangeOperatorContext) IntegerLiteral 

func (s *RangeOperatorContext) IntegerLiteral(i int) IIntegerLiteralContext

func (*RangeOperatorContext) IsRangeOperatorContext 

func (*RangeOperatorContext) IsRangeOperatorContext()

func (*RangeOperatorContext) Param 

func (s *RangeOperatorContext) Param(i int) IParamContext

func (*RangeOperatorContext) Range 

func (s *RangeOperatorContext) Range() antlr.TerminalNode

func (*RangeOperatorContext) ToStringTree 

func (s *RangeOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*RangeOperatorContext) Variable 

func (s *RangeOperatorContext) Variable(i int) IVariableContext

type RegexpOperatorContext added in v0.8.0 

type RegexpOperatorContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyRegexpOperatorContext added in v0.8.0 

func NewEmptyRegexpOperatorContext() *RegexpOperatorContext

func NewRegexpOperatorContext added in v0.8.0 

func NewRegexpOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RegexpOperatorContext

func (*RegexpOperatorContext) Accept added in v0.8.0 

func (s *RegexpOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*RegexpOperatorContext) EnterRule added in v0.8.0 

func (s *RegexpOperatorContext) EnterRule(listener antlr.ParseTreeListener)

func (*RegexpOperatorContext) ExitRule added in v0.8.0 

func (s *RegexpOperatorContext) ExitRule(listener antlr.ParseTreeListener)

func (*RegexpOperatorContext) GetParser added in v0.8.0 

func (s *RegexpOperatorContext) GetParser() antlr.Parser

func (*RegexpOperatorContext) GetRuleContext added in v0.8.0 

func (s *RegexpOperatorContext) GetRuleContext() antlr.RuleContext

func (*RegexpOperatorContext) IsRegexpOperatorContext added in v0.8.0 

func (*RegexpOperatorContext) IsRegexpOperatorContext()

func (*RegexpOperatorContext) RegexMatch added in v0.8.0 

func (s *RegexpOperatorContext) RegexMatch() antlr.TerminalNode

func (*RegexpOperatorContext) RegexNotMatch added in v0.8.0 

func (s *RegexpOperatorContext) RegexNotMatch() antlr.TerminalNode

func (*RegexpOperatorContext) ToStringTree added in v0.8.0 

func (s *RegexpOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ReturnExpressionContext 

type ReturnExpressionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyReturnExpressionContext 

func NewEmptyReturnExpressionContext() *ReturnExpressionContext

func NewReturnExpressionContext 

func NewReturnExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ReturnExpressionContext

func (*ReturnExpressionContext) Accept 

func (s *ReturnExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ReturnExpressionContext) CloseParen 

func (s *ReturnExpressionContext) CloseParen() antlr.TerminalNode

func (*ReturnExpressionContext) Distinct 

func (s *ReturnExpressionContext) Distinct() antlr.TerminalNode

func (*ReturnExpressionContext) EnterRule 

func (s *ReturnExpressionContext) EnterRule(listener antlr.ParseTreeListener)

func (*ReturnExpressionContext) ExitRule 

func (s *ReturnExpressionContext) ExitRule(listener antlr.ParseTreeListener)

func (*ReturnExpressionContext) Expression 

func (s *ReturnExpressionContext) Expression() IExpressionContext

func (*ReturnExpressionContext) ForExpression 

func (s *ReturnExpressionContext) ForExpression() IForExpressionContext

func (*ReturnExpressionContext) ForTernaryExpression 

func (s *ReturnExpressionContext) ForTernaryExpression() IForTernaryExpressionContext

func (*ReturnExpressionContext) GetParser 

func (s *ReturnExpressionContext) GetParser() antlr.Parser

func (*ReturnExpressionContext) GetRuleContext 

func (s *ReturnExpressionContext) GetRuleContext() antlr.RuleContext

func (*ReturnExpressionContext) IsReturnExpressionContext 

func (*ReturnExpressionContext) IsReturnExpressionContext()

func (*ReturnExpressionContext) OpenParen 

func (s *ReturnExpressionContext) OpenParen() antlr.TerminalNode

func (*ReturnExpressionContext) Return 

func (s *ReturnExpressionContext) Return() antlr.TerminalNode

func (*ReturnExpressionContext) ToStringTree 

func (s *ReturnExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ShorthandPropertyNameContext 

type ShorthandPropertyNameContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyShorthandPropertyNameContext 

func NewEmptyShorthandPropertyNameContext() *ShorthandPropertyNameContext

func NewShorthandPropertyNameContext 

func NewShorthandPropertyNameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ShorthandPropertyNameContext

func (*ShorthandPropertyNameContext) Accept 

func (s *ShorthandPropertyNameContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*ShorthandPropertyNameContext) EnterRule 

func (s *ShorthandPropertyNameContext) EnterRule(listener antlr.ParseTreeListener)

func (*ShorthandPropertyNameContext) ExitRule 

func (s *ShorthandPropertyNameContext) ExitRule(listener antlr.ParseTreeListener)

func (*ShorthandPropertyNameContext) GetParser 

func (s *ShorthandPropertyNameContext) GetParser() antlr.Parser

func (*ShorthandPropertyNameContext) GetRuleContext 

func (s *ShorthandPropertyNameContext) GetRuleContext() antlr.RuleContext

func (*ShorthandPropertyNameContext) IsShorthandPropertyNameContext 

func (*ShorthandPropertyNameContext) IsShorthandPropertyNameContext()

func (*ShorthandPropertyNameContext) ToStringTree 

func (s *ShorthandPropertyNameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*ShorthandPropertyNameContext) Variable 

func (s *ShorthandPropertyNameContext) Variable() IVariableContext

type SortClauseContext 

type SortClauseContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySortClauseContext 

func NewEmptySortClauseContext() *SortClauseContext

func NewSortClauseContext 

func NewSortClauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SortClauseContext

func (*SortClauseContext) Accept 

func (s *SortClauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SortClauseContext) AllComma 

func (s *SortClauseContext) AllComma() []antlr.TerminalNode

func (*SortClauseContext) AllSortClauseExpression 

func (s *SortClauseContext) AllSortClauseExpression() []ISortClauseExpressionContext

func (*SortClauseContext) Comma 

func (s *SortClauseContext) Comma(i int) antlr.TerminalNode

func (*SortClauseContext) EnterRule 

func (s *SortClauseContext) EnterRule(listener antlr.ParseTreeListener)

func (*SortClauseContext) ExitRule 

func (s *SortClauseContext) ExitRule(listener antlr.ParseTreeListener)

func (*SortClauseContext) GetParser 

func (s *SortClauseContext) GetParser() antlr.Parser

func (*SortClauseContext) GetRuleContext 

func (s *SortClauseContext) GetRuleContext() antlr.RuleContext

func (*SortClauseContext) IsSortClauseContext 

func (*SortClauseContext) IsSortClauseContext()

func (*SortClauseContext) Sort 

func (s *SortClauseContext) Sort() antlr.TerminalNode

func (*SortClauseContext) SortClauseExpression 

func (s *SortClauseContext) SortClauseExpression(i int) ISortClauseExpressionContext

func (*SortClauseContext) ToStringTree 

func (s *SortClauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type SortClauseExpressionContext 

type SortClauseExpressionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptySortClauseExpressionContext 

func NewEmptySortClauseExpressionContext() *SortClauseExpressionContext

func NewSortClauseExpressionContext 

func NewSortClauseExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SortClauseExpressionContext

func (*SortClauseExpressionContext) Accept 

func (s *SortClauseExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*SortClauseExpressionContext) EnterRule 

func (s *SortClauseExpressionContext) EnterRule(listener antlr.ParseTreeListener)

func (*SortClauseExpressionContext) ExitRule 

func (s *SortClauseExpressionContext) ExitRule(listener antlr.ParseTreeListener)

func (*SortClauseExpressionContext) Expression 

func (s *SortClauseExpressionContext) Expression() IExpressionContext

func (*SortClauseExpressionContext) GetParser 

func (s *SortClauseExpressionContext) GetParser() antlr.Parser

func (*SortClauseExpressionContext) GetRuleContext 

func (s *SortClauseExpressionContext) GetRuleContext() antlr.RuleContext

func (*SortClauseExpressionContext) IsSortClauseExpressionContext 

func (*SortClauseExpressionContext) IsSortClauseExpressionContext()

func (*SortClauseExpressionContext) SortDirection 

func (s *SortClauseExpressionContext) SortDirection() antlr.TerminalNode

func (*SortClauseExpressionContext) ToStringTree 

func (s *SortClauseExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type StringLiteralContext 

type StringLiteralContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyStringLiteralContext 

func NewEmptyStringLiteralContext() *StringLiteralContext

func NewStringLiteralContext 

func NewStringLiteralContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StringLiteralContext

func (*StringLiteralContext) Accept 

func (s *StringLiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*StringLiteralContext) EnterRule 

func (s *StringLiteralContext) EnterRule(listener antlr.ParseTreeListener)

func (*StringLiteralContext) ExitRule 

func (s *StringLiteralContext) ExitRule(listener antlr.ParseTreeListener)

func (*StringLiteralContext) GetParser 

func (s *StringLiteralContext) GetParser() antlr.Parser

func (*StringLiteralContext) GetRuleContext 

func (s *StringLiteralContext) GetRuleContext() antlr.RuleContext

func (*StringLiteralContext) IsStringLiteralContext 

func (*StringLiteralContext) IsStringLiteralContext()

func (*StringLiteralContext) StringLiteral 

func (s *StringLiteralContext) StringLiteral() antlr.TerminalNode

func (*StringLiteralContext) ToStringTree 

func (s *StringLiteralContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type UnaryOperatorContext 

type UnaryOperatorContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUnaryOperatorContext 

func NewEmptyUnaryOperatorContext() *UnaryOperatorContext

func NewUnaryOperatorContext 

func NewUnaryOperatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UnaryOperatorContext

func (*UnaryOperatorContext) Accept 

func (s *UnaryOperatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*UnaryOperatorContext) EnterRule 

func (s *UnaryOperatorContext) EnterRule(listener antlr.ParseTreeListener)

func (*UnaryOperatorContext) ExitRule 

func (s *UnaryOperatorContext) ExitRule(listener antlr.ParseTreeListener)

func (*UnaryOperatorContext) GetParser 

func (s *UnaryOperatorContext) GetParser() antlr.Parser

func (*UnaryOperatorContext) GetRuleContext 

func (s *UnaryOperatorContext) GetRuleContext() antlr.RuleContext

func (*UnaryOperatorContext) IsUnaryOperatorContext 

func (*UnaryOperatorContext) IsUnaryOperatorContext()

func (*UnaryOperatorContext) Like 

func (s *UnaryOperatorContext) Like() antlr.TerminalNode

func (*UnaryOperatorContext) Minus 

func (s *UnaryOperatorContext) Minus() antlr.TerminalNode

func (*UnaryOperatorContext) Not 

func (s *UnaryOperatorContext) Not() antlr.TerminalNode

func (*UnaryOperatorContext) Plus 

func (s *UnaryOperatorContext) Plus() antlr.TerminalNode

func (*UnaryOperatorContext) ToStringTree 

func (s *UnaryOperatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type UseContext added in v0.11.0 

type UseContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUseContext added in v0.11.0 

func NewEmptyUseContext() *UseContext

func NewUseContext added in v0.11.0 

func NewUseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UseContext

func (*UseContext) Accept added in v0.11.0 

func (s *UseContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*UseContext) EnterRule added in v0.11.0 

func (s *UseContext) EnterRule(listener antlr.ParseTreeListener)

func (*UseContext) ExitRule added in v0.11.0 

func (s *UseContext) ExitRule(listener antlr.ParseTreeListener)

func (*UseContext) GetParser added in v0.11.0 

func (s *UseContext) GetParser() antlr.Parser

func (*UseContext) GetRuleContext added in v0.11.0 

func (s *UseContext) GetRuleContext() antlr.RuleContext

func (*UseContext) IsUseContext added in v0.11.0 

func (*UseContext) IsUseContext()

func (*UseContext) NamespaceIdentifier added in v0.11.0 

func (s *UseContext) NamespaceIdentifier() INamespaceIdentifierContext

func (*UseContext) ToStringTree added in v0.11.0 

func (s *UseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*UseContext) Use added in v0.11.0 

func (s *UseContext) Use() antlr.TerminalNode

type UseExpressionContext added in v0.11.0 

type UseExpressionContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyUseExpressionContext added in v0.11.0 

func NewEmptyUseExpressionContext() *UseExpressionContext

func NewUseExpressionContext added in v0.11.0 

func NewUseExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *UseExpressionContext

func (*UseExpressionContext) Accept added in v0.11.0 

func (s *UseExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*UseExpressionContext) EnterRule added in v0.11.0 

func (s *UseExpressionContext) EnterRule(listener antlr.ParseTreeListener)

func (*UseExpressionContext) ExitRule added in v0.11.0 

func (s *UseExpressionContext) ExitRule(listener antlr.ParseTreeListener)

func (*UseExpressionContext) GetParser added in v0.11.0 

func (s *UseExpressionContext) GetParser() antlr.Parser

func (*UseExpressionContext) GetRuleContext added in v0.11.0 

func (s *UseExpressionContext) GetRuleContext() antlr.RuleContext

func (*UseExpressionContext) IsUseExpressionContext added in v0.11.0 

func (*UseExpressionContext) IsUseExpressionContext()

func (*UseExpressionContext) ToStringTree added in v0.11.0 

func (s *UseExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

func (*UseExpressionContext) Use added in v0.11.0 

func (s *UseExpressionContext) Use() IUseContext

type VariableContext 

type VariableContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyVariableContext 

func NewEmptyVariableContext() *VariableContext

func NewVariableContext 

func NewVariableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableContext

func (*VariableContext) Accept 

func (s *VariableContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*VariableContext) EnterRule 

func (s *VariableContext) EnterRule(listener antlr.ParseTreeListener)

func (*VariableContext) ExitRule 

func (s *VariableContext) ExitRule(listener antlr.ParseTreeListener)

func (*VariableContext) GetParser 

func (s *VariableContext) GetParser() antlr.Parser

func (*VariableContext) GetRuleContext 

func (s *VariableContext) GetRuleContext() antlr.RuleContext

func (*VariableContext) Identifier 

func (s *VariableContext) Identifier() antlr.TerminalNode

func (*VariableContext) IsVariableContext 

func (*VariableContext) IsVariableContext()

func (*VariableContext) ToStringTree 

func (s *VariableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type VariableDeclarationContext 

type VariableDeclarationContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyVariableDeclarationContext 

func NewEmptyVariableDeclarationContext() *VariableDeclarationContext

func NewVariableDeclarationContext 

func NewVariableDeclarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *VariableDeclarationContext

func (*VariableDeclarationContext) Accept 

func (s *VariableDeclarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{}

func (*VariableDeclarationContext) Assign 

func (s *VariableDeclarationContext) Assign() antlr.TerminalNode

func (*VariableDeclarationContext) CloseParen 

func (s *VariableDeclarationContext) CloseParen() antlr.TerminalNode

func (*VariableDeclarationContext) EnterRule 

func (s *VariableDeclarationContext) EnterRule(listener antlr.ParseTreeListener)

func (*VariableDeclarationContext) ExitRule 

func (s *VariableDeclarationContext) ExitRule(listener antlr.ParseTreeListener)

func (*VariableDeclarationContext) Expression 

func (s *VariableDeclarationContext) Expression() IExpressionContext

func (*VariableDeclarationContext) ForExpression 

func (s *VariableDeclarationContext) ForExpression() IForExpressionContext

func (*VariableDeclarationContext) ForTernaryExpression 

func (s *VariableDeclarationContext) ForTernaryExpression() IForTernaryExpressionContext

func (*VariableDeclarationContext) GetParser 

func (s *VariableDeclarationContext) GetParser() antlr.Parser

func (*VariableDeclarationContext) GetRuleContext 

func (s *VariableDeclarationContext) GetRuleContext() antlr.RuleContext

func (*VariableDeclarationContext) Identifier 

func (s *VariableDeclarationContext) Identifier() antlr.TerminalNode

func (*VariableDeclarationContext) IsVariableDeclarationContext 

func (*VariableDeclarationContext) IsVariableDeclarationContext()

func (*VariableDeclarationContext) Let 

func (s *VariableDeclarationContext) Let() antlr.TerminalNode

func (*VariableDeclarationContext) OpenParen 

func (s *VariableDeclarationContext) OpenParen() antlr.TerminalNode

func (*VariableDeclarationContext) ToStringTree 

func (s *VariableDeclarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.