di/registry/registry.go

package registry

import (
	"fmt"
	"log"
	"reflect"
	"runtime"
	"strings"

	cda "git.loafle.net/commons_go/di/annotation"
	cdur "git.loafle.net/commons_go/di/util/reflect"
	"git.loafle.net/commons_go/logging"
)

func init() {
	registry = newRegistry()
}

var registry ComponentRegistry

type ComponentRegistry interface {
	RegisterType(t reflect.Type, ca *cda.ComponentAnnotation)
	RegisterResource(name string, resource interface{}) error

	GetInstance(t reflect.Type) (interface{}, error)
	GetInstanceByName(name string) (interface{}, error)
}

func newRegistry() ComponentRegistry {
	r := &defaultComponentRegistry{}
	r.definitionByType = make(map[reflect.Type]*TypeDefinition, 0)
	r.definitionByName = make(map[string]*TypeDefinition, 0)
	r.instanceByType = make(map[reflect.Type]interface{}, 0)
	r.resourceByName = make(map[string]interface{}, 0)

	return r
}

type defaultComponentRegistry struct {
	definitionByType map[reflect.Type]*TypeDefinition
	definitionByName map[string]*TypeDefinition
	instanceByType   map[reflect.Type]interface{}
	resourceByName   map[string]interface{}
}

func RegisterType(t reflect.Type, ca *cda.ComponentAnnotation) {
	pc, _, _, ok := runtime.Caller(1)
	details := runtime.FuncForPC(pc)
	if ok && details != nil {
		log.Printf("called from %s\n", details.Name())
	}

	registry.RegisterType(t, ca)
}
func (cr *defaultComponentRegistry) RegisterType(t reflect.Type, ca *cda.ComponentAnnotation) {
	if nil == t {
		logging.Logger().Panic("DI: t[reflect.Type] is nil")
	}
	if !cdur.IsTypeKind(t, reflect.Struct, true) {
		logging.Logger().Panic(fmt.Sprintf("DI: t[reflect.Type] must be specified but is %v", t))
	}

	td, err := cr.buildDefinition(t)
	if nil != err {
		logging.Logger().Panic(fmt.Sprintf("DI: %v", err))
	}

	if _, ok := cr.definitionByType[td.RealType]; ok {
		logging.Logger().Panic(fmt.Sprintf("DI: The type[%s] of Component is exist already", td.FullName))
	}
	cr.definitionByType[td.RealType] = td

	name := ""
	if nil != ca && "" != strings.Trim(ca.Name, " ") {
		name = ca.Name
	} else {
		name = td.TypeName
	}

	if eTD, ok := cr.definitionByName[name]; ok {
		logging.Logger().Panic(fmt.Sprintf("DI: The name[%s] of Component is exist already type[%s]", name, eTD.FullName))
	}
	cr.definitionByName[name] = td
}

func RegisterResource(name string, resource interface{}) error {
	return registry.RegisterResource(name, resource)
}
func (cr *defaultComponentRegistry) RegisterResource(name string, resource interface{}) error {
	if _, ok := cr.resourceByName[name]; ok {
		return fmt.Errorf("DI: Resource[%s] is already exist", name)
	}
	cr.resourceByName[name] = resource

	return nil
}

// GetInstance returns instance of type
// t must be pointer of struct
func GetInstance(t reflect.Type) (interface{}, error) {
	return registry.GetInstance(t)
}
func (cr *defaultComponentRegistry) GetInstance(t reflect.Type) (interface{}, error) {
	if nil == t {
		return nil, fmt.Errorf("DI: t[reflect.Type] is nil")
	}

	if reflect.Ptr != t.Kind() {
		return nil, fmt.Errorf("DI: t[reflect.Type] must be pointer of struct")
	}

	if reflect.Struct != t.Elem().Kind() {
		return nil, fmt.Errorf("DI: t[reflect.Type] must be pointer of struct")
	}

	var err error

	rt, _, _ := cdur.GetTypeInfo(t)
	td, ok := cr.definitionByType[rt]
	if !ok {
		td, err = cr.buildDefinition(t)
		if nil != err {
			return nil, err
		}
	}

	comV, ok := cr.instanceByType[td.RealType]
	if ok {
		return comV, nil
	}

	v := reflect.New(rt)
	rv := v.Elem()

	var annotation cda.Annotation
	var fV interface{}

	for _, fd := range td.Fields {
		f := rv.FieldByName(fd.FieldName)

		if !f.IsValid() {
			return nil, fmt.Errorf("DI: Field[%s] is not valid", fd.FieldName)
		}
		if !f.CanSet() {
			return nil, fmt.Errorf("DI: Field[%s] can not set", fd.FieldName)
		}

		annotation = fd.GetAnnotation(cda.InjectTag)
		if nil != annotation {
			fV, err = cr.GetInstance(fd.Type)
		}
		annotation = fd.GetAnnotation(cda.ResourceTag)
		if nil != annotation {
			n := annotation.(*cda.Resource).Name
			if "" == n {
				n = fd.FieldName
			}
			fV, err = cr.GetInstanceByName(n)
		}

		if nil != err {
			return nil, err
		}
		f.Set(reflect.ValueOf(fV))
	}

	cr.instanceByType[td.RealType] = v.Interface()

	return v.Interface(), nil
}

func GetInstanceByName(name string) (interface{}, error) {
	return registry.GetInstanceByName(name)
}
func (cr *defaultComponentRegistry) GetInstanceByName(name string) (interface{}, error) {
	v, ok := cr.resourceByName[name]
	if ok {
		return v, nil
	}
	return nil, fmt.Errorf("DI: Resource[%s] is not exist", name)
}

func (cr *defaultComponentRegistry) buildDefinition(t reflect.Type) (*TypeDefinition, error) {
	if nil == t {
		return nil, fmt.Errorf("t[reflect.Type] is nil")
	}

	rt, pkgName, tName := cdur.GetTypeInfo(t)
	td := &TypeDefinition{}
	td.FullName = FullName(pkgName, tName)
	td.PkgName = pkgName
	td.TypeName = tName
	td.Type = t
	td.RealType = rt

	fields := getFields(rt)

	if 0 < len(fields) {
		td.Fields = fields
	}

	return td, nil
}

func getFields(t reflect.Type) []*FieldDefinition {
	fields := make([]*FieldDefinition, 0)
	rt, _, _ := cdur.GetTypeInfo(t)
	if reflect.Struct != rt.Kind() {
		return fields
	}

	for i := 0; i < rt.NumField(); i++ {
		f := rt.Field(i)

		if f.Anonymous {
			fields = append(fields, getFields(f.Type)...)
		} else {
			as, err := cda.ParseAnnotation(f.Tag)
			if nil != err {
				return fields
			}
			if nil != as && 0 < len(as) {
				fRT, fPkgName, fTName := cdur.GetTypeInfo(f.Type)

				fd := &FieldDefinition{
					FieldName:   f.Name,
					PkgName:     fPkgName,
					TypeName:    fTName,
					Type:        f.Type,
					RealType:    fRT,
					Annotations: as,
				}
				fields = append(fields, fd)
			}
		}
	}

	return fields
}