base

type Arg struct {
	Constant       *Constant
	Variable       string
	FunctionCall   *FunctionCall
	MethodCall     *MethodCall
	ThreeLevelCall *ThreeLevelCall
	MapVar         *MapVar
	Expression     *Expression
}

type Args struct {
	ArgList []*Arg
}

type ArgsHolder interface {
	AcceptArgs(funcArg *Args) error
}

type Assignment struct {
	SourceCode
	Variable       string
	MapVar         *MapVar
	AssignOperator string
	MathExpression *MathExpression
	Expression     *Expression
}

type AssignmentHolder interface {
	AcceptAssignment(a *Assignment) error
}

type AtDescHolder interface {
	AcceptDesc(val string) error
}

type AtIdHolder interface {
	AcceptId(val int64) error
}

type AtNameHolder interface {
	AcceptName(val string) error
}

type AtSalienceHolder interface {
	AcceptSalience(val int64) error
}

type BreakStmt struct {
}

type ConcStatement struct {
	Assignments     []*Assignment
	FunctionCalls   []*FunctionCall
	MethodCalls     []*MethodCall
	ThreeLevelCalls []*ThreeLevelCall
}

type Constant struct {
	ConstantValue reflect.Value
}

type ConstantHolder interface {
	AcceptConstant(cons *Constant) error
}

type ContinueStmt struct {
}

type ElseIfStmt struct {
	Expression    *Expression
	StatementList *Statements
}

type ElseStmt struct {
	StatementList *Statements
}

type Expression struct {
	SourceCode
	ExpressionLeft     *Expression
	ExpressionRight    *Expression
	ExpressionAtom     *ExpressionAtom
	MathExpression     *MathExpression
	LogicalOperator    string
	ComparisonOperator string
	NotOperator        string
}

type ExpressionAtom struct {
	SourceCode
	Variable       string
	Constant       *Constant
	FunctionCall   *FunctionCall
	MethodCall     *MethodCall
	ThreeLevelCall *ThreeLevelCall
	MapVar         *MapVar
}

type ExpressionAtomHolder interface {
	AcceptExpressionAtom(atom *ExpressionAtom) error
}

type ExpressionHolder interface {
	AcceptExpression(expression *Expression) error
}

type ForRangeStmt struct {
	SourceCode
	StatementList *Statements
	// contains filtered or unexported fields
}

type ForStmt struct {
	SourceCode
	Expression    *Expression   // 表达式
	StatementList *Statements   // 执行语句列表
	Assignments   []*Assignment // 赋值语句
}

type FunctionCall struct {
	SourceCode
	FunctionName string
	FunctionArgs *Args
}

type FunctionCallHolder interface {
	AcceptFunctionCall(funcCall *FunctionCall) error
}

type IfStmt struct {
	Expression     *Expression
	StatementList  *Statements
	ElseIfStmtList []*ElseIfStmt
	ElseStmt       *ElseStmt
}

type IntegerHolder interface {
	AcceptInteger(val int64) error
}

type KnowledgeContext struct {
	// ruleName - RuleEntity
	RuleEntities      map[string]*RuleEntity
	SortRules         []*RuleEntity
	SortRulesIndexMap map[string]int
}

type MapVar struct {
	SourceCode
	Name   string // map name
	Intkey int64  // array index
	Strkey string // map key
	Varkey string // array index or map key
}

type MapVarHolder interface {
	AcceptMapVar(mv *MapVar) error
}

type MathExpression struct {
	SourceCode
	MathExpressionLeft  *MathExpression
	MathPmOperator      string
	MathMdOperator      string
	MathExpressionRight *MathExpression
	ExpressionAtom      *ExpressionAtom
}

type MathExpressionHolder interface {
	AcceptMathExpression(mh *MathExpression) error
}

type MethodCall struct {
	SourceCode
	MethodName string
	MethodArgs *Args
}

type MethodCallHolder interface {
	AcceptMethodCall(methodCall *MethodCall) error
}

type ReturnStatement struct {
	Expression *Expression
}

type RuleContent struct {
	Statements *Statements
}

type RuleEntity struct {
	RuleName        string
	Salience        int64
	RuleDescription string
	RuleContent     *RuleContent
}

type SourceCode struct {
	Code     string //raw code            -> ctx.GetText()
	LineNum  int    //line number         -> ctx.GetStart().GetLine()
	Column   int    //line start location -> ctx.GetStart().GetColumn()
	LineStop int    //line end location   -> ctx.GetStop().GetColumn()
}

type Statement struct {
	IfStmt         *IfStmt
	MethodCall     *MethodCall
	FunctionCall   *FunctionCall
	ThreeLevelCall *ThreeLevelCall
	Assignment     *Assignment
	ConcStatement  *ConcStatement
	ForStmt        *ForStmt      // for语句
	BreakStmt      *BreakStmt    // break语句
	ForRangeStmt   *ForRangeStmt // forRange语句
	ContinueStmt   *ContinueStmt // continue语句
}

type Statements struct {
	StatementList   []*Statement
	ReturnStatement *ReturnStatement
}

type StatementsHolder interface {
	AcceptStatements(statement *Statements) error
}

type StringHolder interface {
	AcceptString(str string) error
}

type ThreeLevelCall struct {
	SourceCode
	ThreeLevel string
	MethodArgs *Args
}

type ThreeLevelCallHolder interface {
	AcceptThreeLevelCall(threeLevelCall *ThreeLevelCall) error
}

type VariableHolder interface {
	AcceptVariable(name string) error
}