gconv.Map()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
func Map(value interface{}, tags ...string) map[string]interface{} {
if value == nil {
return nil
}
if r, ok := value.(map[string]interface{}); ok {
return r
} else {
// Only assert the common combination of types, and finally it uses reflection.
m := make(map[string]interface{})
switch value.(type) {
case map[interface{}]interface{}:
for k, v := range value.(map[interface{}]interface{}) {
m[String(k)] = v
}
case map[interface{}]string:
for k, v := range value.(map[interface{}]string) {
m[String(k)] = v
}
case map[interface{}]int:
for k, v := range value.(map[interface{}]int) {
m[String(k)] = v
}
case map[interface{}]uint:
for k, v := range value.(map[interface{}]uint) {
m[String(k)] = v
}
case map[interface{}]float32:
for k, v := range value.(map[interface{}]float32) {
m[String(k)] = v
}
case map[interface{}]float64:
for k, v := range value.(map[interface{}]float64) {
m[String(k)] = v
}
case map[string]bool:
for k, v := range value.(map[string]bool) {
m[k] = v
}
case map[string]int:
for k, v := range value.(map[string]int) {
m[k] = v
}
case map[string]uint:
for k, v := range value.(map[string]uint) {
m[k] = v
}
case map[string]float32:
for k, v := range value.(map[string]float32) {
m[k] = v
}
case map[string]float64:
for k, v := range value.(map[string]float64) {
m[k] = v
}
case map[int]interface{}:
for k, v := range value.(map[int]interface{}) {
m[String(k)] = v
}
case map[int]string:
for k, v := range value.(map[int]string) {
m[String(k)] = v
}
case map[uint]string:
for k, v := range value.(map[uint]string) {
m[String(k)] = v
}
// Not a common type, use reflection
default:
rv := reflect.ValueOf(value)
kind := rv.Kind()
// If it is a pointer, we should find its real data type.
if kind == reflect.Ptr {
rv = rv.Elem()
kind = rv.Kind()
}
switch kind {
case reflect.Map:
ks := rv.MapKeys()
for _, k := range ks {
m[String(k.Interface())] = rv.MapIndex(k).Interface()
}
case reflect.Struct:
if v, ok := value.(apiMapStrAny); ok {
return v.MapStrAny()
}
rt := rv.Type()
name := ""
tagArray := structTagPriority
switch len(tags) {
case 0:
// No need handle.
case 1:
tagArray = append(strings.Split(tags[0], ","), structTagPriority...)
default:
tagArray = append(tags, structTagPriority...)
}
for i := 0; i < rv.NumField(); i++ {
// Only convert the public attributes.
fieldName := rt.Field(i).Name
if !utilstr.IsLetterUpper(fieldName[0]) {
continue
}
name = ""
fieldTag := rt.Field(i).Tag
for _, tag := range tagArray {
if name = fieldTag.Get(tag); name != "" {
break
}
}
if name == "" {
name = strings.TrimSpace(fieldName)
} else {
// Support json tag feature: -, omitempty
name = strings.TrimSpace(name)
if name == "-" {
continue
}
array := strings.Split(name, ",")
if len(array) > 1 {
switch strings.TrimSpace(array[1]) {
case "omitempty":
if empty.IsEmpty(rv.Field(i).Interface()) {
continue
} else {
name = strings.TrimSpace(array[0])
}
default:
name = strings.TrimSpace(array[0])
}
}
}
m[name] = rv.Field(i).Interface()
}
default:
return nil
}
}
return m
}
}