remove the old 'mvc' folder - examples are not changed yet - add the 'di' package inside the mvc2 package - which will be renamed to 'mvc' on the next commit - new mvc.Application and some dublications removed - The new version will be version 9 because it will contain breaking changes (not to the end-developer's controllers but to the API they register them) - get ready for 'Christmas Edition' for believers

Former-commit-id: c7114233dee90ee308c0a3e77ec2ad0c361094b8

mvc2/di/func.go

@@ -0,0 +1,108 @@
+package di
+
+import (
+	"reflect"
+)
+
+type (
+	targetFuncInput struct {
+		Object     *BindObject
+		InputIndex int
+	}
+
+	FuncInjector struct {
+		// the original function, is being used
+		// only the .Call, which is refering to the same function, always.
+		fn reflect.Value
+
+		inputs []*targetFuncInput
+		// Length is the number of the valid, final binded input arguments.
+		Length int
+		// Valid is True when `Length` is > 0, it's statically set-ed for
+		// performance reasons.
+		Valid bool //
+	}
+)
+
+func MakeFuncInjector(fn reflect.Value, hijack Hijacker, goodFunc TypeChecker, values ...reflect.Value) *FuncInjector {
+	typ := IndirectType(fn.Type())
+	s := &FuncInjector{
+		fn: fn,
+	}
+
+	if !IsFunc(typ) {
+		return s
+	}
+
+	n := typ.NumIn()
+
+	// function input can have many values of the same types,
+	// so keep track of them in order to not set a func input to a next bind value,
+	// i.e (string, string) with two different binder funcs because of the different param's name.
+	consumedValues := make(map[int]bool, n)
+
+	for i := 0; i < n; i++ {
+		inTyp := typ.In(i)
+
+		if hijack != nil {
+			if b, ok := hijack(inTyp); ok && b != nil {
+				s.inputs = append(s.inputs, &targetFuncInput{
+					InputIndex: i,
+					Object:     b,
+				})
+
+				continue
+			}
+		}
+
+		for valIdx, val := range values {
+			if _, shouldSkip := consumedValues[valIdx]; shouldSkip {
+				continue
+			}
+			inTyp := typ.In(i)
+
+			// the binded values to the func's inputs.
+			b, err := MakeBindObject(val, goodFunc)
+
+			if err != nil {
+				return s // if error stop here.
+			}
+
+			if b.IsAssignable(inTyp) {
+				// fmt.Printf("binded input index: %d for type: %s and value: %v with pointer: %v\n",
+				// 	i, b.Type.String(), val.String(), val.Pointer())
+				s.inputs = append(s.inputs, &targetFuncInput{
+					InputIndex: i,
+					Object:     &b,
+				})
+
+				consumedValues[valIdx] = true
+				break
+			}
+		}
+	}
+
+	s.Length = n
+	s.Valid = len(s.inputs) > 0
+	return s
+}
+
+func (s *FuncInjector) Inject(in *[]reflect.Value, ctx ...reflect.Value) {
+	args := *in
+	for _, input := range s.inputs {
+		input.Object.Assign(ctx, func(v reflect.Value) {
+			// fmt.Printf("assign input index: %d for value: %v\n",
+			// 	input.InputIndex, v.String())
+			args[input.InputIndex] = v
+		})
+
+	}
+
+	*in = args
+}
+
+func (s *FuncInjector) Call(ctx ...reflect.Value) []reflect.Value {
+	in := make([]reflect.Value, s.Length, s.Length)
+	s.Inject(&in, ctx...)
+	return s.fn.Call(in)
+}