bbgo_origin/pkg/bbgo/injection.go

142 lines
3.3 KiB
Go
Raw Normal View History

package bbgo
import (
2020-11-09 08:34:35 +00:00
"fmt"
"reflect"
"github.com/sirupsen/logrus"
)
func isSymbolBasedStrategy(rs reflect.Value) (string, bool) {
field := rs.FieldByName("Symbol")
if !field.IsValid() {
return "", false
}
if field.Kind() != reflect.String {
return "", false
}
return field.String(), true
}
2020-12-07 03:43:17 +00:00
func hasField(rs reflect.Value, fieldName string) (field reflect.Value, ok bool) {
field = rs.FieldByName(fieldName)
return field, field.IsValid()
}
func injectField(rs reflect.Value, fieldName string, obj interface{}, pointerOnly bool) error {
field := rs.FieldByName(fieldName)
if !field.IsValid() {
return nil
}
if !field.CanSet() {
2020-11-09 08:34:35 +00:00
return fmt.Errorf("field %s of %s can not be set", fieldName, rs.Type())
}
rv := reflect.ValueOf(obj)
if field.Kind() == reflect.Ptr {
if field.Type() != rv.Type() {
2020-11-09 08:34:35 +00:00
return fmt.Errorf("field type mismatches: %s != %s", field.Type(), rv.Type())
}
field.Set(rv)
} else if field.Kind() == reflect.Interface {
field.Set(rv)
} else {
// set as value
if pointerOnly {
2020-11-09 08:34:35 +00:00
return fmt.Errorf("field %s %s does not allow value assignment (pointer type only)", field.Type(), rv.Type())
}
field.Set(rv.Elem())
}
return nil
}
// parseStructAndInject parses the struct fields and injects the objects into the corresponding fields by its type.
// if the given object is a reference of an object, the type of the target field MUST BE a pointer field.
// if the given object is a struct value, the type of the target field CAN BE a pointer field or a struct value field.
func parseStructAndInject(f interface{}, objects ...interface{}) error {
sv := reflect.ValueOf(f)
st := reflect.TypeOf(f)
if st.Kind() != reflect.Ptr {
return fmt.Errorf("f needs to be a pointer of a struct, %s given", st)
}
2022-03-05 04:39:39 +00:00
// solve the reference
st = st.Elem()
sv = sv.Elem()
if st.Kind() != reflect.Struct {
return fmt.Errorf("f needs to be a struct, %s given", st)
}
for i := 0; i < sv.NumField(); i++ {
fv := sv.Field(i)
ft := fv.Type()
// skip unexported fields
if !st.Field(i).IsExported() {
continue
}
2022-03-14 13:21:04 +00:00
fieldName := st.Field(i).Name
switch k := fv.Kind(); k {
case reflect.Ptr, reflect.Struct:
for oi := 0; oi < len(objects); oi++ {
obj := objects[oi]
if obj == nil {
continue
}
ot := reflect.TypeOf(obj)
if ft.AssignableTo(ot) {
if !fv.CanSet() {
return fmt.Errorf("field %v of %s can not be set to %s, make sure it is an exported field", fv, sv.Type(), ot)
}
2022-03-14 13:21:04 +00:00
if k == reflect.Ptr && !fv.IsNil() {
logrus.Debugf("[injection] field %s is not nil, not injecting", fieldName)
continue
}
if k == reflect.Ptr && ot.Kind() == reflect.Struct {
2022-03-14 13:21:04 +00:00
logrus.Debugf("[injection] found ptr + struct, injecting field %s to %T", fieldName, obj)
fv.Set(reflect.ValueOf(obj).Addr())
} else {
2022-03-14 13:21:04 +00:00
logrus.Debugf("[injection] injecting field %s to %T", fieldName, obj)
fv.Set(reflect.ValueOf(obj))
}
}
}
case reflect.Interface:
for oi := 0; oi < len(objects); oi++ {
obj := objects[oi]
if obj == nil {
continue
}
objT := reflect.TypeOf(obj)
logrus.Debugln(
ft.PkgPath(),
ft.Name(),
objT, "implements", ft, "=", objT.Implements(ft),
)
if objT.Implements(ft) {
fv.Set(reflect.ValueOf(obj))
}
}
}
}
return nil
}