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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
|
/*
Copyright 2019 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package value
import (
"fmt"
"reflect"
)
type structReflect struct {
valueReflect
}
func (r structReflect) Length() int {
i := 0
eachStructField(r.Value, func(_ *TypeReflectCacheEntry, s string, value reflect.Value) bool {
i++
return true
})
return i
}
func (r structReflect) Empty() bool {
return eachStructField(r.Value, func(_ *TypeReflectCacheEntry, s string, value reflect.Value) bool {
return false // exit early if the struct is non-empty
})
}
func (r structReflect) Get(key string) (Value, bool) {
return r.GetUsing(HeapAllocator, key)
}
func (r structReflect) GetUsing(a Allocator, key string) (Value, bool) {
if val, ok := r.findJsonNameField(key); ok {
return a.allocValueReflect().mustReuse(val, nil, nil, nil), true
}
return nil, false
}
func (r structReflect) Has(key string) bool {
_, ok := r.findJsonNameField(key)
return ok
}
func (r structReflect) Set(key string, val Value) {
fieldEntry, ok := TypeReflectEntryOf(r.Value.Type()).Fields()[key]
if !ok {
panic(fmt.Sprintf("key %s may not be set on struct %T: field does not exist", key, r.Value.Interface()))
}
oldVal := fieldEntry.GetFrom(r.Value)
newVal := reflect.ValueOf(val.Unstructured())
r.update(fieldEntry, key, oldVal, newVal)
}
func (r structReflect) Delete(key string) {
fieldEntry, ok := TypeReflectEntryOf(r.Value.Type()).Fields()[key]
if !ok {
panic(fmt.Sprintf("key %s may not be deleted on struct %T: field does not exist", key, r.Value.Interface()))
}
oldVal := fieldEntry.GetFrom(r.Value)
if oldVal.Kind() != reflect.Ptr && !fieldEntry.isOmitEmpty {
panic(fmt.Sprintf("key %s may not be deleted on struct: %T: value is neither a pointer nor an omitempty field", key, r.Value.Interface()))
}
r.update(fieldEntry, key, oldVal, reflect.Zero(oldVal.Type()))
}
func (r structReflect) update(fieldEntry *FieldCacheEntry, key string, oldVal, newVal reflect.Value) {
if oldVal.CanSet() {
oldVal.Set(newVal)
return
}
// map items are not addressable, so if a struct is contained in a map, the only way to modify it is
// to write a replacement fieldEntry into the map.
if r.ParentMap != nil {
if r.ParentMapKey == nil {
panic("ParentMapKey must not be nil if ParentMap is not nil")
}
replacement := reflect.New(r.Value.Type()).Elem()
fieldEntry.GetFrom(replacement).Set(newVal)
r.ParentMap.SetMapIndex(*r.ParentMapKey, replacement)
return
}
// This should never happen since NewValueReflect ensures that the root object reflected on is a pointer and map
// item replacement is handled above.
panic(fmt.Sprintf("key %s may not be modified on struct: %T: struct is not settable", key, r.Value.Interface()))
}
func (r structReflect) Iterate(fn func(string, Value) bool) bool {
return r.IterateUsing(HeapAllocator, fn)
}
func (r structReflect) IterateUsing(a Allocator, fn func(string, Value) bool) bool {
vr := a.allocValueReflect()
defer a.Free(vr)
return eachStructField(r.Value, func(e *TypeReflectCacheEntry, s string, value reflect.Value) bool {
return fn(s, vr.mustReuse(value, e, nil, nil))
})
}
func eachStructField(structVal reflect.Value, fn func(*TypeReflectCacheEntry, string, reflect.Value) bool) bool {
for _, fieldCacheEntry := range TypeReflectEntryOf(structVal.Type()).OrderedFields() {
fieldVal := fieldCacheEntry.GetFrom(structVal)
if fieldCacheEntry.CanOmit(fieldVal) {
// omit it
continue
}
ok := fn(fieldCacheEntry.TypeEntry, fieldCacheEntry.JsonName, fieldVal)
if !ok {
return false
}
}
return true
}
func (r structReflect) Unstructured() interface{} {
// Use number of struct fields as a cheap way to rough estimate map size
result := make(map[string]interface{}, r.Value.NumField())
r.Iterate(func(s string, value Value) bool {
result[s] = value.Unstructured()
return true
})
return result
}
func (r structReflect) Equals(m Map) bool {
return r.EqualsUsing(HeapAllocator, m)
}
func (r structReflect) EqualsUsing(a Allocator, m Map) bool {
// MapEquals uses zip and is fairly efficient for structReflect
return MapEqualsUsing(a, &r, m)
}
func (r structReflect) findJsonNameFieldAndNotEmpty(jsonName string) (reflect.Value, bool) {
structCacheEntry, ok := TypeReflectEntryOf(r.Value.Type()).Fields()[jsonName]
if !ok {
return reflect.Value{}, false
}
fieldVal := structCacheEntry.GetFrom(r.Value)
return fieldVal, !structCacheEntry.CanOmit(fieldVal)
}
func (r structReflect) findJsonNameField(jsonName string) (val reflect.Value, ok bool) {
structCacheEntry, ok := TypeReflectEntryOf(r.Value.Type()).Fields()[jsonName]
if !ok {
return reflect.Value{}, false
}
fieldVal := structCacheEntry.GetFrom(r.Value)
return fieldVal, !structCacheEntry.CanOmit(fieldVal)
}
func (r structReflect) Zip(other Map, order MapTraverseOrder, fn func(key string, lhs, rhs Value) bool) bool {
return r.ZipUsing(HeapAllocator, other, order, fn)
}
func (r structReflect) ZipUsing(a Allocator, other Map, order MapTraverseOrder, fn func(key string, lhs, rhs Value) bool) bool {
if otherStruct, ok := other.(*structReflect); ok && r.Value.Type() == otherStruct.Value.Type() {
lhsvr, rhsvr := a.allocValueReflect(), a.allocValueReflect()
defer a.Free(lhsvr)
defer a.Free(rhsvr)
return r.structZip(otherStruct, lhsvr, rhsvr, fn)
}
return defaultMapZip(a, &r, other, order, fn)
}
// structZip provides an optimized zip for structReflect types. The zip is always lexical key ordered since there is
// no additional cost to ordering the zip for structured types.
func (r structReflect) structZip(other *structReflect, lhsvr, rhsvr *valueReflect, fn func(key string, lhs, rhs Value) bool) bool {
lhsVal := r.Value
rhsVal := other.Value
for _, fieldCacheEntry := range TypeReflectEntryOf(lhsVal.Type()).OrderedFields() {
lhsFieldVal := fieldCacheEntry.GetFrom(lhsVal)
rhsFieldVal := fieldCacheEntry.GetFrom(rhsVal)
lhsOmit := fieldCacheEntry.CanOmit(lhsFieldVal)
rhsOmit := fieldCacheEntry.CanOmit(rhsFieldVal)
if lhsOmit && rhsOmit {
continue
}
var lhsVal, rhsVal Value
if !lhsOmit {
lhsVal = lhsvr.mustReuse(lhsFieldVal, fieldCacheEntry.TypeEntry, nil, nil)
}
if !rhsOmit {
rhsVal = rhsvr.mustReuse(rhsFieldVal, fieldCacheEntry.TypeEntry, nil, nil)
}
if !fn(fieldCacheEntry.JsonName, lhsVal, rhsVal) {
return false
}
}
return true
}
|
