LogicBaseVisitor (Arden Parser 1.1 API)

java.lang.Object
- org.antlr.v4.runtime.tree.AbstractParseTreeVisitor<T>
- - edu.uvm.ccts.arden.logic.antlr.LogicBaseVisitor<T>

Type Parameters:
T - The return type of the visit operation. Use Void for operations with no return type.

All Implemented Interfaces:

LogicVisitor<T>, org.antlr.v4.runtime.tree.ParseTreeVisitor<T>
```
public class LogicBaseVisitor<T>
extends org.antlr.v4.runtime.tree.AbstractParseTreeVisitor<T>
implements LogicVisitor<T>
```
This class provides an empty implementation of LogicVisitor, which can be extended to create a visitor which only needs to handle a subset of the available methods.

Constructor Summary

Constructors
Constructor and Description

LogicBaseVisitor()

Constructors
Constructor and Description
`LogicBaseVisitor()`

Method Summary

Methods
Modifier and Type	Method and Description
`T`	`visitAbs(LogicParser.AbsContext ctx)` Visit a parse tree produced by `LogicParser#abs`.
`T`	`visitAdd(LogicParser.AddContext ctx)` Visit a parse tree produced by `LogicParser#add`.
`T`	`visitAddToList(LogicParser.AddToListContext ctx)` Visit a parse tree produced by `LogicParser#addToList`.
`T`	`visitAfter(LogicParser.AfterContext ctx)` Visit a parse tree produced by `LogicParser#after`.
`T`	`visitAgo(LogicParser.AgoContext ctx)` Visit a parse tree produced by `LogicParser#ago`.
`T`	`visitAll(LogicParser.AllContext ctx)` Visit a parse tree produced by `LogicParser#all`.
`T`	`visitAnd(LogicParser.AndContext ctx)` Visit a parse tree produced by `LogicParser#and`.
`T`	`visitAny(LogicParser.AnyContext ctx)` Visit a parse tree produced by `LogicParser#any`.
`T`	`visitArccos(LogicParser.ArccosContext ctx)` Visit a parse tree produced by `LogicParser#arccos`.
`T`	`visitArcsin(LogicParser.ArcsinContext ctx)` Visit a parse tree produced by `LogicParser#arcsin`.
`T`	`visitArctan(LogicParser.ArctanContext ctx)` Visit a parse tree produced by `LogicParser#arctan`.
`T`	`visitAsNumber(LogicParser.AsNumberContext ctx)` Visit a parse tree produced by `LogicParser#asNumber`.
`T`	`visitAssignable(LogicParser.AssignableContext ctx)` Visit a parse tree produced by `LogicParser.assignable()`.
`T`	`visitAssignment(LogicParser.AssignmentContext ctx)` Visit a parse tree produced by `LogicParser#assignment`.
`T`	`visitAsString(LogicParser.AsStringContext ctx)` Visit a parse tree produced by `LogicParser#asString`.
`T`	`visitAsTime(LogicParser.AsTimeContext ctx)` Visit a parse tree produced by `LogicParser#asTime`.
`T`	`visitAtMostOrLeast(LogicParser.AtMostOrLeastContext ctx)` Visit a parse tree produced by `LogicParser#atMostOrLeast`.
`T`	`visitAtTime(LogicParser.AtTimeContext ctx)` Visit a parse tree produced by `LogicParser#atTime`.
`T`	`visitAttributeFrom(LogicParser.AttributeFromContext ctx)` Visit a parse tree produced by `LogicParser#attributeFrom`.
`T`	`visitAverage(LogicParser.AverageContext ctx)` Visit a parse tree produced by `LogicParser#average`.
`T`	`visitBefore(LogicParser.BeforeContext ctx)` Visit a parse tree produced by `LogicParser#before`.
`T`	`visitBinaryList(LogicParser.BinaryListContext ctx)` Visit a parse tree produced by `LogicParser#binaryList`.
`T`	`visitBlock(LogicParser.BlockContext ctx)` Visit a parse tree produced by `LogicParser.block()`.
`T`	`visitBooleanVal(LogicParser.BooleanValContext ctx)` Visit a parse tree produced by `LogicParser#booleanVal`.
`T`	`visitBreakLoop(LogicParser.BreakLoopContext ctx)` Visit a parse tree produced by `LogicParser.breakLoop()`.
`T`	`visitBuildString(LogicParser.BuildStringContext ctx)` Visit a parse tree produced by `LogicParser#buildString`.
`T`	`visitCall(LogicParser.CallContext ctx)` Visit a parse tree produced by `LogicParser.call()`.
`T`	`visitCeiling(LogicParser.CeilingContext ctx)` Visit a parse tree produced by `LogicParser#ceiling`.
`T`	`visitClone(LogicParser.CloneContext ctx)` Visit a parse tree produced by `Object.clone()`.
`T`	`visitConcat(LogicParser.ConcatContext ctx)` Visit a parse tree produced by `LogicParser#concat`.
`T`	`visitConclude(LogicParser.ConcludeContext ctx)` Visit a parse tree produced by `LogicParser.conclude()`.
`T`	`visitContinueLoop(LogicParser.ContinueLoopContext ctx)` Visit a parse tree produced by `LogicParser.continueLoop()`.
`T`	`visitCosine(LogicParser.CosineContext ctx)` Visit a parse tree produced by `LogicParser#cosine`.
`T`	`visitCount(LogicParser.CountContext ctx)` Visit a parse tree produced by `LogicParser#count`.
`T`	`visitCurrentTime(LogicParser.CurrentTimeContext ctx)` Visit a parse tree produced by `LogicParser#currentTime`.
`T`	`visitDataType(LogicParser.DataTypeContext ctx)` Visit a parse tree produced by `LogicParser.dataType()`.
`T`	`visitDayOfWeek(LogicParser.DayOfWeekContext ctx)` Visit a parse tree produced by `LogicParser#dayOfWeek`.
`T`	`visitDayOfWeekFunc(LogicParser.DayOfWeekFuncContext ctx)` Visit a parse tree produced by `LogicParser#dayOfWeekFunc`.
`T`	`visitDecrease(LogicParser.DecreaseContext ctx)` Visit a parse tree produced by `LogicParser#decrease`.
`T`	`visitDivide(LogicParser.DivideContext ctx)` Visit a parse tree produced by `LogicParser#divide`.
`T`	`visitDot(LogicParser.DotContext ctx)` Visit a parse tree produced by `LogicParser#dot`.
`T`	`visitDuration(LogicParser.DurationContext ctx)` Visit a parse tree produced by `LogicParser#duration`.
`T`	`visitDurationExpr(LogicParser.DurationExprContext ctx)` Visit a parse tree produced by `LogicParser.durationExpr()`.
`T`	`visitDurationUnit(LogicParser.DurationUnitContext ctx)` Visit a parse tree produced by `LogicParser.durationUnit()`.
`T`	`visitEarliest(LogicParser.EarliestContext ctx)` Visit a parse tree produced by `LogicParser#earliest`.
`T`	`visitEarliestFrom(LogicParser.EarliestFromContext ctx)` Visit a parse tree produced by `LogicParser#earliestFrom`.
`T`	`visitElement(LogicParser.ElementContext ctx)` Visit a parse tree produced by `LogicParser#element`.
`T`	`visitEmptyList(LogicParser.EmptyListContext ctx)` Visit a parse tree produced by `LogicParser#emptyList`.
`T`	`visitEnhancedAssignment(LogicParser.EnhancedAssignmentContext ctx)` Visit a parse tree produced by `LogicParser#enhancedAssignment`.
`T`	`visitExist(LogicParser.ExistContext ctx)` Visit a parse tree produced by `LogicParser#exist`.
`T`	`visitExp(LogicParser.ExpContext ctx)` Visit a parse tree produced by `LogicParser#exp`.
`T`	`visitExtract(LogicParser.ExtractContext ctx)` Visit a parse tree produced by `LogicParser#extract`.
`T`	`visitExtractAttrNames(LogicParser.ExtractAttrNamesContext ctx)` Visit a parse tree produced by `LogicParser#extractAttrNames`.
`T`	`visitExtractChars(LogicParser.ExtractCharsContext ctx)` Visit a parse tree produced by `LogicParser#extractChars`.
`T`	`visitFindInString(LogicParser.FindInStringContext ctx)` Visit a parse tree produced by `LogicParser#findInString`.
`T`	`visitFirst(LogicParser.FirstContext ctx)` Visit a parse tree produced by `LogicParser#first`.
`T`	`visitFirstFrom(LogicParser.FirstFromContext ctx)` Visit a parse tree produced by `LogicParser#firstFrom`.
`T`	`visitFloor(LogicParser.FloorContext ctx)` Visit a parse tree produced by `LogicParser#floor`.
`T`	`visitForLoop(LogicParser.ForLoopContext ctx)` Visit a parse tree produced by `LogicParser.forLoop()`.
`T`	`visitId(LogicParser.IdContext ctx)` Visit a parse tree produced by `LogicParser#id`.
`T`	`visitIfStatement(LogicParser.IfStatementContext ctx)` Visit a parse tree produced by `LogicParser.ifStatement()`.
`T`	`visitIncrease(LogicParser.IncreaseContext ctx)` Visit a parse tree produced by `LogicParser#increase`.
`T`	`visitIndex(LogicParser.IndexContext ctx)` Visit a parse tree produced by `LogicParser#index`.
`T`	`visitIndexFrom(LogicParser.IndexFromContext ctx)` Visit a parse tree produced by `LogicParser#indexFrom`.
`T`	`visitIndexOfFrom(LogicParser.IndexOfFromContext ctx)` Visit a parse tree produced by `LogicParser#indexOfFrom`.
`T`	`visitIndexType(LogicParser.IndexTypeContext ctx)` Visit a parse tree produced by `LogicParser.indexType()`.
`T`	`visitInit(LogicParser.InitContext ctx)` Visit a parse tree produced by `LogicParser.init()`.
`T`	`visitInterval(LogicParser.IntervalContext ctx)` Visit a parse tree produced by `LogicParser#interval`.
`T`	`visitIsAfter(LogicParser.IsAfterContext ctx)` Visit a parse tree produced by `LogicParser#isAfter`.
`T`	`visitIsBefore(LogicParser.IsBeforeContext ctx)` Visit a parse tree produced by `LogicParser#isBefore`.
`T`	`visitIsDataType(LogicParser.IsDataTypeContext ctx)` Visit a parse tree produced by `LogicParser#isDataType`.
`T`	`visitIsEqual(LogicParser.IsEqualContext ctx)` Visit a parse tree produced by `LogicParser#isEqual`.
`T`	`visitIsGreaterThan(LogicParser.IsGreaterThanContext ctx)` Visit a parse tree produced by `LogicParser#isGreaterThan`.
`T`	`visitIsGreaterThanOrEqual(LogicParser.IsGreaterThanOrEqualContext ctx)` Visit a parse tree produced by `LogicParser#isGreaterThanOrEqual`.
`T`	`visitIsIn(LogicParser.IsInContext ctx)` Visit a parse tree produced by `LogicParser#isIn`.
`T`	`visitIsLessThan(LogicParser.IsLessThanContext ctx)` Visit a parse tree produced by `LogicParser#isLessThan`.
`T`	`visitIsLessThanOrEqual(LogicParser.IsLessThanOrEqualContext ctx)` Visit a parse tree produced by `LogicParser#isLessThanOrEqual`.
`T`	`visitIsNotEqual(LogicParser.IsNotEqualContext ctx)` Visit a parse tree produced by `LogicParser#isNotEqual`.
`T`	`visitIsObjectType(LogicParser.IsObjectTypeContext ctx)` Visit a parse tree produced by `LogicParser#isObjectType`.
`T`	`visitIsWithinFollowing(LogicParser.IsWithinFollowingContext ctx)` Visit a parse tree produced by `LogicParser#isWithinFollowing`.
`T`	`visitIsWithinPast(LogicParser.IsWithinPastContext ctx)` Visit a parse tree produced by `LogicParser#isWithinPast`.
`T`	`visitIsWithinPreceding(LogicParser.IsWithinPrecedingContext ctx)` Visit a parse tree produced by `LogicParser#isWithinPreceding`.
`T`	`visitIsWithinSameDay(LogicParser.IsWithinSameDayContext ctx)` Visit a parse tree produced by `LogicParser#isWithinSameDay`.
`T`	`visitIsWithinSurrounding(LogicParser.IsWithinSurroundingContext ctx)` Visit a parse tree produced by `LogicParser#isWithinSurrounding`.
`T`	`visitIsWithinTo(LogicParser.IsWithinToContext ctx)` Visit a parse tree produced by `LogicParser#isWithinTo`.
`T`	`visitLast(LogicParser.LastContext ctx)` Visit a parse tree produced by `LogicParser#last`.
`T`	`visitLastFrom(LogicParser.LastFromContext ctx)` Visit a parse tree produced by `LogicParser#lastFrom`.
`T`	`visitLatest(LogicParser.LatestContext ctx)` Visit a parse tree produced by `LogicParser#latest`.
`T`	`visitLatestFrom(LogicParser.LatestFromContext ctx)` Visit a parse tree produced by `LogicParser#latestFrom`.
`T`	`visitLength(LogicParser.LengthContext ctx)` Visit a parse tree produced by `LogicParser#length`.
`T`	`visitLog(LogicParser.LogContext ctx)` Visit a parse tree produced by `LogicParser#log`.
`T`	`visitLog10(LogicParser.Log10Context ctx)` Visit a parse tree produced by `LogicParser#log10`.
`T`	`visitLowercase(LogicParser.LowercaseContext ctx)` Visit a parse tree produced by `LogicParser#lowercase`.
`T`	`visitMatches(LogicParser.MatchesContext ctx)` Visit a parse tree produced by `LogicParser#matches`.
`T`	`visitMaximum(LogicParser.MaximumContext ctx)` Visit a parse tree produced by `LogicParser#maximum`.
`T`	`visitMaximumFrom(LogicParser.MaximumFromContext ctx)` Visit a parse tree produced by `LogicParser#maximumFrom`.
`T`	`visitMedian(LogicParser.MedianContext ctx)` Visit a parse tree produced by `LogicParser#median`.
`T`	`visitMerge(LogicParser.MergeContext ctx)` Visit a parse tree produced by `LogicParser#merge`.
`T`	`visitMinimum(LogicParser.MinimumContext ctx)` Visit a parse tree produced by `LogicParser#minimum`.
`T`	`visitMinimumFrom(LogicParser.MinimumFromContext ctx)` Visit a parse tree produced by `LogicParser#minimumFrom`.
`T`	`visitMultipleAssignment(LogicParser.MultipleAssignmentContext ctx)` Visit a parse tree produced by `LogicParser#multipleAssignment`.
`T`	`visitMultiply(LogicParser.MultiplyContext ctx)` Visit a parse tree produced by `LogicParser#multiply`.
`T`	`visitNearest(LogicParser.NearestContext ctx)` Visit a parse tree produced by `LogicParser#nearest`.
`T`	`visitNewObject(LogicParser.NewObjectContext ctx)` Visit a parse tree produced by `LogicParser#newObject`.
`T`	`visitNo(LogicParser.NoContext ctx)` Visit a parse tree produced by `LogicParser#no`.
`T`	`visitNot(LogicParser.NotContext ctx)` Visit a parse tree produced by `LogicParser#not`.
`T`	`visitNow(LogicParser.NowContext ctx)` Visit a parse tree produced by `LogicParser#now`.
`T`	`visitNullVal(LogicParser.NullValContext ctx)` Visit a parse tree produced by `LogicParser#nullVal`.
`T`	`visitNumberVal(LogicParser.NumberValContext ctx)` Visit a parse tree produced by `LogicParser#numberVal`.
`T`	`visitObjNamedWith(LogicParser.ObjNamedWithContext ctx)` Visit a parse tree produced by `LogicParser.objNamedWith()`.
`T`	`visitObjOrderedWith(LogicParser.ObjOrderedWithContext ctx)` Visit a parse tree produced by `LogicParser.objOrderedWith()`.
`T`	`visitObjOrIndexRule(LogicParser.ObjOrIndexRuleContext ctx)` Visit a parse tree produced by `LogicParser.objOrIndexRule()`.
`T`	`visitOccurAfter(LogicParser.OccurAfterContext ctx)` Visit a parse tree produced by `LogicParser#occurAfter`.
`T`	`visitOccurBefore(LogicParser.OccurBeforeContext ctx)` Visit a parse tree produced by `LogicParser#occurBefore`.
`T`	`visitOccurEqual(LogicParser.OccurEqualContext ctx)` Visit a parse tree produced by `LogicParser#occurEqual`.
`T`	`visitOccurWithinFollowing(LogicParser.OccurWithinFollowingContext ctx)` Visit a parse tree produced by `LogicParser#occurWithinFollowing`.
`T`	`visitOccurWithinPast(LogicParser.OccurWithinPastContext ctx)` Visit a parse tree produced by `LogicParser#occurWithinPast`.
`T`	`visitOccurWithinPreceding(LogicParser.OccurWithinPrecedingContext ctx)` Visit a parse tree produced by `LogicParser#occurWithinPreceding`.
`T`	`visitOccurWithinSameDay(LogicParser.OccurWithinSameDayContext ctx)` Visit a parse tree produced by `LogicParser#occurWithinSameDay`.
`T`	`visitOccurWithinSurrounding(LogicParser.OccurWithinSurroundingContext ctx)` Visit a parse tree produced by `LogicParser#occurWithinSurrounding`.
`T`	`visitOccurWithinTo(LogicParser.OccurWithinToContext ctx)` Visit a parse tree produced by `LogicParser#occurWithinTo`.
`T`	`visitOr(LogicParser.OrContext ctx)` Visit a parse tree produced by `LogicParser#or`.
`T`	`visitParens(LogicParser.ParensContext ctx)` Visit a parse tree produced by `LogicParser#parens`.
`T`	`visitPrint(LogicParser.PrintContext ctx)` Visit a parse tree produced by `LogicParser.print()`.
`T`	`visitRaiseToPower(LogicParser.RaiseToPowerContext ctx)` Visit a parse tree produced by `LogicParser#raiseToPower`.
`T`	`visitRemoveFromList(LogicParser.RemoveFromListContext ctx)` Visit a parse tree produced by `LogicParser#removeFromList`.
`T`	`visitReplace(LogicParser.ReplaceContext ctx)` Visit a parse tree produced by `LogicParser#replace`.
`T`	`visitReverse(LogicParser.ReverseContext ctx)` Visit a parse tree produced by `LogicParser#reverse`.
`T`	`visitRound(LogicParser.RoundContext ctx)` Visit a parse tree produced by `LogicParser#round`.
`T`	`visitSeqto(LogicParser.SeqtoContext ctx)` Visit a parse tree produced by `LogicParser#seqto`.
`T`	`visitSine(LogicParser.SineContext ctx)` Visit a parse tree produced by `LogicParser#sine`.
`T`	`visitSort(LogicParser.SortContext ctx)` Visit a parse tree produced by `LogicParser#sort`.
`T`	`visitSqrt(LogicParser.SqrtContext ctx)` Visit a parse tree produced by `LogicParser#sqrt`.
`T`	`visitStdDev(LogicParser.StdDevContext ctx)` Visit a parse tree produced by `LogicParser#stdDev`.
`T`	`visitStmt(LogicParser.StmtContext ctx)` Visit a parse tree produced by `LogicParser.stmt()`.
`T`	`visitStringVal(LogicParser.StringValContext ctx)` Visit a parse tree produced by `LogicParser#stringVal`.
`T`	`visitSubList(LogicParser.SubListContext ctx)` Visit a parse tree produced by `LogicParser#subList`.
`T`	`visitSubstring(LogicParser.SubstringContext ctx)` Visit a parse tree produced by `LogicParser#substring`.
`T`	`visitSubtract(LogicParser.SubtractContext ctx)` Visit a parse tree produced by `LogicParser#subtract`.
`T`	`visitSum(LogicParser.SumContext ctx)` Visit a parse tree produced by `LogicParser#sum`.
`T`	`visitSwitchStatement(LogicParser.SwitchStatementContext ctx)` Visit a parse tree produced by `LogicParser.switchStatement()`.
`T`	`visitTangent(LogicParser.TangentContext ctx)` Visit a parse tree produced by `LogicParser#tangent`.
`T`	`visitTemporalUnit(LogicParser.TemporalUnitContext ctx)` Visit a parse tree produced by `LogicParser.temporalUnit()`.
`T`	`visitTimeFunc(LogicParser.TimeFuncContext ctx)` Visit a parse tree produced by `LogicParser#timeFunc`.
`T`	`visitTimeOfDayFunc(LogicParser.TimeOfDayFuncContext ctx)` Visit a parse tree produced by `LogicParser#timeOfDayFunc`.
`T`	`visitTimeOfDayVal(LogicParser.TimeOfDayValContext ctx)` Visit a parse tree produced by `LogicParser#timeOfDayVal`.
`T`	`visitTimeVal(LogicParser.TimeValContext ctx)` Visit a parse tree produced by `LogicParser#timeVal`.
`T`	`visitTrim(LogicParser.TrimContext ctx)` Visit a parse tree produced by `LogicParser#trim`.
`T`	`visitTruncate(LogicParser.TruncateContext ctx)` Visit a parse tree produced by `LogicParser#truncate`.
`T`	`visitUnaryList(LogicParser.UnaryListContext ctx)` Visit a parse tree produced by `LogicParser#unaryList`.
`T`	`visitUnaryMinus(LogicParser.UnaryMinusContext ctx)` Visit a parse tree produced by `LogicParser#unaryMinus`.
`T`	`visitUnaryPlus(LogicParser.UnaryPlusContext ctx)` Visit a parse tree produced by `LogicParser#unaryPlus`.
`T`	`visitUppercase(LogicParser.UppercaseContext ctx)` Visit a parse tree produced by `LogicParser#uppercase`.
`T`	`visitVariance(LogicParser.VarianceContext ctx)` Visit a parse tree produced by `LogicParser#variance`.
`T`	`visitWhere(LogicParser.WhereContext ctx)` Visit a parse tree produced by `LogicParser#where`.
`T`	`visitWhereTimeIsPresent(LogicParser.WhereTimeIsPresentContext ctx)` Visit a parse tree produced by `LogicParser#whereTimeIsPresent`.
`T`	`visitWhileLoop(LogicParser.WhileLoopContext ctx)` Visit a parse tree produced by `LogicParser.whileLoop()`.

Methods inherited from class org.antlr.v4.runtime.tree.AbstractParseTreeVisitor
aggregateResult, defaultResult, shouldVisitNextChild, visit, visitChildren, visitErrorNode, visitTerminal

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

Methods inherited from interface org.antlr.v4.runtime.tree.ParseTreeVisitor
visit, visitChildren, visitErrorNode, visitTerminal

- Constructor Detail
  - LogicBaseVisitor
```
public LogicBaseVisitor()
```
- Method Detail
  - visitDurationExpr
```
public T visitDurationExpr(@NotNull
                  LogicParser.DurationExprContext ctx)
```
    Visit a parse tree produced by LogicParser.durationExpr().
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitDurationExpr in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitArccos
```
public T visitArccos(@NotNull
            LogicParser.ArccosContext ctx)
```
    Visit a parse tree produced by LogicParser#arccos.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitArccos in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitNo
```
public T visitNo(@NotNull
        LogicParser.NoContext ctx)
```
    Visit a parse tree produced by LogicParser#no.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitNo in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitAsString
```
public T visitAsString(@NotNull
              LogicParser.AsStringContext ctx)
```
    Visit a parse tree produced by LogicParser#asString.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitAsString in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitFirstFrom
```
public T visitFirstFrom(@NotNull
               LogicParser.FirstFromContext ctx)
```
    Visit a parse tree produced by LogicParser#firstFrom.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitFirstFrom in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitDot
```
public T visitDot(@NotNull
         LogicParser.DotContext ctx)
```
    Visit a parse tree produced by LogicParser#dot.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitDot in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitTemporalUnit
```
public T visitTemporalUnit(@NotNull
                  LogicParser.TemporalUnitContext ctx)
```
    Visit a parse tree produced by LogicParser.temporalUnit().
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitTemporalUnit in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitMinimumFrom
```
public T visitMinimumFrom(@NotNull
                 LogicParser.MinimumFromContext ctx)
```
    Visit a parse tree produced by LogicParser#minimumFrom.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitMinimumFrom in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitIndexType
```
public T visitIndexType(@NotNull
               LogicParser.IndexTypeContext ctx)
```
    Visit a parse tree produced by LogicParser.indexType().
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitIndexType in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitMatches
```
public T visitMatches(@NotNull
             LogicParser.MatchesContext ctx)
```
    Visit a parse tree produced by LogicParser#matches.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitMatches in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitDurationUnit
```
public T visitDurationUnit(@NotNull
                  LogicParser.DurationUnitContext ctx)
```
    Visit a parse tree produced by LogicParser.durationUnit().
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitDurationUnit in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitAbs
```
public T visitAbs(@NotNull
         LogicParser.AbsContext ctx)
```
    Visit a parse tree produced by LogicParser#abs.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitAbs in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitIsIn
```
public T visitIsIn(@NotNull
          LogicParser.IsInContext ctx)
```
    Visit a parse tree produced by LogicParser#isIn.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitIsIn in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitIndexOfFrom
```
public T visitIndexOfFrom(@NotNull
                 LogicParser.IndexOfFromContext ctx)
```
    Visit a parse tree produced by LogicParser#indexOfFrom.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitIndexOfFrom in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitSubstring
```
public T visitSubstring(@NotNull
               LogicParser.SubstringContext ctx)
```
    Visit a parse tree produced by LogicParser#substring.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitSubstring in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitForLoop
```
public T visitForLoop(@NotNull
             LogicParser.ForLoopContext ctx)
```
    Visit a parse tree produced by LogicParser.forLoop().
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitForLoop in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitElement
```
public T visitElement(@NotNull
             LogicParser.ElementContext ctx)
```
    Visit a parse tree produced by LogicParser#element.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitElement in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitClone
```
public T visitClone(@NotNull
           LogicParser.CloneContext ctx)
```
    Visit a parse tree produced by Object.clone().
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitClone in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitOccurEqual
```
public T visitOccurEqual(@NotNull
                LogicParser.OccurEqualContext ctx)
```
    Visit a parse tree produced by LogicParser#occurEqual.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitOccurEqual in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitIsWithinFollowing
```
public T visitIsWithinFollowing(@NotNull
                       LogicParser.IsWithinFollowingContext ctx)
```
    Visit a parse tree produced by LogicParser#isWithinFollowing.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitIsWithinFollowing in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitUnaryMinus
```
public T visitUnaryMinus(@NotNull
                LogicParser.UnaryMinusContext ctx)
```
    Visit a parse tree produced by LogicParser#unaryMinus.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitUnaryMinus in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitOr
```
public T visitOr(@NotNull
        LogicParser.OrContext ctx)
```
    Visit a parse tree produced by LogicParser#or.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitOr in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitUnaryList
```
public T visitUnaryList(@NotNull
               LogicParser.UnaryListContext ctx)
```
    Visit a parse tree produced by LogicParser#unaryList.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitUnaryList in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitParens
```
public T visitParens(@NotNull
            LogicParser.ParensContext ctx)
```
    Visit a parse tree produced by LogicParser#parens.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitParens in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitLog
```
public T visitLog(@NotNull
         LogicParser.LogContext ctx)
```
    Visit a parse tree produced by LogicParser#log.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitLog in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitAtMostOrLeast
```
public T visitAtMostOrLeast(@NotNull
                   LogicParser.AtMostOrLeastContext ctx)
```
    Visit a parse tree produced by LogicParser#atMostOrLeast.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitAtMostOrLeast in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitExtract
```
public T visitExtract(@NotNull
             LogicParser.ExtractContext ctx)
```
    Visit a parse tree produced by LogicParser#extract.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitExtract in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitTimeOfDayVal
```
public T visitTimeOfDayVal(@NotNull
                  LogicParser.TimeOfDayValContext ctx)
```
    Visit a parse tree produced by LogicParser#timeOfDayVal.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitTimeOfDayVal in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitNot
```
public T visitNot(@NotNull
         LogicParser.NotContext ctx)
```
    Visit a parse tree produced by LogicParser#not.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitNot in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitMedian
```
public T visitMedian(@NotNull
            LogicParser.MedianContext ctx)
```
    Visit a parse tree produced by LogicParser#median.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitMedian in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitFloor
```
public T visitFloor(@NotNull
           LogicParser.FloorContext ctx)
```
    Visit a parse tree produced by LogicParser#floor.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitFloor in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitNow
```
public T visitNow(@NotNull
         LogicParser.NowContext ctx)
```
    Visit a parse tree produced by LogicParser#now.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitNow in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitTruncate
```
public T visitTruncate(@NotNull
              LogicParser.TruncateContext ctx)
```
    Visit a parse tree produced by LogicParser#truncate.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitTruncate in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitIsLessThanOrEqual
```
public T visitIsLessThanOrEqual(@NotNull
                       LogicParser.IsLessThanOrEqualContext ctx)
```
    Visit a parse tree produced by LogicParser#isLessThanOrEqual.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitIsLessThanOrEqual in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitNullVal
```
public T visitNullVal(@NotNull
             LogicParser.NullValContext ctx)
```
    Visit a parse tree produced by LogicParser#nullVal.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitNullVal in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitOccurBefore
```
public T visitOccurBefore(@NotNull
                 LogicParser.OccurBeforeContext ctx)
```
    Visit a parse tree produced by LogicParser#occurBefore.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitOccurBefore in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitObjOrIndexRule
```
public T visitObjOrIndexRule(@NotNull
                    LogicParser.ObjOrIndexRuleContext ctx)
```
    Visit a parse tree produced by LogicParser.objOrIndexRule().
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitObjOrIndexRule in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitWhereTimeIsPresent
```
public T visitWhereTimeIsPresent(@NotNull
                        LogicParser.WhereTimeIsPresentContext ctx)
```
    Visit a parse tree produced by LogicParser#whereTimeIsPresent.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitWhereTimeIsPresent in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitSort
```
public T visitSort(@NotNull
          LogicParser.SortContext ctx)
```
    Visit a parse tree produced by LogicParser#sort.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitSort in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitInterval
```
public T visitInterval(@NotNull
              LogicParser.IntervalContext ctx)
```
    Visit a parse tree produced by LogicParser#interval.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitInterval in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitMinimum
```
public T visitMinimum(@NotNull
             LogicParser.MinimumContext ctx)
```
    Visit a parse tree produced by LogicParser#minimum.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitMinimum in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitBefore
```
public T visitBefore(@NotNull
            LogicParser.BeforeContext ctx)
```
    Visit a parse tree produced by LogicParser#before.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitBefore in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitMerge
```
public T visitMerge(@NotNull
           LogicParser.MergeContext ctx)
```
    Visit a parse tree produced by LogicParser#merge.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitMerge in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitBlock
```
public T visitBlock(@NotNull
           LogicParser.BlockContext ctx)
```
    Visit a parse tree produced by LogicParser.block().
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitBlock in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitIsLessThan
```
public T visitIsLessThan(@NotNull
                LogicParser.IsLessThanContext ctx)
```
    Visit a parse tree produced by LogicParser#isLessThan.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitIsLessThan in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitIsBefore
```
public T visitIsBefore(@NotNull
              LogicParser.IsBeforeContext ctx)
```
    Visit a parse tree produced by LogicParser#isBefore.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitIsBefore in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitUnaryPlus
```
public T visitUnaryPlus(@NotNull
               LogicParser.UnaryPlusContext ctx)
```
    Visit a parse tree produced by LogicParser#unaryPlus.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitUnaryPlus in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitLength
```
public T visitLength(@NotNull
            LogicParser.LengthContext ctx)
```
    Visit a parse tree produced by LogicParser#length.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitLength in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitAddToList
```
public T visitAddToList(@NotNull
               LogicParser.AddToListContext ctx)
```
    Visit a parse tree produced by LogicParser#addToList.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitAddToList in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitAtTime
```
public T visitAtTime(@NotNull
            LogicParser.AtTimeContext ctx)
```
    Visit a parse tree produced by LogicParser#atTime.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitAtTime in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitOccurWithinFollowing
```
public T visitOccurWithinFollowing(@NotNull
                          LogicParser.OccurWithinFollowingContext ctx)
```
    Visit a parse tree produced by LogicParser#occurWithinFollowing.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitOccurWithinFollowing in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitEarliestFrom
```
public T visitEarliestFrom(@NotNull
                  LogicParser.EarliestFromContext ctx)
```
    Visit a parse tree produced by LogicParser#earliestFrom.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitEarliestFrom in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitOccurWithinPreceding
```
public T visitOccurWithinPreceding(@NotNull
                          LogicParser.OccurWithinPrecedingContext ctx)
```
    Visit a parse tree produced by LogicParser#occurWithinPreceding.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitOccurWithinPreceding in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitMultipleAssignment
```
public T visitMultipleAssignment(@NotNull
                        LogicParser.MultipleAssignmentContext ctx)
```
    Visit a parse tree produced by LogicParser#multipleAssignment.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitMultipleAssignment in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitReverse
```
public T visitReverse(@NotNull
             LogicParser.ReverseContext ctx)
```
    Visit a parse tree produced by LogicParser#reverse.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitReverse in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitIsDataType
```
public T visitIsDataType(@NotNull
                LogicParser.IsDataTypeContext ctx)
```
    Visit a parse tree produced by LogicParser#isDataType.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitIsDataType in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitArctan
```
public T visitArctan(@NotNull
            LogicParser.ArctanContext ctx)
```
    Visit a parse tree produced by LogicParser#arctan.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitArctan in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitSqrt
```
public T visitSqrt(@NotNull
          LogicParser.SqrtContext ctx)
```
    Visit a parse tree produced by LogicParser#sqrt.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitSqrt in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitOccurWithinPast
```
public T visitOccurWithinPast(@NotNull
                     LogicParser.OccurWithinPastContext ctx)
```
    Visit a parse tree produced by LogicParser#occurWithinPast.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitOccurWithinPast in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitAsNumber
```
public T visitAsNumber(@NotNull
              LogicParser.AsNumberContext ctx)
```
    Visit a parse tree produced by LogicParser#asNumber.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitAsNumber in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitDivide
```
public T visitDivide(@NotNull
            LogicParser.DivideContext ctx)
```
    Visit a parse tree produced by LogicParser#divide.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitDivide in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitStringVal
```
public T visitStringVal(@NotNull
               LogicParser.StringValContext ctx)
```
    Visit a parse tree produced by LogicParser#stringVal.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitStringVal in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitReplace
```
public T visitReplace(@NotNull
             LogicParser.ReplaceContext ctx)
```
    Visit a parse tree produced by LogicParser#replace.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitReplace in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitArcsin
```
public T visitArcsin(@NotNull
            LogicParser.ArcsinContext ctx)
```
    Visit a parse tree produced by LogicParser#arcsin.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitArcsin in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitIsWithinTo
```
public T visitIsWithinTo(@NotNull
                LogicParser.IsWithinToContext ctx)
```
    Visit a parse tree produced by LogicParser#isWithinTo.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitIsWithinTo in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitAssignment
```
public T visitAssignment(@NotNull
                LogicParser.AssignmentContext ctx)
```
    Visit a parse tree produced by LogicParser#assignment.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitAssignment in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitSwitchStatement
```
public T visitSwitchStatement(@NotNull
                     LogicParser.SwitchStatementContext ctx)
```
    Visit a parse tree produced by LogicParser.switchStatement().
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitSwitchStatement in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitMaximumFrom
```
public T visitMaximumFrom(@NotNull
                 LogicParser.MaximumFromContext ctx)
```
    Visit a parse tree produced by LogicParser#maximumFrom.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitMaximumFrom in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitIsWithinSurrounding
```
public T visitIsWithinSurrounding(@NotNull
                         LogicParser.IsWithinSurroundingContext ctx)
```
    Visit a parse tree produced by LogicParser#isWithinSurrounding.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitIsWithinSurrounding in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitIsObjectType
```
public T visitIsObjectType(@NotNull
                  LogicParser.IsObjectTypeContext ctx)
```
    Visit a parse tree produced by LogicParser#isObjectType.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitIsObjectType in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitWhileLoop
```
public T visitWhileLoop(@NotNull
               LogicParser.WhileLoopContext ctx)
```
    Visit a parse tree produced by LogicParser.whileLoop().
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitWhileLoop in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitAgo
```
public T visitAgo(@NotNull
         LogicParser.AgoContext ctx)
```
    Visit a parse tree produced by LogicParser#ago.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitAgo in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitDecrease
```
public T visitDecrease(@NotNull
              LogicParser.DecreaseContext ctx)
```
    Visit a parse tree produced by LogicParser#decrease.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitDecrease in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitStdDev
```
public T visitStdDev(@NotNull
            LogicParser.StdDevContext ctx)
```
    Visit a parse tree produced by LogicParser#stdDev.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitStdDev in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitExtractChars
```
public T visitExtractChars(@NotNull
                  LogicParser.ExtractCharsContext ctx)
```
    Visit a parse tree produced by LogicParser#extractChars.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitExtractChars in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitLast
```
public T visitLast(@NotNull
          LogicParser.LastContext ctx)
```
    Visit a parse tree produced by LogicParser#last.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitLast in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitCount
```
public T visitCount(@NotNull
           LogicParser.CountContext ctx)
```
    Visit a parse tree produced by LogicParser#count.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitCount in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitNumberVal
```
public T visitNumberVal(@NotNull
               LogicParser.NumberValContext ctx)
```
    Visit a parse tree produced by LogicParser#numberVal.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitNumberVal in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitBooleanVal
```
public T visitBooleanVal(@NotNull
                LogicParser.BooleanValContext ctx)
```
    Visit a parse tree produced by LogicParser#booleanVal.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitBooleanVal in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitRound
```
public T visitRound(@NotNull
           LogicParser.RoundContext ctx)
```
    Visit a parse tree produced by LogicParser#round.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitRound in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitWhere
```
public T visitWhere(@NotNull
           LogicParser.WhereContext ctx)
```
    Visit a parse tree produced by LogicParser#where.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitWhere in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitIsWithinPreceding
```
public T visitIsWithinPreceding(@NotNull
                       LogicParser.IsWithinPrecedingContext ctx)
```
    Visit a parse tree produced by LogicParser#isWithinPreceding.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitIsWithinPreceding in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitLastFrom
```
public T visitLastFrom(@NotNull
              LogicParser.LastFromContext ctx)
```
    Visit a parse tree produced by LogicParser#lastFrom.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitLastFrom in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitBinaryList
```
public T visitBinaryList(@NotNull
                LogicParser.BinaryListContext ctx)
```
    Visit a parse tree produced by LogicParser#binaryList.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitBinaryList in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitIsAfter
```
public T visitIsAfter(@NotNull
             LogicParser.IsAfterContext ctx)
```
    Visit a parse tree produced by LogicParser#isAfter.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitIsAfter in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitAfter
```
public T visitAfter(@NotNull
           LogicParser.AfterContext ctx)
```
    Visit a parse tree produced by LogicParser#after.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitAfter in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitBuildString
```
public T visitBuildString(@NotNull
                 LogicParser.BuildStringContext ctx)
```
    Visit a parse tree produced by LogicParser#buildString.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitBuildString in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitUppercase
```
public T visitUppercase(@NotNull
               LogicParser.UppercaseContext ctx)
```
    Visit a parse tree produced by LogicParser#uppercase.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitUppercase in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitOccurWithinTo
```
public T visitOccurWithinTo(@NotNull
                   LogicParser.OccurWithinToContext ctx)
```
    Visit a parse tree produced by LogicParser#occurWithinTo.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitOccurWithinTo in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitEarliest
```
public T visitEarliest(@NotNull
              LogicParser.EarliestContext ctx)
```
    Visit a parse tree produced by LogicParser#earliest.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitEarliest in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitOccurWithinSameDay
```
public T visitOccurWithinSameDay(@NotNull
                        LogicParser.OccurWithinSameDayContext ctx)
```
    Visit a parse tree produced by LogicParser#occurWithinSameDay.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitOccurWithinSameDay in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitDayOfWeekFunc
```
public T visitDayOfWeekFunc(@NotNull
                   LogicParser.DayOfWeekFuncContext ctx)
```
    Visit a parse tree produced by LogicParser#dayOfWeekFunc.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitDayOfWeekFunc in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitAny
```
public T visitAny(@NotNull
         LogicParser.AnyContext ctx)
```
    Visit a parse tree produced by LogicParser#any.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitAny in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitIsWithinSameDay
```
public T visitIsWithinSameDay(@NotNull
                     LogicParser.IsWithinSameDayContext ctx)
```
    Visit a parse tree produced by LogicParser#isWithinSameDay.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitIsWithinSameDay in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitSubList
```
public T visitSubList(@NotNull
             LogicParser.SubListContext ctx)
```
    Visit a parse tree produced by LogicParser#subList.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitSubList in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitObjNamedWith
```
public T visitObjNamedWith(@NotNull
                  LogicParser.ObjNamedWithContext ctx)
```
    Visit a parse tree produced by LogicParser.objNamedWith().
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitObjNamedWith in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitConclude
```
public T visitConclude(@NotNull
              LogicParser.ConcludeContext ctx)
```
    Visit a parse tree produced by LogicParser.conclude().
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitConclude in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitIndex
```
public T visitIndex(@NotNull
           LogicParser.IndexContext ctx)
```
    Visit a parse tree produced by LogicParser#index.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitIndex in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitAssignable
```
public T visitAssignable(@NotNull
                LogicParser.AssignableContext ctx)
```
    Visit a parse tree produced by LogicParser.assignable().
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitAssignable in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitContinueLoop
```
public T visitContinueLoop(@NotNull
                  LogicParser.ContinueLoopContext ctx)
```
    Visit a parse tree produced by LogicParser.continueLoop().
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitContinueLoop in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitInit
```
public T visitInit(@NotNull
          LogicParser.InitContext ctx)
```
    Visit a parse tree produced by LogicParser.init().
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitInit in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitLatestFrom
```
public T visitLatestFrom(@NotNull
                LogicParser.LatestFromContext ctx)
```
    Visit a parse tree produced by LogicParser#latestFrom.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitLatestFrom in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitIndexFrom
```
public T visitIndexFrom(@NotNull
               LogicParser.IndexFromContext ctx)
```
    Visit a parse tree produced by LogicParser#indexFrom.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitIndexFrom in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitAnd
```
public T visitAnd(@NotNull
         LogicParser.AndContext ctx)
```
    Visit a parse tree produced by LogicParser#and.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitAnd in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitIsGreaterThanOrEqual
```
public T visitIsGreaterThanOrEqual(@NotNull
                          LogicParser.IsGreaterThanOrEqualContext ctx)
```
    Visit a parse tree produced by LogicParser#isGreaterThanOrEqual.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitIsGreaterThanOrEqual in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitExtractAttrNames
```
public T visitExtractAttrNames(@NotNull
                      LogicParser.ExtractAttrNamesContext ctx)
```
    Visit a parse tree produced by LogicParser#extractAttrNames.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitExtractAttrNames in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitExp
```
public T visitExp(@NotNull
         LogicParser.ExpContext ctx)
```
    Visit a parse tree produced by LogicParser#exp.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitExp in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitBreakLoop
```
public T visitBreakLoop(@NotNull
               LogicParser.BreakLoopContext ctx)
```
    Visit a parse tree produced by LogicParser.breakLoop().
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitBreakLoop in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitSine
```
public T visitSine(@NotNull
          LogicParser.SineContext ctx)
```
    Visit a parse tree produced by LogicParser#sine.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitSine in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitCeiling
```
public T visitCeiling(@NotNull
             LogicParser.CeilingContext ctx)
```
    Visit a parse tree produced by LogicParser#ceiling.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitCeiling in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitIsEqual
```
public T visitIsEqual(@NotNull
             LogicParser.IsEqualContext ctx)
```
    Visit a parse tree produced by LogicParser#isEqual.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitIsEqual in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitMaximum
```
public T visitMaximum(@NotNull
             LogicParser.MaximumContext ctx)
```
    Visit a parse tree produced by LogicParser#maximum.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitMaximum in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitAsTime
```
public T visitAsTime(@NotNull
            LogicParser.AsTimeContext ctx)
```
    Visit a parse tree produced by LogicParser#asTime.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitAsTime in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitTangent
```
public T visitTangent(@NotNull
             LogicParser.TangentContext ctx)
```
    Visit a parse tree produced by LogicParser#tangent.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitTangent in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitEnhancedAssignment
```
public T visitEnhancedAssignment(@NotNull
                        LogicParser.EnhancedAssignmentContext ctx)
```
    Visit a parse tree produced by LogicParser#enhancedAssignment.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitEnhancedAssignment in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitIsGreaterThan
```
public T visitIsGreaterThan(@NotNull
                   LogicParser.IsGreaterThanContext ctx)
```
    Visit a parse tree produced by LogicParser#isGreaterThan.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitIsGreaterThan in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitCall
```
public T visitCall(@NotNull
          LogicParser.CallContext ctx)
```
    Visit a parse tree produced by LogicParser.call().
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitCall in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitOccurAfter
```
public T visitOccurAfter(@NotNull
                LogicParser.OccurAfterContext ctx)
```
    Visit a parse tree produced by LogicParser#occurAfter.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitOccurAfter in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitSum
```
public T visitSum(@NotNull
         LogicParser.SumContext ctx)
```
    Visit a parse tree produced by LogicParser#sum.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitSum in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitAdd
```
public T visitAdd(@NotNull
         LogicParser.AddContext ctx)
```
    Visit a parse tree produced by LogicParser#add.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitAdd in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitSeqto
```
public T visitSeqto(@NotNull
           LogicParser.SeqtoContext ctx)
```
    Visit a parse tree produced by LogicParser#seqto.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitSeqto in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitTimeOfDayFunc
```
public T visitTimeOfDayFunc(@NotNull
                   LogicParser.TimeOfDayFuncContext ctx)
```
    Visit a parse tree produced by LogicParser#timeOfDayFunc.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitTimeOfDayFunc in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitOccurWithinSurrounding
```
public T visitOccurWithinSurrounding(@NotNull
                            LogicParser.OccurWithinSurroundingContext ctx)
```
    Visit a parse tree produced by LogicParser#occurWithinSurrounding.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitOccurWithinSurrounding in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitId
```
public T visitId(@NotNull
        LogicParser.IdContext ctx)
```
    Visit a parse tree produced by LogicParser#id.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitId in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitNewObject
```
public T visitNewObject(@NotNull
               LogicParser.NewObjectContext ctx)
```
    Visit a parse tree produced by LogicParser#newObject.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitNewObject in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitAttributeFrom
```
public T visitAttributeFrom(@NotNull
                   LogicParser.AttributeFromContext ctx)
```
    Visit a parse tree produced by LogicParser#attributeFrom.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitAttributeFrom in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitLowercase
```
public T visitLowercase(@NotNull
               LogicParser.LowercaseContext ctx)
```
    Visit a parse tree produced by LogicParser#lowercase.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitLowercase in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitObjOrderedWith
```
public T visitObjOrderedWith(@NotNull
                    LogicParser.ObjOrderedWithContext ctx)
```
    Visit a parse tree produced by LogicParser.objOrderedWith().
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitObjOrderedWith in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitTimeVal
```
public T visitTimeVal(@NotNull
             LogicParser.TimeValContext ctx)
```
    Visit a parse tree produced by LogicParser#timeVal.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitTimeVal in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitTrim
```
public T visitTrim(@NotNull
          LogicParser.TrimContext ctx)
```
    Visit a parse tree produced by LogicParser#trim.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitTrim in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitExist
```
public T visitExist(@NotNull
           LogicParser.ExistContext ctx)
```
    Visit a parse tree produced by LogicParser#exist.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitExist in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitDayOfWeek
```
public T visitDayOfWeek(@NotNull
               LogicParser.DayOfWeekContext ctx)
```
    Visit a parse tree produced by LogicParser#dayOfWeek.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitDayOfWeek in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitAll
```
public T visitAll(@NotNull
         LogicParser.AllContext ctx)
```
    Visit a parse tree produced by LogicParser#all.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitAll in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitCosine
```
public T visitCosine(@NotNull
            LogicParser.CosineContext ctx)
```
    Visit a parse tree produced by LogicParser#cosine.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitCosine in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitStmt
```
public T visitStmt(@NotNull
          LogicParser.StmtContext ctx)
```
    Visit a parse tree produced by LogicParser.stmt().
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitStmt in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitRemoveFromList
```
public T visitRemoveFromList(@NotNull
                    LogicParser.RemoveFromListContext ctx)
```
    Visit a parse tree produced by LogicParser#removeFromList.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitRemoveFromList in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitMultiply
```
public T visitMultiply(@NotNull
              LogicParser.MultiplyContext ctx)
```
    Visit a parse tree produced by LogicParser#multiply.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitMultiply in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitVariance
```
public T visitVariance(@NotNull
              LogicParser.VarianceContext ctx)
```
    Visit a parse tree produced by LogicParser#variance.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitVariance in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitConcat
```
public T visitConcat(@NotNull
            LogicParser.ConcatContext ctx)
```
    Visit a parse tree produced by LogicParser#concat.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitConcat in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitNearest
```
public T visitNearest(@NotNull
             LogicParser.NearestContext ctx)
```
    Visit a parse tree produced by LogicParser#nearest.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitNearest in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitEmptyList
```
public T visitEmptyList(@NotNull
               LogicParser.EmptyListContext ctx)
```
    Visit a parse tree produced by LogicParser#emptyList.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitEmptyList in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitPrint
```
public T visitPrint(@NotNull
           LogicParser.PrintContext ctx)
```
    Visit a parse tree produced by LogicParser.print().
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitPrint in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitLog10
```
public T visitLog10(@NotNull
           LogicParser.Log10Context ctx)
```
    Visit a parse tree produced by LogicParser#log10.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitLog10 in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitIfStatement
```
public T visitIfStatement(@NotNull
                 LogicParser.IfStatementContext ctx)
```
    Visit a parse tree produced by LogicParser.ifStatement().
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitIfStatement in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitCurrentTime
```
public T visitCurrentTime(@NotNull
                 LogicParser.CurrentTimeContext ctx)
```
    Visit a parse tree produced by LogicParser#currentTime.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitCurrentTime in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitSubtract
```
public T visitSubtract(@NotNull
              LogicParser.SubtractContext ctx)
```
    Visit a parse tree produced by LogicParser#subtract.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitSubtract in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitDataType
```
public T visitDataType(@NotNull
              LogicParser.DataTypeContext ctx)
```
    Visit a parse tree produced by LogicParser.dataType().
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitDataType in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitDuration
```
public T visitDuration(@NotNull
              LogicParser.DurationContext ctx)
```
    Visit a parse tree produced by LogicParser#duration.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitDuration in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitFindInString
```
public T visitFindInString(@NotNull
                  LogicParser.FindInStringContext ctx)
```
    Visit a parse tree produced by LogicParser#findInString.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitFindInString in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitIsNotEqual
```
public T visitIsNotEqual(@NotNull
                LogicParser.IsNotEqualContext ctx)
```
    Visit a parse tree produced by LogicParser#isNotEqual.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitIsNotEqual in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitIncrease
```
public T visitIncrease(@NotNull
              LogicParser.IncreaseContext ctx)
```
    Visit a parse tree produced by LogicParser#increase.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitIncrease in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitRaiseToPower
```
public T visitRaiseToPower(@NotNull
                  LogicParser.RaiseToPowerContext ctx)
```
    Visit a parse tree produced by LogicParser#raiseToPower.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitRaiseToPower in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitTimeFunc
```
public T visitTimeFunc(@NotNull
              LogicParser.TimeFuncContext ctx)
```
    Visit a parse tree produced by LogicParser#timeFunc.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitTimeFunc in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitLatest
```
public T visitLatest(@NotNull
            LogicParser.LatestContext ctx)
```
    Visit a parse tree produced by LogicParser#latest.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitLatest in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitIsWithinPast
```
public T visitIsWithinPast(@NotNull
                  LogicParser.IsWithinPastContext ctx)
```
    Visit a parse tree produced by LogicParser#isWithinPast.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitIsWithinPast in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitFirst
```
public T visitFirst(@NotNull
           LogicParser.FirstContext ctx)
```
    Visit a parse tree produced by LogicParser#first.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitFirst in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result
  - visitAverage
```
public T visitAverage(@NotNull
             LogicParser.AverageContext ctx)
```
    Visit a parse tree produced by LogicParser#average.
    The default implementation returns the result of calling AbstractParseTreeVisitor.visitChildren(org.antlr.v4.runtime.tree.RuleNode) on ctx.
    
    Specified by:
    
    visitAverage in interface LogicVisitor<T>
    
    Parameters:
    ctx - the parse tree
    
    Returns:
    the visitor result

Class LogicBaseVisitor<T>

Constructor Summary

Method Summary

Methods inherited from class org.antlr.v4.runtime.tree.AbstractParseTreeVisitor

Methods inherited from class java.lang.Object

Methods inherited from interface org.antlr.v4.runtime.tree.ParseTreeVisitor

Constructor Detail

LogicBaseVisitor

Method Detail

visitDurationExpr

visitArccos

visitNo

visitAsString

visitFirstFrom

visitDot

visitTemporalUnit

visitMinimumFrom

visitIndexType

visitMatches

visitDurationUnit

visitAbs

visitIsIn

visitIndexOfFrom

visitSubstring

visitForLoop

visitElement

visitClone

visitOccurEqual

visitIsWithinFollowing

visitUnaryMinus

visitOr

visitUnaryList

visitParens

visitLog

visitAtMostOrLeast

visitExtract

visitTimeOfDayVal

visitNot

visitMedian

visitFloor

visitNow

visitTruncate

visitIsLessThanOrEqual

visitNullVal

visitOccurBefore

visitObjOrIndexRule

visitWhereTimeIsPresent

visitSort

visitInterval

visitMinimum

visitBefore

visitMerge

visitBlock

visitIsLessThan

visitIsBefore

visitUnaryPlus

visitLength

visitAddToList

visitAtTime

visitOccurWithinFollowing

visitEarliestFrom

visitOccurWithinPreceding

visitMultipleAssignment

visitReverse

visitIsDataType

visitArctan

visitSqrt

visitOccurWithinPast

visitAsNumber

visitDivide

visitStringVal

visitReplace

visitArcsin

visitIsWithinTo

visitAssignment

visitSwitchStatement

visitMaximumFrom

visitIsWithinSurrounding

visitIsObjectType

visitWhileLoop