fbast

package
v0.51.1 Latest Latest
Warning

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

 Go to latest Published: Oct 28, 2019 License: MIT Imports: 1 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var EnumNamesAssignment = map[Assignment]string{
	AssignmentNONE:               "NONE",
	AssignmentMemberAssignment:   "MemberAssignment",
	AssignmentVariableAssignment: "VariableAssignment",
}
View Source 
var EnumNamesExpression = map[Expression]string{
	ExpressionNONE:                   "NONE",
	ExpressionStringExpression:       "StringExpression",
	ExpressionParenExpression:        "ParenExpression",
	ExpressionArrayExpression:        "ArrayExpression",
	ExpressionFunctionExpression:     "FunctionExpression",
	ExpressionBinaryExpression:       "BinaryExpression",
	ExpressionBooleanLiteral:         "BooleanLiteral",
	ExpressionCallExpression:         "CallExpression",
	ExpressionConditionalExpression:  "ConditionalExpression",
	ExpressionDateTimeLiteral:        "DateTimeLiteral",
	ExpressionDurationLiteral:        "DurationLiteral",
	ExpressionFloatLiteral:           "FloatLiteral",
	ExpressionIdentifier:             "Identifier",
	ExpressionIntegerLiteral:         "IntegerLiteral",
	ExpressionLogicalExpression:      "LogicalExpression",
	ExpressionMemberExpression:       "MemberExpression",
	ExpressionIndexExpression:        "IndexExpression",
	ExpressionObjectExpression:       "ObjectExpression",
	ExpressionPipeExpression:         "PipeExpression",
	ExpressionPipeLiteral:            "PipeLiteral",
	ExpressionRegexpLiteral:          "RegexpLiteral",
	ExpressionStringLiteral:          "StringLiteral",
	ExpressionUnaryExpression:        "UnaryExpression",
	ExpressionUnsignedIntegerLiteral: "UnsignedIntegerLiteral",
}
View Source 
var EnumNamesExpressionOrBlock = map[ExpressionOrBlock]string{
	ExpressionOrBlockNONE:              "NONE",
	ExpressionOrBlockBlock:             "Block",
	ExpressionOrBlockWrappedExpression: "WrappedExpression",
}
View Source 
var EnumNamesLogicalOperator = map[LogicalOperator]string{
	LogicalOperatorAndOperator: "AndOperator",
	LogicalOperatorOrOperator:  "OrOperator",
}
View Source 
var EnumNamesOperator = map[Operator]string{
	OperatorMultiplicationOperator:   "MultiplicationOperator",
	OperatorDivisionOperator:         "DivisionOperator",
	OperatorModuloOperator:           "ModuloOperator",
	OperatorPowerOperator:            "PowerOperator",
	OperatorAdditionOperator:         "AdditionOperator",
	OperatorSubtractionOperator:      "SubtractionOperator",
	OperatorLessThanEqualOperator:    "LessThanEqualOperator",
	OperatorLessThanOperator:         "LessThanOperator",
	OperatorGreaterThanEqualOperator: "GreaterThanEqualOperator",
	OperatorGreaterThanOperator:      "GreaterThanOperator",
	OperatorStartsWithOperator:       "StartsWithOperator",
	OperatorInOperator:               "InOperator",
	OperatorNotOperator:              "NotOperator",
	OperatorExistsOperator:           "ExistsOperator",
	OperatorNotEmptyOperator:         "NotEmptyOperator",
	OperatorEmptyOperator:            "EmptyOperator",
	OperatorEqualOperator:            "EqualOperator",
	OperatorNotEqualOperator:         "NotEqualOperator",
	OperatorRegexpMatchOperator:      "RegexpMatchOperator",
	OperatorNotRegexpMatchOperator:   "NotRegexpMatchOperator",
}
View Source 
var EnumNamesPropertyKey = map[PropertyKey]string{
	PropertyKeyNONE:          "NONE",
	PropertyKeyIdentifier:    "Identifier",
	PropertyKeyStringLiteral: "StringLiteral",
}
View Source 
var EnumNamesStatement = map[Statement]string{
	StatementNONE:                "NONE",
	StatementBadStatement:        "BadStatement",
	StatementVariableAssignment:  "VariableAssignment",
	StatementMemberAssignment:    "MemberAssignment",
	StatementExpressionStatement: "ExpressionStatement",
	StatementReturnStatement:     "ReturnStatement",
	StatementOptionStatement:     "OptionStatement",
	StatementBuiltinStatement:    "BuiltinStatement",
	StatementTestStatement:       "TestStatement",
}
View Source 
var EnumNamesTimeUnit = map[TimeUnit]string{
	TimeUnity:  "y",
	TimeUnitmo: "mo",
	TimeUnitw:  "w",
	TimeUnitd:  "d",
	TimeUnith:  "h",
	TimeUnitm:  "m",
	TimeUnits:  "s",
	TimeUnitms: "ms",
	TimeUnitus: "us",
	TimeUnitns: "ns",
}

Functions

func ArrayExpressionAddBaseNode 

func ArrayExpressionAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func ArrayExpressionAddElements 

func ArrayExpressionAddElements(builder *flatbuffers.Builder, elements flatbuffers.UOffsetT)

func ArrayExpressionEnd 

func ArrayExpressionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func ArrayExpressionStart 

func ArrayExpressionStart(builder *flatbuffers.Builder)

func ArrayExpressionStartElementsVector 

func ArrayExpressionStartElementsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func BadStatementAddBaseNode 

func BadStatementAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func BadStatementAddText 

func BadStatementAddText(builder *flatbuffers.Builder, text flatbuffers.UOffsetT)

func BadStatementEnd 

func BadStatementEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func BadStatementStart 

func BadStatementStart(builder *flatbuffers.Builder)

func BaseNodeAddErrors 

func BaseNodeAddErrors(builder *flatbuffers.Builder, errors flatbuffers.UOffsetT)

func BaseNodeAddLoc 

func BaseNodeAddLoc(builder *flatbuffers.Builder, loc flatbuffers.UOffsetT)

func BaseNodeEnd 

func BaseNodeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func BaseNodeStart 

func BaseNodeStart(builder *flatbuffers.Builder)

func BaseNodeStartErrorsVector 

func BaseNodeStartErrorsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func BinaryExpressionAddBaseNode 

func BinaryExpressionAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func BinaryExpressionAddLeft 

func BinaryExpressionAddLeft(builder *flatbuffers.Builder, left flatbuffers.UOffsetT)

func BinaryExpressionAddLeftType 

func BinaryExpressionAddLeftType(builder *flatbuffers.Builder, leftType byte)

func BinaryExpressionAddOperator 

func BinaryExpressionAddOperator(builder *flatbuffers.Builder, operator int8)

func BinaryExpressionAddRight 

func BinaryExpressionAddRight(builder *flatbuffers.Builder, right flatbuffers.UOffsetT)

func BinaryExpressionAddRightType 

func BinaryExpressionAddRightType(builder *flatbuffers.Builder, rightType byte)

func BinaryExpressionEnd 

func BinaryExpressionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func BinaryExpressionStart 

func BinaryExpressionStart(builder *flatbuffers.Builder)

func BlockAddBaseNode 

func BlockAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func BlockAddBody 

func BlockAddBody(builder *flatbuffers.Builder, body flatbuffers.UOffsetT)

func BlockEnd 

func BlockEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func BlockStart 

func BlockStart(builder *flatbuffers.Builder)

func BlockStartBodyVector 

func BlockStartBodyVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func BooleanLiteralAddBaseNode 

func BooleanLiteralAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func BooleanLiteralAddValue 

func BooleanLiteralAddValue(builder *flatbuffers.Builder, value bool)

func BooleanLiteralEnd 

func BooleanLiteralEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func BooleanLiteralStart 

func BooleanLiteralStart(builder *flatbuffers.Builder)

func BuiltinStatementAddBaseNode 

func BuiltinStatementAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func BuiltinStatementAddId 

func BuiltinStatementAddId(builder *flatbuffers.Builder, id flatbuffers.UOffsetT)

func BuiltinStatementEnd 

func BuiltinStatementEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func BuiltinStatementStart 

func BuiltinStatementStart(builder *flatbuffers.Builder)

func CallExpressionAddArguments 

func CallExpressionAddArguments(builder *flatbuffers.Builder, arguments flatbuffers.UOffsetT)

func CallExpressionAddBaseNode 

func CallExpressionAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func CallExpressionAddCallee 

func CallExpressionAddCallee(builder *flatbuffers.Builder, callee flatbuffers.UOffsetT)

func CallExpressionAddCalleeType 

func CallExpressionAddCalleeType(builder *flatbuffers.Builder, calleeType byte)

func CallExpressionEnd 

func CallExpressionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func CallExpressionStart 

func CallExpressionStart(builder *flatbuffers.Builder)

func ConditionalExpressionAddAlternate 

func ConditionalExpressionAddAlternate(builder *flatbuffers.Builder, alternate flatbuffers.UOffsetT)

func ConditionalExpressionAddAlternateType 

func ConditionalExpressionAddAlternateType(builder *flatbuffers.Builder, alternateType byte)

func ConditionalExpressionAddBaseNode 

func ConditionalExpressionAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func ConditionalExpressionAddConsequent 

func ConditionalExpressionAddConsequent(builder *flatbuffers.Builder, consequent flatbuffers.UOffsetT)

func ConditionalExpressionAddConsequentType 

func ConditionalExpressionAddConsequentType(builder *flatbuffers.Builder, consequentType byte)

func ConditionalExpressionAddTest 

func ConditionalExpressionAddTest(builder *flatbuffers.Builder, test flatbuffers.UOffsetT)

func ConditionalExpressionAddTestType 

func ConditionalExpressionAddTestType(builder *flatbuffers.Builder, testType byte)

func ConditionalExpressionEnd 

func ConditionalExpressionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func ConditionalExpressionStart 

func ConditionalExpressionStart(builder *flatbuffers.Builder)

func CreatePosition 

func CreatePosition(builder *flatbuffers.Builder, line int32, column int32) flatbuffers.UOffsetT

func DateTimeLiteralAddBaseNode 

func DateTimeLiteralAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func DateTimeLiteralAddValue 

func DateTimeLiteralAddValue(builder *flatbuffers.Builder, value flatbuffers.UOffsetT)

func DateTimeLiteralEnd 

func DateTimeLiteralEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func DateTimeLiteralStart 

func DateTimeLiteralStart(builder *flatbuffers.Builder)

func DurationAddMagnitude 

func DurationAddMagnitude(builder *flatbuffers.Builder, magnitude int64)

func DurationAddUnit 

func DurationAddUnit(builder *flatbuffers.Builder, unit int8)

func DurationEnd 

func DurationEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func DurationLiteralAddBaseNode 

func DurationLiteralAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func DurationLiteralAddValues 

func DurationLiteralAddValues(builder *flatbuffers.Builder, values flatbuffers.UOffsetT)

func DurationLiteralEnd 

func DurationLiteralEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func DurationLiteralStart 

func DurationLiteralStart(builder *flatbuffers.Builder)

func DurationLiteralStartValuesVector 

func DurationLiteralStartValuesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func DurationStart 

func DurationStart(builder *flatbuffers.Builder)

func ExpressionStatementAddBaseNode 

func ExpressionStatementAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func ExpressionStatementAddExpression 

func ExpressionStatementAddExpression(builder *flatbuffers.Builder, expression flatbuffers.UOffsetT)

func ExpressionStatementAddExpressionType 

func ExpressionStatementAddExpressionType(builder *flatbuffers.Builder, expressionType byte)

func ExpressionStatementEnd 

func ExpressionStatementEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func ExpressionStatementStart 

func ExpressionStatementStart(builder *flatbuffers.Builder)

func FileAddBaseNode 

func FileAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func FileAddBody 

func FileAddBody(builder *flatbuffers.Builder, body flatbuffers.UOffsetT)

func FileAddImports 

func FileAddImports(builder *flatbuffers.Builder, imports flatbuffers.UOffsetT)

func FileAddName 

func FileAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT)

func FileAddPackage 

func FileAddPackage(builder *flatbuffers.Builder, package_ flatbuffers.UOffsetT)

func FileEnd 

func FileEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func FileStart 

func FileStart(builder *flatbuffers.Builder)

func FileStartBodyVector 

func FileStartBodyVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func FileStartImportsVector 

func FileStartImportsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func FloatLiteralAddBaseNode 

func FloatLiteralAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func FloatLiteralAddValue 

func FloatLiteralAddValue(builder *flatbuffers.Builder, value float64)

func FloatLiteralEnd 

func FloatLiteralEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func FloatLiteralStart 

func FloatLiteralStart(builder *flatbuffers.Builder)

func FunctionExpressionAddBaseNode 

func FunctionExpressionAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func FunctionExpressionAddBody 

func FunctionExpressionAddBody(builder *flatbuffers.Builder, body flatbuffers.UOffsetT)

func FunctionExpressionAddBodyType 

func FunctionExpressionAddBodyType(builder *flatbuffers.Builder, bodyType byte)

func FunctionExpressionAddParams 

func FunctionExpressionAddParams(builder *flatbuffers.Builder, params flatbuffers.UOffsetT)

func FunctionExpressionEnd 

func FunctionExpressionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func FunctionExpressionStart 

func FunctionExpressionStart(builder *flatbuffers.Builder)

func FunctionExpressionStartParamsVector 

func FunctionExpressionStartParamsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func IdentifierAddBaseNode 

func IdentifierAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func IdentifierAddName 

func IdentifierAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT)

func IdentifierEnd 

func IdentifierEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func IdentifierStart 

func IdentifierStart(builder *flatbuffers.Builder)

func ImportDeclarationAddAs 

func ImportDeclarationAddAs(builder *flatbuffers.Builder, as flatbuffers.UOffsetT)

func ImportDeclarationAddBaseNode 

func ImportDeclarationAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func ImportDeclarationAddPath 

func ImportDeclarationAddPath(builder *flatbuffers.Builder, path flatbuffers.UOffsetT)

func ImportDeclarationEnd 

func ImportDeclarationEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func ImportDeclarationStart 

func ImportDeclarationStart(builder *flatbuffers.Builder)

func IndexExpressionAddArray 

func IndexExpressionAddArray(builder *flatbuffers.Builder, array flatbuffers.UOffsetT)

func IndexExpressionAddArrayType 

func IndexExpressionAddArrayType(builder *flatbuffers.Builder, arrayType byte)

func IndexExpressionAddBaseNode 

func IndexExpressionAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func IndexExpressionAddIndex 

func IndexExpressionAddIndex(builder *flatbuffers.Builder, index flatbuffers.UOffsetT)

func IndexExpressionAddIndexType 

func IndexExpressionAddIndexType(builder *flatbuffers.Builder, indexType byte)

func IndexExpressionEnd 

func IndexExpressionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func IndexExpressionStart 

func IndexExpressionStart(builder *flatbuffers.Builder)

func IntegerLiteralAddBaseNode 

func IntegerLiteralAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func IntegerLiteralAddValue 

func IntegerLiteralAddValue(builder *flatbuffers.Builder, value int64)

func IntegerLiteralEnd 

func IntegerLiteralEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func IntegerLiteralStart 

func IntegerLiteralStart(builder *flatbuffers.Builder)

func InterpolatedPartAddBaseNode 

func InterpolatedPartAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func InterpolatedPartAddExpression 

func InterpolatedPartAddExpression(builder *flatbuffers.Builder, expression flatbuffers.UOffsetT)

func InterpolatedPartAddExpressionType 

func InterpolatedPartAddExpressionType(builder *flatbuffers.Builder, expressionType byte)

func InterpolatedPartEnd 

func InterpolatedPartEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func InterpolatedPartStart 

func InterpolatedPartStart(builder *flatbuffers.Builder)

func LogicalExpressionAddBaseNode 

func LogicalExpressionAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func LogicalExpressionAddLeft 

func LogicalExpressionAddLeft(builder *flatbuffers.Builder, left flatbuffers.UOffsetT)

func LogicalExpressionAddLeftType 

func LogicalExpressionAddLeftType(builder *flatbuffers.Builder, leftType byte)

func LogicalExpressionAddOperator 

func LogicalExpressionAddOperator(builder *flatbuffers.Builder, operator int8)

func LogicalExpressionAddRight 

func LogicalExpressionAddRight(builder *flatbuffers.Builder, right flatbuffers.UOffsetT)

func LogicalExpressionAddRightType 

func LogicalExpressionAddRightType(builder *flatbuffers.Builder, rightType byte)

func LogicalExpressionEnd 

func LogicalExpressionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func LogicalExpressionStart 

func LogicalExpressionStart(builder *flatbuffers.Builder)

func MemberAssignmentAddBaseNode 

func MemberAssignmentAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func MemberAssignmentAddInit_ 

func MemberAssignmentAddInit_(builder *flatbuffers.Builder, init_ flatbuffers.UOffsetT)

func MemberAssignmentAddInit_type 

func MemberAssignmentAddInit_type(builder *flatbuffers.Builder, init_type byte)

func MemberAssignmentAddMember 

func MemberAssignmentAddMember(builder *flatbuffers.Builder, member flatbuffers.UOffsetT)

func MemberAssignmentEnd 

func MemberAssignmentEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func MemberAssignmentStart 

func MemberAssignmentStart(builder *flatbuffers.Builder)

func MemberExpressionAddBaseNode 

func MemberExpressionAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func MemberExpressionAddObject 

func MemberExpressionAddObject(builder *flatbuffers.Builder, object flatbuffers.UOffsetT)

func MemberExpressionAddObjectType 

func MemberExpressionAddObjectType(builder *flatbuffers.Builder, objectType byte)

func MemberExpressionAddProperty 

func MemberExpressionAddProperty(builder *flatbuffers.Builder, property flatbuffers.UOffsetT)

func MemberExpressionAddPropertyType 

func MemberExpressionAddPropertyType(builder *flatbuffers.Builder, propertyType byte)

func MemberExpressionEnd 

func MemberExpressionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func MemberExpressionStart 

func MemberExpressionStart(builder *flatbuffers.Builder)

func ObjectExpressionAddBaseNode 

func ObjectExpressionAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func ObjectExpressionAddProperties 

func ObjectExpressionAddProperties(builder *flatbuffers.Builder, properties flatbuffers.UOffsetT)

func ObjectExpressionAddWith 

func ObjectExpressionAddWith(builder *flatbuffers.Builder, with flatbuffers.UOffsetT)

func ObjectExpressionEnd 

func ObjectExpressionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func ObjectExpressionStart 

func ObjectExpressionStart(builder *flatbuffers.Builder)

func ObjectExpressionStartPropertiesVector 

func ObjectExpressionStartPropertiesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func OptionStatementAddAssignment 

func OptionStatementAddAssignment(builder *flatbuffers.Builder, assignment flatbuffers.UOffsetT)

func OptionStatementAddAssignmentType 

func OptionStatementAddAssignmentType(builder *flatbuffers.Builder, assignmentType byte)

func OptionStatementAddBaseNode 

func OptionStatementAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func OptionStatementEnd 

func OptionStatementEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func OptionStatementStart 

func OptionStatementStart(builder *flatbuffers.Builder)

func PackageAddBaseNode 

func PackageAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func PackageAddFiles 

func PackageAddFiles(builder *flatbuffers.Builder, files flatbuffers.UOffsetT)

func PackageAddPackage 

func PackageAddPackage(builder *flatbuffers.Builder, package_ flatbuffers.UOffsetT)

func PackageAddPath 

func PackageAddPath(builder *flatbuffers.Builder, path flatbuffers.UOffsetT)

func PackageClauseAddBaseNode 

func PackageClauseAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func PackageClauseAddName 

func PackageClauseAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT)

func PackageClauseEnd 

func PackageClauseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func PackageClauseStart 

func PackageClauseStart(builder *flatbuffers.Builder)

func PackageEnd 

func PackageEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func PackageStart 

func PackageStart(builder *flatbuffers.Builder)

func PackageStartFilesVector 

func PackageStartFilesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func ParenExpressionAddBaseNode 

func ParenExpressionAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func ParenExpressionAddExpression 

func ParenExpressionAddExpression(builder *flatbuffers.Builder, expression flatbuffers.UOffsetT)

func ParenExpressionAddExpressionType 

func ParenExpressionAddExpressionType(builder *flatbuffers.Builder, expressionType byte)

func ParenExpressionEnd 

func ParenExpressionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func ParenExpressionStart 

func ParenExpressionStart(builder *flatbuffers.Builder)

func PipeExpressionAddArgument 

func PipeExpressionAddArgument(builder *flatbuffers.Builder, argument flatbuffers.UOffsetT)

func PipeExpressionAddArgumentType 

func PipeExpressionAddArgumentType(builder *flatbuffers.Builder, argumentType byte)

func PipeExpressionAddBaseNode 

func PipeExpressionAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func PipeExpressionAddCall 

func PipeExpressionAddCall(builder *flatbuffers.Builder, call flatbuffers.UOffsetT)

func PipeExpressionEnd 

func PipeExpressionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func PipeExpressionStart 

func PipeExpressionStart(builder *flatbuffers.Builder)

func PipeLiteralAddBaseNode 

func PipeLiteralAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func PipeLiteralEnd 

func PipeLiteralEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func PipeLiteralStart 

func PipeLiteralStart(builder *flatbuffers.Builder)

func PropertyAddBaseNode 

func PropertyAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func PropertyAddKey 

func PropertyAddKey(builder *flatbuffers.Builder, key flatbuffers.UOffsetT)

func PropertyAddKeyType 

func PropertyAddKeyType(builder *flatbuffers.Builder, keyType byte)

func PropertyAddValue 

func PropertyAddValue(builder *flatbuffers.Builder, value flatbuffers.UOffsetT)

func PropertyAddValueType 

func PropertyAddValueType(builder *flatbuffers.Builder, valueType byte)

func PropertyEnd 

func PropertyEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func PropertyStart 

func PropertyStart(builder *flatbuffers.Builder)

func RegexpLiteralAddBaseNode 

func RegexpLiteralAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func RegexpLiteralAddValue 

func RegexpLiteralAddValue(builder *flatbuffers.Builder, value flatbuffers.UOffsetT)

func RegexpLiteralEnd 

func RegexpLiteralEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func RegexpLiteralStart 

func RegexpLiteralStart(builder *flatbuffers.Builder)

func ReturnStatementAddArgument 

func ReturnStatementAddArgument(builder *flatbuffers.Builder, argument flatbuffers.UOffsetT)

func ReturnStatementAddArgumentType 

func ReturnStatementAddArgumentType(builder *flatbuffers.Builder, argumentType byte)

func ReturnStatementAddBaseNode 

func ReturnStatementAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func ReturnStatementEnd 

func ReturnStatementEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func ReturnStatementStart 

func ReturnStatementStart(builder *flatbuffers.Builder)

func SourceLocationAddEnd 

func SourceLocationAddEnd(builder *flatbuffers.Builder, end flatbuffers.UOffsetT)

func SourceLocationAddFile 

func SourceLocationAddFile(builder *flatbuffers.Builder, file flatbuffers.UOffsetT)

func SourceLocationAddSource 

func SourceLocationAddSource(builder *flatbuffers.Builder, source flatbuffers.UOffsetT)

func SourceLocationAddStart 

func SourceLocationAddStart(builder *flatbuffers.Builder, start flatbuffers.UOffsetT)

func SourceLocationEnd 

func SourceLocationEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func SourceLocationStart 

func SourceLocationStart(builder *flatbuffers.Builder)

func StringExpressionAddBaseNode 

func StringExpressionAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func StringExpressionAddParts 

func StringExpressionAddParts(builder *flatbuffers.Builder, parts flatbuffers.UOffsetT)

func StringExpressionEnd 

func StringExpressionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func StringExpressionPartAddBaseNode 

func StringExpressionPartAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func StringExpressionPartAddInterpolatedExpression 

func StringExpressionPartAddInterpolatedExpression(builder *flatbuffers.Builder, interpolatedExpression flatbuffers.UOffsetT)

func StringExpressionPartAddInterpolatedExpressionType 

func StringExpressionPartAddInterpolatedExpressionType(builder *flatbuffers.Builder, interpolatedExpressionType byte)

func StringExpressionPartAddTextValue 

func StringExpressionPartAddTextValue(builder *flatbuffers.Builder, textValue flatbuffers.UOffsetT)

func StringExpressionPartEnd 

func StringExpressionPartEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func StringExpressionPartStart 

func StringExpressionPartStart(builder *flatbuffers.Builder)

func StringExpressionStart 

func StringExpressionStart(builder *flatbuffers.Builder)

func StringExpressionStartPartsVector 

func StringExpressionStartPartsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT

func StringLiteralAddBaseNode 

func StringLiteralAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func StringLiteralAddValue 

func StringLiteralAddValue(builder *flatbuffers.Builder, value flatbuffers.UOffsetT)

func StringLiteralEnd 

func StringLiteralEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func StringLiteralStart 

func StringLiteralStart(builder *flatbuffers.Builder)

func TestStatementAddAssignment 

func TestStatementAddAssignment(builder *flatbuffers.Builder, assignment flatbuffers.UOffsetT)

func TestStatementAddAssignmentType 

func TestStatementAddAssignmentType(builder *flatbuffers.Builder, assignmentType byte)

func TestStatementAddBaseNode 

func TestStatementAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func TestStatementEnd 

func TestStatementEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func TestStatementStart 

func TestStatementStart(builder *flatbuffers.Builder)

func TextPartAddBaseNode 

func TextPartAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func TextPartAddValue 

func TextPartAddValue(builder *flatbuffers.Builder, value flatbuffers.UOffsetT)

func TextPartEnd 

func TextPartEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func TextPartStart 

func TextPartStart(builder *flatbuffers.Builder)

func UnaryExpressionAddArgument 

func UnaryExpressionAddArgument(builder *flatbuffers.Builder, argument flatbuffers.UOffsetT)

func UnaryExpressionAddArgumentType 

func UnaryExpressionAddArgumentType(builder *flatbuffers.Builder, argumentType byte)

func UnaryExpressionAddBaseNode 

func UnaryExpressionAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func UnaryExpressionAddOperator 

func UnaryExpressionAddOperator(builder *flatbuffers.Builder, operator int8)

func UnaryExpressionEnd 

func UnaryExpressionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func UnaryExpressionStart 

func UnaryExpressionStart(builder *flatbuffers.Builder)

func UnsignedIntegerLiteralAddBaseNode 

func UnsignedIntegerLiteralAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func UnsignedIntegerLiteralAddValue 

func UnsignedIntegerLiteralAddValue(builder *flatbuffers.Builder, value uint64)

func UnsignedIntegerLiteralEnd 

func UnsignedIntegerLiteralEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func UnsignedIntegerLiteralStart 

func UnsignedIntegerLiteralStart(builder *flatbuffers.Builder)

func VariableAssignmentAddBaseNode 

func VariableAssignmentAddBaseNode(builder *flatbuffers.Builder, baseNode flatbuffers.UOffsetT)

func VariableAssignmentAddId 

func VariableAssignmentAddId(builder *flatbuffers.Builder, id flatbuffers.UOffsetT)

func VariableAssignmentAddInit_ 

func VariableAssignmentAddInit_(builder *flatbuffers.Builder, init_ flatbuffers.UOffsetT)

func VariableAssignmentAddInit_type 

func VariableAssignmentAddInit_type(builder *flatbuffers.Builder, init_type byte)

func VariableAssignmentEnd 

func VariableAssignmentEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func VariableAssignmentStart 

func VariableAssignmentStart(builder *flatbuffers.Builder)

func WrappedExpressionAddExpr 

func WrappedExpressionAddExpr(builder *flatbuffers.Builder, expr flatbuffers.UOffsetT)

func WrappedExpressionAddExprType 

func WrappedExpressionAddExprType(builder *flatbuffers.Builder, exprType byte)

func WrappedExpressionEnd 

func WrappedExpressionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func WrappedExpressionStart 

func WrappedExpressionStart(builder *flatbuffers.Builder)

func WrappedStatementAddStatement 

func WrappedStatementAddStatement(builder *flatbuffers.Builder, statement flatbuffers.UOffsetT)

func WrappedStatementAddStatementType 

func WrappedStatementAddStatementType(builder *flatbuffers.Builder, statementType byte)

func WrappedStatementEnd 

func WrappedStatementEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT

func WrappedStatementStart 

func WrappedStatementStart(builder *flatbuffers.Builder)

Types

type ArrayExpression 

type ArrayExpression struct {
	// contains filtered or unexported fields
}

func GetRootAsArrayExpression 

func GetRootAsArrayExpression(buf []byte, offset flatbuffers.UOffsetT) *ArrayExpression

func (*ArrayExpression) BaseNode 

func (rcv *ArrayExpression) BaseNode(obj *BaseNode) *BaseNode

func (*ArrayExpression) Elements 

func (rcv *ArrayExpression) Elements(obj *WrappedExpression, j int) bool

func (*ArrayExpression) ElementsLength 

func (rcv *ArrayExpression) ElementsLength() int

func (*ArrayExpression) Init 

func (rcv *ArrayExpression) Init(buf []byte, i flatbuffers.UOffsetT)

func (*ArrayExpression) Table 

func (rcv *ArrayExpression) Table() flatbuffers.Table

type Assignment 

type Assignment = byte
const (
	AssignmentNONE               Assignment = 0
	AssignmentMemberAssignment   Assignment = 1
	AssignmentVariableAssignment Assignment = 2
)

type BadStatement 

type BadStatement struct {
	// contains filtered or unexported fields
}

func GetRootAsBadStatement 

func GetRootAsBadStatement(buf []byte, offset flatbuffers.UOffsetT) *BadStatement

func (*BadStatement) BaseNode 

func (rcv *BadStatement) BaseNode(obj *BaseNode) *BaseNode

func (*BadStatement) Init 

func (rcv *BadStatement) Init(buf []byte, i flatbuffers.UOffsetT)

func (*BadStatement) Table 

func (rcv *BadStatement) Table() flatbuffers.Table

func (*BadStatement) Text 

func (rcv *BadStatement) Text() []byte

type BaseNode 

type BaseNode struct {
	// contains filtered or unexported fields
}

func GetRootAsBaseNode 

func GetRootAsBaseNode(buf []byte, offset flatbuffers.UOffsetT) *BaseNode

func (*BaseNode) Errors 

func (rcv *BaseNode) Errors(j int) []byte

func (*BaseNode) ErrorsLength 

func (rcv *BaseNode) ErrorsLength() int

func (*BaseNode) Init 

func (rcv *BaseNode) Init(buf []byte, i flatbuffers.UOffsetT)

func (*BaseNode) Loc 

func (rcv *BaseNode) Loc(obj *SourceLocation) *SourceLocation

func (*BaseNode) Table 

func (rcv *BaseNode) Table() flatbuffers.Table

type BinaryExpression 

type BinaryExpression struct {
	// contains filtered or unexported fields
}

func GetRootAsBinaryExpression 

func GetRootAsBinaryExpression(buf []byte, offset flatbuffers.UOffsetT) *BinaryExpression

func (*BinaryExpression) BaseNode 

func (rcv *BinaryExpression) BaseNode(obj *BaseNode) *BaseNode

func (*BinaryExpression) Init 

func (rcv *BinaryExpression) Init(buf []byte, i flatbuffers.UOffsetT)

func (*BinaryExpression) Left 

func (rcv *BinaryExpression) Left(obj *flatbuffers.Table) bool

func (*BinaryExpression) LeftType 

func (rcv *BinaryExpression) LeftType() byte

func (*BinaryExpression) MutateLeftType 

func (rcv *BinaryExpression) MutateLeftType(n byte) bool

func (*BinaryExpression) MutateOperator 

func (rcv *BinaryExpression) MutateOperator(n Operator) bool

func (*BinaryExpression) MutateRightType 

func (rcv *BinaryExpression) MutateRightType(n byte) bool

func (*BinaryExpression) Operator 

func (rcv *BinaryExpression) Operator() Operator

func (*BinaryExpression) Right 

func (rcv *BinaryExpression) Right(obj *flatbuffers.Table) bool

func (*BinaryExpression) RightType 

func (rcv *BinaryExpression) RightType() byte

func (*BinaryExpression) Table 

func (rcv *BinaryExpression) Table() flatbuffers.Table

type Block 

type Block struct {
	// contains filtered or unexported fields
}

func GetRootAsBlock 

func GetRootAsBlock(buf []byte, offset flatbuffers.UOffsetT) *Block

func (*Block) BaseNode 

func (rcv *Block) BaseNode(obj *BaseNode) *BaseNode

func (*Block) Body 

func (rcv *Block) Body(obj *WrappedStatement, j int) bool

func (*Block) BodyLength 

func (rcv *Block) BodyLength() int

func (*Block) Init 

func (rcv *Block) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Block) Table 

func (rcv *Block) Table() flatbuffers.Table

type BooleanLiteral 

type BooleanLiteral struct {
	// contains filtered or unexported fields
}

func GetRootAsBooleanLiteral 

func GetRootAsBooleanLiteral(buf []byte, offset flatbuffers.UOffsetT) *BooleanLiteral

func (*BooleanLiteral) BaseNode 

func (rcv *BooleanLiteral) BaseNode(obj *BaseNode) *BaseNode

func (*BooleanLiteral) Init 

func (rcv *BooleanLiteral) Init(buf []byte, i flatbuffers.UOffsetT)

func (*BooleanLiteral) MutateValue 

func (rcv *BooleanLiteral) MutateValue(n bool) bool

func (*BooleanLiteral) Table 

func (rcv *BooleanLiteral) Table() flatbuffers.Table

func (*BooleanLiteral) Value 

func (rcv *BooleanLiteral) Value() bool

type BuiltinStatement 

type BuiltinStatement struct {
	// contains filtered or unexported fields
}

func GetRootAsBuiltinStatement 

func GetRootAsBuiltinStatement(buf []byte, offset flatbuffers.UOffsetT) *BuiltinStatement

func (*BuiltinStatement) BaseNode 

func (rcv *BuiltinStatement) BaseNode(obj *BaseNode) *BaseNode

func (*BuiltinStatement) Id 

func (rcv *BuiltinStatement) Id(obj *Identifier) *Identifier

func (*BuiltinStatement) Init 

func (rcv *BuiltinStatement) Init(buf []byte, i flatbuffers.UOffsetT)

func (*BuiltinStatement) Table 

func (rcv *BuiltinStatement) Table() flatbuffers.Table

type CallExpression 

type CallExpression struct {
	// contains filtered or unexported fields
}

func GetRootAsCallExpression 

func GetRootAsCallExpression(buf []byte, offset flatbuffers.UOffsetT) *CallExpression

func (*CallExpression) Arguments 

func (rcv *CallExpression) Arguments(obj *ObjectExpression) *ObjectExpression

func (*CallExpression) BaseNode 

func (rcv *CallExpression) BaseNode(obj *BaseNode) *BaseNode

func (*CallExpression) Callee 

func (rcv *CallExpression) Callee(obj *flatbuffers.Table) bool

func (*CallExpression) CalleeType 

func (rcv *CallExpression) CalleeType() byte

func (*CallExpression) Init 

func (rcv *CallExpression) Init(buf []byte, i flatbuffers.UOffsetT)

func (*CallExpression) MutateCalleeType 

func (rcv *CallExpression) MutateCalleeType(n byte) bool

func (*CallExpression) Table 

func (rcv *CallExpression) Table() flatbuffers.Table

type ConditionalExpression 

type ConditionalExpression struct {
	// contains filtered or unexported fields
}

func GetRootAsConditionalExpression 

func GetRootAsConditionalExpression(buf []byte, offset flatbuffers.UOffsetT) *ConditionalExpression

func (*ConditionalExpression) Alternate 

func (rcv *ConditionalExpression) Alternate(obj *flatbuffers.Table) bool

func (*ConditionalExpression) AlternateType 

func (rcv *ConditionalExpression) AlternateType() byte

func (*ConditionalExpression) BaseNode 

func (rcv *ConditionalExpression) BaseNode(obj *BaseNode) *BaseNode

func (*ConditionalExpression) Consequent 

func (rcv *ConditionalExpression) Consequent(obj *flatbuffers.Table) bool

func (*ConditionalExpression) ConsequentType 

func (rcv *ConditionalExpression) ConsequentType() byte

func (*ConditionalExpression) Init 

func (rcv *ConditionalExpression) Init(buf []byte, i flatbuffers.UOffsetT)

func (*ConditionalExpression) MutateAlternateType 

func (rcv *ConditionalExpression) MutateAlternateType(n byte) bool

func (*ConditionalExpression) MutateConsequentType 

func (rcv *ConditionalExpression) MutateConsequentType(n byte) bool

func (*ConditionalExpression) MutateTestType 

func (rcv *ConditionalExpression) MutateTestType(n byte) bool

func (*ConditionalExpression) Table 

func (rcv *ConditionalExpression) Table() flatbuffers.Table

func (*ConditionalExpression) Test 

func (rcv *ConditionalExpression) Test(obj *flatbuffers.Table) bool

func (*ConditionalExpression) TestType 

func (rcv *ConditionalExpression) TestType() byte

type DateTimeLiteral 

type DateTimeLiteral struct {
	// contains filtered or unexported fields
}

func GetRootAsDateTimeLiteral 

func GetRootAsDateTimeLiteral(buf []byte, offset flatbuffers.UOffsetT) *DateTimeLiteral

func (*DateTimeLiteral) BaseNode 

func (rcv *DateTimeLiteral) BaseNode(obj *BaseNode) *BaseNode

func (*DateTimeLiteral) Init 

func (rcv *DateTimeLiteral) Init(buf []byte, i flatbuffers.UOffsetT)

func (*DateTimeLiteral) Table 

func (rcv *DateTimeLiteral) Table() flatbuffers.Table

func (*DateTimeLiteral) Value 

func (rcv *DateTimeLiteral) Value() []byte

type Duration 

type Duration struct {
	// contains filtered or unexported fields
}

func GetRootAsDuration 

func GetRootAsDuration(buf []byte, offset flatbuffers.UOffsetT) *Duration

func (*Duration) Init 

func (rcv *Duration) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Duration) Magnitude 

func (rcv *Duration) Magnitude() int64

func (*Duration) MutateMagnitude 

func (rcv *Duration) MutateMagnitude(n int64) bool

func (*Duration) MutateUnit 

func (rcv *Duration) MutateUnit(n TimeUnit) bool

func (*Duration) Table 

func (rcv *Duration) Table() flatbuffers.Table

func (*Duration) Unit 

func (rcv *Duration) Unit() TimeUnit

type DurationLiteral 

type DurationLiteral struct {
	// contains filtered or unexported fields
}

func GetRootAsDurationLiteral 

func GetRootAsDurationLiteral(buf []byte, offset flatbuffers.UOffsetT) *DurationLiteral

func (*DurationLiteral) BaseNode 

func (rcv *DurationLiteral) BaseNode(obj *BaseNode) *BaseNode

func (*DurationLiteral) Init 

func (rcv *DurationLiteral) Init(buf []byte, i flatbuffers.UOffsetT)

func (*DurationLiteral) Table 

func (rcv *DurationLiteral) Table() flatbuffers.Table

func (*DurationLiteral) Values 

func (rcv *DurationLiteral) Values(obj *Duration, j int) bool

func (*DurationLiteral) ValuesLength 

func (rcv *DurationLiteral) ValuesLength() int

type Expression 

type Expression = byte
const (
	ExpressionNONE                   Expression = 0
	ExpressionStringExpression       Expression = 1
	ExpressionParenExpression        Expression = 2
	ExpressionArrayExpression        Expression = 3
	ExpressionFunctionExpression     Expression = 4
	ExpressionBinaryExpression       Expression = 5
	ExpressionBooleanLiteral         Expression = 6
	ExpressionCallExpression         Expression = 7
	ExpressionConditionalExpression  Expression = 8
	ExpressionDateTimeLiteral        Expression = 9
	ExpressionDurationLiteral        Expression = 10
	ExpressionFloatLiteral           Expression = 11
	ExpressionIdentifier             Expression = 12
	ExpressionIntegerLiteral         Expression = 13
	ExpressionLogicalExpression      Expression = 14
	ExpressionMemberExpression       Expression = 15
	ExpressionIndexExpression        Expression = 16
	ExpressionObjectExpression       Expression = 17
	ExpressionPipeExpression         Expression = 18
	ExpressionPipeLiteral            Expression = 19
	ExpressionRegexpLiteral          Expression = 20
	ExpressionStringLiteral          Expression = 21
	ExpressionUnaryExpression        Expression = 22
	ExpressionUnsignedIntegerLiteral Expression = 23
)

type ExpressionOrBlock 

type ExpressionOrBlock = byte
const (
	ExpressionOrBlockNONE              ExpressionOrBlock = 0
	ExpressionOrBlockBlock             ExpressionOrBlock = 1
	ExpressionOrBlockWrappedExpression ExpressionOrBlock = 2
)

type ExpressionStatement 

type ExpressionStatement struct {
	// contains filtered or unexported fields
}

func GetRootAsExpressionStatement 

func GetRootAsExpressionStatement(buf []byte, offset flatbuffers.UOffsetT) *ExpressionStatement

func (*ExpressionStatement) BaseNode 

func (rcv *ExpressionStatement) BaseNode(obj *BaseNode) *BaseNode

func (*ExpressionStatement) Expression 

func (rcv *ExpressionStatement) Expression(obj *flatbuffers.Table) bool

func (*ExpressionStatement) ExpressionType 

func (rcv *ExpressionStatement) ExpressionType() byte

func (*ExpressionStatement) Init 

func (rcv *ExpressionStatement) Init(buf []byte, i flatbuffers.UOffsetT)

func (*ExpressionStatement) MutateExpressionType 

func (rcv *ExpressionStatement) MutateExpressionType(n byte) bool

func (*ExpressionStatement) Table 

func (rcv *ExpressionStatement) Table() flatbuffers.Table

type File 

type File struct {
	// contains filtered or unexported fields
}

func GetRootAsFile 

func GetRootAsFile(buf []byte, offset flatbuffers.UOffsetT) *File

func (*File) BaseNode 

func (rcv *File) BaseNode(obj *BaseNode) *BaseNode

func (*File) Body 

func (rcv *File) Body(obj *WrappedStatement, j int) bool

func (*File) BodyLength 

func (rcv *File) BodyLength() int

func (*File) Imports 

func (rcv *File) Imports(obj *ImportDeclaration, j int) bool

func (*File) ImportsLength 

func (rcv *File) ImportsLength() int

func (*File) Init 

func (rcv *File) Init(buf []byte, i flatbuffers.UOffsetT)

func (*File) Name 

func (rcv *File) Name() []byte

func (*File) Package 

func (rcv *File) Package(obj *PackageClause) *PackageClause

func (*File) Table 

func (rcv *File) Table() flatbuffers.Table

type FloatLiteral 

type FloatLiteral struct {
	// contains filtered or unexported fields
}

func GetRootAsFloatLiteral 

func GetRootAsFloatLiteral(buf []byte, offset flatbuffers.UOffsetT) *FloatLiteral

func (*FloatLiteral) BaseNode 

func (rcv *FloatLiteral) BaseNode(obj *BaseNode) *BaseNode

func (*FloatLiteral) Init 

func (rcv *FloatLiteral) Init(buf []byte, i flatbuffers.UOffsetT)

func (*FloatLiteral) MutateValue 

func (rcv *FloatLiteral) MutateValue(n float64) bool

func (*FloatLiteral) Table 

func (rcv *FloatLiteral) Table() flatbuffers.Table

func (*FloatLiteral) Value 

func (rcv *FloatLiteral) Value() float64

type FunctionExpression 

type FunctionExpression struct {
	// contains filtered or unexported fields
}

func GetRootAsFunctionExpression 

func GetRootAsFunctionExpression(buf []byte, offset flatbuffers.UOffsetT) *FunctionExpression

func (*FunctionExpression) BaseNode 

func (rcv *FunctionExpression) BaseNode(obj *BaseNode) *BaseNode

func (*FunctionExpression) Body 

func (rcv *FunctionExpression) Body(obj *flatbuffers.Table) bool

func (*FunctionExpression) BodyType 

func (rcv *FunctionExpression) BodyType() byte

func (*FunctionExpression) Init 

func (rcv *FunctionExpression) Init(buf []byte, i flatbuffers.UOffsetT)

func (*FunctionExpression) MutateBodyType 

func (rcv *FunctionExpression) MutateBodyType(n byte) bool

func (*FunctionExpression) Params 

func (rcv *FunctionExpression) Params(obj *Property, j int) bool

func (*FunctionExpression) ParamsLength 

func (rcv *FunctionExpression) ParamsLength() int

func (*FunctionExpression) Table 

func (rcv *FunctionExpression) Table() flatbuffers.Table

type Identifier 

type Identifier struct {
	// contains filtered or unexported fields
}

func GetRootAsIdentifier 

func GetRootAsIdentifier(buf []byte, offset flatbuffers.UOffsetT) *Identifier

func (*Identifier) BaseNode 

func (rcv *Identifier) BaseNode(obj *BaseNode) *BaseNode

func (*Identifier) Init 

func (rcv *Identifier) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Identifier) Name 

func (rcv *Identifier) Name() []byte

func (*Identifier) Table 

func (rcv *Identifier) Table() flatbuffers.Table

type ImportDeclaration 

type ImportDeclaration struct {
	// contains filtered or unexported fields
}

func GetRootAsImportDeclaration 

func GetRootAsImportDeclaration(buf []byte, offset flatbuffers.UOffsetT) *ImportDeclaration

func (*ImportDeclaration) As 

func (rcv *ImportDeclaration) As(obj *Identifier) *Identifier

func (*ImportDeclaration) BaseNode 

func (rcv *ImportDeclaration) BaseNode(obj *BaseNode) *BaseNode

func (*ImportDeclaration) Init 

func (rcv *ImportDeclaration) Init(buf []byte, i flatbuffers.UOffsetT)

func (*ImportDeclaration) Path 

func (rcv *ImportDeclaration) Path(obj *StringLiteral) *StringLiteral

func (*ImportDeclaration) Table 

func (rcv *ImportDeclaration) Table() flatbuffers.Table

type IndexExpression 

type IndexExpression struct {
	// contains filtered or unexported fields
}

func GetRootAsIndexExpression 

func GetRootAsIndexExpression(buf []byte, offset flatbuffers.UOffsetT) *IndexExpression

func (*IndexExpression) Array 

func (rcv *IndexExpression) Array(obj *flatbuffers.Table) bool

func (*IndexExpression) ArrayType 

func (rcv *IndexExpression) ArrayType() byte

func (*IndexExpression) BaseNode 

func (rcv *IndexExpression) BaseNode(obj *BaseNode) *BaseNode

func (*IndexExpression) Index 

func (rcv *IndexExpression) Index(obj *flatbuffers.Table) bool

func (*IndexExpression) IndexType 

func (rcv *IndexExpression) IndexType() byte

func (*IndexExpression) Init 

func (rcv *IndexExpression) Init(buf []byte, i flatbuffers.UOffsetT)

func (*IndexExpression) MutateArrayType 

func (rcv *IndexExpression) MutateArrayType(n byte) bool

func (*IndexExpression) MutateIndexType 

func (rcv *IndexExpression) MutateIndexType(n byte) bool

func (*IndexExpression) Table 

func (rcv *IndexExpression) Table() flatbuffers.Table

type IntegerLiteral 

type IntegerLiteral struct {
	// contains filtered or unexported fields
}

func GetRootAsIntegerLiteral 

func GetRootAsIntegerLiteral(buf []byte, offset flatbuffers.UOffsetT) *IntegerLiteral

func (*IntegerLiteral) BaseNode 

func (rcv *IntegerLiteral) BaseNode(obj *BaseNode) *BaseNode

func (*IntegerLiteral) Init 

func (rcv *IntegerLiteral) Init(buf []byte, i flatbuffers.UOffsetT)

func (*IntegerLiteral) MutateValue 

func (rcv *IntegerLiteral) MutateValue(n int64) bool

func (*IntegerLiteral) Table 

func (rcv *IntegerLiteral) Table() flatbuffers.Table

func (*IntegerLiteral) Value 

func (rcv *IntegerLiteral) Value() int64

type InterpolatedPart 

type InterpolatedPart struct {
	// contains filtered or unexported fields
}

func GetRootAsInterpolatedPart 

func GetRootAsInterpolatedPart(buf []byte, offset flatbuffers.UOffsetT) *InterpolatedPart

func (*InterpolatedPart) BaseNode 

func (rcv *InterpolatedPart) BaseNode(obj *BaseNode) *BaseNode

func (*InterpolatedPart) Expression 

func (rcv *InterpolatedPart) Expression(obj *flatbuffers.Table) bool

func (*InterpolatedPart) ExpressionType 

func (rcv *InterpolatedPart) ExpressionType() byte

func (*InterpolatedPart) Init 

func (rcv *InterpolatedPart) Init(buf []byte, i flatbuffers.UOffsetT)

func (*InterpolatedPart) MutateExpressionType 

func (rcv *InterpolatedPart) MutateExpressionType(n byte) bool

func (*InterpolatedPart) Table 

func (rcv *InterpolatedPart) Table() flatbuffers.Table

type LogicalExpression 

type LogicalExpression struct {
	// contains filtered or unexported fields
}

func GetRootAsLogicalExpression 

func GetRootAsLogicalExpression(buf []byte, offset flatbuffers.UOffsetT) *LogicalExpression

func (*LogicalExpression) BaseNode 

func (rcv *LogicalExpression) BaseNode(obj *BaseNode) *BaseNode

func (*LogicalExpression) Init 

func (rcv *LogicalExpression) Init(buf []byte, i flatbuffers.UOffsetT)

func (*LogicalExpression) Left 

func (rcv *LogicalExpression) Left(obj *flatbuffers.Table) bool

func (*LogicalExpression) LeftType 

func (rcv *LogicalExpression) LeftType() byte

func (*LogicalExpression) MutateLeftType 

func (rcv *LogicalExpression) MutateLeftType(n byte) bool

func (*LogicalExpression) MutateOperator 

func (rcv *LogicalExpression) MutateOperator(n Operator) bool

func (*LogicalExpression) MutateRightType 

func (rcv *LogicalExpression) MutateRightType(n byte) bool

func (*LogicalExpression) Operator 

func (rcv *LogicalExpression) Operator() Operator

func (*LogicalExpression) Right 

func (rcv *LogicalExpression) Right(obj *flatbuffers.Table) bool

func (*LogicalExpression) RightType 

func (rcv *LogicalExpression) RightType() byte

func (*LogicalExpression) Table 

func (rcv *LogicalExpression) Table() flatbuffers.Table

type LogicalOperator 

type LogicalOperator = int8
const (
	LogicalOperatorAndOperator LogicalOperator = 0
	LogicalOperatorOrOperator  LogicalOperator = 1
)

type MemberAssignment 

type MemberAssignment struct {
	// contains filtered or unexported fields
}

func GetRootAsMemberAssignment 

func GetRootAsMemberAssignment(buf []byte, offset flatbuffers.UOffsetT) *MemberAssignment

func (*MemberAssignment) BaseNode 

func (rcv *MemberAssignment) BaseNode(obj *BaseNode) *BaseNode

func (*MemberAssignment) Init 

func (rcv *MemberAssignment) Init(buf []byte, i flatbuffers.UOffsetT)

func (*MemberAssignment) Init_ 

func (rcv *MemberAssignment) Init_(obj *flatbuffers.Table) bool

func (*MemberAssignment) Init_type 

func (rcv *MemberAssignment) Init_type() byte

func (*MemberAssignment) Member 

func (rcv *MemberAssignment) Member(obj *MemberExpression) *MemberExpression

func (*MemberAssignment) MutateInit_type 

func (rcv *MemberAssignment) MutateInit_type(n byte) bool

func (*MemberAssignment) Table 

func (rcv *MemberAssignment) Table() flatbuffers.Table

type MemberExpression 

type MemberExpression struct {
	// contains filtered or unexported fields
}

func GetRootAsMemberExpression 

func GetRootAsMemberExpression(buf []byte, offset flatbuffers.UOffsetT) *MemberExpression

func (*MemberExpression) BaseNode 

func (rcv *MemberExpression) BaseNode(obj *BaseNode) *BaseNode

func (*MemberExpression) Init 

func (rcv *MemberExpression) Init(buf []byte, i flatbuffers.UOffsetT)

func (*MemberExpression) MutateObjectType 

func (rcv *MemberExpression) MutateObjectType(n byte) bool

func (*MemberExpression) MutatePropertyType 

func (rcv *MemberExpression) MutatePropertyType(n byte) bool

func (*MemberExpression) Object 

func (rcv *MemberExpression) Object(obj *flatbuffers.Table) bool

func (*MemberExpression) ObjectType 

func (rcv *MemberExpression) ObjectType() byte

func (*MemberExpression) Property 

func (rcv *MemberExpression) Property(obj *flatbuffers.Table) bool

func (*MemberExpression) PropertyType 

func (rcv *MemberExpression) PropertyType() byte

func (*MemberExpression) Table 

func (rcv *MemberExpression) Table() flatbuffers.Table

type ObjectExpression 

type ObjectExpression struct {
	// contains filtered or unexported fields
}

func GetRootAsObjectExpression 

func GetRootAsObjectExpression(buf []byte, offset flatbuffers.UOffsetT) *ObjectExpression

func (*ObjectExpression) BaseNode 

func (rcv *ObjectExpression) BaseNode(obj *BaseNode) *BaseNode

func (*ObjectExpression) Init 

func (rcv *ObjectExpression) Init(buf []byte, i flatbuffers.UOffsetT)

func (*ObjectExpression) Properties 

func (rcv *ObjectExpression) Properties(obj *Property, j int) bool

func (*ObjectExpression) PropertiesLength 

func (rcv *ObjectExpression) PropertiesLength() int

func (*ObjectExpression) Table 

func (rcv *ObjectExpression) Table() flatbuffers.Table

func (*ObjectExpression) With 

func (rcv *ObjectExpression) With(obj *Identifier) *Identifier

type Operator 

type Operator = int8
const (
	OperatorMultiplicationOperator   Operator = 0
	OperatorDivisionOperator         Operator = 1
	OperatorModuloOperator           Operator = 2
	OperatorPowerOperator            Operator = 3
	OperatorAdditionOperator         Operator = 4
	OperatorSubtractionOperator      Operator = 5
	OperatorLessThanEqualOperator    Operator = 6
	OperatorLessThanOperator         Operator = 7
	OperatorGreaterThanEqualOperator Operator = 8
	OperatorGreaterThanOperator      Operator = 9
	OperatorStartsWithOperator       Operator = 10
	OperatorInOperator               Operator = 11
	OperatorNotOperator              Operator = 12
	OperatorExistsOperator           Operator = 13
	OperatorNotEmptyOperator         Operator = 14
	OperatorEmptyOperator            Operator = 15
	OperatorEqualOperator            Operator = 16
	OperatorNotEqualOperator         Operator = 17
	OperatorRegexpMatchOperator      Operator = 18
	OperatorNotRegexpMatchOperator   Operator = 19
)

type OptionStatement 

type OptionStatement struct {
	// contains filtered or unexported fields
}

func GetRootAsOptionStatement 

func GetRootAsOptionStatement(buf []byte, offset flatbuffers.UOffsetT) *OptionStatement

func (*OptionStatement) Assignment 

func (rcv *OptionStatement) Assignment(obj *flatbuffers.Table) bool

func (*OptionStatement) AssignmentType 

func (rcv *OptionStatement) AssignmentType() byte

func (*OptionStatement) BaseNode 

func (rcv *OptionStatement) BaseNode(obj *BaseNode) *BaseNode

func (*OptionStatement) Init 

func (rcv *OptionStatement) Init(buf []byte, i flatbuffers.UOffsetT)

func (*OptionStatement) MutateAssignmentType 

func (rcv *OptionStatement) MutateAssignmentType(n byte) bool

func (*OptionStatement) Table 

func (rcv *OptionStatement) Table() flatbuffers.Table

type Package 

type Package struct {
	// contains filtered or unexported fields
}

func GetRootAsPackage 

func GetRootAsPackage(buf []byte, offset flatbuffers.UOffsetT) *Package

func (*Package) BaseNode 

func (rcv *Package) BaseNode(obj *BaseNode) *BaseNode

func (*Package) Files 

func (rcv *Package) Files(obj *File, j int) bool

func (*Package) FilesLength 

func (rcv *Package) FilesLength() int

func (*Package) Init 

func (rcv *Package) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Package) Package 

func (rcv *Package) Package() []byte

func (*Package) Path 

func (rcv *Package) Path() []byte

func (*Package) Table 

func (rcv *Package) Table() flatbuffers.Table

type PackageClause 

type PackageClause struct {
	// contains filtered or unexported fields
}

func GetRootAsPackageClause 

func GetRootAsPackageClause(buf []byte, offset flatbuffers.UOffsetT) *PackageClause

func (*PackageClause) BaseNode 

func (rcv *PackageClause) BaseNode(obj *BaseNode) *BaseNode

func (*PackageClause) Init 

func (rcv *PackageClause) Init(buf []byte, i flatbuffers.UOffsetT)

func (*PackageClause) Name 

func (rcv *PackageClause) Name(obj *Identifier) *Identifier

func (*PackageClause) Table 

func (rcv *PackageClause) Table() flatbuffers.Table

type ParenExpression 

type ParenExpression struct {
	// contains filtered or unexported fields
}

func GetRootAsParenExpression 

func GetRootAsParenExpression(buf []byte, offset flatbuffers.UOffsetT) *ParenExpression

func (*ParenExpression) BaseNode 

func (rcv *ParenExpression) BaseNode(obj *BaseNode) *BaseNode

func (*ParenExpression) Expression 

func (rcv *ParenExpression) Expression(obj *flatbuffers.Table) bool

func (*ParenExpression) ExpressionType 

func (rcv *ParenExpression) ExpressionType() byte

func (*ParenExpression) Init 

func (rcv *ParenExpression) Init(buf []byte, i flatbuffers.UOffsetT)

func (*ParenExpression) MutateExpressionType 

func (rcv *ParenExpression) MutateExpressionType(n byte) bool

func (*ParenExpression) Table 

func (rcv *ParenExpression) Table() flatbuffers.Table

type PipeExpression 

type PipeExpression struct {
	// contains filtered or unexported fields
}

func GetRootAsPipeExpression 

func GetRootAsPipeExpression(buf []byte, offset flatbuffers.UOffsetT) *PipeExpression

func (*PipeExpression) Argument 

func (rcv *PipeExpression) Argument(obj *flatbuffers.Table) bool

func (*PipeExpression) ArgumentType 

func (rcv *PipeExpression) ArgumentType() byte

func (*PipeExpression) BaseNode 

func (rcv *PipeExpression) BaseNode(obj *BaseNode) *BaseNode

func (*PipeExpression) Call 

func (rcv *PipeExpression) Call(obj *CallExpression) *CallExpression

func (*PipeExpression) Init 

func (rcv *PipeExpression) Init(buf []byte, i flatbuffers.UOffsetT)

func (*PipeExpression) MutateArgumentType 

func (rcv *PipeExpression) MutateArgumentType(n byte) bool

func (*PipeExpression) Table 

func (rcv *PipeExpression) Table() flatbuffers.Table

type PipeLiteral 

type PipeLiteral struct {
	// contains filtered or unexported fields
}

func GetRootAsPipeLiteral 

func GetRootAsPipeLiteral(buf []byte, offset flatbuffers.UOffsetT) *PipeLiteral

func (*PipeLiteral) BaseNode 

func (rcv *PipeLiteral) BaseNode(obj *BaseNode) *BaseNode

func (*PipeLiteral) Init 

func (rcv *PipeLiteral) Init(buf []byte, i flatbuffers.UOffsetT)

func (*PipeLiteral) Table 

func (rcv *PipeLiteral) Table() flatbuffers.Table

type Position 

type Position struct {
	// contains filtered or unexported fields
}

func (*Position) Column 

func (rcv *Position) Column() int32

func (*Position) Init 

func (rcv *Position) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Position) Line 

func (rcv *Position) Line() int32

func (*Position) MutateColumn 

func (rcv *Position) MutateColumn(n int32) bool

func (*Position) MutateLine 

func (rcv *Position) MutateLine(n int32) bool

func (*Position) Table 

func (rcv *Position) Table() flatbuffers.Table

type Property 

type Property struct {
	// contains filtered or unexported fields
}

func GetRootAsProperty 

func GetRootAsProperty(buf []byte, offset flatbuffers.UOffsetT) *Property

func (*Property) BaseNode 

func (rcv *Property) BaseNode(obj *BaseNode) *BaseNode

func (*Property) Init 

func (rcv *Property) Init(buf []byte, i flatbuffers.UOffsetT)

func (*Property) Key 

func (rcv *Property) Key(obj *flatbuffers.Table) bool

func (*Property) KeyType 

func (rcv *Property) KeyType() byte

func (*Property) MutateKeyType 

func (rcv *Property) MutateKeyType(n byte) bool

func (*Property) MutateValueType 

func (rcv *Property) MutateValueType(n byte) bool

func (*Property) Table 

func (rcv *Property) Table() flatbuffers.Table

func (*Property) Value 

func (rcv *Property) Value(obj *flatbuffers.Table) bool

func (*Property) ValueType 

func (rcv *Property) ValueType() byte

type PropertyKey 

type PropertyKey = byte
const (
	PropertyKeyNONE          PropertyKey = 0
	PropertyKeyIdentifier    PropertyKey = 1
	PropertyKeyStringLiteral PropertyKey = 2
)

type RegexpLiteral 

type RegexpLiteral struct {
	// contains filtered or unexported fields
}

func GetRootAsRegexpLiteral 

func GetRootAsRegexpLiteral(buf []byte, offset flatbuffers.UOffsetT) *RegexpLiteral

func (*RegexpLiteral) BaseNode 

func (rcv *RegexpLiteral) BaseNode(obj *BaseNode) *BaseNode

func (*RegexpLiteral) Init 

func (rcv *RegexpLiteral) Init(buf []byte, i flatbuffers.UOffsetT)

func (*RegexpLiteral) Table 

func (rcv *RegexpLiteral) Table() flatbuffers.Table

func (*RegexpLiteral) Value 

func (rcv *RegexpLiteral) Value() []byte

type ReturnStatement 

type ReturnStatement struct {
	// contains filtered or unexported fields
}

func GetRootAsReturnStatement 

func GetRootAsReturnStatement(buf []byte, offset flatbuffers.UOffsetT) *ReturnStatement

func (*ReturnStatement) Argument 

func (rcv *ReturnStatement) Argument(obj *flatbuffers.Table) bool

func (*ReturnStatement) ArgumentType 

func (rcv *ReturnStatement) ArgumentType() byte

func (*ReturnStatement) BaseNode 

func (rcv *ReturnStatement) BaseNode(obj *BaseNode) *BaseNode

func (*ReturnStatement) Init 

func (rcv *ReturnStatement) Init(buf []byte, i flatbuffers.UOffsetT)

func (*ReturnStatement) MutateArgumentType 

func (rcv *ReturnStatement) MutateArgumentType(n byte) bool

func (*ReturnStatement) Table 

func (rcv *ReturnStatement) Table() flatbuffers.Table

type SourceLocation 

type SourceLocation struct {
	// contains filtered or unexported fields
}

func GetRootAsSourceLocation 

func GetRootAsSourceLocation(buf []byte, offset flatbuffers.UOffsetT) *SourceLocation

func (*SourceLocation) End 

func (rcv *SourceLocation) End(obj *Position) *Position

func (*SourceLocation) File 

func (rcv *SourceLocation) File() []byte

func (*SourceLocation) Init 

func (rcv *SourceLocation) Init(buf []byte, i flatbuffers.UOffsetT)

func (*SourceLocation) Source 

func (rcv *SourceLocation) Source() []byte

func (*SourceLocation) Start 

func (rcv *SourceLocation) Start(obj *Position) *Position

func (*SourceLocation) Table 

func (rcv *SourceLocation) Table() flatbuffers.Table

type Statement 

type Statement = byte
const (
	StatementNONE                Statement = 0
	StatementBadStatement        Statement = 1
	StatementVariableAssignment  Statement = 2
	StatementMemberAssignment    Statement = 3
	StatementExpressionStatement Statement = 4
	StatementReturnStatement     Statement = 5
	StatementOptionStatement     Statement = 6
	StatementBuiltinStatement    Statement = 7
	StatementTestStatement       Statement = 8
)

type StringExpression 

type StringExpression struct {
	// contains filtered or unexported fields
}

func GetRootAsStringExpression 

func GetRootAsStringExpression(buf []byte, offset flatbuffers.UOffsetT) *StringExpression

func (*StringExpression) BaseNode 

func (rcv *StringExpression) BaseNode(obj *BaseNode) *BaseNode

func (*StringExpression) Init 

func (rcv *StringExpression) Init(buf []byte, i flatbuffers.UOffsetT)

func (*StringExpression) Parts 

func (rcv *StringExpression) Parts(obj *StringExpressionPart, j int) bool

func (*StringExpression) PartsLength 

func (rcv *StringExpression) PartsLength() int

func (*StringExpression) Table 

func (rcv *StringExpression) Table() flatbuffers.Table

type StringExpressionPart 

type StringExpressionPart struct {
	// contains filtered or unexported fields
}

func GetRootAsStringExpressionPart 

func GetRootAsStringExpressionPart(buf []byte, offset flatbuffers.UOffsetT) *StringExpressionPart

func (*StringExpressionPart) BaseNode 

func (rcv *StringExpressionPart) BaseNode(obj *BaseNode) *BaseNode

func (*StringExpressionPart) Init 

func (rcv *StringExpressionPart) Init(buf []byte, i flatbuffers.UOffsetT)

func (*StringExpressionPart) InterpolatedExpression 

func (rcv *StringExpressionPart) InterpolatedExpression(obj *flatbuffers.Table) bool

func (*StringExpressionPart) InterpolatedExpressionType 

func (rcv *StringExpressionPart) InterpolatedExpressionType() byte

func (*StringExpressionPart) MutateInterpolatedExpressionType 

func (rcv *StringExpressionPart) MutateInterpolatedExpressionType(n byte) bool

func (*StringExpressionPart) Table 

func (rcv *StringExpressionPart) Table() flatbuffers.Table

func (*StringExpressionPart) TextValue 

func (rcv *StringExpressionPart) TextValue() []byte

type StringLiteral 

type StringLiteral struct {
	// contains filtered or unexported fields
}

func GetRootAsStringLiteral 

func GetRootAsStringLiteral(buf []byte, offset flatbuffers.UOffsetT) *StringLiteral

func (*StringLiteral) BaseNode 

func (rcv *StringLiteral) BaseNode(obj *BaseNode) *BaseNode

func (*StringLiteral) Init 

func (rcv *StringLiteral) Init(buf []byte, i flatbuffers.UOffsetT)

func (*StringLiteral) Table 

func (rcv *StringLiteral) Table() flatbuffers.Table

func (*StringLiteral) Value 

func (rcv *StringLiteral) Value() []byte

type TestStatement 

type TestStatement struct {
	// contains filtered or unexported fields
}

func GetRootAsTestStatement 

func GetRootAsTestStatement(buf []byte, offset flatbuffers.UOffsetT) *TestStatement

func (*TestStatement) Assignment 

func (rcv *TestStatement) Assignment(obj *flatbuffers.Table) bool

func (*TestStatement) AssignmentType 

func (rcv *TestStatement) AssignmentType() byte

func (*TestStatement) BaseNode 

func (rcv *TestStatement) BaseNode(obj *BaseNode) *BaseNode

func (*TestStatement) Init 

func (rcv *TestStatement) Init(buf []byte, i flatbuffers.UOffsetT)

func (*TestStatement) MutateAssignmentType 

func (rcv *TestStatement) MutateAssignmentType(n byte) bool

func (*TestStatement) Table 

func (rcv *TestStatement) Table() flatbuffers.Table

type TextPart 

type TextPart struct {
	// contains filtered or unexported fields
}

func GetRootAsTextPart 

func GetRootAsTextPart(buf []byte, offset flatbuffers.UOffsetT) *TextPart

func (*TextPart) BaseNode 

func (rcv *TextPart) BaseNode(obj *BaseNode) *BaseNode

func (*TextPart) Init 

func (rcv *TextPart) Init(buf []byte, i flatbuffers.UOffsetT)

func (*TextPart) Table 

func (rcv *TextPart) Table() flatbuffers.Table

func (*TextPart) Value 

func (rcv *TextPart) Value() []byte

type TimeUnit 

type TimeUnit = int8
const (
	TimeUnity  TimeUnit = 0
	TimeUnitmo TimeUnit = 1
	TimeUnitw  TimeUnit = 2
	TimeUnitd  TimeUnit = 3
	TimeUnith  TimeUnit = 4
	TimeUnitm  TimeUnit = 5
	TimeUnits  TimeUnit = 6
	TimeUnitms TimeUnit = 7
	TimeUnitus TimeUnit = 8
	TimeUnitns TimeUnit = 9
)

type UnaryExpression 

type UnaryExpression struct {
	// contains filtered or unexported fields
}

func GetRootAsUnaryExpression 

func GetRootAsUnaryExpression(buf []byte, offset flatbuffers.UOffsetT) *UnaryExpression

func (*UnaryExpression) Argument 

func (rcv *UnaryExpression) Argument(obj *flatbuffers.Table) bool

func (*UnaryExpression) ArgumentType 

func (rcv *UnaryExpression) ArgumentType() byte

func (*UnaryExpression) BaseNode 

func (rcv *UnaryExpression) BaseNode(obj *BaseNode) *BaseNode

func (*UnaryExpression) Init 

func (rcv *UnaryExpression) Init(buf []byte, i flatbuffers.UOffsetT)

func (*UnaryExpression) MutateArgumentType 

func (rcv *UnaryExpression) MutateArgumentType(n byte) bool

func (*UnaryExpression) MutateOperator 

func (rcv *UnaryExpression) MutateOperator(n Operator) bool

func (*UnaryExpression) Operator 

func (rcv *UnaryExpression) Operator() Operator

func (*UnaryExpression) Table 

func (rcv *UnaryExpression) Table() flatbuffers.Table

type UnsignedIntegerLiteral 

type UnsignedIntegerLiteral struct {
	// contains filtered or unexported fields
}

func GetRootAsUnsignedIntegerLiteral 

func GetRootAsUnsignedIntegerLiteral(buf []byte, offset flatbuffers.UOffsetT) *UnsignedIntegerLiteral

func (*UnsignedIntegerLiteral) BaseNode 

func (rcv *UnsignedIntegerLiteral) BaseNode(obj *BaseNode) *BaseNode

func (*UnsignedIntegerLiteral) Init 

func (rcv *UnsignedIntegerLiteral) Init(buf []byte, i flatbuffers.UOffsetT)

func (*UnsignedIntegerLiteral) MutateValue 

func (rcv *UnsignedIntegerLiteral) MutateValue(n uint64) bool

func (*UnsignedIntegerLiteral) Table 

func (rcv *UnsignedIntegerLiteral) Table() flatbuffers.Table

func (*UnsignedIntegerLiteral) Value 

func (rcv *UnsignedIntegerLiteral) Value() uint64

type VariableAssignment 

type VariableAssignment struct {
	// contains filtered or unexported fields
}

func GetRootAsVariableAssignment 

func GetRootAsVariableAssignment(buf []byte, offset flatbuffers.UOffsetT) *VariableAssignment

func (*VariableAssignment) BaseNode 

func (rcv *VariableAssignment) BaseNode(obj *BaseNode) *BaseNode

func (*VariableAssignment) Id 

func (rcv *VariableAssignment) Id(obj *Identifier) *Identifier

func (*VariableAssignment) Init 

func (rcv *VariableAssignment) Init(buf []byte, i flatbuffers.UOffsetT)

func (*VariableAssignment) Init_ 

func (rcv *VariableAssignment) Init_(obj *flatbuffers.Table) bool

func (*VariableAssignment) Init_type 

func (rcv *VariableAssignment) Init_type() byte

func (*VariableAssignment) MutateInit_type 

func (rcv *VariableAssignment) MutateInit_type(n byte) bool

func (*VariableAssignment) Table 

func (rcv *VariableAssignment) Table() flatbuffers.Table

type WrappedExpression 

type WrappedExpression struct {
	// contains filtered or unexported fields
}

func GetRootAsWrappedExpression 

func GetRootAsWrappedExpression(buf []byte, offset flatbuffers.UOffsetT) *WrappedExpression

func (*WrappedExpression) Expr 

func (rcv *WrappedExpression) Expr(obj *flatbuffers.Table) bool

func (*WrappedExpression) ExprType 

func (rcv *WrappedExpression) ExprType() byte

func (*WrappedExpression) Init 

func (rcv *WrappedExpression) Init(buf []byte, i flatbuffers.UOffsetT)

func (*WrappedExpression) MutateExprType 

func (rcv *WrappedExpression) MutateExprType(n byte) bool

func (*WrappedExpression) Table 

func (rcv *WrappedExpression) Table() flatbuffers.Table

type WrappedStatement 

type WrappedStatement struct {
	// contains filtered or unexported fields
}

func GetRootAsWrappedStatement 

func GetRootAsWrappedStatement(buf []byte, offset flatbuffers.UOffsetT) *WrappedStatement

func (*WrappedStatement) Init 

func (rcv *WrappedStatement) Init(buf []byte, i flatbuffers.UOffsetT)

func (*WrappedStatement) MutateStatementType 

func (rcv *WrappedStatement) MutateStatementType(n byte) bool

func (*WrappedStatement) Statement 

func (rcv *WrappedStatement) Statement(obj *flatbuffers.Table) bool

func (*WrappedStatement) StatementType 

func (rcv *WrappedStatement) StatementType() byte

func (*WrappedStatement) Table 

func (rcv *WrappedStatement) Table() flatbuffers.Table

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.