crontabex/condition_test.go

package crontab

// import (
// 	"strconv"
// 	"testing"

// 	"github.com/davecgh/go-spew/spew"
// )

// //xx={xx()},n>f|n > x |{w=5},5<f<8{w=5s;},

// // Condition 条件表达式的结构实例
// type Condition struct {
// 	execList []Execute
// }

// type Cond struct {
// 	expr string
// 	op   string
// }

// type Execute struct {
// 	conds []*Call
// 	calls []*Call
// }

// // func indexOperator(s string, start int) (start int, end int) {
// // 	return 0, 1
// // }

// var VarDict = make(map[string]interface{})
// var FuncDict = make(map[string]func(vars ...interface{}) interface{})

// func init() {
// 	VarDict["w"] = float64(2.0)
// 	VarDict["f"] = float64(0.0)
// 	VarDict["s"] = float64(0.0)
// }

// func parseFunc(fname string) func(...interface{}) interface{} {
// 	return FuncDict[fname]
// }

// func parseVar(v string) float64 {
// 	fvar, err := strconv.ParseFloat(v, 64)
// 	if err != nil {
// 		return VarDict[v].(float64)
// 	}
// 	return fvar
// }

// type Operator struct {
// 	Value   interface{}
// 	Operate func(v1, v2 interface{}) interface{}
// }

// func parseExpr(e string) []Operator {
// 	i := 1
// 	s := 1

// 	isCall := false
// 	// isVar := false

// 	var ops []Operator

// 	for ; i < len(e); i++ {
// 		switch e[i] {
// 		case '(':
// 			isCall = true
// 		case '+':
// 			if isCall {
// 				ops = append(ops, Operator{Value: parseCall(e[s:i]), Operate: Add})
// 			} else {
// 				ops = append(ops, Operator{Value: parseVar(e[s:i]), Operate: Add})
// 			}

// 			s = i + 1
// 			isCall = false

// 		case '-':
// 			if isCall {
// 				ops = append(ops, Operator{Value: parseCall(e[s:i]), Operate: Sub})
// 			} else {
// 				ops = append(ops, Operator{Value: parseVar(e[s:i]), Operate: Sub})
// 			}

// 			s = i + 1
// 			isCall = false
// 		case '*':
// 			if isCall {
// 				ops = append(ops, Operator{Value: parseCall(e[s:i]), Operate: Mul})
// 			} else {
// 				ops = append(ops, Operator{Value: parseVar(e[s:i]), Operate: Mul})
// 			}

// 			s = i + 1
// 			isCall = false
// 		case '/':
// 			if isCall {
// 				ops = append(ops, Operator{Value: parseCall(e[s:i]), Operate: Div})
// 			} else {
// 				ops = append(ops, Operator{Value: parseVar(e[s:i]), Operate: Div})
// 			}

// 			s = i + 1
// 			isCall = false

// 		case '>':

// 		case '<':

// 		case '=':

// 		}
// 	}

// 	return ops
// }

// func parseCallParams(value string) []interface{} {

// 	i := 0
// 	s := 0

// 	var params []interface{}

// 	for ; i < len(value); i++ {
// 		switch value[i] {
// 		case '{':
// 			s++
// 			continue
// 		case ',', '=', ')':
// 			params = append(params, parseExpr(value[s:i]))
// 			s = i + 1
// 		case '|':
// 			params = append(params, parseExpr(value[s:i]))
// 			s = i + 1
// 		}
// 	}

// 	return params
// 	// panic("can't find )")
// }

// type Call struct {
// 	fname  string
// 	params string
// }

// func (call *Call) Execute() {
// 	parseFunc(call.fname)(parseCallParams(call.params)...)
// }

// func parseCall(value string) *Call {

// 	for i := 0; i < len(value); i++ {
// 		switch value[i] {
// 		case '(':
// 			return &Call{fname: value[0:i], params: value[i:]}
// 			// parseFunc(value[0:i])
// 			// parseCallParams(value[i:])
// 		case '=': // assignment
// 			return &Call{fname: "=", params: value}
// 		}
// 	}

// 	return nil
// }

// func parseCondCalls(expr string) []*Call {
// 	// var execList []string
// 	i := 0
// 	s := 0

// 	var calls []*Call

// 	for ; i < len(expr); i++ {
// 		switch expr[i] {
// 		case '|':
// 			calls = append(calls, &Call{fname: "|", params: expr[s:i]})
// 			s = i + 1
// 		case '&':
// 			calls = append(calls, &Call{fname: "&", params: expr[s:i]})
// 			s = i + 1
// 		}
// 	}

// 	if s < i {
// 		calls = append(calls, &Call{fname: "", params: expr[s:i]}) //可能存在问题
// 	}
// 	return calls

// }

// func parseCalls(expr string) []*Call {

// 	// var execList []string
// 	i := 0
// 	s := 0

// 	var calls []*Call
// FOR:
// 	for ; i < len(expr); i++ {
// 		switch expr[i] {
// 		case '}':
// 			break FOR
// 		case ';':
// 			calls = append(calls, parseCall(expr[s:i]))
// 			s = i + 1
// 		}
// 	}

// 	if s < i {
// 		calls = append(calls, parseCall(expr[s:i]))
// 	}
// 	return calls
// }

// func parseDefine(v, method string) {

// }

// func parseConditionList(condExpr string) []string {

// 	var conds []string
// 	OpenClose := 0
// 	cur := 0
// 	i := 0
// 	for ; i < len(condExpr); i++ {
// 		switch condExpr[i] {
// 		case ',':
// 			if OpenClose == 0 {
// 				conds = append(conds, condExpr[cur:i])
// 				cur = i + 1
// 			}
// 		case '(':
// 			OpenClose++
// 		case ')':
// 			OpenClose--
// 		}
// 	}

// 	if cur < i {
// 		conds = append(conds, condExpr[cur:i])
// 	}

// 	return conds
// }

// func TestBaseCond(t *testing.T) {
// 	t.Error()
// 	condition := Condition{}
// 	condExpr := "5>n>12|n<15|add(1,5){w=5},f>5{w=5s;add(1,2)}"

// ParseExpr:
// 	for _, expr := range parseConditionList(condExpr) {
// 		// condexpr

// 		for i := 0; i < len(expr); i++ {

// 			if expr[i] == '{' {
// 				s := i

// 				for s > 0 {
// 					switch expr[s] {
// 					case ' ':
// 						s--
// 					case '=':
// 						// 判断 = 定义表达
// 						parseDefine(expr[0:s], expr[i+1:])
// 						continue ParseExpr

// 					default:
// 						// 判断 = 条件表达

// 						exec := Execute{conds: parseCondCalls(expr[0:s]), calls: parseCalls(expr[i+1:])}
// 						condition.execList = append(condition.execList, exec)

// 						continue ParseExpr

// 					}
// 				}

// 				// 判断 = 执行表达
// 				exec := Execute{calls: parseCalls(expr)}
// 				condition.execList = append(condition.execList, exec)

// 				continue ParseExpr
// 			}

// 		}

// 		// 找不到{ 判断 = 执行表达
// 		exec := Execute{calls: parseCalls(expr)}
// 		condition.execList = append(condition.execList, exec)
// 	}

// 	spew.Dump(condition)
// }