source: code/trunk/vendor/google.golang.org/protobuf/proto/decode_gen.go@ 822

Last change on this file since 822 was 822, checked in by yakumo.izuru, 22 months ago

Prefer immortal.run over runit and rc.d, use vendored modules
for convenience.

Signed-off-by: Izuru Yakumo <yakumo.izuru@…>
File size: 14.6 KB
Line 
1// Copyright 2018 The Go Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style
3// license that can be found in the LICENSE file.
4
5// Code generated by generate-types. DO NOT EDIT.
6
7package proto
8
9import (
10 "math"
11 "unicode/utf8"
12
13 "google.golang.org/protobuf/encoding/protowire"
14 "google.golang.org/protobuf/internal/errors"
15 "google.golang.org/protobuf/internal/strs"
16 "google.golang.org/protobuf/reflect/protoreflect"
17)
18
19// unmarshalScalar decodes a value of the given kind.
20//
21// Message values are decoded into a []byte which aliases the input data.
22func (o UnmarshalOptions) unmarshalScalar(b []byte, wtyp protowire.Type, fd protoreflect.FieldDescriptor) (val protoreflect.Value, n int, err error) {
23 switch fd.Kind() {
24 case protoreflect.BoolKind:
25 if wtyp != protowire.VarintType {
26 return val, 0, errUnknown
27 }
28 v, n := protowire.ConsumeVarint(b)
29 if n < 0 {
30 return val, 0, errDecode
31 }
32 return protoreflect.ValueOfBool(protowire.DecodeBool(v)), n, nil
33 case protoreflect.EnumKind:
34 if wtyp != protowire.VarintType {
35 return val, 0, errUnknown
36 }
37 v, n := protowire.ConsumeVarint(b)
38 if n < 0 {
39 return val, 0, errDecode
40 }
41 return protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)), n, nil
42 case protoreflect.Int32Kind:
43 if wtyp != protowire.VarintType {
44 return val, 0, errUnknown
45 }
46 v, n := protowire.ConsumeVarint(b)
47 if n < 0 {
48 return val, 0, errDecode
49 }
50 return protoreflect.ValueOfInt32(int32(v)), n, nil
51 case protoreflect.Sint32Kind:
52 if wtyp != protowire.VarintType {
53 return val, 0, errUnknown
54 }
55 v, n := protowire.ConsumeVarint(b)
56 if n < 0 {
57 return val, 0, errDecode
58 }
59 return protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))), n, nil
60 case protoreflect.Uint32Kind:
61 if wtyp != protowire.VarintType {
62 return val, 0, errUnknown
63 }
64 v, n := protowire.ConsumeVarint(b)
65 if n < 0 {
66 return val, 0, errDecode
67 }
68 return protoreflect.ValueOfUint32(uint32(v)), n, nil
69 case protoreflect.Int64Kind:
70 if wtyp != protowire.VarintType {
71 return val, 0, errUnknown
72 }
73 v, n := protowire.ConsumeVarint(b)
74 if n < 0 {
75 return val, 0, errDecode
76 }
77 return protoreflect.ValueOfInt64(int64(v)), n, nil
78 case protoreflect.Sint64Kind:
79 if wtyp != protowire.VarintType {
80 return val, 0, errUnknown
81 }
82 v, n := protowire.ConsumeVarint(b)
83 if n < 0 {
84 return val, 0, errDecode
85 }
86 return protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)), n, nil
87 case protoreflect.Uint64Kind:
88 if wtyp != protowire.VarintType {
89 return val, 0, errUnknown
90 }
91 v, n := protowire.ConsumeVarint(b)
92 if n < 0 {
93 return val, 0, errDecode
94 }
95 return protoreflect.ValueOfUint64(v), n, nil
96 case protoreflect.Sfixed32Kind:
97 if wtyp != protowire.Fixed32Type {
98 return val, 0, errUnknown
99 }
100 v, n := protowire.ConsumeFixed32(b)
101 if n < 0 {
102 return val, 0, errDecode
103 }
104 return protoreflect.ValueOfInt32(int32(v)), n, nil
105 case protoreflect.Fixed32Kind:
106 if wtyp != protowire.Fixed32Type {
107 return val, 0, errUnknown
108 }
109 v, n := protowire.ConsumeFixed32(b)
110 if n < 0 {
111 return val, 0, errDecode
112 }
113 return protoreflect.ValueOfUint32(uint32(v)), n, nil
114 case protoreflect.FloatKind:
115 if wtyp != protowire.Fixed32Type {
116 return val, 0, errUnknown
117 }
118 v, n := protowire.ConsumeFixed32(b)
119 if n < 0 {
120 return val, 0, errDecode
121 }
122 return protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))), n, nil
123 case protoreflect.Sfixed64Kind:
124 if wtyp != protowire.Fixed64Type {
125 return val, 0, errUnknown
126 }
127 v, n := protowire.ConsumeFixed64(b)
128 if n < 0 {
129 return val, 0, errDecode
130 }
131 return protoreflect.ValueOfInt64(int64(v)), n, nil
132 case protoreflect.Fixed64Kind:
133 if wtyp != protowire.Fixed64Type {
134 return val, 0, errUnknown
135 }
136 v, n := protowire.ConsumeFixed64(b)
137 if n < 0 {
138 return val, 0, errDecode
139 }
140 return protoreflect.ValueOfUint64(v), n, nil
141 case protoreflect.DoubleKind:
142 if wtyp != protowire.Fixed64Type {
143 return val, 0, errUnknown
144 }
145 v, n := protowire.ConsumeFixed64(b)
146 if n < 0 {
147 return val, 0, errDecode
148 }
149 return protoreflect.ValueOfFloat64(math.Float64frombits(v)), n, nil
150 case protoreflect.StringKind:
151 if wtyp != protowire.BytesType {
152 return val, 0, errUnknown
153 }
154 v, n := protowire.ConsumeBytes(b)
155 if n < 0 {
156 return val, 0, errDecode
157 }
158 if strs.EnforceUTF8(fd) && !utf8.Valid(v) {
159 return protoreflect.Value{}, 0, errors.InvalidUTF8(string(fd.FullName()))
160 }
161 return protoreflect.ValueOfString(string(v)), n, nil
162 case protoreflect.BytesKind:
163 if wtyp != protowire.BytesType {
164 return val, 0, errUnknown
165 }
166 v, n := protowire.ConsumeBytes(b)
167 if n < 0 {
168 return val, 0, errDecode
169 }
170 return protoreflect.ValueOfBytes(append(emptyBuf[:], v...)), n, nil
171 case protoreflect.MessageKind:
172 if wtyp != protowire.BytesType {
173 return val, 0, errUnknown
174 }
175 v, n := protowire.ConsumeBytes(b)
176 if n < 0 {
177 return val, 0, errDecode
178 }
179 return protoreflect.ValueOfBytes(v), n, nil
180 case protoreflect.GroupKind:
181 if wtyp != protowire.StartGroupType {
182 return val, 0, errUnknown
183 }
184 v, n := protowire.ConsumeGroup(fd.Number(), b)
185 if n < 0 {
186 return val, 0, errDecode
187 }
188 return protoreflect.ValueOfBytes(v), n, nil
189 default:
190 return val, 0, errUnknown
191 }
192}
193
194func (o UnmarshalOptions) unmarshalList(b []byte, wtyp protowire.Type, list protoreflect.List, fd protoreflect.FieldDescriptor) (n int, err error) {
195 switch fd.Kind() {
196 case protoreflect.BoolKind:
197 if wtyp == protowire.BytesType {
198 buf, n := protowire.ConsumeBytes(b)
199 if n < 0 {
200 return 0, errDecode
201 }
202 for len(buf) > 0 {
203 v, n := protowire.ConsumeVarint(buf)
204 if n < 0 {
205 return 0, errDecode
206 }
207 buf = buf[n:]
208 list.Append(protoreflect.ValueOfBool(protowire.DecodeBool(v)))
209 }
210 return n, nil
211 }
212 if wtyp != protowire.VarintType {
213 return 0, errUnknown
214 }
215 v, n := protowire.ConsumeVarint(b)
216 if n < 0 {
217 return 0, errDecode
218 }
219 list.Append(protoreflect.ValueOfBool(protowire.DecodeBool(v)))
220 return n, nil
221 case protoreflect.EnumKind:
222 if wtyp == protowire.BytesType {
223 buf, n := protowire.ConsumeBytes(b)
224 if n < 0 {
225 return 0, errDecode
226 }
227 for len(buf) > 0 {
228 v, n := protowire.ConsumeVarint(buf)
229 if n < 0 {
230 return 0, errDecode
231 }
232 buf = buf[n:]
233 list.Append(protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)))
234 }
235 return n, nil
236 }
237 if wtyp != protowire.VarintType {
238 return 0, errUnknown
239 }
240 v, n := protowire.ConsumeVarint(b)
241 if n < 0 {
242 return 0, errDecode
243 }
244 list.Append(protoreflect.ValueOfEnum(protoreflect.EnumNumber(v)))
245 return n, nil
246 case protoreflect.Int32Kind:
247 if wtyp == protowire.BytesType {
248 buf, n := protowire.ConsumeBytes(b)
249 if n < 0 {
250 return 0, errDecode
251 }
252 for len(buf) > 0 {
253 v, n := protowire.ConsumeVarint(buf)
254 if n < 0 {
255 return 0, errDecode
256 }
257 buf = buf[n:]
258 list.Append(protoreflect.ValueOfInt32(int32(v)))
259 }
260 return n, nil
261 }
262 if wtyp != protowire.VarintType {
263 return 0, errUnknown
264 }
265 v, n := protowire.ConsumeVarint(b)
266 if n < 0 {
267 return 0, errDecode
268 }
269 list.Append(protoreflect.ValueOfInt32(int32(v)))
270 return n, nil
271 case protoreflect.Sint32Kind:
272 if wtyp == protowire.BytesType {
273 buf, n := protowire.ConsumeBytes(b)
274 if n < 0 {
275 return 0, errDecode
276 }
277 for len(buf) > 0 {
278 v, n := protowire.ConsumeVarint(buf)
279 if n < 0 {
280 return 0, errDecode
281 }
282 buf = buf[n:]
283 list.Append(protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))))
284 }
285 return n, nil
286 }
287 if wtyp != protowire.VarintType {
288 return 0, errUnknown
289 }
290 v, n := protowire.ConsumeVarint(b)
291 if n < 0 {
292 return 0, errDecode
293 }
294 list.Append(protoreflect.ValueOfInt32(int32(protowire.DecodeZigZag(v & math.MaxUint32))))
295 return n, nil
296 case protoreflect.Uint32Kind:
297 if wtyp == protowire.BytesType {
298 buf, n := protowire.ConsumeBytes(b)
299 if n < 0 {
300 return 0, errDecode
301 }
302 for len(buf) > 0 {
303 v, n := protowire.ConsumeVarint(buf)
304 if n < 0 {
305 return 0, errDecode
306 }
307 buf = buf[n:]
308 list.Append(protoreflect.ValueOfUint32(uint32(v)))
309 }
310 return n, nil
311 }
312 if wtyp != protowire.VarintType {
313 return 0, errUnknown
314 }
315 v, n := protowire.ConsumeVarint(b)
316 if n < 0 {
317 return 0, errDecode
318 }
319 list.Append(protoreflect.ValueOfUint32(uint32(v)))
320 return n, nil
321 case protoreflect.Int64Kind:
322 if wtyp == protowire.BytesType {
323 buf, n := protowire.ConsumeBytes(b)
324 if n < 0 {
325 return 0, errDecode
326 }
327 for len(buf) > 0 {
328 v, n := protowire.ConsumeVarint(buf)
329 if n < 0 {
330 return 0, errDecode
331 }
332 buf = buf[n:]
333 list.Append(protoreflect.ValueOfInt64(int64(v)))
334 }
335 return n, nil
336 }
337 if wtyp != protowire.VarintType {
338 return 0, errUnknown
339 }
340 v, n := protowire.ConsumeVarint(b)
341 if n < 0 {
342 return 0, errDecode
343 }
344 list.Append(protoreflect.ValueOfInt64(int64(v)))
345 return n, nil
346 case protoreflect.Sint64Kind:
347 if wtyp == protowire.BytesType {
348 buf, n := protowire.ConsumeBytes(b)
349 if n < 0 {
350 return 0, errDecode
351 }
352 for len(buf) > 0 {
353 v, n := protowire.ConsumeVarint(buf)
354 if n < 0 {
355 return 0, errDecode
356 }
357 buf = buf[n:]
358 list.Append(protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)))
359 }
360 return n, nil
361 }
362 if wtyp != protowire.VarintType {
363 return 0, errUnknown
364 }
365 v, n := protowire.ConsumeVarint(b)
366 if n < 0 {
367 return 0, errDecode
368 }
369 list.Append(protoreflect.ValueOfInt64(protowire.DecodeZigZag(v)))
370 return n, nil
371 case protoreflect.Uint64Kind:
372 if wtyp == protowire.BytesType {
373 buf, n := protowire.ConsumeBytes(b)
374 if n < 0 {
375 return 0, errDecode
376 }
377 for len(buf) > 0 {
378 v, n := protowire.ConsumeVarint(buf)
379 if n < 0 {
380 return 0, errDecode
381 }
382 buf = buf[n:]
383 list.Append(protoreflect.ValueOfUint64(v))
384 }
385 return n, nil
386 }
387 if wtyp != protowire.VarintType {
388 return 0, errUnknown
389 }
390 v, n := protowire.ConsumeVarint(b)
391 if n < 0 {
392 return 0, errDecode
393 }
394 list.Append(protoreflect.ValueOfUint64(v))
395 return n, nil
396 case protoreflect.Sfixed32Kind:
397 if wtyp == protowire.BytesType {
398 buf, n := protowire.ConsumeBytes(b)
399 if n < 0 {
400 return 0, errDecode
401 }
402 for len(buf) > 0 {
403 v, n := protowire.ConsumeFixed32(buf)
404 if n < 0 {
405 return 0, errDecode
406 }
407 buf = buf[n:]
408 list.Append(protoreflect.ValueOfInt32(int32(v)))
409 }
410 return n, nil
411 }
412 if wtyp != protowire.Fixed32Type {
413 return 0, errUnknown
414 }
415 v, n := protowire.ConsumeFixed32(b)
416 if n < 0 {
417 return 0, errDecode
418 }
419 list.Append(protoreflect.ValueOfInt32(int32(v)))
420 return n, nil
421 case protoreflect.Fixed32Kind:
422 if wtyp == protowire.BytesType {
423 buf, n := protowire.ConsumeBytes(b)
424 if n < 0 {
425 return 0, errDecode
426 }
427 for len(buf) > 0 {
428 v, n := protowire.ConsumeFixed32(buf)
429 if n < 0 {
430 return 0, errDecode
431 }
432 buf = buf[n:]
433 list.Append(protoreflect.ValueOfUint32(uint32(v)))
434 }
435 return n, nil
436 }
437 if wtyp != protowire.Fixed32Type {
438 return 0, errUnknown
439 }
440 v, n := protowire.ConsumeFixed32(b)
441 if n < 0 {
442 return 0, errDecode
443 }
444 list.Append(protoreflect.ValueOfUint32(uint32(v)))
445 return n, nil
446 case protoreflect.FloatKind:
447 if wtyp == protowire.BytesType {
448 buf, n := protowire.ConsumeBytes(b)
449 if n < 0 {
450 return 0, errDecode
451 }
452 for len(buf) > 0 {
453 v, n := protowire.ConsumeFixed32(buf)
454 if n < 0 {
455 return 0, errDecode
456 }
457 buf = buf[n:]
458 list.Append(protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))))
459 }
460 return n, nil
461 }
462 if wtyp != protowire.Fixed32Type {
463 return 0, errUnknown
464 }
465 v, n := protowire.ConsumeFixed32(b)
466 if n < 0 {
467 return 0, errDecode
468 }
469 list.Append(protoreflect.ValueOfFloat32(math.Float32frombits(uint32(v))))
470 return n, nil
471 case protoreflect.Sfixed64Kind:
472 if wtyp == protowire.BytesType {
473 buf, n := protowire.ConsumeBytes(b)
474 if n < 0 {
475 return 0, errDecode
476 }
477 for len(buf) > 0 {
478 v, n := protowire.ConsumeFixed64(buf)
479 if n < 0 {
480 return 0, errDecode
481 }
482 buf = buf[n:]
483 list.Append(protoreflect.ValueOfInt64(int64(v)))
484 }
485 return n, nil
486 }
487 if wtyp != protowire.Fixed64Type {
488 return 0, errUnknown
489 }
490 v, n := protowire.ConsumeFixed64(b)
491 if n < 0 {
492 return 0, errDecode
493 }
494 list.Append(protoreflect.ValueOfInt64(int64(v)))
495 return n, nil
496 case protoreflect.Fixed64Kind:
497 if wtyp == protowire.BytesType {
498 buf, n := protowire.ConsumeBytes(b)
499 if n < 0 {
500 return 0, errDecode
501 }
502 for len(buf) > 0 {
503 v, n := protowire.ConsumeFixed64(buf)
504 if n < 0 {
505 return 0, errDecode
506 }
507 buf = buf[n:]
508 list.Append(protoreflect.ValueOfUint64(v))
509 }
510 return n, nil
511 }
512 if wtyp != protowire.Fixed64Type {
513 return 0, errUnknown
514 }
515 v, n := protowire.ConsumeFixed64(b)
516 if n < 0 {
517 return 0, errDecode
518 }
519 list.Append(protoreflect.ValueOfUint64(v))
520 return n, nil
521 case protoreflect.DoubleKind:
522 if wtyp == protowire.BytesType {
523 buf, n := protowire.ConsumeBytes(b)
524 if n < 0 {
525 return 0, errDecode
526 }
527 for len(buf) > 0 {
528 v, n := protowire.ConsumeFixed64(buf)
529 if n < 0 {
530 return 0, errDecode
531 }
532 buf = buf[n:]
533 list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
534 }
535 return n, nil
536 }
537 if wtyp != protowire.Fixed64Type {
538 return 0, errUnknown
539 }
540 v, n := protowire.ConsumeFixed64(b)
541 if n < 0 {
542 return 0, errDecode
543 }
544 list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
545 return n, nil
546 case protoreflect.StringKind:
547 if wtyp != protowire.BytesType {
548 return 0, errUnknown
549 }
550 v, n := protowire.ConsumeBytes(b)
551 if n < 0 {
552 return 0, errDecode
553 }
554 if strs.EnforceUTF8(fd) && !utf8.Valid(v) {
555 return 0, errors.InvalidUTF8(string(fd.FullName()))
556 }
557 list.Append(protoreflect.ValueOfString(string(v)))
558 return n, nil
559 case protoreflect.BytesKind:
560 if wtyp != protowire.BytesType {
561 return 0, errUnknown
562 }
563 v, n := protowire.ConsumeBytes(b)
564 if n < 0 {
565 return 0, errDecode
566 }
567 list.Append(protoreflect.ValueOfBytes(append(emptyBuf[:], v...)))
568 return n, nil
569 case protoreflect.MessageKind:
570 if wtyp != protowire.BytesType {
571 return 0, errUnknown
572 }
573 v, n := protowire.ConsumeBytes(b)
574 if n < 0 {
575 return 0, errDecode
576 }
577 m := list.NewElement()
578 if err := o.unmarshalMessage(v, m.Message()); err != nil {
579 return 0, err
580 }
581 list.Append(m)
582 return n, nil
583 case protoreflect.GroupKind:
584 if wtyp != protowire.StartGroupType {
585 return 0, errUnknown
586 }
587 v, n := protowire.ConsumeGroup(fd.Number(), b)
588 if n < 0 {
589 return 0, errDecode
590 }
591 m := list.NewElement()
592 if err := o.unmarshalMessage(v, m.Message()); err != nil {
593 return 0, err
594 }
595 list.Append(m)
596 return n, nil
597 default:
598 return 0, errUnknown
599 }
600}
601
602// We append to an empty array rather than a nil []byte to get non-nil zero-length byte slices.
603var emptyBuf [0]byte
Note: See TracBrowser for help on using the repository browser.