Golang reflect.FuncValue类代码示例

func invokeByName(obj interface{}, name string, in ...reflect.Value) []reflect.Value {
	ov := reflect.NewValue(obj)
	ot := ov.Type()
	var fn *reflect.FuncValue = nil
	for i := 0; i < ot.NumMethod(); i++ {
		if ot.Method(i).Name == name {
			fn = ot.Method(i).Func
			break
		}
	}
	if fn == nil {
		return []reflect.Value{reflect.NewValue(nil)}
	}
	params := make([]reflect.Value, len(in)+1)
	params[0] = ov
	for i := 1; i < len(params); i++ {
		params[i] = in[i-1]
	}
	return fn.Call(params)
}

//Calls a function with recover block
func (s *Server) safelyCall(function *reflect.FuncValue, args []reflect.Value) (resp []reflect.Value, e interface{}) {
	defer func() {
		if err := recover(); err != nil {
			if !s.Config.RecoverPanic {
				// go back to panic
				panic(err)
			} else {
				e = err
				resp = nil
				s.Logger.Println("Handler crashed with error", err)
				for i := 1; ; i += 1 {
					_, file, line, ok := runtime.Caller(i)
					if !ok {
						break
					}
					s.Logger.Println(file, line)
				}
			}
		}
	}()
	return function.Call(args), nil
}

func newThread(route []interface{}) *Thread {
	if len(route) == 0 {
		return nil
	}
	first := reflect.NewValue(route[0])
	args := make([]reflect.Value, 0, 8)
	canStop := true
	ok := false
	var fv *reflect.FuncValue
	switch first.(type) {
	case *reflect.PtrValue:
		{
			if len(route) < 2 {
				return nil
			}
			if str, typeok := route[1].(string); typeok {
				fv = getMemFunc(first.(*reflect.PtrValue), str)
				typ := fv.Type().(*reflect.FuncType)
				needArgs := typ.NumIn()
				actualArgs := len(route) - 1
				if needArgs == actualArgs {
					ok = true
					canStop = false
				} else if needArgs == actualArgs+1 {
					canStop = true
					ok = checkLastArg(typ)
				}
				if ok {
					args = append(args, first)
					for _, i := range route[2:] {
						args = append(args, reflect.NewValue(i))
					}
				}
			}
		}
	case *reflect.FuncValue:
		{
			fv = first.(*reflect.FuncValue)
			typ := fv.Type().(*reflect.FuncType)
			needArgs := typ.NumIn()
			actualArgs := len(route) - 1
			if needArgs == actualArgs {
				ok = true
				canStop = false
			} else if needArgs == actualArgs+1 {
				canStop = true
				ok = checkLastArg(typ)
			}
			if ok {
				for _, i := range route[1:] {
					args = append(args, reflect.NewValue(i))
				}
			}
		}
	}

	if ok {
		t := new(Thread)
		t.fv = fv
		t.canStop = canStop
		t.args = args
		return t
	}
	return nil
}

// tryOneFunction is the common code for tryMethod and tryFunction.
func tryOneFunction(pkg, firstArg, name string, typ *reflect.FuncType, rfn *reflect.FuncValue, args []interface{}) {
	// Any results?
	if typ.NumOut() == 0 {
		return // Nothing to do.
	}
	// Right number of arguments + results?
	if typ.NumIn()+typ.NumOut() != len(args) {
		return
	}
	// Right argument and result types?
	for i, a := range args {
		if i < typ.NumIn() {
			if !compatible(a, typ.In(i)) {
				return
			}
		} else {
			if !compatible(a, typ.Out(i-typ.NumIn())) {
				return
			}
		}
	}
	// Build the call args.
	argsVal := make([]reflect.Value, typ.NumIn()+typ.NumOut())
	for i, a := range args {
		argsVal[i] = reflect.NewValue(a)
	}
	// Call the function and see if the results are as expected.
	resultVal := rfn.Call(argsVal[:typ.NumIn()])
	for i, v := range resultVal {
		if !reflect.DeepEqual(v.Interface(), args[i+typ.NumIn()]) {
			return
		}
	}
	// Present the result including a godoc command to get more information.
	firstIndex := 0
	if firstArg != "" {
		fmt.Fprintf(output, "%s.%s(", firstArg, name)
		firstIndex = 1
	} else {
		fmt.Fprintf(output, "%s.%s(", pkg, name)
	}
	for i := firstIndex; i < typ.NumIn(); i++ {
		if i > firstIndex {
			fmt.Fprint(output, ", ")
		}
		fmt.Fprintf(output, "%#v", args[i])
	}
	fmt.Fprint(output, ") = ")
	if typ.NumOut() > 1 {
		fmt.Fprint(output, "(")
	}
	for i := 0; i < typ.NumOut(); i++ {
		if i > 0 {
			fmt.Fprint(output, ", ")
		}
		fmt.Fprintf(output, "%#v", resultVal[i].Interface())
	}
	if typ.NumOut() > 1 {
		fmt.Fprint(output, ")")
	}
	fmt.Fprintf(output, "  // godoc %s %s\n", pkg, name)
}

func (c *C) logArgPanic(funcValue *reflect.FuncValue, expectedType string) {
	c.logf("... Panic: %s argument should be %s",
		niceFuncName(funcValue.Get()), expectedType)
}