|
|
package nmapper
|
|
|
|
|
|
import (
|
|
|
"errors"
|
|
|
"fmt"
|
|
|
"git.noahlan.cn/noahlan/ntool/internal/convert"
|
|
|
"git.noahlan.cn/noahlan/ntool/nmap"
|
|
|
"git.noahlan.cn/noahlan/ntool/nmapper/wrapper"
|
|
|
"git.noahlan.cn/noahlan/ntool/nmath"
|
|
|
"git.noahlan.cn/noahlan/ntool/nreflect"
|
|
|
"git.noahlan.cn/noahlan/ntool/nstr"
|
|
|
"git.noahlan.cn/noahlan/ntool/nstruct"
|
|
|
"reflect"
|
|
|
"strings"
|
|
|
"sync"
|
|
|
"time"
|
|
|
)
|
|
|
|
|
|
type (
|
|
|
field struct {
|
|
|
name string // 原始名
|
|
|
tagName string
|
|
|
index []int // 索引列表，层级
|
|
|
tagMap nmap.SMap // tag Map
|
|
|
omitEmpty bool // 空值忽略
|
|
|
typ reflect.Type
|
|
|
}
|
|
|
|
|
|
structFields struct {
|
|
|
list []field
|
|
|
nameIndex map[string]int
|
|
|
}
|
|
|
|
|
|
MapperObject struct {
|
|
|
ZeroValue reflect.Value
|
|
|
|
|
|
typeWrappers []wrapper.TypeWrapper
|
|
|
timeType reflect.Type // 时间类型
|
|
|
enabledTypeChecking bool // 是否开启类型检查
|
|
|
|
|
|
customTagName string // 自定义Tag名称
|
|
|
}
|
|
|
)
|
|
|
|
|
|
func NewMapper(opts ...Option) *MapperObject {
|
|
|
tmp := &MapperObject{
|
|
|
ZeroValue: reflect.Value{},
|
|
|
timeType: reflect.TypeOf(time.Time{}),
|
|
|
typeWrappers: make([]wrapper.TypeWrapper, 0),
|
|
|
enabledTypeChecking: false,
|
|
|
customTagName: "",
|
|
|
}
|
|
|
|
|
|
for _, opt := range opts {
|
|
|
opt(tmp)
|
|
|
}
|
|
|
|
|
|
return tmp
|
|
|
}
|
|
|
|
|
|
func (m *MapperObject) SetTypeWrapper(wrappers ...wrapper.TypeWrapper) {
|
|
|
m.typeWrappers = wrappers
|
|
|
}
|
|
|
|
|
|
func (m *MapperObject) RegisterTypeWrapper(wrappers ...wrapper.TypeWrapper) {
|
|
|
m.typeWrappers = append(m.typeWrappers, wrappers...)
|
|
|
}
|
|
|
|
|
|
// Mapper 将src转换为dst
|
|
|
// src为struct类型, dst为map类型 map[string]any 或者 map[string]string
|
|
|
func (m *MapperObject) Mapper(dst any, src any) error {
|
|
|
srcElem := reflect.ValueOf(src)
|
|
|
srcElem = nreflect.Indirect(srcElem)
|
|
|
|
|
|
dstElem := reflect.ValueOf(dst)
|
|
|
dstElem = nreflect.Indirect(dstElem)
|
|
|
|
|
|
if srcElem == m.ZeroValue {
|
|
|
return errors.New("src is not legal value")
|
|
|
}
|
|
|
if srcElem.Kind() != reflect.Struct {
|
|
|
return errors.New("src must be struct")
|
|
|
}
|
|
|
|
|
|
if dstElem == m.ZeroValue {
|
|
|
return errors.New("dst is not legal value")
|
|
|
}
|
|
|
if dstElem.Type().Kind() != reflect.Map {
|
|
|
return errors.New("dst is not map")
|
|
|
}
|
|
|
flatten := dstElem.Type().Elem().Kind() == reflect.String
|
|
|
if flatten {
|
|
|
m.SetTypeWrapper(wrapper.StrWrapper()...)
|
|
|
defer func() {
|
|
|
m.SetTypeWrapper()
|
|
|
}()
|
|
|
}
|
|
|
m.elemToMap(dstElem, srcElem, "", flatten)
|
|
|
return nil
|
|
|
}
|
|
|
|
|
|
func isEmptyValue(v reflect.Value) bool {
|
|
|
switch v.Kind() {
|
|
|
case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
|
|
|
return v.Len() == 0
|
|
|
case reflect.Bool:
|
|
|
return !v.Bool()
|
|
|
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
|
|
return v.Int() == 0
|
|
|
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
|
|
|
return v.Uint() == 0
|
|
|
case reflect.Float32, reflect.Float64:
|
|
|
return v.Float() == 0
|
|
|
case reflect.Interface, reflect.Pointer:
|
|
|
return v.IsNil()
|
|
|
}
|
|
|
return false
|
|
|
}
|
|
|
|
|
|
func (m *MapperObject) elemToMap(dstElem, srcElem reflect.Value, preKey string, flatten bool) {
|
|
|
fields := cachedTypeFields(srcElem.Type(), m.customTagName)
|
|
|
FieldLoop:
|
|
|
for i := range fields.list {
|
|
|
f := &fields.list[i]
|
|
|
|
|
|
fv := srcElem
|
|
|
for _, i := range f.index {
|
|
|
if fv.Kind() == reflect.Ptr {
|
|
|
if fv.IsNil() {
|
|
|
continue FieldLoop
|
|
|
}
|
|
|
fv = fv.Elem()
|
|
|
}
|
|
|
fv = fv.Field(i)
|
|
|
}
|
|
|
if f.omitEmpty && isEmptyValue(fv) {
|
|
|
continue
|
|
|
}
|
|
|
fv = nreflect.IndirectAddr(fv)
|
|
|
if fv.Kind() == reflect.Struct && fv.Type().Name() != "Time" {
|
|
|
if flatten {
|
|
|
m.elemToMap(dstElem, fv, f.tagName, flatten)
|
|
|
} else {
|
|
|
tmpMapV := reflect.ValueOf(make(map[string]any))
|
|
|
dstElem.SetMapIndex(reflect.ValueOf(f.tagName), tmpMapV)
|
|
|
m.elemToMap(tmpMapV, fv, f.tagName, flatten)
|
|
|
}
|
|
|
} else {
|
|
|
wrappedFv := fv
|
|
|
for _, w := range m.typeWrappers {
|
|
|
if w.Supported(wrappedFv) {
|
|
|
wrappedFv = w.Wrap(wrappedFv, i, f.tagMap)
|
|
|
break
|
|
|
}
|
|
|
}
|
|
|
key := reflect.ValueOf(f.tagName)
|
|
|
if flatten && preKey != "" {
|
|
|
key = reflect.ValueOf(preKey + flattenSeparator + f.tagName)
|
|
|
}
|
|
|
dstElem.SetMapIndex(key, wrappedFv)
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
func (m *MapperObject) Parse(dst any, src any, flatten bool) error {
|
|
|
srcElem := reflect.ValueOf(src)
|
|
|
if srcElem.Type().Kind() != reflect.Map {
|
|
|
return errors.New("src is not legal value, must be map[string]any or map[string]string")
|
|
|
}
|
|
|
//flatten := srcElem.Type().Elem().Kind() == reflect.String
|
|
|
if flatten {
|
|
|
m.SetTypeWrapper(wrapper.StrWrapper()...)
|
|
|
defer func() {
|
|
|
m.SetTypeWrapper()
|
|
|
}()
|
|
|
}
|
|
|
|
|
|
dstElem := reflect.ValueOf(dst)
|
|
|
if dstElem.Kind() != reflect.Pointer || dstElem.IsNil() {
|
|
|
return errors.New("non-pointer dst")
|
|
|
}
|
|
|
|
|
|
return m.parseInner(dstElem, srcElem, flatten)
|
|
|
}
|
|
|
|
|
|
func (m *MapperObject) parseInner(v reflect.Value, srcElem reflect.Value, flatten bool) error {
|
|
|
pv := nreflect.IndirectAddr(v)
|
|
|
|
|
|
v = pv
|
|
|
t := v.Type()
|
|
|
|
|
|
// Decoding into nil interface? Switch to non-reflect code.
|
|
|
if v.Kind() == reflect.Interface && v.NumMethod() == 0 {
|
|
|
v.Set(srcElem)
|
|
|
return nil
|
|
|
}
|
|
|
var fields structFields
|
|
|
// Check type of target:
|
|
|
// struct or
|
|
|
// map[T1]T2 where T1 is string
|
|
|
switch v.Kind() {
|
|
|
case reflect.Map:
|
|
|
// Map key must either have string kind
|
|
|
switch t.Key().Kind() {
|
|
|
case reflect.String:
|
|
|
default:
|
|
|
//return errors.New("the type of key must be string")
|
|
|
return nil
|
|
|
}
|
|
|
if v.IsNil() {
|
|
|
v.Set(reflect.MakeMap(t))
|
|
|
}
|
|
|
case reflect.Struct:
|
|
|
fields = cachedTypeFields(t, m.customTagName)
|
|
|
// ok
|
|
|
default:
|
|
|
return errors.New("type of dst must be map[string]xx or struct")
|
|
|
}
|
|
|
|
|
|
var mapElem reflect.Value
|
|
|
mapIter := srcElem.MapRange()
|
|
|
for mapIter.Next() {
|
|
|
mapKey, mapValue := mapIter.Key(), mapIter.Value()
|
|
|
if !mapValue.IsValid() || mapValue.IsZero() {
|
|
|
continue
|
|
|
}
|
|
|
// key
|
|
|
key := mapKey.String()
|
|
|
|
|
|
// Figure out field corresponding to key.
|
|
|
var (
|
|
|
subv reflect.Value
|
|
|
tagMap nmap.SMap
|
|
|
)
|
|
|
if v.Kind() == reflect.Map {
|
|
|
elemType := t.Elem()
|
|
|
if !mapElem.IsValid() {
|
|
|
mapElem = reflect.New(elemType).Elem()
|
|
|
} else {
|
|
|
mapElem.Set(reflect.Zero(elemType))
|
|
|
}
|
|
|
subv = mapElem
|
|
|
} else {
|
|
|
var f *field
|
|
|
// 对于key中包含分隔符
|
|
|
if strings.Contains(mapKey.String(), flattenSeparator) {
|
|
|
keys := nstr.Split(mapKey.String(), flattenSeparator)
|
|
|
keyLen := len(keys)
|
|
|
var tmpFields = fields
|
|
|
for i := 0; i < keyLen; i++ {
|
|
|
k := keys[i]
|
|
|
var tmpF *field
|
|
|
if i, ok := tmpFields.nameIndex[k]; ok {
|
|
|
// Found an exact name match.
|
|
|
tmpF = &tmpFields.list[i]
|
|
|
} else {
|
|
|
// Fall back to the expensive case-insensitive
|
|
|
// linear search.
|
|
|
for i := range tmpFields.list {
|
|
|
ff := &tmpFields.list[i]
|
|
|
if ff.tagName == k {
|
|
|
tmpF = ff
|
|
|
break
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if tmpF != nil {
|
|
|
f = tmpF
|
|
|
if f.typ.Kind() == reflect.Struct {
|
|
|
if i < keyLen-1 {
|
|
|
if flatten {
|
|
|
// 扁平化模式下，需要将subv指定为倒数第二个key所指向的struct
|
|
|
subv = m.findRValueByField(subv, v, f)
|
|
|
}
|
|
|
if f.typ.Kind() == reflect.Struct {
|
|
|
tmpFields = cachedTypeFields(f.typ, m.customTagName)
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
} else {
|
|
|
// 当未能发现对应key的指向时，需判断上层是否为map，所为map则需要构建
|
|
|
if f != nil && f.typ.Kind() == reflect.Map {
|
|
|
// 此时的f为上层field
|
|
|
if subv.Kind() != reflect.Map {
|
|
|
subv = m.findRValueByField(subv, v, f)
|
|
|
}
|
|
|
if subv.Kind() == reflect.Map {
|
|
|
if subv.IsNil() {
|
|
|
subv.Set(reflect.MakeMap(f.typ))
|
|
|
}
|
|
|
if i < keyLen-1 {
|
|
|
subvTElem := subv.Type().Elem()
|
|
|
if subvTElem.Kind() == reflect.Interface || subvTElem.Kind() == reflect.Map {
|
|
|
tmpMap := reflect.MakeMap(f.typ)
|
|
|
subv.SetMapIndex(reflect.ValueOf(k), tmpMap)
|
|
|
subv = tmpMap
|
|
|
}
|
|
|
}
|
|
|
if i == keyLen-1 {
|
|
|
mapKey = reflect.ValueOf(k)
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if i == keyLen-1 {
|
|
|
f = nil
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
} else {
|
|
|
if i, ok := fields.nameIndex[key]; ok {
|
|
|
// Found an exact name match.
|
|
|
f = &fields.list[i]
|
|
|
} else {
|
|
|
// Fall back to the expensive case-insensitive
|
|
|
// linear search.
|
|
|
for i := range fields.list {
|
|
|
ff := &fields.list[i]
|
|
|
if ff.tagName == key {
|
|
|
f = ff
|
|
|
break
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if f != nil {
|
|
|
tagMap = f.tagMap
|
|
|
subv = m.findRValueByField(subv, v, f)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if !subv.IsValid() {
|
|
|
continue
|
|
|
}
|
|
|
subv = nreflect.IndirectAddr(subv)
|
|
|
|
|
|
switch subv.Kind() {
|
|
|
case reflect.Map:
|
|
|
if subv.IsNil() {
|
|
|
subv.Set(reflect.MakeMap(subv.Type()))
|
|
|
}
|
|
|
if mapValue.Kind() == reflect.Interface && mapValue.Elem().Kind() == reflect.Map {
|
|
|
subv.Set(mapValue.Elem())
|
|
|
} else {
|
|
|
subv.SetMapIndex(mapKey, mapValue)
|
|
|
}
|
|
|
case reflect.Struct:
|
|
|
// 递归，将mapValue作为本次的src进行传递
|
|
|
if mapValue.Kind() == reflect.Interface && mapValue.Elem().Kind() == reflect.Map {
|
|
|
if err := m.parseInner(subv, reflect.ValueOf(mapValue.Interface()), false); err != nil {
|
|
|
return err
|
|
|
}
|
|
|
} else {
|
|
|
m.setFieldValue(subv, tagMap, mapValue.Interface())
|
|
|
}
|
|
|
default:
|
|
|
// 普通属性，直接设置值
|
|
|
m.setFieldValue(subv, tagMap, mapValue.Interface())
|
|
|
}
|
|
|
|
|
|
// 递归回溯后
|
|
|
// Write value back to map;
|
|
|
// if using struct, subv points into struct already.
|
|
|
if v.Kind() == reflect.Map {
|
|
|
kt := t.Key()
|
|
|
var kv reflect.Value
|
|
|
switch {
|
|
|
case kt.Kind() == reflect.String:
|
|
|
kv = reflect.ValueOf(key).Convert(kt)
|
|
|
default:
|
|
|
return fmt.Errorf("unexpected key type")
|
|
|
}
|
|
|
if kv.IsValid() {
|
|
|
v.SetMapIndex(kv, subv)
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return nil
|
|
|
}
|
|
|
|
|
|
func (m *MapperObject) findRValueByField(subv reflect.Value, topv reflect.Value, f *field) reflect.Value {
|
|
|
if !subv.IsValid() {
|
|
|
subv = topv
|
|
|
}
|
|
|
for _, i := range f.index {
|
|
|
if subv.Kind() == reflect.Ptr {
|
|
|
if subv.IsNil() {
|
|
|
// If a struct embeds a pointer to an unexported type,
|
|
|
// it is not possible to set a newly allocated value
|
|
|
// since the field is unexported.
|
|
|
//
|
|
|
// See https://golang.org/issue/21357
|
|
|
if !subv.CanSet() {
|
|
|
//return fmt.Errorf("cannot set embedded pointer to unexported struct: %v", subv.Type().Elem())
|
|
|
break
|
|
|
}
|
|
|
subv.Set(reflect.New(subv.Type().Elem()))
|
|
|
}
|
|
|
subv = subv.Elem()
|
|
|
}
|
|
|
subv = subv.Field(i)
|
|
|
}
|
|
|
return subv
|
|
|
}
|
|
|
|
|
|
func (m *MapperObject) setFieldValue(fieldElem reflect.Value, tagMap nmap.SMap, value any) {
|
|
|
fieldKind := fieldElem.Type().Kind()
|
|
|
//v := nreflect.IndirectAddr(fieldElem)
|
|
|
|
|
|
switch fieldKind {
|
|
|
case reflect.Bool:
|
|
|
if value == nil {
|
|
|
fieldElem.SetBool(false)
|
|
|
} else if v, ok := value.(bool); ok {
|
|
|
fieldElem.SetBool(v)
|
|
|
} else {
|
|
|
b, _ := convert.StrToBool(nstr.SafeString(value))
|
|
|
fieldElem.SetBool(b)
|
|
|
}
|
|
|
case reflect.String:
|
|
|
if value == nil {
|
|
|
fieldElem.SetString("")
|
|
|
} else {
|
|
|
fieldElem.SetString(nstr.SafeString(value))
|
|
|
}
|
|
|
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
|
|
if value == nil {
|
|
|
fieldElem.SetInt(0)
|
|
|
} else {
|
|
|
val := reflect.ValueOf(value)
|
|
|
switch val.Kind() {
|
|
|
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
|
|
fieldElem.SetInt(val.Int())
|
|
|
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
|
|
|
fieldElem.SetInt(int64(val.Uint()))
|
|
|
default:
|
|
|
v, _ := nmath.ToInt64(value)
|
|
|
fieldElem.SetInt(v)
|
|
|
}
|
|
|
}
|
|
|
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
|
|
|
if value == nil {
|
|
|
fieldElem.SetUint(0)
|
|
|
} else {
|
|
|
val := reflect.ValueOf(value)
|
|
|
switch val.Kind() {
|
|
|
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
|
|
|
fieldElem.SetUint(uint64(val.Int()))
|
|
|
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
|
|
|
fieldElem.SetUint(val.Uint())
|
|
|
default:
|
|
|
v, _ := nmath.ToUint(value)
|
|
|
fieldElem.SetUint(v)
|
|
|
}
|
|
|
}
|
|
|
case reflect.Float64, reflect.Float32:
|
|
|
if value == nil {
|
|
|
fieldElem.SetFloat(0)
|
|
|
} else {
|
|
|
val := reflect.ValueOf(value)
|
|
|
switch val.Kind() {
|
|
|
case reflect.Float64:
|
|
|
fieldElem.SetFloat(val.Float())
|
|
|
default:
|
|
|
fieldElem.SetFloat(nmath.QuietFloat(value))
|
|
|
}
|
|
|
}
|
|
|
case reflect.Struct:
|
|
|
if value == nil {
|
|
|
fieldElem.Set(reflect.Zero(fieldElem.Type()))
|
|
|
} else {
|
|
|
for _, w := range m.typeWrappers {
|
|
|
if w.Supported(fieldElem) {
|
|
|
w.Set(fieldElem, value, tagMap)
|
|
|
break
|
|
|
}
|
|
|
}
|
|
|
if reflect.ValueOf(value).Type() == fieldElem.Type() {
|
|
|
fieldElem.Set(reflect.ValueOf(value))
|
|
|
}
|
|
|
}
|
|
|
default:
|
|
|
if !fieldElem.IsValid() {
|
|
|
fieldElem.Set(reflect.Zero(fieldElem.Type()))
|
|
|
return
|
|
|
}
|
|
|
// Type check
|
|
|
if reflect.ValueOf(value).Type() == fieldElem.Type() {
|
|
|
fieldElem.Set(reflect.ValueOf(value))
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// getFieldNameAndMap 获取字段名称和tagMap
|
|
|
func getFieldNameAndMap(field reflect.StructField, customTagName string) (string, nmap.SMap) {
|
|
|
// 1. custom
|
|
|
tagVal, ok := field.Tag.Lookup(customTagName)
|
|
|
if ok && tagVal != "" {
|
|
|
sMap, _ := nstruct.ParseTagValueDefault(field.Name, tagVal)
|
|
|
name := sMap.Get("name")
|
|
|
if name != "" {
|
|
|
return name, sMap
|
|
|
} else {
|
|
|
// tag "-"
|
|
|
return "", nil
|
|
|
}
|
|
|
}
|
|
|
// 2. mapper
|
|
|
tagVal, ok = field.Tag.Lookup(mapperTagKey)
|
|
|
if ok && tagVal != "" {
|
|
|
sMap, _ := nstruct.ParseTagValueDefault(field.Name, tagVal)
|
|
|
name := sMap.Get("name")
|
|
|
if name != "" {
|
|
|
return name, sMap
|
|
|
} else {
|
|
|
// tag "-"
|
|
|
return "", nil
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 3. json
|
|
|
tagVal, ok = field.Tag.Lookup(jsonTagKey)
|
|
|
if ok && tagVal != "" {
|
|
|
sMap, _ := nstruct.ParseTagValueDefault(field.Name, tagVal)
|
|
|
name := sMap.Get("name")
|
|
|
if name != "" {
|
|
|
return name, sMap
|
|
|
} else {
|
|
|
// tag "-"
|
|
|
return "", nil
|
|
|
}
|
|
|
}
|
|
|
return field.Name, nmap.SMap{"name": field.Name}
|
|
|
}
|
|
|
|
|
|
var fieldCache sync.Map
|
|
|
|
|
|
func cachedTypeFields(t reflect.Type, customTagName string) structFields {
|
|
|
if f, ok := fieldCache.Load(t); ok {
|
|
|
return f.(structFields)
|
|
|
}
|
|
|
f, _ := fieldCache.LoadOrStore(t, typeFields(t, customTagName))
|
|
|
return f.(structFields)
|
|
|
}
|
|
|
|
|
|
// typeFields returns a list of fields that JSON should recognize for the given type.
|
|
|
// The algorithm is breadth-first search over the set of structs to include - the top struct
|
|
|
// and then any reachable anonymous structs.
|
|
|
func typeFields(t reflect.Type, customTagName string) structFields {
|
|
|
// Anonymous fields to explore at the current level and the next.
|
|
|
var current []field
|
|
|
next := []field{{typ: t}}
|
|
|
|
|
|
// Count of queued names for current level and the next.
|
|
|
var count, nextCount map[reflect.Type]int
|
|
|
|
|
|
// Types already visited at an earlier level.
|
|
|
visited := map[reflect.Type]bool{}
|
|
|
|
|
|
// Fields found.
|
|
|
var fields []field
|
|
|
|
|
|
for len(next) > 0 {
|
|
|
current, next = next, current[:0]
|
|
|
count, nextCount = nextCount, map[reflect.Type]int{}
|
|
|
|
|
|
for _, f := range current {
|
|
|
if visited[f.typ] {
|
|
|
continue
|
|
|
}
|
|
|
visited[f.typ] = true
|
|
|
|
|
|
// Scan f.typ for fields to include.
|
|
|
for i := 0; i < f.typ.NumField(); i++ {
|
|
|
sf := f.typ.Field(i)
|
|
|
if sf.Anonymous {
|
|
|
t := sf.Type
|
|
|
if t.Kind() == reflect.Pointer {
|
|
|
t = t.Elem()
|
|
|
}
|
|
|
if !sf.IsExported() && t.Kind() != reflect.Struct {
|
|
|
// Ignore embedded fields of unexported non-struct types.
|
|
|
continue
|
|
|
}
|
|
|
// Do not ignore embedded fields of unexported struct types
|
|
|
// since they may have exported fields.
|
|
|
} else if !sf.IsExported() {
|
|
|
// Ignore unexported non-embedded fields.
|
|
|
continue
|
|
|
}
|
|
|
name, tagMap := getFieldNameAndMap(sf, customTagName)
|
|
|
if name == "" {
|
|
|
continue
|
|
|
}
|
|
|
index := make([]int, len(f.index)+1)
|
|
|
copy(index, f.index)
|
|
|
index[len(f.index)] = i
|
|
|
|
|
|
ft := sf.Type
|
|
|
if ft.Name() == "" && ft.Kind() == reflect.Pointer {
|
|
|
// Follow pointer.
|
|
|
ft = ft.Elem()
|
|
|
}
|
|
|
|
|
|
// Record found field and index sequence.
|
|
|
if !sf.Anonymous || ft.Kind() != reflect.Struct {
|
|
|
fields = append(fields, field{
|
|
|
name: sf.Name,
|
|
|
tagName: name,
|
|
|
index: index,
|
|
|
tagMap: tagMap,
|
|
|
omitEmpty: tagMap.Has("omitempty"),
|
|
|
typ: ft,
|
|
|
})
|
|
|
if count[f.typ] > 1 {
|
|
|
// If there were multiple instances, add a second,
|
|
|
// so that the annihilation code will see a duplicate.
|
|
|
// It only cares about the distinction between 1 or 2,
|
|
|
// so don't bother generating any more copies.
|
|
|
fields = append(fields, fields[len(fields)-1])
|
|
|
}
|
|
|
continue
|
|
|
}
|
|
|
// Record new anonymous struct to explore in next round.
|
|
|
nextCount[ft]++
|
|
|
if nextCount[ft] == 1 {
|
|
|
next = append(next, field{name: ft.Name(), index: index, typ: ft})
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
// Delete all fields that are hidden by the Go rules for embedded fields,
|
|
|
// except that fields with JSON tags are promoted.
|
|
|
|
|
|
// The fields are sorted in primary order of name, secondary order
|
|
|
// of field index length. Loop over names; for each name, delete
|
|
|
// hidden fields by choosing the one dominant field that survives.
|
|
|
out := fields[:0]
|
|
|
for advance, i := 0, 0; i < len(fields); i += advance {
|
|
|
// One iteration per name.
|
|
|
// Find the sequence of fields with the name of this first field.
|
|
|
fi := fields[i]
|
|
|
name := fi.name
|
|
|
for advance = 1; i+advance < len(fields); advance++ {
|
|
|
fj := fields[i+advance]
|
|
|
if fj.name != name {
|
|
|
break
|
|
|
}
|
|
|
}
|
|
|
if advance == 1 { // Only one field with this name
|
|
|
out = append(out, fi)
|
|
|
continue
|
|
|
}
|
|
|
dominant, ok := dominantField(fields[i : i+advance])
|
|
|
if ok {
|
|
|
out = append(out, dominant)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
fields = out
|
|
|
|
|
|
nameIndex := make(map[string]int, len(fields))
|
|
|
for i, field := range fields {
|
|
|
nameIndex[field.tagName] = i
|
|
|
}
|
|
|
|
|
|
return structFields{fields, nameIndex}
|
|
|
}
|
|
|
|
|
|
// dominantField looks through the fields, all of which are known to
|
|
|
// have the same name, to find the single field that dominates the
|
|
|
// others using Go's embedding rules, modified by the presence of
|
|
|
// JSON tags. If there are multiple top-level fields, the boolean
|
|
|
// will be false: This condition is an error in Go and we skip all
|
|
|
// the fields.
|
|
|
func dominantField(fields []field) (field, bool) {
|
|
|
// The fields are sorted in increasing index-length order, then by presence of tag.
|
|
|
// That means that the first field is the dominant one. We need only check
|
|
|
// for error cases: two fields at top level, either both tagged or neither tagged.
|
|
|
if len(fields) > 1 && len(fields[0].index) == len(fields[1].index) {
|
|
|
return field{}, false
|
|
|
}
|
|
|
return fields[0], true
|
|
|
}
|