Golang Value.CallSlice方法代码示例

// 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)
		}

		plugins.Finally(c)
	}()

	// 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)

	if c.Result == nil {
		// Invoke the action.
		var resultValue reflect.Value
		if method.Type().IsVariadic() {
			resultValue = method.CallSlice(methodArgs)[0]
		} else {
			resultValue = method.Call(methodArgs)[0]
		}
		if resultValue.Kind() == reflect.Interface && !resultValue.IsNil() {
			c.Result = resultValue.Interface().(Result)
		}

		plugins.AfterRequest(c)
		if c.Result == nil {
			return
		}
	}

	// Apply the result, which generally results in the ResponseWriter getting written.
	c.Result.Apply(c.Request, c.Response)
}

func (engine *Engine) GoFuncToJsFunc(gofunc reflect.Value) *FunctionTemplate {
	funcType := gofunc.Type()
	return engine.NewFunctionTemplate(func(callbackInfo FunctionCallbackInfo) {
		numIn := funcType.NumIn()
		numArgs := callbackInfo.Length()

		var out []reflect.Value

		if funcType.IsVariadic() {
			in := make([]reflect.Value, 1)
			in[0] = reflect.MakeSlice(funcType.In(0), numArgs, numArgs)

			for i := 0; i < numArgs; i++ {
				jsvalue := callbackInfo.Get(i)
				engine.SetJsValueToGo(in[0].Index(i), jsvalue)
			}

			out = gofunc.CallSlice(in)
		} else {
			in := make([]reflect.Value, numIn)

			for i := 0; i < len(in); i++ {
				jsvalue := callbackInfo.Get(i)
				in[i] = reflect.Indirect(reflect.New(funcType.In(i)))
				engine.SetJsValueToGo(in[i], jsvalue)
			}

			out = gofunc.Call(in)
		}

		if out == nil {
			callbackInfo.CurrentScope().ThrowException("argument number not match")
			return
		}

		switch {
		// when Go function returns only one value
		case len(out) == 1:
			callbackInfo.ReturnValue().Set(engine.GoValueToJsValue(out[0]))
		// when Go function returns multi-value, put them in a JavaScript array
		case len(out) > 1:
			jsResults := engine.NewArray(len(out))
			jsResultsArray := jsResults.ToArray()

			for i := 0; i < len(out); i++ {
				jsResultsArray.SetElement(i, engine.GoValueToJsValue(out[i]))
			}

			callbackInfo.ReturnValue().Set(jsResults)
		}
	}, nil)
}

func wrapperGen(l *Luna, impl reflect.Value) lua.LuaGoFunction {
	typ := impl.Type()
	params := make([]reflect.Value, typ.NumIn())

	return func(L *lua.State) int {
		for i := range params {
			params[i] = reflect.New(typ.In(i)).Elem()
		}
		args := L.GetTop()
		if args < len(params) {
			panic(fmt.Sprintf("Args: %d, Params: %d", args, len(params)))
		}

		var varargs reflect.Value
		if typ.IsVariadic() {
			params[len(params)-1] = params[len(params)-1].Slice(0, 0)
			varargs = params[len(params)-1]
		}

		for i := 1; i <= args; i++ {
			if i >= len(params) && typ.IsVariadic() {
				val := reflect.New(varargs.Type().Elem()).Elem()
				l.set(val, i)
				varargs = reflect.Append(varargs, val)
			} else if i > len(params) {
				// ignore extra args
				break
			} else {
				if err := l.set(params[i-1], i); err != nil {
					panic(err)
				}
			}
		}

		var ret []reflect.Value
		if typ.IsVariadic() {
			params[len(params)-1] = varargs
			ret = impl.CallSlice(params)
		} else {
			ret = impl.Call(params)
		}
		for _, val := range ret {
			if l.pushBasicType(val.Interface()) {
				continue
			}
			if err := l.pushComplexType(val.Interface()); err != nil {
				panic(err)
			}
		}
		return len(ret)
	}
}

func safeCall(obj reflect.Value, in []reflect.Value) (ok bool, out []reflect.Value, err error) {
	defer func() {
		if r := recover(); r != nil {
			ok = false
			err = fmt.Errorf("%v", r)
		}
	}()
	if obj.Type().IsVariadic() {
		out = obj.CallSlice(in)
	} else {
		out = obj.Call(in)
	}
	return true, out, nil
}

func (s *Server) newHandlerFn(handler interface{}, f *reflect.Value, guards []GuarderFn) HandlerFn {
	return func(request *Request) (Reply, error) {
		input := []reflect.Value{reflect.ValueOf(handler)}
		for _, guard := range guards {
			value, errReply := guard(request)
			if errReply != nil {
				return errReply, nil
			}
			input = append(input, value)
		}
		if f.Type().NumIn() == 0 {
			input = []reflect.Value{}
		} else if !f.Type().In(0).AssignableTo(reflect.TypeOf(handler)) {
			input = input[1:]
		}

		var monitorString string
		if len(request.Arguments) > 0 {
			monitorString = fmt.Sprintf("%.6f [0 %s] \"%s\" \"%s\"",
				float64(time.Now().UTC().UnixNano())/1e9,
				request.RemoteAddress,
				request.Command,
				bytes.Join(request.Arguments, []byte{'"', ' ', '"'}))
		} else {
			monitorString = fmt.Sprintf("%.6f [0 %s] \"%s\"",
				float64(time.Now().UTC().UnixNano())/1e9,
				request.RemoteAddress,
				request.Command)
		}
		if s.MonitorLog {
			log.Printf("[Monitor] %s", monitorString)
		}

		var results []reflect.Value
		if f.Type().IsVariadic() {
			results = f.CallSlice(input)
		} else {
			results = f.Call(input)
		}
		if err := results[len(results)-1].Interface(); err != nil {
			return &ErrorReply{err.(error).Error()}, nil
		}
		if len(results) > 1 {
			return NewReply(s, request, results[0].Interface())
		}
		return &StatusReply{"OK"}, nil
	}
}

func createHandlerFunc(o interface{}, f *reflect.Value) (HandlerFunc, error) {
	t := f.Type()
	arg0Type := reflect.TypeOf((*interface{})(nil)).Elem()
	argsType := reflect.TypeOf([][]byte{})
	if t.NumIn() != 3 || t.In(1) != arg0Type || t.In(2) != argsType {
		return nil, errors.Errorf("register with invalid func type = '%s'", t)
	}
	ret0Type := reflect.TypeOf((*Resp)(nil)).Elem()
	ret1Type := reflect.TypeOf((*error)(nil)).Elem()
	if t.NumOut() != 2 || t.Out(0) != ret0Type || t.Out(1) != ret1Type {
		return nil, errors.Errorf("register with invalid func type = '%s'", t)
	}
	return func(arg0 interface{}, args ...[]byte) (Resp, error) {
		var arg0Value reflect.Value
		if arg0 == nil {
			arg0Value = reflect.ValueOf((*interface{})(nil))
		} else {
			arg0Value = reflect.ValueOf(arg0)
		}
		var input, output []reflect.Value
		input = []reflect.Value{reflect.ValueOf(o), arg0Value, reflect.ValueOf(args)}
		if t.IsVariadic() {
			output = f.CallSlice(input)
		} else {
			output = f.Call(input)
		}
		var ret0 Resp
		var ret1 error
		if i := output[0].Interface(); i != nil {
			ret0 = i.(Resp)
		}
		if i := output[1].Interface(); i != nil {
			ret1 = i.(error)
		}
		return ret0, ret1
	}, nil
}

func (this *Module) router(method, pattern string, controllerOrhandler []interface{}) {
	this.Mutex.Lock()
	defer func() {
		recover()
		this.Mutex.Unlock()
	}()
	if pattern[0] != '/' {
		pattern = "/" + SnakeString(pattern)
	} else {
		pattern = "/" + SnakeString(pattern[1:])
	}
	pattern = strings.Replace(pattern, "/?", "?", -1)
	pattern = strings.Trim(pattern, "?")
	pattern = strings.TrimSuffix(pattern, "/")
	a := re.FindStringSubmatch(pattern)
	if len(a) < 3 {
		log.Panicln(`[ERROR]  配置路由规则: 匹配规则 "` + pattern + `" 不正确`)
	}
	var (
		hfs             = make([]HandlerFunc, len(controllerOrhandler))
		countController int
		cName           string
		callfunc        = CamelString(strings.TrimPrefix(a[1], "/"))
	)
	for i, v := range controllerOrhandler {
		c, ok := v.(Controller)
		if ok {
			cName, callfunc, hfs[i] = this.newHandler(method, callfunc, c)
			countController++
			continue
		}
		h, ok := v.(HandlerFunc)
		if ok {
			hfs[i] = h
			continue
		}
		log.Panicln(`[ERROR] 配置路由规则: "` + this.RouterGroup.BasePath() + method + `" 指定了类型错误的操作`)
	}
	if countController != 1 {
		log.Panicln(`[ERROR] 配置路由规则: "` + this.RouterGroup.BasePath() + method + `" 须且仅须设置1个控制器`)
	}

	{
		callMethod := reflect.ValueOf(this.RouterGroup).MethodByName(method)
		// 当为"home"模块时，添加注册根路由
		var defaultCallMethod reflect.Value
		if this.RouterGroup.BasePath() == "/home" {
			defaultCallMethod = reflect.ValueOf(ThinkGo).MethodByName(method)
		}
		hfsv := reflect.ValueOf(hfs)
		if callfunc == "index" && a[2] != "/" {
			// 允许省略index
			p := path.Join(cName, pattern[len(a[1]):])
			p = strings.Replace(p, "/?", "?", -1)
			param := []reflect.Value{reflect.ValueOf(p), hfsv}
			callMethod.CallSlice(param)
			if defaultCallMethod != (reflect.Value{}) {
				defaultCallMethod.CallSlice(param)
			}
			if cName == "index" {
				param = []reflect.Value{reflect.ValueOf(pattern[len(a[1]):]), hfsv}
				callMethod.CallSlice(param)
				if defaultCallMethod != (reflect.Value{}) {
					defaultCallMethod.CallSlice(param)
				}
			}
		}
		param := []reflect.Value{reflect.ValueOf(path.Join(cName, pattern)), hfsv}
		callMethod.CallSlice(param)
		if defaultCallMethod != (reflect.Value{}) {
			defaultCallMethod.CallSlice(param)
		}
	}
}

func (srv *Server) handlerFn(autoHandler interface{}, f *reflect.Value, checkers []CheckerFn) (HandlerFn, error) {
	return func(request *Request) (ReplyWriter, error) {
		input := []reflect.Value{reflect.ValueOf(autoHandler)}

		for _, checker := range checkers {
			value, reply := checker(request)
			if reply != nil {
				return reply, nil
			}
			input = append(input, value)
		}
		var monitorString string
		if len(request.Args) > 0 {
			monitorString = fmt.Sprintf("%.6f [0 %s] \"%s\" \"%s\"",
				float64(time.Now().UTC().UnixNano())/1e9,
				request.Host,
				request.Name,
				bytes.Join(request.Args, []byte{'"', ' ', '"'}))
		} else {
			monitorString = fmt.Sprintf("%.6f [0 %s] \"%s\"",
				float64(time.Now().UTC().UnixNano())/1e9,
				request.Host,
				request.Name)
		}
		for _, c := range srv.MonitorChans {
			select {
			case c <- monitorString:
			default:
			}
		}
		Debugf("%s (connected monitors: %d)\n", monitorString, len(srv.MonitorChans))

		var result []reflect.Value

		// If we don't have any input, it means we are dealing with a function.
		// Then remove the first parameter (object instance)
		if f.Type().NumIn() == 0 {
			input = []reflect.Value{}
		} else if f.Type().In(0).AssignableTo(reflect.TypeOf(autoHandler)) == false {
			// If we have at least one input, we check if the first one is an instance of our object
			// If it is, then remove it from the input list.
			input = input[1:]
		}

		if f.Type().IsVariadic() {
			result = f.CallSlice(input)
		} else {
			result = f.Call(input)
		}

		var ret interface{}
		if ierr := result[len(result)-1].Interface(); ierr != nil {
			// Last return value is an error, wrap it to redis error
			err := ierr.(error)
			// convert to redis error reply
			return NewError(err.Error()), nil
		}
		if len(result) > 1 {
			ret = result[0].Interface()
			return srv.createReply(request, ret)
		}
		return &StatusReply{Code: "OK"}, nil
	}, nil
}

// call fn, remove its args from the stack and push the result
func (s *State) call(fn reflect.Value, ftyp reflect.Type, numIn int, isVariadic bool, name string, args int, traits FuncTrait, fp fastPath) error {
	pos := len(s.stack) - args
	in := s.stack[pos : pos+args]
	last := numIn
	if isVariadic {
		last--
		if args < last {
			// Show the number of passed arguments without the context
			// in the error, otherwise it can be confusing for the user.
			tn := traits.nTraitArgs()
			last -= tn
			args -= tn
			return fmt.Errorf("function %q requires at least %d arguments, %d given", funcDebugName(name, fn), last, args)
		}
	} else {
		if args != numIn {
			// See comment after the previous args < last
			tn := traits.nTraitArgs()
			last -= tn
			args -= tn
			return fmt.Errorf("function %q requires exactly %d arguments, %d given", funcDebugName(name, fn), numIn, args)
		}
	}
	// arguments are in reverse order
	for ii := 0; ii < len(in)/2; ii++ {
		in[ii], in[len(in)-1-ii] = in[len(in)-1-ii], in[ii]
	}
	var lastType reflect.Type
	for ii, v := range in {
		var ityp reflect.Type
		if ii < last {
			ityp = ftyp.In(ii)
		} else {
			ityp = ftyp.In(last).Elem()
			lastType = ityp
		}
		if !v.IsValid() {
			in[ii] = reflect.Zero(ityp)
			continue
		}
		vtyp := v.Type()
		if !vtyp.AssignableTo(ityp) {
			k := vtyp.Kind()
			if (k == reflect.Ptr || k == reflect.Interface) && !v.IsNil() && vtyp.Elem().AssignableTo(ityp) {
				in[ii] = v.Elem()
				continue
			}
			if reflect.PtrTo(vtyp).AssignableTo(ityp) && v.CanAddr() {
				in[ii] = v.Addr()
				continue
			}
			if ii == 0 && traits.HasTrait(FuncTraitContext) {
				return fmt.Errorf("context function %q requires a context of type %s, not %s", name, ityp, vtyp)
			}
			return fmt.Errorf("can't call %q with %s as argument %d, need %s", name, vtyp, ii+1, ityp)
		}
	}
	var res []reflect.Value
	if isVariadic {
		// empty the scratch here, so it's only pointless
		// the first time. the alternative would be emptying it
		// after the call and in reset(), because CallSlice can end
		// up calling a function which panics. that would cause
		// a lot of unrequired emptys because templates don't
		// necessarily use the scratch.
		s.scratch = s.scratch[:0]
		for _, v := range in[last:] {
			s.scratch = append(s.scratch, v.Interface())
		}
		if fp != nil {
			if err := fp(in, s.scratch, s.resPtr); err != nil {
				return fmt.Errorf("%q returned an error: %s", name, err)
			}
			res = s.res
		} else {
			if len(in) <= last {
				// no varargs provided by the call, but
				// CallSlice requires an empty slice at
				// the end.
				in = append(in, reflect.Value{})
			}
			if lastType == emptyType {
				in[last] = reflect.ValueOf(s.scratch)
			} else {
				lastSlice := reflect.MakeSlice(ftyp.In(last), len(s.scratch), len(s.scratch))
				for ii, v := range s.scratch {
					lastSlice.Index(ii).Set(reflect.ValueOf(v))
				}
				in[last] = lastSlice
			}
			in = in[:last+1]
			res = fn.CallSlice(in)
		}
	} else {
		if fp != nil {
			if err := fp(in, nil, s.resPtr); err != nil {
				return fmt.Errorf("%q returned an error: %s", name, err)
			}
			res = s.res
//.........这里部分代码省略.........