func walkIdentity(ctx expr.EvalContext, node *expr.IdentityNode) (value.Value, bool) {
if node.IsBooleanIdentity() {
//u.Debugf("walkIdentity() boolean: node=%T %v Bool:%v", node, node, node.Bool())
return value.NewBoolValue(node.Bool()), true
}
if ctx == nil {
return value.NewStringValue(node.Text), true
}
return ctx.Get(node.Text)
}
// Exists
func Exists(ctx expr.EvalContext, item interface{}) (value.BoolValue, bool) {
//u.Debugf("Exists(): %T %v", item, item)
switch node := item.(type) {
case expr.IdentityNode:
_, ok := ctx.Get(node.Text)
if ok {
return value.BoolValueTrue, true
}
return value.BoolValueFalse, true
case expr.StringNode:
_, ok := ctx.Get(node.Text)
if ok {
return value.BoolValueTrue, true
}
return value.BoolValueFalse, true
}
return value.BoolValueFalse, true
}
// Exists: Answers True/False if the field exists and is non null
//
// exists(real_field) => true
// exists("value") => true
// exists("") => false
// exists(empty_field) => false
// exists(2) => true
// exists(todate(date_field)) => true
//
func Exists(ctx expr.EvalContext, item interface{}) (value.BoolValue, bool) {
//u.Debugf("Exists(): %T %v", item, item)
switch node := item.(type) {
case expr.IdentityNode:
_, ok := ctx.Get(node.Text)
if ok {
return value.BoolValueTrue, true
}
return value.BoolValueFalse, true
case expr.StringNode:
_, ok := ctx.Get(node.Text)
if ok {
return value.BoolValueTrue, true
}
return value.BoolValueFalse, true
case value.StringValue:
if node.Nil() {
return value.BoolValueFalse, true
}
return value.BoolValueTrue, true
case value.BoolValue:
return value.BoolValueTrue, true
case value.NumberValue:
if node.Nil() {
return value.BoolValueFalse, true
}
return value.BoolValueTrue, true
case value.IntValue:
if node.Nil() {
return value.BoolValueFalse, true
}
return value.BoolValueTrue, true
case value.TimeValue:
if node.Nil() {
return value.BoolValueFalse, true
}
return value.BoolValueTrue, true
case value.StringsValue, value.SliceValue, value.MapIntValue:
return value.BoolValueTrue, true
}
return value.BoolValueFalse, true
}
func walkFunc(ctx expr.EvalContext, node *expr.FuncNode) (value.Value, bool) {
//u.Debugf("walkFunc node: %v", node.StringAST())
// we create a set of arguments to pass to the function, first arg
// is this Context
var ok bool
funcArgs := make([]reflect.Value, 0)
if ctx != nil {
funcArgs = append(funcArgs, reflect.ValueOf(ctx))
} else {
var nilArg expr.EvalContext
funcArgs = append(funcArgs, reflect.ValueOf(&nilArg).Elem())
}
for _, a := range node.Args {
//u.Debugf("arg %v %T %v", a, a, a)
var v interface{}
switch t := a.(type) {
case *expr.StringNode: // String Literal
v = value.NewStringValue(t.Text)
case *expr.IdentityNode: // Identity node = lookup in context
if t.IsBooleanIdentity() {
v = value.NewBoolValue(t.Bool())
} else {
v, ok = ctx.Get(t.Text)
//u.Infof("%#v", ctx.Row())
//u.Debugf("get '%s'? %T %v %v", t.String(), v, v, ok)
if !ok {
// nil arguments are valid
v = value.NewNilValue()
}
}
case *expr.NumberNode:
v, ok = numberNodeToValue(t)
case *expr.FuncNode:
//u.Debugf("descending to %v()", t.Name)
v, ok = walkFunc(ctx, t)
if !ok {
//return value.NewNilValue(), false
// nil arguments are valid
v = value.NewNilValue()
}
//u.Debugf("result of %v() = %v, %T", t.Name, v, v)
case *expr.UnaryNode:
v, ok = walkUnary(ctx, t)
if !ok {
// nil arguments are valid ??
v = value.NewNilValue()
}
case *expr.BinaryNode:
v, ok = walkBinary(ctx, t)
case *expr.ValueNode:
v = t.Value
default:
panic(fmt.Errorf("expr: unknown func arg type"))
}
if v == nil {
//u.Warnf("Nil vals? %v %T arg:%T", v, v, a)
// What do we do with Nil Values?
switch a.(type) {
case *expr.StringNode: // String Literal
u.Warnf("NOT IMPLEMENTED T:%T v:%v", a, a)
case *expr.IdentityNode: // Identity node = lookup in context
v = value.NewStringValue("")
default:
u.Warnf("un-handled type: %v %T", v, v)
}
funcArgs = append(funcArgs, reflect.ValueOf(v))
} else {
//u.Debugf(`found func arg: "%v" %T arg:%T`, v, v, a)
funcArgs = append(funcArgs, reflect.ValueOf(v))
}
}
// Get the result of calling our Function (Value,bool)
//u.Debugf("Calling func:%v(%v) %v", node.F.Name, funcArgs, node.F.F)
fnRet := node.F.F.Call(funcArgs)
//u.Debugf("fnRet: %v ok?%v", fnRet, fnRet[1].Bool())
// check if has an error response?
if len(fnRet) > 1 && !fnRet[1].Bool() {
// What do we do if not ok?
return value.EmptyStringValue, false
}
//u.Debugf("response %v %v %T", node.F.Name, fnRet[0].Interface(), fnRet[0].Interface())
return fnRet[0].Interface().(value.Value), true
}
