jsonexp

package
v1.4.10 Latest Latest
Warning

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

 Go to latest Published: Apr 6, 2023 License: MIT Imports: 13 Imported by: 0

README

JSON表达式

JSON表达式一个简单优雅而又功能强大的“语义化”的配置语言，可用于各种系统的配置中，让原本静态的配置参数活起来。给你带来全新的思维方式。 JSON表达式组是一个由 n个“JSON表达式”组成的json数组，如下:

{
	"my_json_exp_group": [
		//JSON表达式1
		[

		],
		//JSON表达式2
		[

		]
		//...
	]
}

一个“JSON表达式”的格式如下： 它（“JSON表达式”）是一个json数组，数组的最后一个成员是赋值表达式，其他成员是条件表达式，当所有的条件表达式都成立(返回 真（true）)的时 候， 赋值表达式被执行。如果赋值表达式本身是一个数组，表示多重赋值。 条件表达式和赋值表达式，是一个包含三个成员的形式，第一个成员为系统变量，第二个成员为比较运算符或赋值运算符，第三个成员是运算对象，比如：

[
    ["$hour","=","10"],
    ["$resp.source_icon","=",""],
    ["$resp.source_icon","=","http://xxxxx.jpg"]
]

该"JSON表达式"表达的意思是，如果现在时钟在上午十点区间内，且$resp.source_icon的值为空白，则对$resp.source_icon赋值为http://xxxx.jpg。

若整个"JSON表达式"组中包含不止一个"JSON表达式"，则是按照编写的顺序，从上到下依次执行各个"JSON表达式"的。遇到$break=1,则不再往下执行。

如果"JSON表达式“只有一个成员，这个成员就是赋值表达式。也就是没有条件表达式时，表示无条件执行该赋值表达式。

[
    //由于没有条件表达式，以下赋值表达式无条件执行
    ["$resp.source_icon","=","http://xxxxx.jpg"]
]

如果赋值表达式本身是一个数组，表示多重赋值。 以下举一个多重赋值的例子：

[
    ["$resp.hour","=","10"],
    ["$resp.source_icon","=",""],
    //以下赋值表达式是一个多重赋值表达式，对两个系统变量进行了赋值。
    [ 
        ["$resp.source_icon","=","http://xxxxx.jpg"],
        ["$resp.source","=","ad"]
    ]
]

管道

管道支持对变量进行管道化处理
格式： $varName[|pipeLineFunction1[|pipeLineFunction2[|...]]]
举例：

[
    ["$my_var|md5|fnv32",">", 100000],
    ["$my_var","=", 100000]
]

表示“当变量$my_var的md5哈希的fnv32哈希值>100000时，将$my_var的值设置为100000”

宏

表达式的右值支持宏替换
宏格式：{{$variant}}
举例：

[
    ["$my_var","=", "now: {{$date}}"]
]

最终$my_var将被赋值为 now:2021-11-23

系统变量

表达式中的变量命名必须以$开头，且必须通过Dictionary.RegisterVar进行注册后才可以使用。预定义变量如下：

  • $datetime string yyyy-mm-dd hh:nn:ss
  • $date string yyyy-mm-dd
  • $time string hh:nn:ss
  • $stime string hh:nn
  • $year string yyyy
  • $month string mm
  • $day string dd
  • $hour string hh
  • $minute string nn
  • $second string ss
  • $iyear int 当前4位年份
  • $imonth int 当前月份整数
  • $iday int 当前天1~30(,28,29,31)整数
  • $ihour int 当前小时0~23
  • $iminute int 当前分钟0~59
  • $isecond int 当前秒0~59
  • $rand int 1-100的随机数
  • $break int 当值为1时，终止当前条件表达式组的执行

条件(比较)运算符

  • > 大于
  • >= 大于等于
  • < 小于
  • <= 小于等于
  • = 等于
  • <> 不等于
  • != 不等于
  • between 在区间，例如： [“$ihour”,”between”,”5,10”]表示如果当前时间在5到10点之间
  • ^between between的反义词
  • in 在列表中例如：
  • [“$hour”,”in”,”05,06,07,10”]
  • not in In的反义词，不在列表中
  • has 集合操作符，左值和右值都是以逗号分隔开的集合。 包含，例如 [“$req.mimes”,”has”,”jpg,png”]
  • any 集合操作符，左值和右值都是以逗号分隔开的集合。包含逗号分隔开的一组字符串中的任意一个
  • none 集合操作符，左值和右值都是以逗号分隔开的集合。any的反义词，一个都不包含
  • ~ 包含部分字符串
  • ^~ ~的反义词，不包部分字符串
  • ~* 头部匹配，比如：
  • abcdefg ~* abc 返回真
  • abcdefg ~* cde 返回假
  • ~ 尾部匹配，比如： abcdefg ~ abc 返回假 abcdefg ~* efg 返回真
  • ^~* ~*的反义词
  • ^*~ *~的反义词
  • cv 包含逗号分隔开的部分字符串中的一个或多个，例如： [“$resp.title”,”cv”,”整形,医疗,美容,减肥”]
  • ^cv cv的反义词

系统预定义管道函数

  • len int 返回入参的字符个数
  • upper string 返回入参的英文大写
  • lower string 返回入参的英文小写
  • md5 string 返回入参的md5哈希hex值，小写
  • MD5 string 返回入参的md5哈希hex值，大写
  • fnv32 uint32 返回入参的fnv32哈希值
  • fnv64 uint64 返回入参的fnv64哈希值

赋值操作符

  • = 赋值
  • += 给自己加上某个值
  • -= 给自己减去某个值
  • *= 给自己乘以某个值，如果是字符串，则对字符串进行复制n遍添加到末尾
  • /= 给自己除以某个值
  • %= 给自己除模

Documentation

Index

Constants

View Source 
const (
	PipelineFnLen      = "len"
	PipelineFnUpper    = "upper"
	PipelineFnLower    = "lower"
	PipelineFnFnv32    = "fnv32"
	PipelineFnFnv64    = "fnv64"
	PipelineFnMd5Lower = "md5"
	PipelineFnMd5Upper = "MD5"
)

Variables

View Source 
var AddAssign = func(L string, lValue interface{}, R interface{}, ret Context) error {
	if ret == nil {
		return fmt.Errorf("param ret is nil")
	}

	lType := GetValueType(lValue)
	vType := GetValueType(R)
	if lType == VarInvalid {
		lType = vType
	}
	switch lType {
	case VarStr:
		old, _ := GetStringValue(lValue)
		add, _ := GetStringValue(R)
		ret.SetCtxData(L, old+add)
	case VarFloat:
		old, _ := GetFloatValue(lValue)
		add, _ := GetFloatValue(R)
		ret.SetCtxData(L, old+add)
	case VarInt:
		old, _ := GetIntValue(lValue)
		add, _ := GetIntValue(R)
		ret.SetCtxData(L, old+add)
	default:
		return fmt.Errorf("invalid operand")
	}
	return nil
}
View Source 
var Any = func(L, R interface{}, context Context) (bool, error) {
	l, lOk := GetStringValue(L)
	if !lOk {
		return false, fmt.Errorf("invalid L")
	}
	r, rOk := GetStringValue(R)
	if !rOk {
		return false, fmt.Errorf("right value not string-incompatible")
	}

	if l == "" || r == "" {
		return false, nil
	}

	lList := strings.Split(l, ",")
	rList := strings.Split(r, ",")
	any := false
	for _, v := range rList {
		for _, vL := range lList {
			if v == vL {
				any = true
				break
			}
		}
		if any {
			return true, nil
		}
	}
	return false, nil
}
View Source 
var Assign = func(L string, lValue interface{}, R interface{}, ret Context) error {
	if ret == nil {
		return fmt.Errorf("param ret is nil")
	}
	ret.SetCtxData(L, R)
	return nil
}

assign functions

View Source 
var Between = func(L, R interface{}, context Context) (bool, error) {
	tp := GetValueType(L)
	if tp == VarStr {
		l, _ := GetStringValue(L)
		if r, ok := GetStringValue(R); !ok {
			return false, fmt.Errorf("right value not string-incompatible")
		} else {
			rList := strings.Split(r, ",")
			if len(rList) != 2 {
				return false, fmt.Errorf("right value not a between string")
			} else {
				return l >= rList[0] && l <= rList[1], nil
			}
		}
	} else if tp == VarInt {
		l, _ := GetIntValue(L)
		if r, ok := GetStringValue(R); !ok {
			return false, fmt.Errorf("right value not a between string")
		} else {
			rList := strings.Split(r, ",")
			if len(rList) != 2 {
				return false, fmt.Errorf("right value not a between string")
			} else {
				if b, errB := strconv.ParseInt(rList[0], 0, 64); errB == nil {
					if e, errE := strconv.ParseInt(rList[1], 0, 64); errE == nil {
						return l >= b && l <= e, nil
					}
				}
				return false, fmt.Errorf("right value not a between string")
			}
		}
	} else if tp == VarFloat {
		l, _ := GetFloatValue(L)
		if r, ok := GetStringValue(R); !ok {
			return false, fmt.Errorf("right value not a between string")
		} else {
			rList := strings.Split(r, ",")
			if len(rList) != 2 {
				return false, fmt.Errorf("right value not a between string")
			} else {
				if b, errB := strconv.ParseFloat(rList[0], 64); errB == nil {
					if e, errE := strconv.ParseFloat(rList[1], 64); errE == nil {
						return l >= b && l <= e, nil
					}
				}
				return false, fmt.Errorf("right value not a between string")
			}
		}
	} else {
		return false, fmt.Errorf("invalid data type of L")
	}
}
View Source 
var Contain = func(L, R interface{}, context Context) (bool, error) {
	l, lOk := GetStringValue(L)
	if !lOk {
		return false, fmt.Errorf("invalid L")
	}
	r, rOk := GetStringValue(R)
	if !rOk {
		return false, fmt.Errorf("right value not string-incompatible")
	}

	if l == "" || r == "" {
		return false, nil
	}

	ret := strings.Contains(l, r)
	return ret, nil
}
View Source 
var Cover = func(L, R interface{}, context Context) (bool, error) {
	l, lOk := GetStringValue(L)
	if !lOk {
		return false, fmt.Errorf("invalid L")
	}
	r, rOk := GetStringValue(R)
	if !rOk {
		return false, fmt.Errorf("right value is not string incompatible")
	}

	if l == "" || r == "" {
		return false, nil
	}

	rList := strings.Split(r, ",")
	for _, v := range rList {
		if strings.Contains(l, v) {
			return true, nil
		}
	}
	return false, nil
}
View Source 
var Date = func(context Context) (interface{}, error) {
	return time.Now().Format("2006-01-02"), nil
}
View Source 
var DateTime = func(context Context) (interface{}, error) {
	return time.Now().Format("2006-01-02 15:04:05"), nil
}
View Source 
var Day = func(context Context) (interface{}, error) {
	return time.Now().Format("02"), nil
}
View Source 
var DivAssign = func(L string, lValue interface{}, R interface{}, ret Context) error {
	if ret == nil {
		return fmt.Errorf("param ret is nil")
	}

	old, _ := GetFloatValue(lValue)
	add, _ := GetFloatValue(R)
	if add <= 0.00001 && add >= -0.00001 {
		return fmt.Errorf("invalid operand")
	}
	ret.SetCtxData(L, old/add)
	return nil
}
View Source 
var Equal = func(L, R interface{}, context Context) (bool, error) {
	tp := GetValueType(L)
	if tp == VarInvalid {
		return false, fmt.Errorf("invalid param L")
	} else if tp == VarStr {
		s, _ := GetStringValue(L)
		if sR, ok := GetStringValue(R); ok {
			return s == sR, nil
		} else {
			return false, fmt.Errorf("right value not string-incompatible")
		}
	} else if tp == VarInt {
		i, _ := GetIntValue(L)
		if iR, ok := GetIntValue(R); ok {
			return i == iR, nil
		} else {
			return false, fmt.Errorf("right value not int-incompatible")
		}
	} else if tp == VarFloat {
		f, _ := GetFloatValue(L)
		if fR, ok := GetFloatValue(R); ok {
			return f == fR, nil
		} else {
			return false, fmt.Errorf("right value not float-incompatible")
		}
	}
	return false, nil
}
View Source 
var Has = func(L, R interface{}, context Context) (bool, error) {
	l, lOk := GetStringValue(L)
	if !lOk {
		return false, fmt.Errorf("invalid L")
	}
	r, rOk := GetStringValue(R)
	if !rOk {
		return false, fmt.Errorf("right value not string-incompatible")
	}

	if l == "" || r == "" {
		return false, nil
	}

	lList := strings.Split(l, ",")
	rList := strings.Split(r, ",")
	for _, v := range rList {
		has := false
		for _, vL := range lList {
			if v == vL {
				has = true
				break
			}
		}
		if !has {
			return false, nil
		}
	}
	return true, nil
}
View Source 
var HeadMatch = func(L, R interface{}, context Context) (bool, error) {
	l, lOk := GetStringValue(L)
	if !lOk {
		return false, fmt.Errorf("invalid L")
	}
	r, rOk := GetStringValue(R)
	if !rOk {
		return false, fmt.Errorf("right value not string-incompatible")
	}

	if l == "" || r == "" {
		return false, nil
	}

	ret := strings.Index(l, r) == 0
	return ret, nil
}
View Source 
var Hour = func(context Context) (interface{}, error) {
	return time.Now().Format("15"), nil
}
View Source 
var IDay = func(context Context) (interface{}, error) {
	return time.Now().Day(), nil
}
View Source 
var IHour = func(context Context) (interface{}, error) {
	return time.Now().Hour(), nil
}
View Source 
var IMinute = func(context Context) (interface{}, error) {
	return time.Now().Minute(), nil
}
View Source 
var IMonth = func(context Context) (interface{}, error) {
	return time.Now().Month(), nil
}
View Source 
var ISecond = func(context Context) (interface{}, error) {
	return time.Now().Second(), nil
}
View Source 
var IYear = func(context Context) (interface{}, error) {
	return time.Now().Year(), nil
}
View Source 
var In = func(L, R interface{}, context Context) (bool, error) {
	l, lOk := GetStringValue(L)
	if !lOk {
		return false, fmt.Errorf("invalid L")
	}
	if r, ok := GetStringValue(R); !ok {
		return false, fmt.Errorf("right value not string-incompatible")
	} else {
		rList := strings.Split(r, ",")
		for _, v := range rList {
			if l == v {
				return true, nil
			}
		}
	}
	return false, nil
}
View Source 
var Less = func(L, R interface{}, context Context) (bool, error) {
	tp := GetValueType(L)
	if tp == VarInvalid {
		return false, fmt.Errorf("invalid param L")
	} else if tp == VarStr {
		s, _ := GetStringValue(L)
		if sR, ok := GetStringValue(R); ok {
			return s < sR, nil
		} else {
			return false, fmt.Errorf("right value not string-incompatible")
		}
	} else if tp == VarInt {
		i, _ := GetIntValue(L)
		if iR, ok := GetIntValue(R); ok {
			return i < iR, nil
		} else {
			return false, fmt.Errorf("right value not int-incompatible")
		}
	} else if tp == VarFloat {
		f, _ := GetFloatValue(L)
		if fR, ok := GetFloatValue(R); ok {
			return f < fR, nil
		} else {
			return false, fmt.Errorf("right value not float-incompatible")
		}
	}
	return false, nil
}
View Source 
var LessEqual = func(L, R interface{}, context Context) (bool, error) {
	tp := GetValueType(L)
	if tp == VarInvalid {
		return false, fmt.Errorf("invalid param L")
	} else if tp == VarStr {
		s, _ := GetStringValue(L)
		if sR, ok := GetStringValue(R); ok {
			return s <= sR, nil
		} else {
			return false, fmt.Errorf("right value not string-incompatible")
		}
	} else if tp == VarInt {
		i, _ := GetIntValue(L)
		if iR, ok := GetIntValue(R); ok {
			return i <= iR, nil
		} else {
			return false, fmt.Errorf("right value not int-incompatible")
		}
	} else if tp == VarFloat {
		f, _ := GetFloatValue(L)
		if fR, ok := GetFloatValue(R); ok {
			return f <= fR, nil
		} else {
			return false, fmt.Errorf("right value not float-incompatible")
		}
	}
	return false, nil
}
View Source 
var Minute = func(context Context) (interface{}, error) {
	return time.Now().Format("04"), nil
}
View Source 
var ModAssign = func(L string, lValue interface{}, R interface{}, ret Context) error {
	if ret == nil {
		return fmt.Errorf("param ret is nil")
	}

	old, _ := GetFloatValue(lValue)
	add, _ := GetFloatValue(R)
	addInt := int64(add)
	if addInt == 0 {
		return fmt.Errorf("invalid operand")
	}
	ret.SetCtxData(L, int64(old)%addInt)
	return nil
}
View Source 
var Month = func(context Context) (interface{}, error) {
	return time.Now().Format("01"), nil
}
View Source 
var More = func(L, R interface{}, context Context) (bool, error) {
	tp := GetValueType(L)
	if tp == VarInvalid {
		return false, fmt.Errorf("invalid param L")
	} else if tp == VarStr {
		s, _ := GetStringValue(L)
		if sR, ok := GetStringValue(R); ok {
			return s > sR, nil
		} else {
			return false, fmt.Errorf("right value not string-incompatible")
		}
	} else if tp == VarInt {
		i, _ := GetIntValue(L)
		if iR, ok := GetIntValue(R); ok {
			return i > iR, nil
		} else {
			return false, fmt.Errorf("right value not int-incompatible")
		}
	} else if tp == VarFloat {
		f, _ := GetFloatValue(L)
		if fR, ok := GetFloatValue(R); ok {
			return f > fR, nil
		} else {
			return false, fmt.Errorf("right value not float-incompatible")
		}
	}
	return false, nil
}
View Source 
var MoreEqual = func(L, R interface{}, context Context) (bool, error) {
	tp := GetValueType(L)
	if tp == VarInvalid {
		return false, fmt.Errorf("invalid param L")
	} else if tp == VarStr {
		s, _ := GetStringValue(L)
		if sR, ok := GetStringValue(R); ok {
			return s >= sR, nil
		} else {
			return false, fmt.Errorf("right value not string-incompatible")
		}
	} else if tp == VarInt {
		i, _ := GetIntValue(L)
		if iR, ok := GetIntValue(R); ok {
			return i >= iR, nil
		} else {
			return false, fmt.Errorf("right value not int-incompatible")
		}
	} else if tp == VarFloat {
		f, _ := GetFloatValue(L)
		if fR, ok := GetFloatValue(R); ok {
			return f >= fR, nil
		} else {
			return false, fmt.Errorf("right value not float-incompatible")
		}
	}
	return false, nil
}
View Source 
var MulAssign = func(L string, lValue interface{}, R interface{}, ret Context) error {
	if ret == nil {
		return fmt.Errorf("param ret is nil")
	}

	lType := GetValueType(lValue)
	vType := GetValueType(R)
	if lType == VarInvalid {
		lType = vType
	}
	switch lType {
	case VarStr:
		if vType == VarInt {
			old, _ := GetStringValue(lValue)
			ret.SetCtxData(L, strings.Repeat(old, R.(int)))
		} else {
			return fmt.Errorf("invalid operand")
		}
	case VarFloat:
		old, _ := GetFloatValue(lValue)
		ret.SetCtxData(L, old*R.(float64))
	case VarInt:
		old, _ := GetIntValue(lValue)
		ret.SetCtxData(L, old*R.(int64))
	default:
		return fmt.Errorf("invalid operand")
	}
	return nil
}
View Source 
var None = func(L, R interface{}, context Context) (bool, error) {
	any, err := Any(L, R, context)
	if err != nil {
		return false, err
	}
	return !any, nil
}
View Source 
var NotBetween = func(L, R interface{}, context Context) (bool, error) {
	ret, err := Between(L, R, context)
	if err != nil {
		return false, err
	}
	return !ret, nil
}
View Source 
var NotContain = func(L, R interface{}, context Context) (bool, error) {
	ret, err := Contain(L, R, context)
	if err != nil {
		return false, err
	}
	return !ret, nil
}
View Source 
var NotCover = func(L, R interface{}, context Context) (bool, error) {
	ret, err := Cover(L, R, context)
	if err != nil {
		return false, err
	}
	return !ret, err
}

compares

View Source 
var NotEqual = func(L, R interface{}, context Context) (bool, error) {
	tp := GetValueType(L)
	if tp == VarInvalid {
		return false, fmt.Errorf("invalid param L")
	} else if tp == VarStr {
		s, _ := GetStringValue(L)
		if sR, ok := GetStringValue(R); ok {
			return s != sR, nil
		} else {
			return false, fmt.Errorf("right value not string-incompatible")
		}
	} else if tp == VarInt {
		i, _ := GetIntValue(L)
		if iR, ok := GetIntValue(R); ok {
			return i != iR, nil
		} else {
			return false, fmt.Errorf("right value not int-incompatible")
		}
	} else if tp == VarFloat {
		f, _ := GetFloatValue(L)
		if fR, ok := GetFloatValue(R); ok {
			return f != fR, nil
		} else {
			return false, fmt.Errorf("right value not float-incompatible")
		}
	}
	return false, nil
}
View Source 
var NotHeadMatch = func(L, R interface{}, context Context) (bool, error) {
	ret, err := HeadMatch(L, R, context)
	if err != nil {
		return false, err
	}
	return !ret, nil
}
View Source 
var NotIn = func(L, R interface{}, context Context) (bool, error) {
	l, lOk := GetStringValue(L)
	if !lOk {
		return false, fmt.Errorf("invalid L")
	}
	if r, ok := GetStringValue(R); !ok {
		return false, fmt.Errorf("right value not string-incompatible")
	} else {
		rList := strings.Split(r, ",")
		in := false
		for _, v := range rList {
			if l == v {
				in = true
				break
			}
		}
		return !in, nil
	}
}
View Source 
var NotTailMatch = func(L, R interface{}, context Context) (bool, error) {
	ret, err := TailMatch(L, R, context)
	if err != nil {
		return false, err
	}
	return !ret, nil
}
View Source 
var Rand = func(context Context) (interface{}, error) {
	if ret, ok := context.GetCtxData("$rand"); ok {
		if rd, ok := GetIntValue(ret); ok {
			return rd, nil
		}
	}
	return rand.Intn(100) + 1, nil
}
View Source 
var RegExpMatch = func(L, R interface{}, context Context) (bool, error) {
	l, lOk := GetStringValue(L)
	if !lOk {
		return false, fmt.Errorf("invalid L")
	}
	r, rOk := GetStringValue(R)
	if !rOk {
		return false, fmt.Errorf("right value not string-incompatible")
	}

	if l == "" || r == "" {
		return false, nil
	}

	if matched, err := regexp.Match(r, goutil.UnsafeStringToBytes(l)); err == nil {
		return matched, nil
	} else {
		return false, err
	}
}
View Source 
var Second = func(context Context) (interface{}, error) {
	return time.Now().Format("05"), nil
}
View Source 
var ShortTime = func(context Context) (interface{}, error) {
	return time.Now().Format("15:04"), nil
}
View Source 
var SubAssign = func(L string, lValue interface{}, R interface{}, ret Context) error {
	if ret == nil {
		return fmt.Errorf("param ret is nil")
	}

	vType := GetValueType(R)
	switch vType {
	case VarFloat:
		old, _ := GetFloatValue(lValue)
		ret.SetCtxData(L, old-R.(float64))
	case VarInt:
		old, _ := GetIntValue(lValue)
		ret.SetCtxData(L, old-R.(int64))
	default:
		return fmt.Errorf("invalid operand")
	}
	return nil
}
View Source 
var TailMatch = func(L, R interface{}, context Context) (bool, error) {
	l, lOk := GetStringValue(L)
	if !lOk {
		return false, fmt.Errorf("invalid L")
	}
	r, rOk := GetStringValue(R)
	if !rOk {
		return false, fmt.Errorf("right value not string-incompatible")
	}

	if l == "" || r == "" {
		return false, nil
	}

	ret := strings.Index(l, r) == len(l)-len(r)
	return ret, nil
}
View Source 
var Time = func(context Context) (interface{}, error) {
	return time.Now().Format("15:04:05"), nil
}
View Source 
var Year = func(context Context) (interface{}, error) {
	return time.Now().Format("2006"), nil
}

Functions

func GetFloatValue 

func GetFloatValue(v interface{}) (float64, bool)

func GetIntValue 

func GetIntValue(v interface{}) (int64, bool)

func GetStringValue 

func GetStringValue(v interface{}) (string, bool)

Types

type AssignExp 

type AssignExp struct {
	Left       string
	Right      interface{}
	AssignName string
}

type AssignFunc 

type AssignFunc func(varName string, leftValue interface{}, rightValue interface{}, context Context) error

type CompareExp 

type CompareExp struct {
	Left        string
	Right       interface{}
	CompareName string
}

type CompareFunc 

type CompareFunc func(leftValue interface{}, rightValue interface{}, context Context) (bool, error)

type Configuration 

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

Configuration对象代表一个json配置,其中包含，0个或n个key/value键值对，以及0个或n个JSON表达式组

func NewConfiguration 

func NewConfiguration(jsonSource []byte, dict *Dictionary) (*Configuration, error)

传入json,创建一个Configuration对象

func (*Configuration) GetJsonExpGroup 

func (m *Configuration) GetJsonExpGroup(key string) (*JsonExpGroup, bool)

获取JSON表达式组

func (*Configuration) GetNameValue 

func (m *Configuration) GetNameValue(key string, context Context) (interface{}, bool)

获取键值

type Context 

type Context = goutil.Context

type DefaultContext 

type DefaultContext = goutil.DefaultContext

type Dictionary 

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

func NewDictionary 

func NewDictionary() *Dictionary

func (*Dictionary) Assign 

func (m *Dictionary) Assign(assignName string, left string, right interface{}, context Context) error

func (*Dictionary) Compare 

func (m *Dictionary) Compare(compareName string, left string, right interface{}, context Context) (bool, error)

func (*Dictionary) GetPipeFunction added in v1.4.6 

func (m *Dictionary) GetPipeFunction(name string) PipeFunction

func (*Dictionary) GetVarValue 

func (m *Dictionary) GetVarValue(varName string, context Context) (interface{}, error)

func (*Dictionary) ListAssigns 

func (m *Dictionary) ListAssigns() []string

func (*Dictionary) ListCompares 

func (m *Dictionary) ListCompares() []string

func (*Dictionary) ListObjects added in v1.2.3 

func (m *Dictionary) ListObjects() []string

func (*Dictionary) ListVars 

func (m *Dictionary) ListVars() []string

func (*Dictionary) RegisterAssign 

func (m *Dictionary) RegisterAssign(assignName string, assignFunc AssignFunc)

注册赋值运算符

func (*Dictionary) RegisterCompare 

func (m *Dictionary) RegisterCompare(compareName string, compareFunc CompareFunc)

注册条件运算符

func (*Dictionary) RegisterObject added in v1.2.3 

func (m *Dictionary) RegisterObject(objectName string, object Object) error

注册对象，对象名必须以"$"开头，且不能与变量重名

func (*Dictionary) RegisterObjectInContext added in v1.4.9 

func (m *Dictionary) RegisterObjectInContext(objectName string, object Object, context Context)

func (*Dictionary) RegisterPipeFunction added in v1.4.6 

func (m *Dictionary) RegisterPipeFunction(name string, fn PipeFunction)

func (*Dictionary) RegisterVar 

func (m *Dictionary) RegisterVar(varName string, fetchFunc VarFunc) error

注册变量，变量名必须以"$"开头，且不能与object重名

type JsonExp 

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

func (*JsonExp) Execute 

func (m *JsonExp) Execute(context Context) error

func (*JsonExp) GetAssignExpList 

func (m *JsonExp) GetAssignExpList() []*AssignExp

func (*JsonExp) GetCompareExpList 

func (m *JsonExp) GetCompareExpList() []*CompareExp

type JsonExpGroup 

type JsonExpGroup struct {
	// contains filtered or unexported fields
}
    a group of JsonExp
	json-exp group configuration json demo:
	{
		//json-exp group, from first to last, executing each json-exp node, breaking execution if variant $break = true, $break is a system variant
		"filter": [
			//json-exp node1, if all compare-exp return true, then execute assign-exp
			[
				["left-var","compare-name","right-var"], //compare-exp
				["left-var","compare-name","right-var"], //compare-exp
				["left-var","assign-name","right-var"], //the last exp is always an assign-exp
			],

			//json-exp node2
			[
				["left-var","compare-name","right-var"], //compare-exp
				["left-var","compare-name","right-var"], //compare-exp
				//multi-assign-exp
				[
					["left-var","assign-name","right-var"],
					["left-var","assign-name","right-var"],
					["left-var","assign-name","right-var"]
				]
			],

			//json-exp node3
			[
				//...
			]
		]
	}

func NewJsonExpGroup 

func NewJsonExpGroup(dict *Dictionary, groupSource interface{}) (*JsonExpGroup, error)

func (*JsonExpGroup) Execute 

func (m *JsonExpGroup) Execute(context Context) error

执行表达式组

func (*JsonExpGroup) List 

func (m *JsonExpGroup) List() []*JsonExp

type NameValue 

type NameValue struct {
	Name  string
	Value interface{}
}

type Object added in v1.2.3 

type Object interface {
	GetPropertyValue(property string, context Context) interface{}
	SetPropertyValue(property string, value interface{}, context Context)
}

type PipeFunction added in v1.4.6 

type PipeFunction func(input interface{}, context Context) (output interface{}, err error)

type VarFunc 

type VarFunc func(context Context) (interface{}, error)

type VarType 

type VarType uint
const (
	VarInvalid VarType = iota
	VarStr
	VarInt
	VarFloat
	VarSlice
)

func GetValueType 

func GetValueType(v interface{}) VarType

Source Files

View all Source files

Directories

Path Synopsis

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.