func convertAndSet(to, from reflect.Value, setMethod reflect.Value) { var toType reflect.Type if setMethod.IsValid() { toType = setMethod.Type().In(0) } else { toType = to.Type() } fromType := from.Type() defer func() { if v := recover(); v != nil { panic(fmt.Sprintf("cannot use %s as a %s", fromType, toType)) } }() if fromType == listType && toType.Kind() == reflect.Slice { list := from.Interface().(*List) from = reflect.MakeSlice(toType, len(list.data), len(list.data)) elemType := toType.Elem() for i, elem := range list.data { from.Index(i).Set(reflect.ValueOf(elem).Convert(elemType)) } } else if toType != fromType { from = from.Convert(toType) } if setMethod.IsValid() { setMethod.Call([]reflect.Value{from}) } else { to.Set(from) } }
func funcall(m reflect.Value, args []reflect.Value) (v []reflect.Value, panicked interface{}) { // defer func() { // panicked = recover() // }() ret := m.Call(args) return ret, nil }
// Returns an endpoint that will be bound to a handler. Internally calls the // method endpoint func (rm *ResourceManager) endpoint( res Resource, getData func(http.ResponseWriter, *http.Request) error, endpoint reflect.Value) http.HandlerFunc { callback := func(w http.ResponseWriter, r *http.Request) { // Call the get data function, attempting to get item and list for // resource if it allows err := getData(w, r) if err != nil { return } // Call original endpoint args := []reflect.Value{reflect.ValueOf(w), reflect.ValueOf(r)} endpoint.Call(args) } // If this resource has a wrapper around all calls to the resource // endpoints, then return a function that calls that wrapper. Else, // just return the original call function. Developer will have to manually // call the callback function in the wrapper method return func(w http.ResponseWriter, r *http.Request) { // Set the resource on the current context. context.Set(r, "Resource", res) if wrapper, ok := interface{}(res).(HandlerWrapper); ok { wrapper.HandlerWrapper(w, r, callback) } else { callback(w, r) } } }
// callCustom calls 'custom' with sv & dv. custom must be a conversion function. func (c *Converter) callCustom(sv, dv, custom reflect.Value, scope *scope) error { if !sv.CanAddr() { sv2 := reflect.New(sv.Type()) sv2.Elem().Set(sv) sv = sv2 } else { sv = sv.Addr() } if !dv.CanAddr() { if !dv.CanSet() { return scope.errorf("can't addr or set dest.") } dvOrig := dv dv := reflect.New(dvOrig.Type()) defer func() { dvOrig.Set(dv) }() } else { dv = dv.Addr() } args := []reflect.Value{sv, dv, reflect.ValueOf(scope)} ret := custom.Call(args)[0].Interface() // This convolution is necessary because nil interfaces won't convert // to errors. if ret == nil { return nil } return ret.(error) }
func eachCall(fn, v, i reflect.Value) { args := []reflect.Value{v} if in := fn.Type().NumIn(); in == 2 { args = append(args, i) } fn.Call(args) }
// evalCall executes a function or method call. If it's a method, fun already has the receiver bound, so // it looks just like a function call. The arg list, if non-nil, includes (in the manner of the shell), arg[0] // as the function itself. func (s *state) evalCall(dot, fun reflect.Value, node parse.Node, name string, args []parse.Node, final reflect.Value) reflect.Value { if args != nil { args = args[1:] // Zeroth arg is function name/node; not passed to function. } typ := fun.Type() numIn := len(args) if final.IsValid() { numIn++ } numFixed := len(args) if typ.IsVariadic() { numFixed = typ.NumIn() - 1 // last arg is the variadic one. if numIn < numFixed { s.errorf("wrong number of args for %s: want at least %d got %d", name, typ.NumIn()-1, len(args)) } } else if numIn < typ.NumIn()-1 || !typ.IsVariadic() && numIn != typ.NumIn() { s.errorf("wrong number of args for %s: want %d got %d", name, typ.NumIn(), len(args)) } if !goodFunc(typ) { // TODO: This could still be a confusing error; maybe goodFunc should provide info. s.errorf("can't call method/function %q with %d results", name, typ.NumOut()) } // Build the arg list. argv := make([]reflect.Value, numIn) // Args must be evaluated. Fixed args first. i := 0 for ; i < numFixed && i < len(args); i++ { argv[i] = s.evalArg(dot, typ.In(i), args[i]) } // Now the ... args. if typ.IsVariadic() { argType := typ.In(typ.NumIn() - 1).Elem() // Argument is a slice. for ; i < len(args); i++ { argv[i] = s.evalArg(dot, argType, args[i]) } } // Add final value if necessary. if final.IsValid() { t := typ.In(typ.NumIn() - 1) if typ.IsVariadic() { if numIn-1 < numFixed { // The added final argument corresponds to a fixed parameter of the function. // Validate against the type of the actual parameter. t = typ.In(numIn - 1) } else { // The added final argument corresponds to the variadic part. // Validate against the type of the elements of the variadic slice. t = t.Elem() } } argv[i] = s.validateType(final, t) } result := fun.Call(argv) // If we have an error that is not nil, stop execution and return that error to the caller. if len(result) == 2 && !result[1].IsNil() { s.at(node) s.errorf("error calling %s: %s", name, result[1].Interface().(error)) } return result[0] }
func Invoke(FuncValue reflect.Value, args ...interface{}) []reflect.Value { in := make([]reflect.Value, len(args)) for k, arg := range args { in[k] = reflect.ValueOf(arg) } return FuncValue.Call(in) }
func (t TableEntry) generateIt(itBody reflect.Value) { if t.Pending { ginkgo.PIt(t.Description) return } values := []reflect.Value{} for i, param := range t.Parameters { var value reflect.Value if param == nil { inType := itBody.Type().In(i) value = reflect.Zero(inType) } else { value = reflect.ValueOf(param) } values = append(values, value) } body := func() { itBody.Call(values) } if t.Focused { ginkgo.FIt(t.Description, body) } else { ginkgo.It(t.Description, body) } }
func funcEvaluate(L *lua.LState, fn reflect.Value) int { fnType := fn.Type() top := L.GetTop() expected := fnType.NumIn() variadic := fnType.IsVariadic() if !variadic && top != expected { L.RaiseError("invalid number of function argument (%d expected, got %d)", expected, top) } if variadic && top < expected-1 { L.RaiseError("invalid number of function argument (%d or more expected, got %d)", expected-1, top) } args := make([]reflect.Value, top) for i := 0; i < L.GetTop(); i++ { var hint reflect.Type if variadic && i >= expected-1 { hint = fnType.In(expected - 1).Elem() } else { hint = fnType.In(i) } args[i] = lValueToReflect(L.Get(i+1), hint) } ret := fn.Call(args) for _, val := range ret { L.Push(New(L, val.Interface())) } return len(ret) }
func (t *Task) run(m reflect.Value, input Reader, output Writer) (err error) { collector := NewWriterCollector(output) colValue := reflect.ValueOf(collector) defer func() { if e := output.Close(); e != nil && err == nil { err = e } }() var k, v interface{} for { k, v, err = input.Next() if err != nil { if err == io.EOF { return nil } log.Printf("Read error: %s", err) return } m.Call([]reflect.Value{ reflect.ValueOf(k), reflect.ValueOf(v), colValue, }) } return }
// TryCall attempts to call the task with the supplied arguments. // // `err` is set in the return value in two cases: // 1. The reflected function invocation panics (e.g. due to a mismatched // argument list). // 2. The task func itself returns a non-nil error. func TryCall(f reflect.Value, args []reflect.Value, uuid reflect.Value) (results []reflect.Value, err error) { defer func() { // Recover from panic and set err. if e := recover(); e != nil { switch e := e.(type) { default: err = errors.New("Invoking task caused a panic") case error: err = e case string: err = errors.New(e) } } }() // results = f.Call(args) results = f.Call(append([]reflect.Value{uuid}, args...)) // If an error was returned by the task func, propagate it // to the caller via err. if !results[1].IsNil() { return nil, results[1].Interface().(error) } return results, err }
func shrinkOne(f reflect.Value, args []reflect.Value, ai int, shrinker Shrinker) (bool, error) { if shrinker == nil { return false, nil } for tactic := 0; tactic < MaxTactics; tactic++ { cur := args[ai] nv, err := shrinker(cur, tactic) if err != nil { switch err { case ErrNoMoreTactics: return false, nil case ErrDeadEnd: continue default: return false, err } } args[ai] = nv fret := f.Call(args)[0].Bool() if !fret { return true, nil } args[ai] = cur } return false, nil }
// safelyCall invokes `function` in recover block func (s *Server) safelyCall(function reflect.Value, 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 trace := "" for i := 1; ; i += 1 { _, file, line, ok := runtime.Caller(i) if !ok { break } if len(trace) > 1 { trace = trace + "\n" } trace = trace + file + ":" + strconv.Itoa(line) } s.Logger.Error("Handler crashed with error: %s\n%s", err, trace) } } }() return function.Call(args), nil }
func (this *container) Exec(fv reflect.Value, args []reflect.Type) ([]reflect.Value, error) { if vals, err := this.getVals(args); err == nil { return fv.Call(vals), nil } else { return nil, err } }
func _functionCall(fn reflect.Value, inputs ...interface{}) []reflect.Value { var args []reflect.Value for _, input := range inputs { args = append(args, reflect.ValueOf(input)) } return fn.Call(args) }
// TODO: Use gauge-go result object rather than ProtoExecutionResult func executeFunc(fn reflect.Value, args ...interface{}) (res *m.ProtoExecutionResult) { rargs := make([]reflect.Value, len(args)) for i, a := range args { rargs[i] = reflect.ValueOf(a) } res = &m.ProtoExecutionResult{} T = &testingT{} start := time.Now() defer func() { if r := recover(); r != nil { res.ScreenShot = getScreenshot() res.Failed = proto.Bool(true) res.ExecutionTime = proto.Int64(time.Since(start).Nanoseconds()) res.StackTrace = proto.String(strings.SplitN(string(debug.Stack()), "\n", 9)[8]) res.ErrorMessage = proto.String(fmt.Sprintf("%s", r)) } T = &testingT{} }() fn.Call(rargs) res.Failed = proto.Bool(false) if len(T.errors) != 0 { res.ScreenShot = getScreenshot() res.Failed = proto.Bool(true) res.StackTrace = proto.String(T.getStacktraces()) res.ErrorMessage = proto.String(T.getErrors()) } res.ExecutionTime = proto.Int64(time.Since(start).Nanoseconds()) return res }
// safelyCall invokes `function` in recover block func (a *Wrapper) SafelyCall(fn reflect.Value, args []reflect.Value) (resp []reflect.Value, err error) { defer func() { if e := recover(); e != nil { resp = nil var content string content = fmt.Sprintf("Handler crashed with error: %v", e) for i := 1; ; i += 1 { _, file, line, ok := runtime.Caller(i) if !ok { break } else { content += "\n" } content += fmt.Sprintf("%v %v", file, line) } a.Server.Core.Logger().Error(content) err = errors.New(content) return } }() if fn.Type().NumIn() > 0 { return fn.Call(args), err } return fn.Call(nil), err }
// Invoke the given method, save headers/cookies to the response, and apply the // result. (e.g. render a template to the response) func (c *Controller) Invoke(appControllerPtr reflect.Value, method reflect.Value, methodArgs []reflect.Value) { // Handle panics. defer func() { if err := recover(); err != nil { handleInvocationPanic(c, err) } }() // Clean up from the request. defer func() { // Delete temp files. if c.Request.MultipartForm != nil { err := c.Request.MultipartForm.RemoveAll() if err != nil { WARN.Println("Error removing temporary files:", err) } } for _, tmpFile := range c.Params.tmpFiles { err := os.Remove(tmpFile.Name()) if err != nil { WARN.Println("Could not remove upload temp file:", err) } } }() // Run the plugins. plugins.BeforeRequest(c) // Calculate the Result by running the interceptors and the action. resultValue := func() reflect.Value { // Call the BEFORE interceptors result := c.invokeInterceptors(BEFORE, appControllerPtr) if result != nil { return reflect.ValueOf(result) } // Invoke the action. resultValue := method.Call(methodArgs)[0] // Call the AFTER interceptors result = c.invokeInterceptors(AFTER, appControllerPtr) if result != nil { return reflect.ValueOf(result) } return resultValue }() plugins.AfterRequest(c) if resultValue.IsNil() { return } result := resultValue.Interface().(Result) // Apply the result, which generally results in the ResponseWriter getting written. result.Apply(c.Request, c.Response) }
func (this *handlerType) runRequestBusiness(target ControllerInterface, method reflect.Value, arguments []reflect.Value, basic *Basic) (result []reflect.Value) { defer language.Catch(func(exception language.Exception) { basic.Log.Error("Buiness Error Code:[%d] Message:[%s]\nStackTrace:[%s]", exception.GetCode(), exception.GetMessage(), exception.GetStackTrace()) result = []reflect.Value{reflect.ValueOf(exception)} }) result = method.Call(arguments) return }
func _functionCallWithChanOutput(fn reflect.Value, outChan reflect.Value, inputs ...interface{}) []reflect.Value { var args []reflect.Value for _, input := range inputs { args = append(args, reflect.ValueOf(input)) } args = append(args, outChan) return fn.Call(args) }
// waiting for go1.1 func callableValue(fv reflect.Value) valuefun { if fv.Type().Kind() != reflect.Func { panic("not a function value") } return func(args []reflect.Value) []reflect.Value { return fv.Call(args) } }
func reflectValueFromPath(root reflect.Value, path []string) (reflect.Value, error) { v := root for _, name := range path { var p reflect.Value for v.Kind() == reflect.Ptr { p = v v = v.Elem() } // Try as field first. var f reflect.Value if v.Kind() == reflect.Struct { f = v.FieldByName(name) } if f.IsValid() { v = f } else { // No field, so let's see if we got a method. var m reflect.Value if p.IsValid() { // Try pointer receiver first. m = p.MethodByName(name) } if !m.IsValid() { // No pointer, try directly. m = v.MethodByName(name) } if !m.IsValid() { return v, fmt.Errorf("bad member: '%s'", strings.Join(path, ".")) } // We assume it takes no args and returns one mandatory value plus // maybe an error. rvs := m.Call(nil) switch len(rvs) { case 1: v = rvs[0] case 2: rv2 := rvs[1].Interface() if err, ok := rv2.(error); ok { return v, err } else if rv2 != nil { return v, fmt.Errorf("Second method return value must implement error.") } v = rvs[0] default: return v, fmt.Errorf("Method must return a value plus optionally an error: %s", name) } } } return v, nil }
//call action func callAction(function reflect.Value, args []reflect.Value) (result []reflect.Value, err interface{}) { defer func() { if err = recover(); err != nil { result = nil } }() return function.Call(args), nil }
func callSetter(fn reflect.Value, value reflect.Value) (err error) { results := fn.Call([]reflect.Value{value}) if len(results) > 0 && !results[0].IsNil() { err = results[0].Interface().(error) } return }
func startSingleTaskInner(handler reflect.Value, handlerArgv []reflect.Value, basic *Basic) { defer CatchCrash(func(exception Exception) { basic.Log.Critical("DaemonTask Crash Code:[%d] Message:[%s]\nStackTrace:[%s]", exception.GetCode(), exception.GetMessage(), exception.GetStackTrace()) }) defer Catch(func(exception Exception) { basic.Log.Error("DaemonTask Error Code:[%d] Message:[%s]\nStackTrace:[%s]", exception.GetCode(), exception.GetMessage(), exception.GetStackTrace()) }) handler.Call(handlerArgv) }
func RftCall(function reflect.Value, args ...reflect.Value) (err error) { defer func() { if r := recover(); r != nil { err = errors.New(fmt.Sprintf("RftCall panic: %+v", r)) } }() function.Call(args) return }
func (this *Resolver) Call(method *reflect.Value, args []reflect.Value) (response interface{}, err error) { output := method.Call(args) if (len(output) > 1) && (!output[1].IsNil()) { return nil, output[1].Interface().(error) } return output[0].Interface(), nil }
func (b *block) call(err error, v reflect.Value) error { args := []reflect.Value{reflect.ValueOf(err)} res := v.Call(args) if res[0].IsNil() { return nil } return res[0].Interface().(error) }
func callGo(L *lua.State, funv reflect.Value, args []reflect.Value) []reflect.Value { defer func() { if x := recover(); x != nil { RaiseError(L, sprintf("error %s", x)) } }() resv := funv.Call(args) return resv }
// caller converts from an actual function to a function type // that we can construct on the fly. func caller(f reflect.Value) func(reflect.Value) (reflect.Value, error) { return func(v reflect.Value) (reflect.Value, error) { r := f.Call([]reflect.Value{v}) if r[1].IsNil() { return r[0], nil } return r[0], r[1].Interface().(error) } }