23 merge func(dst, src pointer, f *coderFieldInfo, opts mergeOptions) |
23 merge func(dst, src pointer, f *coderFieldInfo, opts mergeOptions) |
24 } |
24 } |
25 |
25 |
26 // valueCoderFuncs is a set of protoreflect.Value encoding functions. |
26 // valueCoderFuncs is a set of protoreflect.Value encoding functions. |
27 type valueCoderFuncs struct { |
27 type valueCoderFuncs struct { |
28 size func(v pref.Value, tagsize int, opts marshalOptions) int |
28 size func(v protoreflect.Value, tagsize int, opts marshalOptions) int |
29 marshal func(b []byte, v pref.Value, wiretag uint64, opts marshalOptions) ([]byte, error) |
29 marshal func(b []byte, v protoreflect.Value, wiretag uint64, opts marshalOptions) ([]byte, error) |
30 unmarshal func(b []byte, v pref.Value, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (pref.Value, unmarshalOutput, error) |
30 unmarshal func(b []byte, v protoreflect.Value, num protowire.Number, wtyp protowire.Type, opts unmarshalOptions) (protoreflect.Value, unmarshalOutput, error) |
31 isInit func(v pref.Value) error |
31 isInit func(v protoreflect.Value) error |
32 merge func(dst, src pref.Value, opts mergeOptions) pref.Value |
32 merge func(dst, src protoreflect.Value, opts mergeOptions) protoreflect.Value |
33 } |
33 } |
34 |
34 |
35 // fieldCoder returns pointer functions for a field, used for operating on |
35 // fieldCoder returns pointer functions for a field, used for operating on |
36 // struct fields. |
36 // struct fields. |
37 func fieldCoder(fd pref.FieldDescriptor, ft reflect.Type) (*MessageInfo, pointerCoderFuncs) { |
37 func fieldCoder(fd protoreflect.FieldDescriptor, ft reflect.Type) (*MessageInfo, pointerCoderFuncs) { |
38 switch { |
38 switch { |
39 case fd.IsMap(): |
39 case fd.IsMap(): |
40 return encoderFuncsForMap(fd, ft) |
40 return encoderFuncsForMap(fd, ft) |
41 case fd.Cardinality() == pref.Repeated && !fd.IsPacked(): |
41 case fd.Cardinality() == protoreflect.Repeated && !fd.IsPacked(): |
42 // Repeated fields (not packed). |
42 // Repeated fields (not packed). |
43 if ft.Kind() != reflect.Slice { |
43 if ft.Kind() != reflect.Slice { |
44 break |
44 break |
45 } |
45 } |
46 ft := ft.Elem() |
46 ft := ft.Elem() |
47 switch fd.Kind() { |
47 switch fd.Kind() { |
48 case pref.BoolKind: |
48 case protoreflect.BoolKind: |
49 if ft.Kind() == reflect.Bool { |
49 if ft.Kind() == reflect.Bool { |
50 return nil, coderBoolSlice |
50 return nil, coderBoolSlice |
51 } |
51 } |
52 case pref.EnumKind: |
52 case protoreflect.EnumKind: |
53 if ft.Kind() == reflect.Int32 { |
53 if ft.Kind() == reflect.Int32 { |
54 return nil, coderEnumSlice |
54 return nil, coderEnumSlice |
55 } |
55 } |
56 case pref.Int32Kind: |
56 case protoreflect.Int32Kind: |
57 if ft.Kind() == reflect.Int32 { |
57 if ft.Kind() == reflect.Int32 { |
58 return nil, coderInt32Slice |
58 return nil, coderInt32Slice |
59 } |
59 } |
60 case pref.Sint32Kind: |
60 case protoreflect.Sint32Kind: |
61 if ft.Kind() == reflect.Int32 { |
61 if ft.Kind() == reflect.Int32 { |
62 return nil, coderSint32Slice |
62 return nil, coderSint32Slice |
63 } |
63 } |
64 case pref.Uint32Kind: |
64 case protoreflect.Uint32Kind: |
65 if ft.Kind() == reflect.Uint32 { |
65 if ft.Kind() == reflect.Uint32 { |
66 return nil, coderUint32Slice |
66 return nil, coderUint32Slice |
67 } |
67 } |
68 case pref.Int64Kind: |
68 case protoreflect.Int64Kind: |
69 if ft.Kind() == reflect.Int64 { |
69 if ft.Kind() == reflect.Int64 { |
70 return nil, coderInt64Slice |
70 return nil, coderInt64Slice |
71 } |
71 } |
72 case pref.Sint64Kind: |
72 case protoreflect.Sint64Kind: |
73 if ft.Kind() == reflect.Int64 { |
73 if ft.Kind() == reflect.Int64 { |
74 return nil, coderSint64Slice |
74 return nil, coderSint64Slice |
75 } |
75 } |
76 case pref.Uint64Kind: |
76 case protoreflect.Uint64Kind: |
77 if ft.Kind() == reflect.Uint64 { |
77 if ft.Kind() == reflect.Uint64 { |
78 return nil, coderUint64Slice |
78 return nil, coderUint64Slice |
79 } |
79 } |
80 case pref.Sfixed32Kind: |
80 case protoreflect.Sfixed32Kind: |
81 if ft.Kind() == reflect.Int32 { |
81 if ft.Kind() == reflect.Int32 { |
82 return nil, coderSfixed32Slice |
82 return nil, coderSfixed32Slice |
83 } |
83 } |
84 case pref.Fixed32Kind: |
84 case protoreflect.Fixed32Kind: |
85 if ft.Kind() == reflect.Uint32 { |
85 if ft.Kind() == reflect.Uint32 { |
86 return nil, coderFixed32Slice |
86 return nil, coderFixed32Slice |
87 } |
87 } |
88 case pref.FloatKind: |
88 case protoreflect.FloatKind: |
89 if ft.Kind() == reflect.Float32 { |
89 if ft.Kind() == reflect.Float32 { |
90 return nil, coderFloatSlice |
90 return nil, coderFloatSlice |
91 } |
91 } |
92 case pref.Sfixed64Kind: |
92 case protoreflect.Sfixed64Kind: |
93 if ft.Kind() == reflect.Int64 { |
93 if ft.Kind() == reflect.Int64 { |
94 return nil, coderSfixed64Slice |
94 return nil, coderSfixed64Slice |
95 } |
95 } |
96 case pref.Fixed64Kind: |
96 case protoreflect.Fixed64Kind: |
97 if ft.Kind() == reflect.Uint64 { |
97 if ft.Kind() == reflect.Uint64 { |
98 return nil, coderFixed64Slice |
98 return nil, coderFixed64Slice |
99 } |
99 } |
100 case pref.DoubleKind: |
100 case protoreflect.DoubleKind: |
101 if ft.Kind() == reflect.Float64 { |
101 if ft.Kind() == reflect.Float64 { |
102 return nil, coderDoubleSlice |
102 return nil, coderDoubleSlice |
103 } |
103 } |
104 case pref.StringKind: |
104 case protoreflect.StringKind: |
105 if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) { |
105 if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) { |
106 return nil, coderStringSliceValidateUTF8 |
106 return nil, coderStringSliceValidateUTF8 |
107 } |
107 } |
108 if ft.Kind() == reflect.String { |
108 if ft.Kind() == reflect.String { |
109 return nil, coderStringSlice |
109 return nil, coderStringSlice |
112 return nil, coderBytesSliceValidateUTF8 |
112 return nil, coderBytesSliceValidateUTF8 |
113 } |
113 } |
114 if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 { |
114 if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 { |
115 return nil, coderBytesSlice |
115 return nil, coderBytesSlice |
116 } |
116 } |
117 case pref.BytesKind: |
117 case protoreflect.BytesKind: |
118 if ft.Kind() == reflect.String { |
118 if ft.Kind() == reflect.String { |
119 return nil, coderStringSlice |
119 return nil, coderStringSlice |
120 } |
120 } |
121 if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 { |
121 if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 { |
122 return nil, coderBytesSlice |
122 return nil, coderBytesSlice |
123 } |
123 } |
124 case pref.MessageKind: |
124 case protoreflect.MessageKind: |
125 return getMessageInfo(ft), makeMessageSliceFieldCoder(fd, ft) |
125 return getMessageInfo(ft), makeMessageSliceFieldCoder(fd, ft) |
126 case pref.GroupKind: |
126 case protoreflect.GroupKind: |
127 return getMessageInfo(ft), makeGroupSliceFieldCoder(fd, ft) |
127 return getMessageInfo(ft), makeGroupSliceFieldCoder(fd, ft) |
128 } |
128 } |
129 case fd.Cardinality() == pref.Repeated && fd.IsPacked(): |
129 case fd.Cardinality() == protoreflect.Repeated && fd.IsPacked(): |
130 // Packed repeated fields. |
130 // Packed repeated fields. |
131 // |
131 // |
132 // Only repeated fields of primitive numeric types |
132 // Only repeated fields of primitive numeric types |
133 // (Varint, Fixed32, or Fixed64 wire type) can be packed. |
133 // (Varint, Fixed32, or Fixed64 wire type) can be packed. |
134 if ft.Kind() != reflect.Slice { |
134 if ft.Kind() != reflect.Slice { |
135 break |
135 break |
136 } |
136 } |
137 ft := ft.Elem() |
137 ft := ft.Elem() |
138 switch fd.Kind() { |
138 switch fd.Kind() { |
139 case pref.BoolKind: |
139 case protoreflect.BoolKind: |
140 if ft.Kind() == reflect.Bool { |
140 if ft.Kind() == reflect.Bool { |
141 return nil, coderBoolPackedSlice |
141 return nil, coderBoolPackedSlice |
142 } |
142 } |
143 case pref.EnumKind: |
143 case protoreflect.EnumKind: |
144 if ft.Kind() == reflect.Int32 { |
144 if ft.Kind() == reflect.Int32 { |
145 return nil, coderEnumPackedSlice |
145 return nil, coderEnumPackedSlice |
146 } |
146 } |
147 case pref.Int32Kind: |
147 case protoreflect.Int32Kind: |
148 if ft.Kind() == reflect.Int32 { |
148 if ft.Kind() == reflect.Int32 { |
149 return nil, coderInt32PackedSlice |
149 return nil, coderInt32PackedSlice |
150 } |
150 } |
151 case pref.Sint32Kind: |
151 case protoreflect.Sint32Kind: |
152 if ft.Kind() == reflect.Int32 { |
152 if ft.Kind() == reflect.Int32 { |
153 return nil, coderSint32PackedSlice |
153 return nil, coderSint32PackedSlice |
154 } |
154 } |
155 case pref.Uint32Kind: |
155 case protoreflect.Uint32Kind: |
156 if ft.Kind() == reflect.Uint32 { |
156 if ft.Kind() == reflect.Uint32 { |
157 return nil, coderUint32PackedSlice |
157 return nil, coderUint32PackedSlice |
158 } |
158 } |
159 case pref.Int64Kind: |
159 case protoreflect.Int64Kind: |
160 if ft.Kind() == reflect.Int64 { |
160 if ft.Kind() == reflect.Int64 { |
161 return nil, coderInt64PackedSlice |
161 return nil, coderInt64PackedSlice |
162 } |
162 } |
163 case pref.Sint64Kind: |
163 case protoreflect.Sint64Kind: |
164 if ft.Kind() == reflect.Int64 { |
164 if ft.Kind() == reflect.Int64 { |
165 return nil, coderSint64PackedSlice |
165 return nil, coderSint64PackedSlice |
166 } |
166 } |
167 case pref.Uint64Kind: |
167 case protoreflect.Uint64Kind: |
168 if ft.Kind() == reflect.Uint64 { |
168 if ft.Kind() == reflect.Uint64 { |
169 return nil, coderUint64PackedSlice |
169 return nil, coderUint64PackedSlice |
170 } |
170 } |
171 case pref.Sfixed32Kind: |
171 case protoreflect.Sfixed32Kind: |
172 if ft.Kind() == reflect.Int32 { |
172 if ft.Kind() == reflect.Int32 { |
173 return nil, coderSfixed32PackedSlice |
173 return nil, coderSfixed32PackedSlice |
174 } |
174 } |
175 case pref.Fixed32Kind: |
175 case protoreflect.Fixed32Kind: |
176 if ft.Kind() == reflect.Uint32 { |
176 if ft.Kind() == reflect.Uint32 { |
177 return nil, coderFixed32PackedSlice |
177 return nil, coderFixed32PackedSlice |
178 } |
178 } |
179 case pref.FloatKind: |
179 case protoreflect.FloatKind: |
180 if ft.Kind() == reflect.Float32 { |
180 if ft.Kind() == reflect.Float32 { |
181 return nil, coderFloatPackedSlice |
181 return nil, coderFloatPackedSlice |
182 } |
182 } |
183 case pref.Sfixed64Kind: |
183 case protoreflect.Sfixed64Kind: |
184 if ft.Kind() == reflect.Int64 { |
184 if ft.Kind() == reflect.Int64 { |
185 return nil, coderSfixed64PackedSlice |
185 return nil, coderSfixed64PackedSlice |
186 } |
186 } |
187 case pref.Fixed64Kind: |
187 case protoreflect.Fixed64Kind: |
188 if ft.Kind() == reflect.Uint64 { |
188 if ft.Kind() == reflect.Uint64 { |
189 return nil, coderFixed64PackedSlice |
189 return nil, coderFixed64PackedSlice |
190 } |
190 } |
191 case pref.DoubleKind: |
191 case protoreflect.DoubleKind: |
192 if ft.Kind() == reflect.Float64 { |
192 if ft.Kind() == reflect.Float64 { |
193 return nil, coderDoublePackedSlice |
193 return nil, coderDoublePackedSlice |
194 } |
194 } |
195 } |
195 } |
196 case fd.Kind() == pref.MessageKind: |
196 case fd.Kind() == protoreflect.MessageKind: |
197 return getMessageInfo(ft), makeMessageFieldCoder(fd, ft) |
197 return getMessageInfo(ft), makeMessageFieldCoder(fd, ft) |
198 case fd.Kind() == pref.GroupKind: |
198 case fd.Kind() == protoreflect.GroupKind: |
199 return getMessageInfo(ft), makeGroupFieldCoder(fd, ft) |
199 return getMessageInfo(ft), makeGroupFieldCoder(fd, ft) |
200 case fd.Syntax() == pref.Proto3 && fd.ContainingOneof() == nil: |
200 case fd.Syntax() == protoreflect.Proto3 && fd.ContainingOneof() == nil: |
201 // Populated oneof fields always encode even if set to the zero value, |
201 // Populated oneof fields always encode even if set to the zero value, |
202 // which normally are not encoded in proto3. |
202 // which normally are not encoded in proto3. |
203 switch fd.Kind() { |
203 switch fd.Kind() { |
204 case pref.BoolKind: |
204 case protoreflect.BoolKind: |
205 if ft.Kind() == reflect.Bool { |
205 if ft.Kind() == reflect.Bool { |
206 return nil, coderBoolNoZero |
206 return nil, coderBoolNoZero |
207 } |
207 } |
208 case pref.EnumKind: |
208 case protoreflect.EnumKind: |
209 if ft.Kind() == reflect.Int32 { |
209 if ft.Kind() == reflect.Int32 { |
210 return nil, coderEnumNoZero |
210 return nil, coderEnumNoZero |
211 } |
211 } |
212 case pref.Int32Kind: |
212 case protoreflect.Int32Kind: |
213 if ft.Kind() == reflect.Int32 { |
213 if ft.Kind() == reflect.Int32 { |
214 return nil, coderInt32NoZero |
214 return nil, coderInt32NoZero |
215 } |
215 } |
216 case pref.Sint32Kind: |
216 case protoreflect.Sint32Kind: |
217 if ft.Kind() == reflect.Int32 { |
217 if ft.Kind() == reflect.Int32 { |
218 return nil, coderSint32NoZero |
218 return nil, coderSint32NoZero |
219 } |
219 } |
220 case pref.Uint32Kind: |
220 case protoreflect.Uint32Kind: |
221 if ft.Kind() == reflect.Uint32 { |
221 if ft.Kind() == reflect.Uint32 { |
222 return nil, coderUint32NoZero |
222 return nil, coderUint32NoZero |
223 } |
223 } |
224 case pref.Int64Kind: |
224 case protoreflect.Int64Kind: |
225 if ft.Kind() == reflect.Int64 { |
225 if ft.Kind() == reflect.Int64 { |
226 return nil, coderInt64NoZero |
226 return nil, coderInt64NoZero |
227 } |
227 } |
228 case pref.Sint64Kind: |
228 case protoreflect.Sint64Kind: |
229 if ft.Kind() == reflect.Int64 { |
229 if ft.Kind() == reflect.Int64 { |
230 return nil, coderSint64NoZero |
230 return nil, coderSint64NoZero |
231 } |
231 } |
232 case pref.Uint64Kind: |
232 case protoreflect.Uint64Kind: |
233 if ft.Kind() == reflect.Uint64 { |
233 if ft.Kind() == reflect.Uint64 { |
234 return nil, coderUint64NoZero |
234 return nil, coderUint64NoZero |
235 } |
235 } |
236 case pref.Sfixed32Kind: |
236 case protoreflect.Sfixed32Kind: |
237 if ft.Kind() == reflect.Int32 { |
237 if ft.Kind() == reflect.Int32 { |
238 return nil, coderSfixed32NoZero |
238 return nil, coderSfixed32NoZero |
239 } |
239 } |
240 case pref.Fixed32Kind: |
240 case protoreflect.Fixed32Kind: |
241 if ft.Kind() == reflect.Uint32 { |
241 if ft.Kind() == reflect.Uint32 { |
242 return nil, coderFixed32NoZero |
242 return nil, coderFixed32NoZero |
243 } |
243 } |
244 case pref.FloatKind: |
244 case protoreflect.FloatKind: |
245 if ft.Kind() == reflect.Float32 { |
245 if ft.Kind() == reflect.Float32 { |
246 return nil, coderFloatNoZero |
246 return nil, coderFloatNoZero |
247 } |
247 } |
248 case pref.Sfixed64Kind: |
248 case protoreflect.Sfixed64Kind: |
249 if ft.Kind() == reflect.Int64 { |
249 if ft.Kind() == reflect.Int64 { |
250 return nil, coderSfixed64NoZero |
250 return nil, coderSfixed64NoZero |
251 } |
251 } |
252 case pref.Fixed64Kind: |
252 case protoreflect.Fixed64Kind: |
253 if ft.Kind() == reflect.Uint64 { |
253 if ft.Kind() == reflect.Uint64 { |
254 return nil, coderFixed64NoZero |
254 return nil, coderFixed64NoZero |
255 } |
255 } |
256 case pref.DoubleKind: |
256 case protoreflect.DoubleKind: |
257 if ft.Kind() == reflect.Float64 { |
257 if ft.Kind() == reflect.Float64 { |
258 return nil, coderDoubleNoZero |
258 return nil, coderDoubleNoZero |
259 } |
259 } |
260 case pref.StringKind: |
260 case protoreflect.StringKind: |
261 if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) { |
261 if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) { |
262 return nil, coderStringNoZeroValidateUTF8 |
262 return nil, coderStringNoZeroValidateUTF8 |
263 } |
263 } |
264 if ft.Kind() == reflect.String { |
264 if ft.Kind() == reflect.String { |
265 return nil, coderStringNoZero |
265 return nil, coderStringNoZero |
268 return nil, coderBytesNoZeroValidateUTF8 |
268 return nil, coderBytesNoZeroValidateUTF8 |
269 } |
269 } |
270 if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 { |
270 if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 { |
271 return nil, coderBytesNoZero |
271 return nil, coderBytesNoZero |
272 } |
272 } |
273 case pref.BytesKind: |
273 case protoreflect.BytesKind: |
274 if ft.Kind() == reflect.String { |
274 if ft.Kind() == reflect.String { |
275 return nil, coderStringNoZero |
275 return nil, coderStringNoZero |
276 } |
276 } |
277 if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 { |
277 if ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8 { |
278 return nil, coderBytesNoZero |
278 return nil, coderBytesNoZero |
279 } |
279 } |
280 } |
280 } |
281 case ft.Kind() == reflect.Ptr: |
281 case ft.Kind() == reflect.Ptr: |
282 ft := ft.Elem() |
282 ft := ft.Elem() |
283 switch fd.Kind() { |
283 switch fd.Kind() { |
284 case pref.BoolKind: |
284 case protoreflect.BoolKind: |
285 if ft.Kind() == reflect.Bool { |
285 if ft.Kind() == reflect.Bool { |
286 return nil, coderBoolPtr |
286 return nil, coderBoolPtr |
287 } |
287 } |
288 case pref.EnumKind: |
288 case protoreflect.EnumKind: |
289 if ft.Kind() == reflect.Int32 { |
289 if ft.Kind() == reflect.Int32 { |
290 return nil, coderEnumPtr |
290 return nil, coderEnumPtr |
291 } |
291 } |
292 case pref.Int32Kind: |
292 case protoreflect.Int32Kind: |
293 if ft.Kind() == reflect.Int32 { |
293 if ft.Kind() == reflect.Int32 { |
294 return nil, coderInt32Ptr |
294 return nil, coderInt32Ptr |
295 } |
295 } |
296 case pref.Sint32Kind: |
296 case protoreflect.Sint32Kind: |
297 if ft.Kind() == reflect.Int32 { |
297 if ft.Kind() == reflect.Int32 { |
298 return nil, coderSint32Ptr |
298 return nil, coderSint32Ptr |
299 } |
299 } |
300 case pref.Uint32Kind: |
300 case protoreflect.Uint32Kind: |
301 if ft.Kind() == reflect.Uint32 { |
301 if ft.Kind() == reflect.Uint32 { |
302 return nil, coderUint32Ptr |
302 return nil, coderUint32Ptr |
303 } |
303 } |
304 case pref.Int64Kind: |
304 case protoreflect.Int64Kind: |
305 if ft.Kind() == reflect.Int64 { |
305 if ft.Kind() == reflect.Int64 { |
306 return nil, coderInt64Ptr |
306 return nil, coderInt64Ptr |
307 } |
307 } |
308 case pref.Sint64Kind: |
308 case protoreflect.Sint64Kind: |
309 if ft.Kind() == reflect.Int64 { |
309 if ft.Kind() == reflect.Int64 { |
310 return nil, coderSint64Ptr |
310 return nil, coderSint64Ptr |
311 } |
311 } |
312 case pref.Uint64Kind: |
312 case protoreflect.Uint64Kind: |
313 if ft.Kind() == reflect.Uint64 { |
313 if ft.Kind() == reflect.Uint64 { |
314 return nil, coderUint64Ptr |
314 return nil, coderUint64Ptr |
315 } |
315 } |
316 case pref.Sfixed32Kind: |
316 case protoreflect.Sfixed32Kind: |
317 if ft.Kind() == reflect.Int32 { |
317 if ft.Kind() == reflect.Int32 { |
318 return nil, coderSfixed32Ptr |
318 return nil, coderSfixed32Ptr |
319 } |
319 } |
320 case pref.Fixed32Kind: |
320 case protoreflect.Fixed32Kind: |
321 if ft.Kind() == reflect.Uint32 { |
321 if ft.Kind() == reflect.Uint32 { |
322 return nil, coderFixed32Ptr |
322 return nil, coderFixed32Ptr |
323 } |
323 } |
324 case pref.FloatKind: |
324 case protoreflect.FloatKind: |
325 if ft.Kind() == reflect.Float32 { |
325 if ft.Kind() == reflect.Float32 { |
326 return nil, coderFloatPtr |
326 return nil, coderFloatPtr |
327 } |
327 } |
328 case pref.Sfixed64Kind: |
328 case protoreflect.Sfixed64Kind: |
329 if ft.Kind() == reflect.Int64 { |
329 if ft.Kind() == reflect.Int64 { |
330 return nil, coderSfixed64Ptr |
330 return nil, coderSfixed64Ptr |
331 } |
331 } |
332 case pref.Fixed64Kind: |
332 case protoreflect.Fixed64Kind: |
333 if ft.Kind() == reflect.Uint64 { |
333 if ft.Kind() == reflect.Uint64 { |
334 return nil, coderFixed64Ptr |
334 return nil, coderFixed64Ptr |
335 } |
335 } |
336 case pref.DoubleKind: |
336 case protoreflect.DoubleKind: |
337 if ft.Kind() == reflect.Float64 { |
337 if ft.Kind() == reflect.Float64 { |
338 return nil, coderDoublePtr |
338 return nil, coderDoublePtr |
339 } |
339 } |
340 case pref.StringKind: |
340 case protoreflect.StringKind: |
341 if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) { |
341 if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) { |
342 return nil, coderStringPtrValidateUTF8 |
342 return nil, coderStringPtrValidateUTF8 |
343 } |
343 } |
344 if ft.Kind() == reflect.String { |
344 if ft.Kind() == reflect.String { |
345 return nil, coderStringPtr |
345 return nil, coderStringPtr |
346 } |
346 } |
347 case pref.BytesKind: |
347 case protoreflect.BytesKind: |
348 if ft.Kind() == reflect.String { |
348 if ft.Kind() == reflect.String { |
349 return nil, coderStringPtr |
349 return nil, coderStringPtr |
350 } |
350 } |
351 } |
351 } |
352 default: |
352 default: |
353 switch fd.Kind() { |
353 switch fd.Kind() { |
354 case pref.BoolKind: |
354 case protoreflect.BoolKind: |
355 if ft.Kind() == reflect.Bool { |
355 if ft.Kind() == reflect.Bool { |
356 return nil, coderBool |
356 return nil, coderBool |
357 } |
357 } |
358 case pref.EnumKind: |
358 case protoreflect.EnumKind: |
359 if ft.Kind() == reflect.Int32 { |
359 if ft.Kind() == reflect.Int32 { |
360 return nil, coderEnum |
360 return nil, coderEnum |
361 } |
361 } |
362 case pref.Int32Kind: |
362 case protoreflect.Int32Kind: |
363 if ft.Kind() == reflect.Int32 { |
363 if ft.Kind() == reflect.Int32 { |
364 return nil, coderInt32 |
364 return nil, coderInt32 |
365 } |
365 } |
366 case pref.Sint32Kind: |
366 case protoreflect.Sint32Kind: |
367 if ft.Kind() == reflect.Int32 { |
367 if ft.Kind() == reflect.Int32 { |
368 return nil, coderSint32 |
368 return nil, coderSint32 |
369 } |
369 } |
370 case pref.Uint32Kind: |
370 case protoreflect.Uint32Kind: |
371 if ft.Kind() == reflect.Uint32 { |
371 if ft.Kind() == reflect.Uint32 { |
372 return nil, coderUint32 |
372 return nil, coderUint32 |
373 } |
373 } |
374 case pref.Int64Kind: |
374 case protoreflect.Int64Kind: |
375 if ft.Kind() == reflect.Int64 { |
375 if ft.Kind() == reflect.Int64 { |
376 return nil, coderInt64 |
376 return nil, coderInt64 |
377 } |
377 } |
378 case pref.Sint64Kind: |
378 case protoreflect.Sint64Kind: |
379 if ft.Kind() == reflect.Int64 { |
379 if ft.Kind() == reflect.Int64 { |
380 return nil, coderSint64 |
380 return nil, coderSint64 |
381 } |
381 } |
382 case pref.Uint64Kind: |
382 case protoreflect.Uint64Kind: |
383 if ft.Kind() == reflect.Uint64 { |
383 if ft.Kind() == reflect.Uint64 { |
384 return nil, coderUint64 |
384 return nil, coderUint64 |
385 } |
385 } |
386 case pref.Sfixed32Kind: |
386 case protoreflect.Sfixed32Kind: |
387 if ft.Kind() == reflect.Int32 { |
387 if ft.Kind() == reflect.Int32 { |
388 return nil, coderSfixed32 |
388 return nil, coderSfixed32 |
389 } |
389 } |
390 case pref.Fixed32Kind: |
390 case protoreflect.Fixed32Kind: |
391 if ft.Kind() == reflect.Uint32 { |
391 if ft.Kind() == reflect.Uint32 { |
392 return nil, coderFixed32 |
392 return nil, coderFixed32 |
393 } |
393 } |
394 case pref.FloatKind: |
394 case protoreflect.FloatKind: |
395 if ft.Kind() == reflect.Float32 { |
395 if ft.Kind() == reflect.Float32 { |
396 return nil, coderFloat |
396 return nil, coderFloat |
397 } |
397 } |
398 case pref.Sfixed64Kind: |
398 case protoreflect.Sfixed64Kind: |
399 if ft.Kind() == reflect.Int64 { |
399 if ft.Kind() == reflect.Int64 { |
400 return nil, coderSfixed64 |
400 return nil, coderSfixed64 |
401 } |
401 } |
402 case pref.Fixed64Kind: |
402 case protoreflect.Fixed64Kind: |
403 if ft.Kind() == reflect.Uint64 { |
403 if ft.Kind() == reflect.Uint64 { |
404 return nil, coderFixed64 |
404 return nil, coderFixed64 |
405 } |
405 } |
406 case pref.DoubleKind: |
406 case protoreflect.DoubleKind: |
407 if ft.Kind() == reflect.Float64 { |
407 if ft.Kind() == reflect.Float64 { |
408 return nil, coderDouble |
408 return nil, coderDouble |
409 } |
409 } |
410 case pref.StringKind: |
410 case protoreflect.StringKind: |
411 if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) { |
411 if ft.Kind() == reflect.String && strs.EnforceUTF8(fd) { |
412 return nil, coderStringValidateUTF8 |
412 return nil, coderStringValidateUTF8 |
413 } |
413 } |
414 if ft.Kind() == reflect.String { |
414 if ft.Kind() == reflect.String { |
415 return nil, coderString |
415 return nil, coderString |
432 panic(fmt.Sprintf("invalid type: no encoder for %v %v %v/%v", fd.FullName(), fd.Cardinality(), fd.Kind(), ft)) |
432 panic(fmt.Sprintf("invalid type: no encoder for %v %v %v/%v", fd.FullName(), fd.Cardinality(), fd.Kind(), ft)) |
433 } |
433 } |
434 |
434 |
435 // encoderFuncsForValue returns value functions for a field, used for |
435 // encoderFuncsForValue returns value functions for a field, used for |
436 // extension values and map encoding. |
436 // extension values and map encoding. |
437 func encoderFuncsForValue(fd pref.FieldDescriptor) valueCoderFuncs { |
437 func encoderFuncsForValue(fd protoreflect.FieldDescriptor) valueCoderFuncs { |
438 switch { |
438 switch { |
439 case fd.Cardinality() == pref.Repeated && !fd.IsPacked(): |
439 case fd.Cardinality() == protoreflect.Repeated && !fd.IsPacked(): |
440 switch fd.Kind() { |
440 switch fd.Kind() { |
441 case pref.BoolKind: |
441 case protoreflect.BoolKind: |
442 return coderBoolSliceValue |
442 return coderBoolSliceValue |
443 case pref.EnumKind: |
443 case protoreflect.EnumKind: |
444 return coderEnumSliceValue |
444 return coderEnumSliceValue |
445 case pref.Int32Kind: |
445 case protoreflect.Int32Kind: |
446 return coderInt32SliceValue |
446 return coderInt32SliceValue |
447 case pref.Sint32Kind: |
447 case protoreflect.Sint32Kind: |
448 return coderSint32SliceValue |
448 return coderSint32SliceValue |
449 case pref.Uint32Kind: |
449 case protoreflect.Uint32Kind: |
450 return coderUint32SliceValue |
450 return coderUint32SliceValue |
451 case pref.Int64Kind: |
451 case protoreflect.Int64Kind: |
452 return coderInt64SliceValue |
452 return coderInt64SliceValue |
453 case pref.Sint64Kind: |
453 case protoreflect.Sint64Kind: |
454 return coderSint64SliceValue |
454 return coderSint64SliceValue |
455 case pref.Uint64Kind: |
455 case protoreflect.Uint64Kind: |
456 return coderUint64SliceValue |
456 return coderUint64SliceValue |
457 case pref.Sfixed32Kind: |
457 case protoreflect.Sfixed32Kind: |
458 return coderSfixed32SliceValue |
458 return coderSfixed32SliceValue |
459 case pref.Fixed32Kind: |
459 case protoreflect.Fixed32Kind: |
460 return coderFixed32SliceValue |
460 return coderFixed32SliceValue |
461 case pref.FloatKind: |
461 case protoreflect.FloatKind: |
462 return coderFloatSliceValue |
462 return coderFloatSliceValue |
463 case pref.Sfixed64Kind: |
463 case protoreflect.Sfixed64Kind: |
464 return coderSfixed64SliceValue |
464 return coderSfixed64SliceValue |
465 case pref.Fixed64Kind: |
465 case protoreflect.Fixed64Kind: |
466 return coderFixed64SliceValue |
466 return coderFixed64SliceValue |
467 case pref.DoubleKind: |
467 case protoreflect.DoubleKind: |
468 return coderDoubleSliceValue |
468 return coderDoubleSliceValue |
469 case pref.StringKind: |
469 case protoreflect.StringKind: |
470 // We don't have a UTF-8 validating coder for repeated string fields. |
470 // We don't have a UTF-8 validating coder for repeated string fields. |
471 // Value coders are used for extensions and maps. |
471 // Value coders are used for extensions and maps. |
472 // Extensions are never proto3, and maps never contain lists. |
472 // Extensions are never proto3, and maps never contain lists. |
473 return coderStringSliceValue |
473 return coderStringSliceValue |
474 case pref.BytesKind: |
474 case protoreflect.BytesKind: |
475 return coderBytesSliceValue |
475 return coderBytesSliceValue |
476 case pref.MessageKind: |
476 case protoreflect.MessageKind: |
477 return coderMessageSliceValue |
477 return coderMessageSliceValue |
478 case pref.GroupKind: |
478 case protoreflect.GroupKind: |
479 return coderGroupSliceValue |
479 return coderGroupSliceValue |
480 } |
480 } |
481 case fd.Cardinality() == pref.Repeated && fd.IsPacked(): |
481 case fd.Cardinality() == protoreflect.Repeated && fd.IsPacked(): |
482 switch fd.Kind() { |
482 switch fd.Kind() { |
483 case pref.BoolKind: |
483 case protoreflect.BoolKind: |
484 return coderBoolPackedSliceValue |
484 return coderBoolPackedSliceValue |
485 case pref.EnumKind: |
485 case protoreflect.EnumKind: |
486 return coderEnumPackedSliceValue |
486 return coderEnumPackedSliceValue |
487 case pref.Int32Kind: |
487 case protoreflect.Int32Kind: |
488 return coderInt32PackedSliceValue |
488 return coderInt32PackedSliceValue |
489 case pref.Sint32Kind: |
489 case protoreflect.Sint32Kind: |
490 return coderSint32PackedSliceValue |
490 return coderSint32PackedSliceValue |
491 case pref.Uint32Kind: |
491 case protoreflect.Uint32Kind: |
492 return coderUint32PackedSliceValue |
492 return coderUint32PackedSliceValue |
493 case pref.Int64Kind: |
493 case protoreflect.Int64Kind: |
494 return coderInt64PackedSliceValue |
494 return coderInt64PackedSliceValue |
495 case pref.Sint64Kind: |
495 case protoreflect.Sint64Kind: |
496 return coderSint64PackedSliceValue |
496 return coderSint64PackedSliceValue |
497 case pref.Uint64Kind: |
497 case protoreflect.Uint64Kind: |
498 return coderUint64PackedSliceValue |
498 return coderUint64PackedSliceValue |
499 case pref.Sfixed32Kind: |
499 case protoreflect.Sfixed32Kind: |
500 return coderSfixed32PackedSliceValue |
500 return coderSfixed32PackedSliceValue |
501 case pref.Fixed32Kind: |
501 case protoreflect.Fixed32Kind: |
502 return coderFixed32PackedSliceValue |
502 return coderFixed32PackedSliceValue |
503 case pref.FloatKind: |
503 case protoreflect.FloatKind: |
504 return coderFloatPackedSliceValue |
504 return coderFloatPackedSliceValue |
505 case pref.Sfixed64Kind: |
505 case protoreflect.Sfixed64Kind: |
506 return coderSfixed64PackedSliceValue |
506 return coderSfixed64PackedSliceValue |
507 case pref.Fixed64Kind: |
507 case protoreflect.Fixed64Kind: |
508 return coderFixed64PackedSliceValue |
508 return coderFixed64PackedSliceValue |
509 case pref.DoubleKind: |
509 case protoreflect.DoubleKind: |
510 return coderDoublePackedSliceValue |
510 return coderDoublePackedSliceValue |
511 } |
511 } |
512 default: |
512 default: |
513 switch fd.Kind() { |
513 switch fd.Kind() { |
514 default: |
514 default: |
515 case pref.BoolKind: |
515 case protoreflect.BoolKind: |
516 return coderBoolValue |
516 return coderBoolValue |
517 case pref.EnumKind: |
517 case protoreflect.EnumKind: |
518 return coderEnumValue |
518 return coderEnumValue |
519 case pref.Int32Kind: |
519 case protoreflect.Int32Kind: |
520 return coderInt32Value |
520 return coderInt32Value |
521 case pref.Sint32Kind: |
521 case protoreflect.Sint32Kind: |
522 return coderSint32Value |
522 return coderSint32Value |
523 case pref.Uint32Kind: |
523 case protoreflect.Uint32Kind: |
524 return coderUint32Value |
524 return coderUint32Value |
525 case pref.Int64Kind: |
525 case protoreflect.Int64Kind: |
526 return coderInt64Value |
526 return coderInt64Value |
527 case pref.Sint64Kind: |
527 case protoreflect.Sint64Kind: |
528 return coderSint64Value |
528 return coderSint64Value |
529 case pref.Uint64Kind: |
529 case protoreflect.Uint64Kind: |
530 return coderUint64Value |
530 return coderUint64Value |
531 case pref.Sfixed32Kind: |
531 case protoreflect.Sfixed32Kind: |
532 return coderSfixed32Value |
532 return coderSfixed32Value |
533 case pref.Fixed32Kind: |
533 case protoreflect.Fixed32Kind: |
534 return coderFixed32Value |
534 return coderFixed32Value |
535 case pref.FloatKind: |
535 case protoreflect.FloatKind: |
536 return coderFloatValue |
536 return coderFloatValue |
537 case pref.Sfixed64Kind: |
537 case protoreflect.Sfixed64Kind: |
538 return coderSfixed64Value |
538 return coderSfixed64Value |
539 case pref.Fixed64Kind: |
539 case protoreflect.Fixed64Kind: |
540 return coderFixed64Value |
540 return coderFixed64Value |
541 case pref.DoubleKind: |
541 case protoreflect.DoubleKind: |
542 return coderDoubleValue |
542 return coderDoubleValue |
543 case pref.StringKind: |
543 case protoreflect.StringKind: |
544 if strs.EnforceUTF8(fd) { |
544 if strs.EnforceUTF8(fd) { |
545 return coderStringValueValidateUTF8 |
545 return coderStringValueValidateUTF8 |
546 } |
546 } |
547 return coderStringValue |
547 return coderStringValue |
548 case pref.BytesKind: |
548 case protoreflect.BytesKind: |
549 return coderBytesValue |
549 return coderBytesValue |
550 case pref.MessageKind: |
550 case protoreflect.MessageKind: |
551 return coderMessageValue |
551 return coderMessageValue |
552 case pref.GroupKind: |
552 case protoreflect.GroupKind: |
553 return coderGroupValue |
553 return coderGroupValue |
554 } |
554 } |
555 } |
555 } |
556 panic(fmt.Sprintf("invalid field: no encoder for %v %v %v", fd.FullName(), fd.Cardinality(), fd.Kind())) |
556 panic(fmt.Sprintf("invalid field: no encoder for %v %v %v", fd.FullName(), fd.Cardinality(), fd.Kind())) |
557 } |
557 } |