blob: 9b1538d0559b27765e64160ec28ec55bb192a0c7 [file] [log] [blame]
Zack Williamse940c7a2019-08-21 14:25:39 -07001// Go support for Protocol Buffers - Google's data interchange format
2//
3// Copyright 2016 The Go Authors. All rights reserved.
4// https://github.com/golang/protobuf
5//
6// Redistribution and use in source and binary forms, with or without
7// modification, are permitted provided that the following conditions are
8// met:
9//
10// * Redistributions of source code must retain the above copyright
11// notice, this list of conditions and the following disclaimer.
12// * Redistributions in binary form must reproduce the above
13// copyright notice, this list of conditions and the following disclaimer
14// in the documentation and/or other materials provided with the
15// distribution.
16// * Neither the name of Google Inc. nor the names of its
17// contributors may be used to endorse or promote products derived from
18// this software without specific prior written permission.
19//
20// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31
32package proto
33
34import (
35 "errors"
36 "fmt"
37 "math"
38 "reflect"
39 "sort"
40 "strconv"
41 "strings"
42 "sync"
43 "sync/atomic"
44 "unicode/utf8"
45)
46
47// a sizer takes a pointer to a field and the size of its tag, computes the size of
48// the encoded data.
49type sizer func(pointer, int) int
50
51// a marshaler takes a byte slice, a pointer to a field, and its tag (in wire format),
52// marshals the field to the end of the slice, returns the slice and error (if any).
53type marshaler func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error)
54
55// marshalInfo is the information used for marshaling a message.
56type marshalInfo struct {
57 typ reflect.Type
58 fields []*marshalFieldInfo
59 unrecognized field // offset of XXX_unrecognized
60 extensions field // offset of XXX_InternalExtensions
61 v1extensions field // offset of XXX_extensions
62 sizecache field // offset of XXX_sizecache
63 initialized int32 // 0 -- only typ is set, 1 -- fully initialized
64 messageset bool // uses message set wire format
65 hasmarshaler bool // has custom marshaler
66 sync.RWMutex // protect extElems map, also for initialization
67 extElems map[int32]*marshalElemInfo // info of extension elements
68
69 hassizer bool // has custom sizer
70 hasprotosizer bool // has custom protosizer
71
72 bytesExtensions field // offset of XXX_extensions where the field type is []byte
73}
74
75// marshalFieldInfo is the information used for marshaling a field of a message.
76type marshalFieldInfo struct {
77 field field
78 wiretag uint64 // tag in wire format
79 tagsize int // size of tag in wire format
80 sizer sizer
81 marshaler marshaler
82 isPointer bool
83 required bool // field is required
84 name string // name of the field, for error reporting
85 oneofElems map[reflect.Type]*marshalElemInfo // info of oneof elements
86}
87
88// marshalElemInfo is the information used for marshaling an extension or oneof element.
89type marshalElemInfo struct {
90 wiretag uint64 // tag in wire format
91 tagsize int // size of tag in wire format
92 sizer sizer
93 marshaler marshaler
94 isptr bool // elem is pointer typed, thus interface of this type is a direct interface (extension only)
95}
96
97var (
98 marshalInfoMap = map[reflect.Type]*marshalInfo{}
99 marshalInfoLock sync.Mutex
100
101 uint8SliceType = reflect.TypeOf(([]uint8)(nil)).Kind()
102)
103
104// getMarshalInfo returns the information to marshal a given type of message.
105// The info it returns may not necessarily initialized.
106// t is the type of the message (NOT the pointer to it).
107func getMarshalInfo(t reflect.Type) *marshalInfo {
108 marshalInfoLock.Lock()
109 u, ok := marshalInfoMap[t]
110 if !ok {
111 u = &marshalInfo{typ: t}
112 marshalInfoMap[t] = u
113 }
114 marshalInfoLock.Unlock()
115 return u
116}
117
118// Size is the entry point from generated code,
119// and should be ONLY called by generated code.
120// It computes the size of encoded data of msg.
121// a is a pointer to a place to store cached marshal info.
122func (a *InternalMessageInfo) Size(msg Message) int {
123 u := getMessageMarshalInfo(msg, a)
124 ptr := toPointer(&msg)
125 if ptr.isNil() {
126 // We get here if msg is a typed nil ((*SomeMessage)(nil)),
127 // so it satisfies the interface, and msg == nil wouldn't
128 // catch it. We don't want crash in this case.
129 return 0
130 }
131 return u.size(ptr)
132}
133
134// Marshal is the entry point from generated code,
135// and should be ONLY called by generated code.
136// It marshals msg to the end of b.
137// a is a pointer to a place to store cached marshal info.
138func (a *InternalMessageInfo) Marshal(b []byte, msg Message, deterministic bool) ([]byte, error) {
139 u := getMessageMarshalInfo(msg, a)
140 ptr := toPointer(&msg)
141 if ptr.isNil() {
142 // We get here if msg is a typed nil ((*SomeMessage)(nil)),
143 // so it satisfies the interface, and msg == nil wouldn't
144 // catch it. We don't want crash in this case.
145 return b, ErrNil
146 }
147 return u.marshal(b, ptr, deterministic)
148}
149
150func getMessageMarshalInfo(msg interface{}, a *InternalMessageInfo) *marshalInfo {
151 // u := a.marshal, but atomically.
152 // We use an atomic here to ensure memory consistency.
153 u := atomicLoadMarshalInfo(&a.marshal)
154 if u == nil {
155 // Get marshal information from type of message.
156 t := reflect.ValueOf(msg).Type()
157 if t.Kind() != reflect.Ptr {
158 panic(fmt.Sprintf("cannot handle non-pointer message type %v", t))
159 }
160 u = getMarshalInfo(t.Elem())
161 // Store it in the cache for later users.
162 // a.marshal = u, but atomically.
163 atomicStoreMarshalInfo(&a.marshal, u)
164 }
165 return u
166}
167
168// size is the main function to compute the size of the encoded data of a message.
169// ptr is the pointer to the message.
170func (u *marshalInfo) size(ptr pointer) int {
171 if atomic.LoadInt32(&u.initialized) == 0 {
172 u.computeMarshalInfo()
173 }
174
175 // If the message can marshal itself, let it do it, for compatibility.
176 // NOTE: This is not efficient.
177 if u.hasmarshaler {
178 // Uses the message's Size method if available
179 if u.hassizer {
180 s := ptr.asPointerTo(u.typ).Interface().(Sizer)
181 return s.Size()
182 }
183 // Uses the message's ProtoSize method if available
184 if u.hasprotosizer {
185 s := ptr.asPointerTo(u.typ).Interface().(ProtoSizer)
186 return s.ProtoSize()
187 }
188
189 m := ptr.asPointerTo(u.typ).Interface().(Marshaler)
190 b, _ := m.Marshal()
191 return len(b)
192 }
193
194 n := 0
195 for _, f := range u.fields {
196 if f.isPointer && ptr.offset(f.field).getPointer().isNil() {
197 // nil pointer always marshals to nothing
198 continue
199 }
200 n += f.sizer(ptr.offset(f.field), f.tagsize)
201 }
202 if u.extensions.IsValid() {
203 e := ptr.offset(u.extensions).toExtensions()
204 if u.messageset {
205 n += u.sizeMessageSet(e)
206 } else {
207 n += u.sizeExtensions(e)
208 }
209 }
210 if u.v1extensions.IsValid() {
211 m := *ptr.offset(u.v1extensions).toOldExtensions()
212 n += u.sizeV1Extensions(m)
213 }
214 if u.bytesExtensions.IsValid() {
215 s := *ptr.offset(u.bytesExtensions).toBytes()
216 n += len(s)
217 }
218 if u.unrecognized.IsValid() {
219 s := *ptr.offset(u.unrecognized).toBytes()
220 n += len(s)
221 }
222
223 // cache the result for use in marshal
224 if u.sizecache.IsValid() {
225 atomic.StoreInt32(ptr.offset(u.sizecache).toInt32(), int32(n))
226 }
227 return n
228}
229
230// cachedsize gets the size from cache. If there is no cache (i.e. message is not generated),
231// fall back to compute the size.
232func (u *marshalInfo) cachedsize(ptr pointer) int {
233 if u.sizecache.IsValid() {
234 return int(atomic.LoadInt32(ptr.offset(u.sizecache).toInt32()))
235 }
236 return u.size(ptr)
237}
238
239// marshal is the main function to marshal a message. It takes a byte slice and appends
240// the encoded data to the end of the slice, returns the slice and error (if any).
241// ptr is the pointer to the message.
242// If deterministic is true, map is marshaled in deterministic order.
243func (u *marshalInfo) marshal(b []byte, ptr pointer, deterministic bool) ([]byte, error) {
244 if atomic.LoadInt32(&u.initialized) == 0 {
245 u.computeMarshalInfo()
246 }
247
248 // If the message can marshal itself, let it do it, for compatibility.
249 // NOTE: This is not efficient.
250 if u.hasmarshaler {
251 m := ptr.asPointerTo(u.typ).Interface().(Marshaler)
252 b1, err := m.Marshal()
253 b = append(b, b1...)
254 return b, err
255 }
256
257 var err, errLater error
258 // The old marshaler encodes extensions at beginning.
259 if u.extensions.IsValid() {
260 e := ptr.offset(u.extensions).toExtensions()
261 if u.messageset {
262 b, err = u.appendMessageSet(b, e, deterministic)
263 } else {
264 b, err = u.appendExtensions(b, e, deterministic)
265 }
266 if err != nil {
267 return b, err
268 }
269 }
270 if u.v1extensions.IsValid() {
271 m := *ptr.offset(u.v1extensions).toOldExtensions()
272 b, err = u.appendV1Extensions(b, m, deterministic)
273 if err != nil {
274 return b, err
275 }
276 }
277 if u.bytesExtensions.IsValid() {
278 s := *ptr.offset(u.bytesExtensions).toBytes()
279 b = append(b, s...)
280 }
281 for _, f := range u.fields {
282 if f.required {
283 if f.isPointer && ptr.offset(f.field).getPointer().isNil() {
284 // Required field is not set.
285 // We record the error but keep going, to give a complete marshaling.
286 if errLater == nil {
287 errLater = &RequiredNotSetError{f.name}
288 }
289 continue
290 }
291 }
292 if f.isPointer && ptr.offset(f.field).getPointer().isNil() {
293 // nil pointer always marshals to nothing
294 continue
295 }
296 b, err = f.marshaler(b, ptr.offset(f.field), f.wiretag, deterministic)
297 if err != nil {
298 if err1, ok := err.(*RequiredNotSetError); ok {
299 // Required field in submessage is not set.
300 // We record the error but keep going, to give a complete marshaling.
301 if errLater == nil {
302 errLater = &RequiredNotSetError{f.name + "." + err1.field}
303 }
304 continue
305 }
306 if err == errRepeatedHasNil {
307 err = errors.New("proto: repeated field " + f.name + " has nil element")
308 }
309 if err == errInvalidUTF8 {
310 if errLater == nil {
311 fullName := revProtoTypes[reflect.PtrTo(u.typ)] + "." + f.name
312 errLater = &invalidUTF8Error{fullName}
313 }
314 continue
315 }
316 return b, err
317 }
318 }
319 if u.unrecognized.IsValid() {
320 s := *ptr.offset(u.unrecognized).toBytes()
321 b = append(b, s...)
322 }
323 return b, errLater
324}
325
326// computeMarshalInfo initializes the marshal info.
327func (u *marshalInfo) computeMarshalInfo() {
328 u.Lock()
329 defer u.Unlock()
330 if u.initialized != 0 { // non-atomic read is ok as it is protected by the lock
331 return
332 }
333
334 t := u.typ
335 u.unrecognized = invalidField
336 u.extensions = invalidField
337 u.v1extensions = invalidField
338 u.bytesExtensions = invalidField
339 u.sizecache = invalidField
340 isOneofMessage := false
341
342 if reflect.PtrTo(t).Implements(sizerType) {
343 u.hassizer = true
344 }
345 if reflect.PtrTo(t).Implements(protosizerType) {
346 u.hasprotosizer = true
347 }
348 // If the message can marshal itself, let it do it, for compatibility.
349 // NOTE: This is not efficient.
350 if reflect.PtrTo(t).Implements(marshalerType) {
351 u.hasmarshaler = true
352 atomic.StoreInt32(&u.initialized, 1)
353 return
354 }
355
356 n := t.NumField()
357
358 // deal with XXX fields first
359 for i := 0; i < t.NumField(); i++ {
360 f := t.Field(i)
361 if f.Tag.Get("protobuf_oneof") != "" {
362 isOneofMessage = true
363 }
364 if !strings.HasPrefix(f.Name, "XXX_") {
365 continue
366 }
367 switch f.Name {
368 case "XXX_sizecache":
369 u.sizecache = toField(&f)
370 case "XXX_unrecognized":
371 u.unrecognized = toField(&f)
372 case "XXX_InternalExtensions":
373 u.extensions = toField(&f)
374 u.messageset = f.Tag.Get("protobuf_messageset") == "1"
375 case "XXX_extensions":
376 if f.Type.Kind() == reflect.Map {
377 u.v1extensions = toField(&f)
378 } else {
379 u.bytesExtensions = toField(&f)
380 }
381 case "XXX_NoUnkeyedLiteral":
382 // nothing to do
383 default:
384 panic("unknown XXX field: " + f.Name)
385 }
386 n--
387 }
388
389 // get oneof implementers
390 var oneofImplementers []interface{}
391 // gogo: isOneofMessage is needed for embedded oneof messages, without a marshaler and unmarshaler
392 if m, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(oneofMessage); ok && isOneofMessage {
393 _, _, _, oneofImplementers = m.XXX_OneofFuncs()
394 }
395
396 // normal fields
397 fields := make([]marshalFieldInfo, n) // batch allocation
398 u.fields = make([]*marshalFieldInfo, 0, n)
399 for i, j := 0, 0; i < t.NumField(); i++ {
400 f := t.Field(i)
401
402 if strings.HasPrefix(f.Name, "XXX_") {
403 continue
404 }
405 field := &fields[j]
406 j++
407 field.name = f.Name
408 u.fields = append(u.fields, field)
409 if f.Tag.Get("protobuf_oneof") != "" {
410 field.computeOneofFieldInfo(&f, oneofImplementers)
411 continue
412 }
413 if f.Tag.Get("protobuf") == "" {
414 // field has no tag (not in generated message), ignore it
415 u.fields = u.fields[:len(u.fields)-1]
416 j--
417 continue
418 }
419 field.computeMarshalFieldInfo(&f)
420 }
421
422 // fields are marshaled in tag order on the wire.
423 sort.Sort(byTag(u.fields))
424
425 atomic.StoreInt32(&u.initialized, 1)
426}
427
428// helper for sorting fields by tag
429type byTag []*marshalFieldInfo
430
431func (a byTag) Len() int { return len(a) }
432func (a byTag) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
433func (a byTag) Less(i, j int) bool { return a[i].wiretag < a[j].wiretag }
434
435// getExtElemInfo returns the information to marshal an extension element.
436// The info it returns is initialized.
437func (u *marshalInfo) getExtElemInfo(desc *ExtensionDesc) *marshalElemInfo {
438 // get from cache first
439 u.RLock()
440 e, ok := u.extElems[desc.Field]
441 u.RUnlock()
442 if ok {
443 return e
444 }
445
446 t := reflect.TypeOf(desc.ExtensionType) // pointer or slice to basic type or struct
447 tags := strings.Split(desc.Tag, ",")
448 tag, err := strconv.Atoi(tags[1])
449 if err != nil {
450 panic("tag is not an integer")
451 }
452 wt := wiretype(tags[0])
453 sizr, marshalr := typeMarshaler(t, tags, false, false)
454 e = &marshalElemInfo{
455 wiretag: uint64(tag)<<3 | wt,
456 tagsize: SizeVarint(uint64(tag) << 3),
457 sizer: sizr,
458 marshaler: marshalr,
459 isptr: t.Kind() == reflect.Ptr,
460 }
461
462 // update cache
463 u.Lock()
464 if u.extElems == nil {
465 u.extElems = make(map[int32]*marshalElemInfo)
466 }
467 u.extElems[desc.Field] = e
468 u.Unlock()
469 return e
470}
471
472// computeMarshalFieldInfo fills up the information to marshal a field.
473func (fi *marshalFieldInfo) computeMarshalFieldInfo(f *reflect.StructField) {
474 // parse protobuf tag of the field.
475 // tag has format of "bytes,49,opt,name=foo,def=hello!"
476 tags := strings.Split(f.Tag.Get("protobuf"), ",")
477 if tags[0] == "" {
478 return
479 }
480 tag, err := strconv.Atoi(tags[1])
481 if err != nil {
482 panic("tag is not an integer")
483 }
484 wt := wiretype(tags[0])
485 if tags[2] == "req" {
486 fi.required = true
487 }
488 fi.setTag(f, tag, wt)
489 fi.setMarshaler(f, tags)
490}
491
492func (fi *marshalFieldInfo) computeOneofFieldInfo(f *reflect.StructField, oneofImplementers []interface{}) {
493 fi.field = toField(f)
494 fi.wiretag = math.MaxInt32 // Use a large tag number, make oneofs sorted at the end. This tag will not appear on the wire.
495 fi.isPointer = true
496 fi.sizer, fi.marshaler = makeOneOfMarshaler(fi, f)
497 fi.oneofElems = make(map[reflect.Type]*marshalElemInfo)
498
499 ityp := f.Type // interface type
500 for _, o := range oneofImplementers {
501 t := reflect.TypeOf(o)
502 if !t.Implements(ityp) {
503 continue
504 }
505 sf := t.Elem().Field(0) // oneof implementer is a struct with a single field
506 tags := strings.Split(sf.Tag.Get("protobuf"), ",")
507 tag, err := strconv.Atoi(tags[1])
508 if err != nil {
509 panic("tag is not an integer")
510 }
511 wt := wiretype(tags[0])
512 sizr, marshalr := typeMarshaler(sf.Type, tags, false, true) // oneof should not omit any zero value
513 fi.oneofElems[t.Elem()] = &marshalElemInfo{
514 wiretag: uint64(tag)<<3 | wt,
515 tagsize: SizeVarint(uint64(tag) << 3),
516 sizer: sizr,
517 marshaler: marshalr,
518 }
519 }
520}
521
522type oneofMessage interface {
523 XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{})
524}
525
526// wiretype returns the wire encoding of the type.
527func wiretype(encoding string) uint64 {
528 switch encoding {
529 case "fixed32":
530 return WireFixed32
531 case "fixed64":
532 return WireFixed64
533 case "varint", "zigzag32", "zigzag64":
534 return WireVarint
535 case "bytes":
536 return WireBytes
537 case "group":
538 return WireStartGroup
539 }
540 panic("unknown wire type " + encoding)
541}
542
543// setTag fills up the tag (in wire format) and its size in the info of a field.
544func (fi *marshalFieldInfo) setTag(f *reflect.StructField, tag int, wt uint64) {
545 fi.field = toField(f)
546 fi.wiretag = uint64(tag)<<3 | wt
547 fi.tagsize = SizeVarint(uint64(tag) << 3)
548}
549
550// setMarshaler fills up the sizer and marshaler in the info of a field.
551func (fi *marshalFieldInfo) setMarshaler(f *reflect.StructField, tags []string) {
552 switch f.Type.Kind() {
553 case reflect.Map:
554 // map field
555 fi.isPointer = true
556 fi.sizer, fi.marshaler = makeMapMarshaler(f)
557 return
558 case reflect.Ptr, reflect.Slice:
559 fi.isPointer = true
560 }
561 fi.sizer, fi.marshaler = typeMarshaler(f.Type, tags, true, false)
562}
563
564// typeMarshaler returns the sizer and marshaler of a given field.
565// t is the type of the field.
566// tags is the generated "protobuf" tag of the field.
567// If nozero is true, zero value is not marshaled to the wire.
568// If oneof is true, it is a oneof field.
569func typeMarshaler(t reflect.Type, tags []string, nozero, oneof bool) (sizer, marshaler) {
570 encoding := tags[0]
571
572 pointer := false
573 slice := false
574 if t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 {
575 slice = true
576 t = t.Elem()
577 }
578 if t.Kind() == reflect.Ptr {
579 pointer = true
580 t = t.Elem()
581 }
582
583 packed := false
584 proto3 := false
585 ctype := false
586 isTime := false
587 isDuration := false
588 isWktPointer := false
589 validateUTF8 := true
590 for i := 2; i < len(tags); i++ {
591 if tags[i] == "packed" {
592 packed = true
593 }
594 if tags[i] == "proto3" {
595 proto3 = true
596 }
597 if strings.HasPrefix(tags[i], "customtype=") {
598 ctype = true
599 }
600 if tags[i] == "stdtime" {
601 isTime = true
602 }
603 if tags[i] == "stdduration" {
604 isDuration = true
605 }
606 if tags[i] == "wktptr" {
607 isWktPointer = true
608 }
609 }
610 validateUTF8 = validateUTF8 && proto3
611 if !proto3 && !pointer && !slice {
612 nozero = false
613 }
614
615 if ctype {
616 if reflect.PtrTo(t).Implements(customType) {
617 if slice {
618 return makeMessageRefSliceMarshaler(getMarshalInfo(t))
619 }
620 if pointer {
621 return makeCustomPtrMarshaler(getMarshalInfo(t))
622 }
623 return makeCustomMarshaler(getMarshalInfo(t))
624 } else {
625 panic(fmt.Sprintf("custom type: type: %v, does not implement the proto.custom interface", t))
626 }
627 }
628
629 if isTime {
630 if pointer {
631 if slice {
632 return makeTimePtrSliceMarshaler(getMarshalInfo(t))
633 }
634 return makeTimePtrMarshaler(getMarshalInfo(t))
635 }
636 if slice {
637 return makeTimeSliceMarshaler(getMarshalInfo(t))
638 }
639 return makeTimeMarshaler(getMarshalInfo(t))
640 }
641
642 if isDuration {
643 if pointer {
644 if slice {
645 return makeDurationPtrSliceMarshaler(getMarshalInfo(t))
646 }
647 return makeDurationPtrMarshaler(getMarshalInfo(t))
648 }
649 if slice {
650 return makeDurationSliceMarshaler(getMarshalInfo(t))
651 }
652 return makeDurationMarshaler(getMarshalInfo(t))
653 }
654
655 if isWktPointer {
656 switch t.Kind() {
657 case reflect.Float64:
658 if pointer {
659 if slice {
660 return makeStdDoubleValuePtrSliceMarshaler(getMarshalInfo(t))
661 }
662 return makeStdDoubleValuePtrMarshaler(getMarshalInfo(t))
663 }
664 if slice {
665 return makeStdDoubleValueSliceMarshaler(getMarshalInfo(t))
666 }
667 return makeStdDoubleValueMarshaler(getMarshalInfo(t))
668 case reflect.Float32:
669 if pointer {
670 if slice {
671 return makeStdFloatValuePtrSliceMarshaler(getMarshalInfo(t))
672 }
673 return makeStdFloatValuePtrMarshaler(getMarshalInfo(t))
674 }
675 if slice {
676 return makeStdFloatValueSliceMarshaler(getMarshalInfo(t))
677 }
678 return makeStdFloatValueMarshaler(getMarshalInfo(t))
679 case reflect.Int64:
680 if pointer {
681 if slice {
682 return makeStdInt64ValuePtrSliceMarshaler(getMarshalInfo(t))
683 }
684 return makeStdInt64ValuePtrMarshaler(getMarshalInfo(t))
685 }
686 if slice {
687 return makeStdInt64ValueSliceMarshaler(getMarshalInfo(t))
688 }
689 return makeStdInt64ValueMarshaler(getMarshalInfo(t))
690 case reflect.Uint64:
691 if pointer {
692 if slice {
693 return makeStdUInt64ValuePtrSliceMarshaler(getMarshalInfo(t))
694 }
695 return makeStdUInt64ValuePtrMarshaler(getMarshalInfo(t))
696 }
697 if slice {
698 return makeStdUInt64ValueSliceMarshaler(getMarshalInfo(t))
699 }
700 return makeStdUInt64ValueMarshaler(getMarshalInfo(t))
701 case reflect.Int32:
702 if pointer {
703 if slice {
704 return makeStdInt32ValuePtrSliceMarshaler(getMarshalInfo(t))
705 }
706 return makeStdInt32ValuePtrMarshaler(getMarshalInfo(t))
707 }
708 if slice {
709 return makeStdInt32ValueSliceMarshaler(getMarshalInfo(t))
710 }
711 return makeStdInt32ValueMarshaler(getMarshalInfo(t))
712 case reflect.Uint32:
713 if pointer {
714 if slice {
715 return makeStdUInt32ValuePtrSliceMarshaler(getMarshalInfo(t))
716 }
717 return makeStdUInt32ValuePtrMarshaler(getMarshalInfo(t))
718 }
719 if slice {
720 return makeStdUInt32ValueSliceMarshaler(getMarshalInfo(t))
721 }
722 return makeStdUInt32ValueMarshaler(getMarshalInfo(t))
723 case reflect.Bool:
724 if pointer {
725 if slice {
726 return makeStdBoolValuePtrSliceMarshaler(getMarshalInfo(t))
727 }
728 return makeStdBoolValuePtrMarshaler(getMarshalInfo(t))
729 }
730 if slice {
731 return makeStdBoolValueSliceMarshaler(getMarshalInfo(t))
732 }
733 return makeStdBoolValueMarshaler(getMarshalInfo(t))
734 case reflect.String:
735 if pointer {
736 if slice {
737 return makeStdStringValuePtrSliceMarshaler(getMarshalInfo(t))
738 }
739 return makeStdStringValuePtrMarshaler(getMarshalInfo(t))
740 }
741 if slice {
742 return makeStdStringValueSliceMarshaler(getMarshalInfo(t))
743 }
744 return makeStdStringValueMarshaler(getMarshalInfo(t))
745 case uint8SliceType:
746 if pointer {
747 if slice {
748 return makeStdBytesValuePtrSliceMarshaler(getMarshalInfo(t))
749 }
750 return makeStdBytesValuePtrMarshaler(getMarshalInfo(t))
751 }
752 if slice {
753 return makeStdBytesValueSliceMarshaler(getMarshalInfo(t))
754 }
755 return makeStdBytesValueMarshaler(getMarshalInfo(t))
756 default:
757 panic(fmt.Sprintf("unknown wktpointer type %#v", t))
758 }
759 }
760
761 switch t.Kind() {
762 case reflect.Bool:
763 if pointer {
764 return sizeBoolPtr, appendBoolPtr
765 }
766 if slice {
767 if packed {
768 return sizeBoolPackedSlice, appendBoolPackedSlice
769 }
770 return sizeBoolSlice, appendBoolSlice
771 }
772 if nozero {
773 return sizeBoolValueNoZero, appendBoolValueNoZero
774 }
775 return sizeBoolValue, appendBoolValue
776 case reflect.Uint32:
777 switch encoding {
778 case "fixed32":
779 if pointer {
780 return sizeFixed32Ptr, appendFixed32Ptr
781 }
782 if slice {
783 if packed {
784 return sizeFixed32PackedSlice, appendFixed32PackedSlice
785 }
786 return sizeFixed32Slice, appendFixed32Slice
787 }
788 if nozero {
789 return sizeFixed32ValueNoZero, appendFixed32ValueNoZero
790 }
791 return sizeFixed32Value, appendFixed32Value
792 case "varint":
793 if pointer {
794 return sizeVarint32Ptr, appendVarint32Ptr
795 }
796 if slice {
797 if packed {
798 return sizeVarint32PackedSlice, appendVarint32PackedSlice
799 }
800 return sizeVarint32Slice, appendVarint32Slice
801 }
802 if nozero {
803 return sizeVarint32ValueNoZero, appendVarint32ValueNoZero
804 }
805 return sizeVarint32Value, appendVarint32Value
806 }
807 case reflect.Int32:
808 switch encoding {
809 case "fixed32":
810 if pointer {
811 return sizeFixedS32Ptr, appendFixedS32Ptr
812 }
813 if slice {
814 if packed {
815 return sizeFixedS32PackedSlice, appendFixedS32PackedSlice
816 }
817 return sizeFixedS32Slice, appendFixedS32Slice
818 }
819 if nozero {
820 return sizeFixedS32ValueNoZero, appendFixedS32ValueNoZero
821 }
822 return sizeFixedS32Value, appendFixedS32Value
823 case "varint":
824 if pointer {
825 return sizeVarintS32Ptr, appendVarintS32Ptr
826 }
827 if slice {
828 if packed {
829 return sizeVarintS32PackedSlice, appendVarintS32PackedSlice
830 }
831 return sizeVarintS32Slice, appendVarintS32Slice
832 }
833 if nozero {
834 return sizeVarintS32ValueNoZero, appendVarintS32ValueNoZero
835 }
836 return sizeVarintS32Value, appendVarintS32Value
837 case "zigzag32":
838 if pointer {
839 return sizeZigzag32Ptr, appendZigzag32Ptr
840 }
841 if slice {
842 if packed {
843 return sizeZigzag32PackedSlice, appendZigzag32PackedSlice
844 }
845 return sizeZigzag32Slice, appendZigzag32Slice
846 }
847 if nozero {
848 return sizeZigzag32ValueNoZero, appendZigzag32ValueNoZero
849 }
850 return sizeZigzag32Value, appendZigzag32Value
851 }
852 case reflect.Uint64:
853 switch encoding {
854 case "fixed64":
855 if pointer {
856 return sizeFixed64Ptr, appendFixed64Ptr
857 }
858 if slice {
859 if packed {
860 return sizeFixed64PackedSlice, appendFixed64PackedSlice
861 }
862 return sizeFixed64Slice, appendFixed64Slice
863 }
864 if nozero {
865 return sizeFixed64ValueNoZero, appendFixed64ValueNoZero
866 }
867 return sizeFixed64Value, appendFixed64Value
868 case "varint":
869 if pointer {
870 return sizeVarint64Ptr, appendVarint64Ptr
871 }
872 if slice {
873 if packed {
874 return sizeVarint64PackedSlice, appendVarint64PackedSlice
875 }
876 return sizeVarint64Slice, appendVarint64Slice
877 }
878 if nozero {
879 return sizeVarint64ValueNoZero, appendVarint64ValueNoZero
880 }
881 return sizeVarint64Value, appendVarint64Value
882 }
883 case reflect.Int64:
884 switch encoding {
885 case "fixed64":
886 if pointer {
887 return sizeFixedS64Ptr, appendFixedS64Ptr
888 }
889 if slice {
890 if packed {
891 return sizeFixedS64PackedSlice, appendFixedS64PackedSlice
892 }
893 return sizeFixedS64Slice, appendFixedS64Slice
894 }
895 if nozero {
896 return sizeFixedS64ValueNoZero, appendFixedS64ValueNoZero
897 }
898 return sizeFixedS64Value, appendFixedS64Value
899 case "varint":
900 if pointer {
901 return sizeVarintS64Ptr, appendVarintS64Ptr
902 }
903 if slice {
904 if packed {
905 return sizeVarintS64PackedSlice, appendVarintS64PackedSlice
906 }
907 return sizeVarintS64Slice, appendVarintS64Slice
908 }
909 if nozero {
910 return sizeVarintS64ValueNoZero, appendVarintS64ValueNoZero
911 }
912 return sizeVarintS64Value, appendVarintS64Value
913 case "zigzag64":
914 if pointer {
915 return sizeZigzag64Ptr, appendZigzag64Ptr
916 }
917 if slice {
918 if packed {
919 return sizeZigzag64PackedSlice, appendZigzag64PackedSlice
920 }
921 return sizeZigzag64Slice, appendZigzag64Slice
922 }
923 if nozero {
924 return sizeZigzag64ValueNoZero, appendZigzag64ValueNoZero
925 }
926 return sizeZigzag64Value, appendZigzag64Value
927 }
928 case reflect.Float32:
929 if pointer {
930 return sizeFloat32Ptr, appendFloat32Ptr
931 }
932 if slice {
933 if packed {
934 return sizeFloat32PackedSlice, appendFloat32PackedSlice
935 }
936 return sizeFloat32Slice, appendFloat32Slice
937 }
938 if nozero {
939 return sizeFloat32ValueNoZero, appendFloat32ValueNoZero
940 }
941 return sizeFloat32Value, appendFloat32Value
942 case reflect.Float64:
943 if pointer {
944 return sizeFloat64Ptr, appendFloat64Ptr
945 }
946 if slice {
947 if packed {
948 return sizeFloat64PackedSlice, appendFloat64PackedSlice
949 }
950 return sizeFloat64Slice, appendFloat64Slice
951 }
952 if nozero {
953 return sizeFloat64ValueNoZero, appendFloat64ValueNoZero
954 }
955 return sizeFloat64Value, appendFloat64Value
956 case reflect.String:
957 if validateUTF8 {
958 if pointer {
959 return sizeStringPtr, appendUTF8StringPtr
960 }
961 if slice {
962 return sizeStringSlice, appendUTF8StringSlice
963 }
964 if nozero {
965 return sizeStringValueNoZero, appendUTF8StringValueNoZero
966 }
967 return sizeStringValue, appendUTF8StringValue
968 }
969 if pointer {
970 return sizeStringPtr, appendStringPtr
971 }
972 if slice {
973 return sizeStringSlice, appendStringSlice
974 }
975 if nozero {
976 return sizeStringValueNoZero, appendStringValueNoZero
977 }
978 return sizeStringValue, appendStringValue
979 case reflect.Slice:
980 if slice {
981 return sizeBytesSlice, appendBytesSlice
982 }
983 if oneof {
984 // Oneof bytes field may also have "proto3" tag.
985 // We want to marshal it as a oneof field. Do this
986 // check before the proto3 check.
987 return sizeBytesOneof, appendBytesOneof
988 }
989 if proto3 {
990 return sizeBytes3, appendBytes3
991 }
992 return sizeBytes, appendBytes
993 case reflect.Struct:
994 switch encoding {
995 case "group":
996 if slice {
997 return makeGroupSliceMarshaler(getMarshalInfo(t))
998 }
999 return makeGroupMarshaler(getMarshalInfo(t))
1000 case "bytes":
1001 if pointer {
1002 if slice {
1003 return makeMessageSliceMarshaler(getMarshalInfo(t))
1004 }
1005 return makeMessageMarshaler(getMarshalInfo(t))
1006 } else {
1007 if slice {
1008 return makeMessageRefSliceMarshaler(getMarshalInfo(t))
1009 }
1010 return makeMessageRefMarshaler(getMarshalInfo(t))
1011 }
1012 }
1013 }
1014 panic(fmt.Sprintf("unknown or mismatched type: type: %v, wire type: %v", t, encoding))
1015}
1016
1017// Below are functions to size/marshal a specific type of a field.
1018// They are stored in the field's info, and called by function pointers.
1019// They have type sizer or marshaler.
1020
1021func sizeFixed32Value(_ pointer, tagsize int) int {
1022 return 4 + tagsize
1023}
1024func sizeFixed32ValueNoZero(ptr pointer, tagsize int) int {
1025 v := *ptr.toUint32()
1026 if v == 0 {
1027 return 0
1028 }
1029 return 4 + tagsize
1030}
1031func sizeFixed32Ptr(ptr pointer, tagsize int) int {
1032 p := *ptr.toUint32Ptr()
1033 if p == nil {
1034 return 0
1035 }
1036 return 4 + tagsize
1037}
1038func sizeFixed32Slice(ptr pointer, tagsize int) int {
1039 s := *ptr.toUint32Slice()
1040 return (4 + tagsize) * len(s)
1041}
1042func sizeFixed32PackedSlice(ptr pointer, tagsize int) int {
1043 s := *ptr.toUint32Slice()
1044 if len(s) == 0 {
1045 return 0
1046 }
1047 return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize
1048}
1049func sizeFixedS32Value(_ pointer, tagsize int) int {
1050 return 4 + tagsize
1051}
1052func sizeFixedS32ValueNoZero(ptr pointer, tagsize int) int {
1053 v := *ptr.toInt32()
1054 if v == 0 {
1055 return 0
1056 }
1057 return 4 + tagsize
1058}
1059func sizeFixedS32Ptr(ptr pointer, tagsize int) int {
1060 p := ptr.getInt32Ptr()
1061 if p == nil {
1062 return 0
1063 }
1064 return 4 + tagsize
1065}
1066func sizeFixedS32Slice(ptr pointer, tagsize int) int {
1067 s := ptr.getInt32Slice()
1068 return (4 + tagsize) * len(s)
1069}
1070func sizeFixedS32PackedSlice(ptr pointer, tagsize int) int {
1071 s := ptr.getInt32Slice()
1072 if len(s) == 0 {
1073 return 0
1074 }
1075 return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize
1076}
1077func sizeFloat32Value(_ pointer, tagsize int) int {
1078 return 4 + tagsize
1079}
1080func sizeFloat32ValueNoZero(ptr pointer, tagsize int) int {
1081 v := math.Float32bits(*ptr.toFloat32())
1082 if v == 0 {
1083 return 0
1084 }
1085 return 4 + tagsize
1086}
1087func sizeFloat32Ptr(ptr pointer, tagsize int) int {
1088 p := *ptr.toFloat32Ptr()
1089 if p == nil {
1090 return 0
1091 }
1092 return 4 + tagsize
1093}
1094func sizeFloat32Slice(ptr pointer, tagsize int) int {
1095 s := *ptr.toFloat32Slice()
1096 return (4 + tagsize) * len(s)
1097}
1098func sizeFloat32PackedSlice(ptr pointer, tagsize int) int {
1099 s := *ptr.toFloat32Slice()
1100 if len(s) == 0 {
1101 return 0
1102 }
1103 return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize
1104}
1105func sizeFixed64Value(_ pointer, tagsize int) int {
1106 return 8 + tagsize
1107}
1108func sizeFixed64ValueNoZero(ptr pointer, tagsize int) int {
1109 v := *ptr.toUint64()
1110 if v == 0 {
1111 return 0
1112 }
1113 return 8 + tagsize
1114}
1115func sizeFixed64Ptr(ptr pointer, tagsize int) int {
1116 p := *ptr.toUint64Ptr()
1117 if p == nil {
1118 return 0
1119 }
1120 return 8 + tagsize
1121}
1122func sizeFixed64Slice(ptr pointer, tagsize int) int {
1123 s := *ptr.toUint64Slice()
1124 return (8 + tagsize) * len(s)
1125}
1126func sizeFixed64PackedSlice(ptr pointer, tagsize int) int {
1127 s := *ptr.toUint64Slice()
1128 if len(s) == 0 {
1129 return 0
1130 }
1131 return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize
1132}
1133func sizeFixedS64Value(_ pointer, tagsize int) int {
1134 return 8 + tagsize
1135}
1136func sizeFixedS64ValueNoZero(ptr pointer, tagsize int) int {
1137 v := *ptr.toInt64()
1138 if v == 0 {
1139 return 0
1140 }
1141 return 8 + tagsize
1142}
1143func sizeFixedS64Ptr(ptr pointer, tagsize int) int {
1144 p := *ptr.toInt64Ptr()
1145 if p == nil {
1146 return 0
1147 }
1148 return 8 + tagsize
1149}
1150func sizeFixedS64Slice(ptr pointer, tagsize int) int {
1151 s := *ptr.toInt64Slice()
1152 return (8 + tagsize) * len(s)
1153}
1154func sizeFixedS64PackedSlice(ptr pointer, tagsize int) int {
1155 s := *ptr.toInt64Slice()
1156 if len(s) == 0 {
1157 return 0
1158 }
1159 return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize
1160}
1161func sizeFloat64Value(_ pointer, tagsize int) int {
1162 return 8 + tagsize
1163}
1164func sizeFloat64ValueNoZero(ptr pointer, tagsize int) int {
1165 v := math.Float64bits(*ptr.toFloat64())
1166 if v == 0 {
1167 return 0
1168 }
1169 return 8 + tagsize
1170}
1171func sizeFloat64Ptr(ptr pointer, tagsize int) int {
1172 p := *ptr.toFloat64Ptr()
1173 if p == nil {
1174 return 0
1175 }
1176 return 8 + tagsize
1177}
1178func sizeFloat64Slice(ptr pointer, tagsize int) int {
1179 s := *ptr.toFloat64Slice()
1180 return (8 + tagsize) * len(s)
1181}
1182func sizeFloat64PackedSlice(ptr pointer, tagsize int) int {
1183 s := *ptr.toFloat64Slice()
1184 if len(s) == 0 {
1185 return 0
1186 }
1187 return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize
1188}
1189func sizeVarint32Value(ptr pointer, tagsize int) int {
1190 v := *ptr.toUint32()
1191 return SizeVarint(uint64(v)) + tagsize
1192}
1193func sizeVarint32ValueNoZero(ptr pointer, tagsize int) int {
1194 v := *ptr.toUint32()
1195 if v == 0 {
1196 return 0
1197 }
1198 return SizeVarint(uint64(v)) + tagsize
1199}
1200func sizeVarint32Ptr(ptr pointer, tagsize int) int {
1201 p := *ptr.toUint32Ptr()
1202 if p == nil {
1203 return 0
1204 }
1205 return SizeVarint(uint64(*p)) + tagsize
1206}
1207func sizeVarint32Slice(ptr pointer, tagsize int) int {
1208 s := *ptr.toUint32Slice()
1209 n := 0
1210 for _, v := range s {
1211 n += SizeVarint(uint64(v)) + tagsize
1212 }
1213 return n
1214}
1215func sizeVarint32PackedSlice(ptr pointer, tagsize int) int {
1216 s := *ptr.toUint32Slice()
1217 if len(s) == 0 {
1218 return 0
1219 }
1220 n := 0
1221 for _, v := range s {
1222 n += SizeVarint(uint64(v))
1223 }
1224 return n + SizeVarint(uint64(n)) + tagsize
1225}
1226func sizeVarintS32Value(ptr pointer, tagsize int) int {
1227 v := *ptr.toInt32()
1228 return SizeVarint(uint64(v)) + tagsize
1229}
1230func sizeVarintS32ValueNoZero(ptr pointer, tagsize int) int {
1231 v := *ptr.toInt32()
1232 if v == 0 {
1233 return 0
1234 }
1235 return SizeVarint(uint64(v)) + tagsize
1236}
1237func sizeVarintS32Ptr(ptr pointer, tagsize int) int {
1238 p := ptr.getInt32Ptr()
1239 if p == nil {
1240 return 0
1241 }
1242 return SizeVarint(uint64(*p)) + tagsize
1243}
1244func sizeVarintS32Slice(ptr pointer, tagsize int) int {
1245 s := ptr.getInt32Slice()
1246 n := 0
1247 for _, v := range s {
1248 n += SizeVarint(uint64(v)) + tagsize
1249 }
1250 return n
1251}
1252func sizeVarintS32PackedSlice(ptr pointer, tagsize int) int {
1253 s := ptr.getInt32Slice()
1254 if len(s) == 0 {
1255 return 0
1256 }
1257 n := 0
1258 for _, v := range s {
1259 n += SizeVarint(uint64(v))
1260 }
1261 return n + SizeVarint(uint64(n)) + tagsize
1262}
1263func sizeVarint64Value(ptr pointer, tagsize int) int {
1264 v := *ptr.toUint64()
1265 return SizeVarint(v) + tagsize
1266}
1267func sizeVarint64ValueNoZero(ptr pointer, tagsize int) int {
1268 v := *ptr.toUint64()
1269 if v == 0 {
1270 return 0
1271 }
1272 return SizeVarint(v) + tagsize
1273}
1274func sizeVarint64Ptr(ptr pointer, tagsize int) int {
1275 p := *ptr.toUint64Ptr()
1276 if p == nil {
1277 return 0
1278 }
1279 return SizeVarint(*p) + tagsize
1280}
1281func sizeVarint64Slice(ptr pointer, tagsize int) int {
1282 s := *ptr.toUint64Slice()
1283 n := 0
1284 for _, v := range s {
1285 n += SizeVarint(v) + tagsize
1286 }
1287 return n
1288}
1289func sizeVarint64PackedSlice(ptr pointer, tagsize int) int {
1290 s := *ptr.toUint64Slice()
1291 if len(s) == 0 {
1292 return 0
1293 }
1294 n := 0
1295 for _, v := range s {
1296 n += SizeVarint(v)
1297 }
1298 return n + SizeVarint(uint64(n)) + tagsize
1299}
1300func sizeVarintS64Value(ptr pointer, tagsize int) int {
1301 v := *ptr.toInt64()
1302 return SizeVarint(uint64(v)) + tagsize
1303}
1304func sizeVarintS64ValueNoZero(ptr pointer, tagsize int) int {
1305 v := *ptr.toInt64()
1306 if v == 0 {
1307 return 0
1308 }
1309 return SizeVarint(uint64(v)) + tagsize
1310}
1311func sizeVarintS64Ptr(ptr pointer, tagsize int) int {
1312 p := *ptr.toInt64Ptr()
1313 if p == nil {
1314 return 0
1315 }
1316 return SizeVarint(uint64(*p)) + tagsize
1317}
1318func sizeVarintS64Slice(ptr pointer, tagsize int) int {
1319 s := *ptr.toInt64Slice()
1320 n := 0
1321 for _, v := range s {
1322 n += SizeVarint(uint64(v)) + tagsize
1323 }
1324 return n
1325}
1326func sizeVarintS64PackedSlice(ptr pointer, tagsize int) int {
1327 s := *ptr.toInt64Slice()
1328 if len(s) == 0 {
1329 return 0
1330 }
1331 n := 0
1332 for _, v := range s {
1333 n += SizeVarint(uint64(v))
1334 }
1335 return n + SizeVarint(uint64(n)) + tagsize
1336}
1337func sizeZigzag32Value(ptr pointer, tagsize int) int {
1338 v := *ptr.toInt32()
1339 return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
1340}
1341func sizeZigzag32ValueNoZero(ptr pointer, tagsize int) int {
1342 v := *ptr.toInt32()
1343 if v == 0 {
1344 return 0
1345 }
1346 return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
1347}
1348func sizeZigzag32Ptr(ptr pointer, tagsize int) int {
1349 p := ptr.getInt32Ptr()
1350 if p == nil {
1351 return 0
1352 }
1353 v := *p
1354 return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
1355}
1356func sizeZigzag32Slice(ptr pointer, tagsize int) int {
1357 s := ptr.getInt32Slice()
1358 n := 0
1359 for _, v := range s {
1360 n += SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
1361 }
1362 return n
1363}
1364func sizeZigzag32PackedSlice(ptr pointer, tagsize int) int {
1365 s := ptr.getInt32Slice()
1366 if len(s) == 0 {
1367 return 0
1368 }
1369 n := 0
1370 for _, v := range s {
1371 n += SizeVarint(uint64((uint32(v) << 1) ^ uint32((int32(v) >> 31))))
1372 }
1373 return n + SizeVarint(uint64(n)) + tagsize
1374}
1375func sizeZigzag64Value(ptr pointer, tagsize int) int {
1376 v := *ptr.toInt64()
1377 return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
1378}
1379func sizeZigzag64ValueNoZero(ptr pointer, tagsize int) int {
1380 v := *ptr.toInt64()
1381 if v == 0 {
1382 return 0
1383 }
1384 return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
1385}
1386func sizeZigzag64Ptr(ptr pointer, tagsize int) int {
1387 p := *ptr.toInt64Ptr()
1388 if p == nil {
1389 return 0
1390 }
1391 v := *p
1392 return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
1393}
1394func sizeZigzag64Slice(ptr pointer, tagsize int) int {
1395 s := *ptr.toInt64Slice()
1396 n := 0
1397 for _, v := range s {
1398 n += SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
1399 }
1400 return n
1401}
1402func sizeZigzag64PackedSlice(ptr pointer, tagsize int) int {
1403 s := *ptr.toInt64Slice()
1404 if len(s) == 0 {
1405 return 0
1406 }
1407 n := 0
1408 for _, v := range s {
1409 n += SizeVarint(uint64(v<<1) ^ uint64((int64(v) >> 63)))
1410 }
1411 return n + SizeVarint(uint64(n)) + tagsize
1412}
1413func sizeBoolValue(_ pointer, tagsize int) int {
1414 return 1 + tagsize
1415}
1416func sizeBoolValueNoZero(ptr pointer, tagsize int) int {
1417 v := *ptr.toBool()
1418 if !v {
1419 return 0
1420 }
1421 return 1 + tagsize
1422}
1423func sizeBoolPtr(ptr pointer, tagsize int) int {
1424 p := *ptr.toBoolPtr()
1425 if p == nil {
1426 return 0
1427 }
1428 return 1 + tagsize
1429}
1430func sizeBoolSlice(ptr pointer, tagsize int) int {
1431 s := *ptr.toBoolSlice()
1432 return (1 + tagsize) * len(s)
1433}
1434func sizeBoolPackedSlice(ptr pointer, tagsize int) int {
1435 s := *ptr.toBoolSlice()
1436 if len(s) == 0 {
1437 return 0
1438 }
1439 return len(s) + SizeVarint(uint64(len(s))) + tagsize
1440}
1441func sizeStringValue(ptr pointer, tagsize int) int {
1442 v := *ptr.toString()
1443 return len(v) + SizeVarint(uint64(len(v))) + tagsize
1444}
1445func sizeStringValueNoZero(ptr pointer, tagsize int) int {
1446 v := *ptr.toString()
1447 if v == "" {
1448 return 0
1449 }
1450 return len(v) + SizeVarint(uint64(len(v))) + tagsize
1451}
1452func sizeStringPtr(ptr pointer, tagsize int) int {
1453 p := *ptr.toStringPtr()
1454 if p == nil {
1455 return 0
1456 }
1457 v := *p
1458 return len(v) + SizeVarint(uint64(len(v))) + tagsize
1459}
1460func sizeStringSlice(ptr pointer, tagsize int) int {
1461 s := *ptr.toStringSlice()
1462 n := 0
1463 for _, v := range s {
1464 n += len(v) + SizeVarint(uint64(len(v))) + tagsize
1465 }
1466 return n
1467}
1468func sizeBytes(ptr pointer, tagsize int) int {
1469 v := *ptr.toBytes()
1470 if v == nil {
1471 return 0
1472 }
1473 return len(v) + SizeVarint(uint64(len(v))) + tagsize
1474}
1475func sizeBytes3(ptr pointer, tagsize int) int {
1476 v := *ptr.toBytes()
1477 if len(v) == 0 {
1478 return 0
1479 }
1480 return len(v) + SizeVarint(uint64(len(v))) + tagsize
1481}
1482func sizeBytesOneof(ptr pointer, tagsize int) int {
1483 v := *ptr.toBytes()
1484 return len(v) + SizeVarint(uint64(len(v))) + tagsize
1485}
1486func sizeBytesSlice(ptr pointer, tagsize int) int {
1487 s := *ptr.toBytesSlice()
1488 n := 0
1489 for _, v := range s {
1490 n += len(v) + SizeVarint(uint64(len(v))) + tagsize
1491 }
1492 return n
1493}
1494
1495// appendFixed32 appends an encoded fixed32 to b.
1496func appendFixed32(b []byte, v uint32) []byte {
1497 b = append(b,
1498 byte(v),
1499 byte(v>>8),
1500 byte(v>>16),
1501 byte(v>>24))
1502 return b
1503}
1504
1505// appendFixed64 appends an encoded fixed64 to b.
1506func appendFixed64(b []byte, v uint64) []byte {
1507 b = append(b,
1508 byte(v),
1509 byte(v>>8),
1510 byte(v>>16),
1511 byte(v>>24),
1512 byte(v>>32),
1513 byte(v>>40),
1514 byte(v>>48),
1515 byte(v>>56))
1516 return b
1517}
1518
1519// appendVarint appends an encoded varint to b.
1520func appendVarint(b []byte, v uint64) []byte {
1521 // TODO: make 1-byte (maybe 2-byte) case inline-able, once we
1522 // have non-leaf inliner.
1523 switch {
1524 case v < 1<<7:
1525 b = append(b, byte(v))
1526 case v < 1<<14:
1527 b = append(b,
1528 byte(v&0x7f|0x80),
1529 byte(v>>7))
1530 case v < 1<<21:
1531 b = append(b,
1532 byte(v&0x7f|0x80),
1533 byte((v>>7)&0x7f|0x80),
1534 byte(v>>14))
1535 case v < 1<<28:
1536 b = append(b,
1537 byte(v&0x7f|0x80),
1538 byte((v>>7)&0x7f|0x80),
1539 byte((v>>14)&0x7f|0x80),
1540 byte(v>>21))
1541 case v < 1<<35:
1542 b = append(b,
1543 byte(v&0x7f|0x80),
1544 byte((v>>7)&0x7f|0x80),
1545 byte((v>>14)&0x7f|0x80),
1546 byte((v>>21)&0x7f|0x80),
1547 byte(v>>28))
1548 case v < 1<<42:
1549 b = append(b,
1550 byte(v&0x7f|0x80),
1551 byte((v>>7)&0x7f|0x80),
1552 byte((v>>14)&0x7f|0x80),
1553 byte((v>>21)&0x7f|0x80),
1554 byte((v>>28)&0x7f|0x80),
1555 byte(v>>35))
1556 case v < 1<<49:
1557 b = append(b,
1558 byte(v&0x7f|0x80),
1559 byte((v>>7)&0x7f|0x80),
1560 byte((v>>14)&0x7f|0x80),
1561 byte((v>>21)&0x7f|0x80),
1562 byte((v>>28)&0x7f|0x80),
1563 byte((v>>35)&0x7f|0x80),
1564 byte(v>>42))
1565 case v < 1<<56:
1566 b = append(b,
1567 byte(v&0x7f|0x80),
1568 byte((v>>7)&0x7f|0x80),
1569 byte((v>>14)&0x7f|0x80),
1570 byte((v>>21)&0x7f|0x80),
1571 byte((v>>28)&0x7f|0x80),
1572 byte((v>>35)&0x7f|0x80),
1573 byte((v>>42)&0x7f|0x80),
1574 byte(v>>49))
1575 case v < 1<<63:
1576 b = append(b,
1577 byte(v&0x7f|0x80),
1578 byte((v>>7)&0x7f|0x80),
1579 byte((v>>14)&0x7f|0x80),
1580 byte((v>>21)&0x7f|0x80),
1581 byte((v>>28)&0x7f|0x80),
1582 byte((v>>35)&0x7f|0x80),
1583 byte((v>>42)&0x7f|0x80),
1584 byte((v>>49)&0x7f|0x80),
1585 byte(v>>56))
1586 default:
1587 b = append(b,
1588 byte(v&0x7f|0x80),
1589 byte((v>>7)&0x7f|0x80),
1590 byte((v>>14)&0x7f|0x80),
1591 byte((v>>21)&0x7f|0x80),
1592 byte((v>>28)&0x7f|0x80),
1593 byte((v>>35)&0x7f|0x80),
1594 byte((v>>42)&0x7f|0x80),
1595 byte((v>>49)&0x7f|0x80),
1596 byte((v>>56)&0x7f|0x80),
1597 1)
1598 }
1599 return b
1600}
1601
1602func appendFixed32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1603 v := *ptr.toUint32()
1604 b = appendVarint(b, wiretag)
1605 b = appendFixed32(b, v)
1606 return b, nil
1607}
1608func appendFixed32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1609 v := *ptr.toUint32()
1610 if v == 0 {
1611 return b, nil
1612 }
1613 b = appendVarint(b, wiretag)
1614 b = appendFixed32(b, v)
1615 return b, nil
1616}
1617func appendFixed32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1618 p := *ptr.toUint32Ptr()
1619 if p == nil {
1620 return b, nil
1621 }
1622 b = appendVarint(b, wiretag)
1623 b = appendFixed32(b, *p)
1624 return b, nil
1625}
1626func appendFixed32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1627 s := *ptr.toUint32Slice()
1628 for _, v := range s {
1629 b = appendVarint(b, wiretag)
1630 b = appendFixed32(b, v)
1631 }
1632 return b, nil
1633}
1634func appendFixed32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1635 s := *ptr.toUint32Slice()
1636 if len(s) == 0 {
1637 return b, nil
1638 }
1639 b = appendVarint(b, wiretag&^7|WireBytes)
1640 b = appendVarint(b, uint64(4*len(s)))
1641 for _, v := range s {
1642 b = appendFixed32(b, v)
1643 }
1644 return b, nil
1645}
1646func appendFixedS32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1647 v := *ptr.toInt32()
1648 b = appendVarint(b, wiretag)
1649 b = appendFixed32(b, uint32(v))
1650 return b, nil
1651}
1652func appendFixedS32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1653 v := *ptr.toInt32()
1654 if v == 0 {
1655 return b, nil
1656 }
1657 b = appendVarint(b, wiretag)
1658 b = appendFixed32(b, uint32(v))
1659 return b, nil
1660}
1661func appendFixedS32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1662 p := ptr.getInt32Ptr()
1663 if p == nil {
1664 return b, nil
1665 }
1666 b = appendVarint(b, wiretag)
1667 b = appendFixed32(b, uint32(*p))
1668 return b, nil
1669}
1670func appendFixedS32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1671 s := ptr.getInt32Slice()
1672 for _, v := range s {
1673 b = appendVarint(b, wiretag)
1674 b = appendFixed32(b, uint32(v))
1675 }
1676 return b, nil
1677}
1678func appendFixedS32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1679 s := ptr.getInt32Slice()
1680 if len(s) == 0 {
1681 return b, nil
1682 }
1683 b = appendVarint(b, wiretag&^7|WireBytes)
1684 b = appendVarint(b, uint64(4*len(s)))
1685 for _, v := range s {
1686 b = appendFixed32(b, uint32(v))
1687 }
1688 return b, nil
1689}
1690func appendFloat32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1691 v := math.Float32bits(*ptr.toFloat32())
1692 b = appendVarint(b, wiretag)
1693 b = appendFixed32(b, v)
1694 return b, nil
1695}
1696func appendFloat32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1697 v := math.Float32bits(*ptr.toFloat32())
1698 if v == 0 {
1699 return b, nil
1700 }
1701 b = appendVarint(b, wiretag)
1702 b = appendFixed32(b, v)
1703 return b, nil
1704}
1705func appendFloat32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1706 p := *ptr.toFloat32Ptr()
1707 if p == nil {
1708 return b, nil
1709 }
1710 b = appendVarint(b, wiretag)
1711 b = appendFixed32(b, math.Float32bits(*p))
1712 return b, nil
1713}
1714func appendFloat32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1715 s := *ptr.toFloat32Slice()
1716 for _, v := range s {
1717 b = appendVarint(b, wiretag)
1718 b = appendFixed32(b, math.Float32bits(v))
1719 }
1720 return b, nil
1721}
1722func appendFloat32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1723 s := *ptr.toFloat32Slice()
1724 if len(s) == 0 {
1725 return b, nil
1726 }
1727 b = appendVarint(b, wiretag&^7|WireBytes)
1728 b = appendVarint(b, uint64(4*len(s)))
1729 for _, v := range s {
1730 b = appendFixed32(b, math.Float32bits(v))
1731 }
1732 return b, nil
1733}
1734func appendFixed64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1735 v := *ptr.toUint64()
1736 b = appendVarint(b, wiretag)
1737 b = appendFixed64(b, v)
1738 return b, nil
1739}
1740func appendFixed64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1741 v := *ptr.toUint64()
1742 if v == 0 {
1743 return b, nil
1744 }
1745 b = appendVarint(b, wiretag)
1746 b = appendFixed64(b, v)
1747 return b, nil
1748}
1749func appendFixed64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1750 p := *ptr.toUint64Ptr()
1751 if p == nil {
1752 return b, nil
1753 }
1754 b = appendVarint(b, wiretag)
1755 b = appendFixed64(b, *p)
1756 return b, nil
1757}
1758func appendFixed64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1759 s := *ptr.toUint64Slice()
1760 for _, v := range s {
1761 b = appendVarint(b, wiretag)
1762 b = appendFixed64(b, v)
1763 }
1764 return b, nil
1765}
1766func appendFixed64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1767 s := *ptr.toUint64Slice()
1768 if len(s) == 0 {
1769 return b, nil
1770 }
1771 b = appendVarint(b, wiretag&^7|WireBytes)
1772 b = appendVarint(b, uint64(8*len(s)))
1773 for _, v := range s {
1774 b = appendFixed64(b, v)
1775 }
1776 return b, nil
1777}
1778func appendFixedS64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1779 v := *ptr.toInt64()
1780 b = appendVarint(b, wiretag)
1781 b = appendFixed64(b, uint64(v))
1782 return b, nil
1783}
1784func appendFixedS64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1785 v := *ptr.toInt64()
1786 if v == 0 {
1787 return b, nil
1788 }
1789 b = appendVarint(b, wiretag)
1790 b = appendFixed64(b, uint64(v))
1791 return b, nil
1792}
1793func appendFixedS64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1794 p := *ptr.toInt64Ptr()
1795 if p == nil {
1796 return b, nil
1797 }
1798 b = appendVarint(b, wiretag)
1799 b = appendFixed64(b, uint64(*p))
1800 return b, nil
1801}
1802func appendFixedS64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1803 s := *ptr.toInt64Slice()
1804 for _, v := range s {
1805 b = appendVarint(b, wiretag)
1806 b = appendFixed64(b, uint64(v))
1807 }
1808 return b, nil
1809}
1810func appendFixedS64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1811 s := *ptr.toInt64Slice()
1812 if len(s) == 0 {
1813 return b, nil
1814 }
1815 b = appendVarint(b, wiretag&^7|WireBytes)
1816 b = appendVarint(b, uint64(8*len(s)))
1817 for _, v := range s {
1818 b = appendFixed64(b, uint64(v))
1819 }
1820 return b, nil
1821}
1822func appendFloat64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1823 v := math.Float64bits(*ptr.toFloat64())
1824 b = appendVarint(b, wiretag)
1825 b = appendFixed64(b, v)
1826 return b, nil
1827}
1828func appendFloat64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1829 v := math.Float64bits(*ptr.toFloat64())
1830 if v == 0 {
1831 return b, nil
1832 }
1833 b = appendVarint(b, wiretag)
1834 b = appendFixed64(b, v)
1835 return b, nil
1836}
1837func appendFloat64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1838 p := *ptr.toFloat64Ptr()
1839 if p == nil {
1840 return b, nil
1841 }
1842 b = appendVarint(b, wiretag)
1843 b = appendFixed64(b, math.Float64bits(*p))
1844 return b, nil
1845}
1846func appendFloat64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1847 s := *ptr.toFloat64Slice()
1848 for _, v := range s {
1849 b = appendVarint(b, wiretag)
1850 b = appendFixed64(b, math.Float64bits(v))
1851 }
1852 return b, nil
1853}
1854func appendFloat64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1855 s := *ptr.toFloat64Slice()
1856 if len(s) == 0 {
1857 return b, nil
1858 }
1859 b = appendVarint(b, wiretag&^7|WireBytes)
1860 b = appendVarint(b, uint64(8*len(s)))
1861 for _, v := range s {
1862 b = appendFixed64(b, math.Float64bits(v))
1863 }
1864 return b, nil
1865}
1866func appendVarint32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1867 v := *ptr.toUint32()
1868 b = appendVarint(b, wiretag)
1869 b = appendVarint(b, uint64(v))
1870 return b, nil
1871}
1872func appendVarint32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1873 v := *ptr.toUint32()
1874 if v == 0 {
1875 return b, nil
1876 }
1877 b = appendVarint(b, wiretag)
1878 b = appendVarint(b, uint64(v))
1879 return b, nil
1880}
1881func appendVarint32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1882 p := *ptr.toUint32Ptr()
1883 if p == nil {
1884 return b, nil
1885 }
1886 b = appendVarint(b, wiretag)
1887 b = appendVarint(b, uint64(*p))
1888 return b, nil
1889}
1890func appendVarint32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1891 s := *ptr.toUint32Slice()
1892 for _, v := range s {
1893 b = appendVarint(b, wiretag)
1894 b = appendVarint(b, uint64(v))
1895 }
1896 return b, nil
1897}
1898func appendVarint32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1899 s := *ptr.toUint32Slice()
1900 if len(s) == 0 {
1901 return b, nil
1902 }
1903 b = appendVarint(b, wiretag&^7|WireBytes)
1904 // compute size
1905 n := 0
1906 for _, v := range s {
1907 n += SizeVarint(uint64(v))
1908 }
1909 b = appendVarint(b, uint64(n))
1910 for _, v := range s {
1911 b = appendVarint(b, uint64(v))
1912 }
1913 return b, nil
1914}
1915func appendVarintS32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1916 v := *ptr.toInt32()
1917 b = appendVarint(b, wiretag)
1918 b = appendVarint(b, uint64(v))
1919 return b, nil
1920}
1921func appendVarintS32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1922 v := *ptr.toInt32()
1923 if v == 0 {
1924 return b, nil
1925 }
1926 b = appendVarint(b, wiretag)
1927 b = appendVarint(b, uint64(v))
1928 return b, nil
1929}
1930func appendVarintS32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1931 p := ptr.getInt32Ptr()
1932 if p == nil {
1933 return b, nil
1934 }
1935 b = appendVarint(b, wiretag)
1936 b = appendVarint(b, uint64(*p))
1937 return b, nil
1938}
1939func appendVarintS32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1940 s := ptr.getInt32Slice()
1941 for _, v := range s {
1942 b = appendVarint(b, wiretag)
1943 b = appendVarint(b, uint64(v))
1944 }
1945 return b, nil
1946}
1947func appendVarintS32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1948 s := ptr.getInt32Slice()
1949 if len(s) == 0 {
1950 return b, nil
1951 }
1952 b = appendVarint(b, wiretag&^7|WireBytes)
1953 // compute size
1954 n := 0
1955 for _, v := range s {
1956 n += SizeVarint(uint64(v))
1957 }
1958 b = appendVarint(b, uint64(n))
1959 for _, v := range s {
1960 b = appendVarint(b, uint64(v))
1961 }
1962 return b, nil
1963}
1964func appendVarint64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1965 v := *ptr.toUint64()
1966 b = appendVarint(b, wiretag)
1967 b = appendVarint(b, v)
1968 return b, nil
1969}
1970func appendVarint64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1971 v := *ptr.toUint64()
1972 if v == 0 {
1973 return b, nil
1974 }
1975 b = appendVarint(b, wiretag)
1976 b = appendVarint(b, v)
1977 return b, nil
1978}
1979func appendVarint64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1980 p := *ptr.toUint64Ptr()
1981 if p == nil {
1982 return b, nil
1983 }
1984 b = appendVarint(b, wiretag)
1985 b = appendVarint(b, *p)
1986 return b, nil
1987}
1988func appendVarint64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1989 s := *ptr.toUint64Slice()
1990 for _, v := range s {
1991 b = appendVarint(b, wiretag)
1992 b = appendVarint(b, v)
1993 }
1994 return b, nil
1995}
1996func appendVarint64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1997 s := *ptr.toUint64Slice()
1998 if len(s) == 0 {
1999 return b, nil
2000 }
2001 b = appendVarint(b, wiretag&^7|WireBytes)
2002 // compute size
2003 n := 0
2004 for _, v := range s {
2005 n += SizeVarint(v)
2006 }
2007 b = appendVarint(b, uint64(n))
2008 for _, v := range s {
2009 b = appendVarint(b, v)
2010 }
2011 return b, nil
2012}
2013func appendVarintS64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2014 v := *ptr.toInt64()
2015 b = appendVarint(b, wiretag)
2016 b = appendVarint(b, uint64(v))
2017 return b, nil
2018}
2019func appendVarintS64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2020 v := *ptr.toInt64()
2021 if v == 0 {
2022 return b, nil
2023 }
2024 b = appendVarint(b, wiretag)
2025 b = appendVarint(b, uint64(v))
2026 return b, nil
2027}
2028func appendVarintS64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2029 p := *ptr.toInt64Ptr()
2030 if p == nil {
2031 return b, nil
2032 }
2033 b = appendVarint(b, wiretag)
2034 b = appendVarint(b, uint64(*p))
2035 return b, nil
2036}
2037func appendVarintS64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2038 s := *ptr.toInt64Slice()
2039 for _, v := range s {
2040 b = appendVarint(b, wiretag)
2041 b = appendVarint(b, uint64(v))
2042 }
2043 return b, nil
2044}
2045func appendVarintS64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2046 s := *ptr.toInt64Slice()
2047 if len(s) == 0 {
2048 return b, nil
2049 }
2050 b = appendVarint(b, wiretag&^7|WireBytes)
2051 // compute size
2052 n := 0
2053 for _, v := range s {
2054 n += SizeVarint(uint64(v))
2055 }
2056 b = appendVarint(b, uint64(n))
2057 for _, v := range s {
2058 b = appendVarint(b, uint64(v))
2059 }
2060 return b, nil
2061}
2062func appendZigzag32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2063 v := *ptr.toInt32()
2064 b = appendVarint(b, wiretag)
2065 b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
2066 return b, nil
2067}
2068func appendZigzag32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2069 v := *ptr.toInt32()
2070 if v == 0 {
2071 return b, nil
2072 }
2073 b = appendVarint(b, wiretag)
2074 b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
2075 return b, nil
2076}
2077func appendZigzag32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2078 p := ptr.getInt32Ptr()
2079 if p == nil {
2080 return b, nil
2081 }
2082 b = appendVarint(b, wiretag)
2083 v := *p
2084 b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
2085 return b, nil
2086}
2087func appendZigzag32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2088 s := ptr.getInt32Slice()
2089 for _, v := range s {
2090 b = appendVarint(b, wiretag)
2091 b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
2092 }
2093 return b, nil
2094}
2095func appendZigzag32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2096 s := ptr.getInt32Slice()
2097 if len(s) == 0 {
2098 return b, nil
2099 }
2100 b = appendVarint(b, wiretag&^7|WireBytes)
2101 // compute size
2102 n := 0
2103 for _, v := range s {
2104 n += SizeVarint(uint64((uint32(v) << 1) ^ uint32((int32(v) >> 31))))
2105 }
2106 b = appendVarint(b, uint64(n))
2107 for _, v := range s {
2108 b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
2109 }
2110 return b, nil
2111}
2112func appendZigzag64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2113 v := *ptr.toInt64()
2114 b = appendVarint(b, wiretag)
2115 b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
2116 return b, nil
2117}
2118func appendZigzag64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2119 v := *ptr.toInt64()
2120 if v == 0 {
2121 return b, nil
2122 }
2123 b = appendVarint(b, wiretag)
2124 b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
2125 return b, nil
2126}
2127func appendZigzag64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2128 p := *ptr.toInt64Ptr()
2129 if p == nil {
2130 return b, nil
2131 }
2132 b = appendVarint(b, wiretag)
2133 v := *p
2134 b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
2135 return b, nil
2136}
2137func appendZigzag64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2138 s := *ptr.toInt64Slice()
2139 for _, v := range s {
2140 b = appendVarint(b, wiretag)
2141 b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
2142 }
2143 return b, nil
2144}
2145func appendZigzag64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2146 s := *ptr.toInt64Slice()
2147 if len(s) == 0 {
2148 return b, nil
2149 }
2150 b = appendVarint(b, wiretag&^7|WireBytes)
2151 // compute size
2152 n := 0
2153 for _, v := range s {
2154 n += SizeVarint(uint64(v<<1) ^ uint64((int64(v) >> 63)))
2155 }
2156 b = appendVarint(b, uint64(n))
2157 for _, v := range s {
2158 b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
2159 }
2160 return b, nil
2161}
2162func appendBoolValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2163 v := *ptr.toBool()
2164 b = appendVarint(b, wiretag)
2165 if v {
2166 b = append(b, 1)
2167 } else {
2168 b = append(b, 0)
2169 }
2170 return b, nil
2171}
2172func appendBoolValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2173 v := *ptr.toBool()
2174 if !v {
2175 return b, nil
2176 }
2177 b = appendVarint(b, wiretag)
2178 b = append(b, 1)
2179 return b, nil
2180}
2181
2182func appendBoolPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2183 p := *ptr.toBoolPtr()
2184 if p == nil {
2185 return b, nil
2186 }
2187 b = appendVarint(b, wiretag)
2188 if *p {
2189 b = append(b, 1)
2190 } else {
2191 b = append(b, 0)
2192 }
2193 return b, nil
2194}
2195func appendBoolSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2196 s := *ptr.toBoolSlice()
2197 for _, v := range s {
2198 b = appendVarint(b, wiretag)
2199 if v {
2200 b = append(b, 1)
2201 } else {
2202 b = append(b, 0)
2203 }
2204 }
2205 return b, nil
2206}
2207func appendBoolPackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2208 s := *ptr.toBoolSlice()
2209 if len(s) == 0 {
2210 return b, nil
2211 }
2212 b = appendVarint(b, wiretag&^7|WireBytes)
2213 b = appendVarint(b, uint64(len(s)))
2214 for _, v := range s {
2215 if v {
2216 b = append(b, 1)
2217 } else {
2218 b = append(b, 0)
2219 }
2220 }
2221 return b, nil
2222}
2223func appendStringValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2224 v := *ptr.toString()
2225 b = appendVarint(b, wiretag)
2226 b = appendVarint(b, uint64(len(v)))
2227 b = append(b, v...)
2228 return b, nil
2229}
2230func appendStringValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2231 v := *ptr.toString()
2232 if v == "" {
2233 return b, nil
2234 }
2235 b = appendVarint(b, wiretag)
2236 b = appendVarint(b, uint64(len(v)))
2237 b = append(b, v...)
2238 return b, nil
2239}
2240func appendStringPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2241 p := *ptr.toStringPtr()
2242 if p == nil {
2243 return b, nil
2244 }
2245 v := *p
2246 b = appendVarint(b, wiretag)
2247 b = appendVarint(b, uint64(len(v)))
2248 b = append(b, v...)
2249 return b, nil
2250}
2251func appendStringSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2252 s := *ptr.toStringSlice()
2253 for _, v := range s {
2254 b = appendVarint(b, wiretag)
2255 b = appendVarint(b, uint64(len(v)))
2256 b = append(b, v...)
2257 }
2258 return b, nil
2259}
2260func appendUTF8StringValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2261 var invalidUTF8 bool
2262 v := *ptr.toString()
2263 if !utf8.ValidString(v) {
2264 invalidUTF8 = true
2265 }
2266 b = appendVarint(b, wiretag)
2267 b = appendVarint(b, uint64(len(v)))
2268 b = append(b, v...)
2269 if invalidUTF8 {
2270 return b, errInvalidUTF8
2271 }
2272 return b, nil
2273}
2274func appendUTF8StringValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2275 var invalidUTF8 bool
2276 v := *ptr.toString()
2277 if v == "" {
2278 return b, nil
2279 }
2280 if !utf8.ValidString(v) {
2281 invalidUTF8 = true
2282 }
2283 b = appendVarint(b, wiretag)
2284 b = appendVarint(b, uint64(len(v)))
2285 b = append(b, v...)
2286 if invalidUTF8 {
2287 return b, errInvalidUTF8
2288 }
2289 return b, nil
2290}
2291func appendUTF8StringPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2292 var invalidUTF8 bool
2293 p := *ptr.toStringPtr()
2294 if p == nil {
2295 return b, nil
2296 }
2297 v := *p
2298 if !utf8.ValidString(v) {
2299 invalidUTF8 = true
2300 }
2301 b = appendVarint(b, wiretag)
2302 b = appendVarint(b, uint64(len(v)))
2303 b = append(b, v...)
2304 if invalidUTF8 {
2305 return b, errInvalidUTF8
2306 }
2307 return b, nil
2308}
2309func appendUTF8StringSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2310 var invalidUTF8 bool
2311 s := *ptr.toStringSlice()
2312 for _, v := range s {
2313 if !utf8.ValidString(v) {
2314 invalidUTF8 = true
2315 }
2316 b = appendVarint(b, wiretag)
2317 b = appendVarint(b, uint64(len(v)))
2318 b = append(b, v...)
2319 }
2320 if invalidUTF8 {
2321 return b, errInvalidUTF8
2322 }
2323 return b, nil
2324}
2325func appendBytes(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2326 v := *ptr.toBytes()
2327 if v == nil {
2328 return b, nil
2329 }
2330 b = appendVarint(b, wiretag)
2331 b = appendVarint(b, uint64(len(v)))
2332 b = append(b, v...)
2333 return b, nil
2334}
2335func appendBytes3(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2336 v := *ptr.toBytes()
2337 if len(v) == 0 {
2338 return b, nil
2339 }
2340 b = appendVarint(b, wiretag)
2341 b = appendVarint(b, uint64(len(v)))
2342 b = append(b, v...)
2343 return b, nil
2344}
2345func appendBytesOneof(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2346 v := *ptr.toBytes()
2347 b = appendVarint(b, wiretag)
2348 b = appendVarint(b, uint64(len(v)))
2349 b = append(b, v...)
2350 return b, nil
2351}
2352func appendBytesSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2353 s := *ptr.toBytesSlice()
2354 for _, v := range s {
2355 b = appendVarint(b, wiretag)
2356 b = appendVarint(b, uint64(len(v)))
2357 b = append(b, v...)
2358 }
2359 return b, nil
2360}
2361
2362// makeGroupMarshaler returns the sizer and marshaler for a group.
2363// u is the marshal info of the underlying message.
2364func makeGroupMarshaler(u *marshalInfo) (sizer, marshaler) {
2365 return func(ptr pointer, tagsize int) int {
2366 p := ptr.getPointer()
2367 if p.isNil() {
2368 return 0
2369 }
2370 return u.size(p) + 2*tagsize
2371 },
2372 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
2373 p := ptr.getPointer()
2374 if p.isNil() {
2375 return b, nil
2376 }
2377 var err error
2378 b = appendVarint(b, wiretag) // start group
2379 b, err = u.marshal(b, p, deterministic)
2380 b = appendVarint(b, wiretag+(WireEndGroup-WireStartGroup)) // end group
2381 return b, err
2382 }
2383}
2384
2385// makeGroupSliceMarshaler returns the sizer and marshaler for a group slice.
2386// u is the marshal info of the underlying message.
2387func makeGroupSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
2388 return func(ptr pointer, tagsize int) int {
2389 s := ptr.getPointerSlice()
2390 n := 0
2391 for _, v := range s {
2392 if v.isNil() {
2393 continue
2394 }
2395 n += u.size(v) + 2*tagsize
2396 }
2397 return n
2398 },
2399 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
2400 s := ptr.getPointerSlice()
2401 var err error
2402 var nerr nonFatal
2403 for _, v := range s {
2404 if v.isNil() {
2405 return b, errRepeatedHasNil
2406 }
2407 b = appendVarint(b, wiretag) // start group
2408 b, err = u.marshal(b, v, deterministic)
2409 b = appendVarint(b, wiretag+(WireEndGroup-WireStartGroup)) // end group
2410 if !nerr.Merge(err) {
2411 if err == ErrNil {
2412 err = errRepeatedHasNil
2413 }
2414 return b, err
2415 }
2416 }
2417 return b, nerr.E
2418 }
2419}
2420
2421// makeMessageMarshaler returns the sizer and marshaler for a message field.
2422// u is the marshal info of the message.
2423func makeMessageMarshaler(u *marshalInfo) (sizer, marshaler) {
2424 return func(ptr pointer, tagsize int) int {
2425 p := ptr.getPointer()
2426 if p.isNil() {
2427 return 0
2428 }
2429 siz := u.size(p)
2430 return siz + SizeVarint(uint64(siz)) + tagsize
2431 },
2432 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
2433 p := ptr.getPointer()
2434 if p.isNil() {
2435 return b, nil
2436 }
2437 b = appendVarint(b, wiretag)
2438 siz := u.cachedsize(p)
2439 b = appendVarint(b, uint64(siz))
2440 return u.marshal(b, p, deterministic)
2441 }
2442}
2443
2444// makeMessageSliceMarshaler returns the sizer and marshaler for a message slice.
2445// u is the marshal info of the message.
2446func makeMessageSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
2447 return func(ptr pointer, tagsize int) int {
2448 s := ptr.getPointerSlice()
2449 n := 0
2450 for _, v := range s {
2451 if v.isNil() {
2452 continue
2453 }
2454 siz := u.size(v)
2455 n += siz + SizeVarint(uint64(siz)) + tagsize
2456 }
2457 return n
2458 },
2459 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
2460 s := ptr.getPointerSlice()
2461 var err error
2462 var nerr nonFatal
2463 for _, v := range s {
2464 if v.isNil() {
2465 return b, errRepeatedHasNil
2466 }
2467 b = appendVarint(b, wiretag)
2468 siz := u.cachedsize(v)
2469 b = appendVarint(b, uint64(siz))
2470 b, err = u.marshal(b, v, deterministic)
2471
2472 if !nerr.Merge(err) {
2473 if err == ErrNil {
2474 err = errRepeatedHasNil
2475 }
2476 return b, err
2477 }
2478 }
2479 return b, nerr.E
2480 }
2481}
2482
2483// makeMapMarshaler returns the sizer and marshaler for a map field.
2484// f is the pointer to the reflect data structure of the field.
2485func makeMapMarshaler(f *reflect.StructField) (sizer, marshaler) {
2486 // figure out key and value type
2487 t := f.Type
2488 keyType := t.Key()
2489 valType := t.Elem()
2490 tags := strings.Split(f.Tag.Get("protobuf"), ",")
2491 keyTags := strings.Split(f.Tag.Get("protobuf_key"), ",")
2492 valTags := strings.Split(f.Tag.Get("protobuf_val"), ",")
2493 stdOptions := false
2494 for _, t := range tags {
2495 if strings.HasPrefix(t, "customtype=") {
2496 valTags = append(valTags, t)
2497 }
2498 if t == "stdtime" {
2499 valTags = append(valTags, t)
2500 stdOptions = true
2501 }
2502 if t == "stdduration" {
2503 valTags = append(valTags, t)
2504 stdOptions = true
2505 }
2506 if t == "wktptr" {
2507 valTags = append(valTags, t)
2508 }
2509 }
2510 keySizer, keyMarshaler := typeMarshaler(keyType, keyTags, false, false) // don't omit zero value in map
2511 valSizer, valMarshaler := typeMarshaler(valType, valTags, false, false) // don't omit zero value in map
2512 keyWireTag := 1<<3 | wiretype(keyTags[0])
2513 valWireTag := 2<<3 | wiretype(valTags[0])
2514
2515 // We create an interface to get the addresses of the map key and value.
2516 // If value is pointer-typed, the interface is a direct interface, the
2517 // idata itself is the value. Otherwise, the idata is the pointer to the
2518 // value.
2519 // Key cannot be pointer-typed.
2520 valIsPtr := valType.Kind() == reflect.Ptr
2521
2522 // If value is a message with nested maps, calling
2523 // valSizer in marshal may be quadratic. We should use
2524 // cached version in marshal (but not in size).
2525 // If value is not message type, we don't have size cache,
2526 // but it cannot be nested either. Just use valSizer.
2527 valCachedSizer := valSizer
2528 if valIsPtr && !stdOptions && valType.Elem().Kind() == reflect.Struct {
2529 u := getMarshalInfo(valType.Elem())
2530 valCachedSizer = func(ptr pointer, tagsize int) int {
2531 // Same as message sizer, but use cache.
2532 p := ptr.getPointer()
2533 if p.isNil() {
2534 return 0
2535 }
2536 siz := u.cachedsize(p)
2537 return siz + SizeVarint(uint64(siz)) + tagsize
2538 }
2539 }
2540 return func(ptr pointer, tagsize int) int {
2541 m := ptr.asPointerTo(t).Elem() // the map
2542 n := 0
2543 for _, k := range m.MapKeys() {
2544 ki := k.Interface()
2545 vi := m.MapIndex(k).Interface()
2546 kaddr := toAddrPointer(&ki, false) // pointer to key
2547 vaddr := toAddrPointer(&vi, valIsPtr) // pointer to value
2548 siz := keySizer(kaddr, 1) + valSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1)
2549 n += siz + SizeVarint(uint64(siz)) + tagsize
2550 }
2551 return n
2552 },
2553 func(b []byte, ptr pointer, tag uint64, deterministic bool) ([]byte, error) {
2554 m := ptr.asPointerTo(t).Elem() // the map
2555 var err error
2556 keys := m.MapKeys()
2557 if len(keys) > 1 && deterministic {
2558 sort.Sort(mapKeys(keys))
2559 }
2560
2561 var nerr nonFatal
2562 for _, k := range keys {
2563 ki := k.Interface()
2564 vi := m.MapIndex(k).Interface()
2565 kaddr := toAddrPointer(&ki, false) // pointer to key
2566 vaddr := toAddrPointer(&vi, valIsPtr) // pointer to value
2567 b = appendVarint(b, tag)
2568 siz := keySizer(kaddr, 1) + valCachedSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1)
2569 b = appendVarint(b, uint64(siz))
2570 b, err = keyMarshaler(b, kaddr, keyWireTag, deterministic)
2571 if !nerr.Merge(err) {
2572 return b, err
2573 }
2574 b, err = valMarshaler(b, vaddr, valWireTag, deterministic)
2575 if err != ErrNil && !nerr.Merge(err) { // allow nil value in map
2576 return b, err
2577 }
2578 }
2579 return b, nerr.E
2580 }
2581}
2582
2583// makeOneOfMarshaler returns the sizer and marshaler for a oneof field.
2584// fi is the marshal info of the field.
2585// f is the pointer to the reflect data structure of the field.
2586func makeOneOfMarshaler(fi *marshalFieldInfo, f *reflect.StructField) (sizer, marshaler) {
2587 // Oneof field is an interface. We need to get the actual data type on the fly.
2588 t := f.Type
2589 return func(ptr pointer, _ int) int {
2590 p := ptr.getInterfacePointer()
2591 if p.isNil() {
2592 return 0
2593 }
2594 v := ptr.asPointerTo(t).Elem().Elem().Elem() // *interface -> interface -> *struct -> struct
2595 telem := v.Type()
2596 e := fi.oneofElems[telem]
2597 return e.sizer(p, e.tagsize)
2598 },
2599 func(b []byte, ptr pointer, _ uint64, deterministic bool) ([]byte, error) {
2600 p := ptr.getInterfacePointer()
2601 if p.isNil() {
2602 return b, nil
2603 }
2604 v := ptr.asPointerTo(t).Elem().Elem().Elem() // *interface -> interface -> *struct -> struct
2605 telem := v.Type()
2606 if telem.Field(0).Type.Kind() == reflect.Ptr && p.getPointer().isNil() {
2607 return b, errOneofHasNil
2608 }
2609 e := fi.oneofElems[telem]
2610 return e.marshaler(b, p, e.wiretag, deterministic)
2611 }
2612}
2613
2614// sizeExtensions computes the size of encoded data for a XXX_InternalExtensions field.
2615func (u *marshalInfo) sizeExtensions(ext *XXX_InternalExtensions) int {
2616 m, mu := ext.extensionsRead()
2617 if m == nil {
2618 return 0
2619 }
2620 mu.Lock()
2621
2622 n := 0
2623 for _, e := range m {
2624 if e.value == nil || e.desc == nil {
2625 // Extension is only in its encoded form.
2626 n += len(e.enc)
2627 continue
2628 }
2629
2630 // We don't skip extensions that have an encoded form set,
2631 // because the extension value may have been mutated after
2632 // the last time this function was called.
2633 ei := u.getExtElemInfo(e.desc)
2634 v := e.value
2635 p := toAddrPointer(&v, ei.isptr)
2636 n += ei.sizer(p, ei.tagsize)
2637 }
2638 mu.Unlock()
2639 return n
2640}
2641
2642// appendExtensions marshals a XXX_InternalExtensions field to the end of byte slice b.
2643func (u *marshalInfo) appendExtensions(b []byte, ext *XXX_InternalExtensions, deterministic bool) ([]byte, error) {
2644 m, mu := ext.extensionsRead()
2645 if m == nil {
2646 return b, nil
2647 }
2648 mu.Lock()
2649 defer mu.Unlock()
2650
2651 var err error
2652 var nerr nonFatal
2653
2654 // Fast-path for common cases: zero or one extensions.
2655 // Don't bother sorting the keys.
2656 if len(m) <= 1 {
2657 for _, e := range m {
2658 if e.value == nil || e.desc == nil {
2659 // Extension is only in its encoded form.
2660 b = append(b, e.enc...)
2661 continue
2662 }
2663
2664 // We don't skip extensions that have an encoded form set,
2665 // because the extension value may have been mutated after
2666 // the last time this function was called.
2667
2668 ei := u.getExtElemInfo(e.desc)
2669 v := e.value
2670 p := toAddrPointer(&v, ei.isptr)
2671 b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
2672 if !nerr.Merge(err) {
2673 return b, err
2674 }
2675 }
2676 return b, nerr.E
2677 }
2678
2679 // Sort the keys to provide a deterministic encoding.
2680 // Not sure this is required, but the old code does it.
2681 keys := make([]int, 0, len(m))
2682 for k := range m {
2683 keys = append(keys, int(k))
2684 }
2685 sort.Ints(keys)
2686
2687 for _, k := range keys {
2688 e := m[int32(k)]
2689 if e.value == nil || e.desc == nil {
2690 // Extension is only in its encoded form.
2691 b = append(b, e.enc...)
2692 continue
2693 }
2694
2695 // We don't skip extensions that have an encoded form set,
2696 // because the extension value may have been mutated after
2697 // the last time this function was called.
2698
2699 ei := u.getExtElemInfo(e.desc)
2700 v := e.value
2701 p := toAddrPointer(&v, ei.isptr)
2702 b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
2703 if !nerr.Merge(err) {
2704 return b, err
2705 }
2706 }
2707 return b, nerr.E
2708}
2709
2710// message set format is:
2711// message MessageSet {
2712// repeated group Item = 1 {
2713// required int32 type_id = 2;
2714// required string message = 3;
2715// };
2716// }
2717
2718// sizeMessageSet computes the size of encoded data for a XXX_InternalExtensions field
2719// in message set format (above).
2720func (u *marshalInfo) sizeMessageSet(ext *XXX_InternalExtensions) int {
2721 m, mu := ext.extensionsRead()
2722 if m == nil {
2723 return 0
2724 }
2725 mu.Lock()
2726
2727 n := 0
2728 for id, e := range m {
2729 n += 2 // start group, end group. tag = 1 (size=1)
2730 n += SizeVarint(uint64(id)) + 1 // type_id, tag = 2 (size=1)
2731
2732 if e.value == nil || e.desc == nil {
2733 // Extension is only in its encoded form.
2734 msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint
2735 siz := len(msgWithLen)
2736 n += siz + 1 // message, tag = 3 (size=1)
2737 continue
2738 }
2739
2740 // We don't skip extensions that have an encoded form set,
2741 // because the extension value may have been mutated after
2742 // the last time this function was called.
2743
2744 ei := u.getExtElemInfo(e.desc)
2745 v := e.value
2746 p := toAddrPointer(&v, ei.isptr)
2747 n += ei.sizer(p, 1) // message, tag = 3 (size=1)
2748 }
2749 mu.Unlock()
2750 return n
2751}
2752
2753// appendMessageSet marshals a XXX_InternalExtensions field in message set format (above)
2754// to the end of byte slice b.
2755func (u *marshalInfo) appendMessageSet(b []byte, ext *XXX_InternalExtensions, deterministic bool) ([]byte, error) {
2756 m, mu := ext.extensionsRead()
2757 if m == nil {
2758 return b, nil
2759 }
2760 mu.Lock()
2761 defer mu.Unlock()
2762
2763 var err error
2764 var nerr nonFatal
2765
2766 // Fast-path for common cases: zero or one extensions.
2767 // Don't bother sorting the keys.
2768 if len(m) <= 1 {
2769 for id, e := range m {
2770 b = append(b, 1<<3|WireStartGroup)
2771 b = append(b, 2<<3|WireVarint)
2772 b = appendVarint(b, uint64(id))
2773
2774 if e.value == nil || e.desc == nil {
2775 // Extension is only in its encoded form.
2776 msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint
2777 b = append(b, 3<<3|WireBytes)
2778 b = append(b, msgWithLen...)
2779 b = append(b, 1<<3|WireEndGroup)
2780 continue
2781 }
2782
2783 // We don't skip extensions that have an encoded form set,
2784 // because the extension value may have been mutated after
2785 // the last time this function was called.
2786
2787 ei := u.getExtElemInfo(e.desc)
2788 v := e.value
2789 p := toAddrPointer(&v, ei.isptr)
2790 b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic)
2791 if !nerr.Merge(err) {
2792 return b, err
2793 }
2794 b = append(b, 1<<3|WireEndGroup)
2795 }
2796 return b, nerr.E
2797 }
2798
2799 // Sort the keys to provide a deterministic encoding.
2800 keys := make([]int, 0, len(m))
2801 for k := range m {
2802 keys = append(keys, int(k))
2803 }
2804 sort.Ints(keys)
2805
2806 for _, id := range keys {
2807 e := m[int32(id)]
2808 b = append(b, 1<<3|WireStartGroup)
2809 b = append(b, 2<<3|WireVarint)
2810 b = appendVarint(b, uint64(id))
2811
2812 if e.value == nil || e.desc == nil {
2813 // Extension is only in its encoded form.
2814 msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint
2815 b = append(b, 3<<3|WireBytes)
2816 b = append(b, msgWithLen...)
2817 b = append(b, 1<<3|WireEndGroup)
2818 continue
2819 }
2820
2821 // We don't skip extensions that have an encoded form set,
2822 // because the extension value may have been mutated after
2823 // the last time this function was called.
2824
2825 ei := u.getExtElemInfo(e.desc)
2826 v := e.value
2827 p := toAddrPointer(&v, ei.isptr)
2828 b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic)
2829 b = append(b, 1<<3|WireEndGroup)
2830 if !nerr.Merge(err) {
2831 return b, err
2832 }
2833 }
2834 return b, nerr.E
2835}
2836
2837// sizeV1Extensions computes the size of encoded data for a V1-API extension field.
2838func (u *marshalInfo) sizeV1Extensions(m map[int32]Extension) int {
2839 if m == nil {
2840 return 0
2841 }
2842
2843 n := 0
2844 for _, e := range m {
2845 if e.value == nil || e.desc == nil {
2846 // Extension is only in its encoded form.
2847 n += len(e.enc)
2848 continue
2849 }
2850
2851 // We don't skip extensions that have an encoded form set,
2852 // because the extension value may have been mutated after
2853 // the last time this function was called.
2854
2855 ei := u.getExtElemInfo(e.desc)
2856 v := e.value
2857 p := toAddrPointer(&v, ei.isptr)
2858 n += ei.sizer(p, ei.tagsize)
2859 }
2860 return n
2861}
2862
2863// appendV1Extensions marshals a V1-API extension field to the end of byte slice b.
2864func (u *marshalInfo) appendV1Extensions(b []byte, m map[int32]Extension, deterministic bool) ([]byte, error) {
2865 if m == nil {
2866 return b, nil
2867 }
2868
2869 // Sort the keys to provide a deterministic encoding.
2870 keys := make([]int, 0, len(m))
2871 for k := range m {
2872 keys = append(keys, int(k))
2873 }
2874 sort.Ints(keys)
2875
2876 var err error
2877 var nerr nonFatal
2878 for _, k := range keys {
2879 e := m[int32(k)]
2880 if e.value == nil || e.desc == nil {
2881 // Extension is only in its encoded form.
2882 b = append(b, e.enc...)
2883 continue
2884 }
2885
2886 // We don't skip extensions that have an encoded form set,
2887 // because the extension value may have been mutated after
2888 // the last time this function was called.
2889
2890 ei := u.getExtElemInfo(e.desc)
2891 v := e.value
2892 p := toAddrPointer(&v, ei.isptr)
2893 b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
2894 if !nerr.Merge(err) {
2895 return b, err
2896 }
2897 }
2898 return b, nerr.E
2899}
2900
2901// newMarshaler is the interface representing objects that can marshal themselves.
2902//
2903// This exists to support protoc-gen-go generated messages.
2904// The proto package will stop type-asserting to this interface in the future.
2905//
2906// DO NOT DEPEND ON THIS.
2907type newMarshaler interface {
2908 XXX_Size() int
2909 XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
2910}
2911
2912// Size returns the encoded size of a protocol buffer message.
2913// This is the main entry point.
2914func Size(pb Message) int {
2915 if m, ok := pb.(newMarshaler); ok {
2916 return m.XXX_Size()
2917 }
2918 if m, ok := pb.(Marshaler); ok {
2919 // If the message can marshal itself, let it do it, for compatibility.
2920 // NOTE: This is not efficient.
2921 b, _ := m.Marshal()
2922 return len(b)
2923 }
2924 // in case somehow we didn't generate the wrapper
2925 if pb == nil {
2926 return 0
2927 }
2928 var info InternalMessageInfo
2929 return info.Size(pb)
2930}
2931
2932// Marshal takes a protocol buffer message
2933// and encodes it into the wire format, returning the data.
2934// This is the main entry point.
2935func Marshal(pb Message) ([]byte, error) {
2936 if m, ok := pb.(newMarshaler); ok {
2937 siz := m.XXX_Size()
2938 b := make([]byte, 0, siz)
2939 return m.XXX_Marshal(b, false)
2940 }
2941 if m, ok := pb.(Marshaler); ok {
2942 // If the message can marshal itself, let it do it, for compatibility.
2943 // NOTE: This is not efficient.
2944 return m.Marshal()
2945 }
2946 // in case somehow we didn't generate the wrapper
2947 if pb == nil {
2948 return nil, ErrNil
2949 }
2950 var info InternalMessageInfo
2951 siz := info.Size(pb)
2952 b := make([]byte, 0, siz)
2953 return info.Marshal(b, pb, false)
2954}
2955
2956// Marshal takes a protocol buffer message
2957// and encodes it into the wire format, writing the result to the
2958// Buffer.
2959// This is an alternative entry point. It is not necessary to use
2960// a Buffer for most applications.
2961func (p *Buffer) Marshal(pb Message) error {
2962 var err error
2963 if p.deterministic {
2964 if _, ok := pb.(Marshaler); ok {
2965 return fmt.Errorf("proto: deterministic not supported by the Marshal method of %T", pb)
2966 }
2967 }
2968 if m, ok := pb.(newMarshaler); ok {
2969 siz := m.XXX_Size()
2970 p.grow(siz) // make sure buf has enough capacity
2971 p.buf, err = m.XXX_Marshal(p.buf, p.deterministic)
2972 return err
2973 }
2974 if m, ok := pb.(Marshaler); ok {
2975 // If the message can marshal itself, let it do it, for compatibility.
2976 // NOTE: This is not efficient.
2977 var b []byte
2978 b, err = m.Marshal()
2979 p.buf = append(p.buf, b...)
2980 return err
2981 }
2982 // in case somehow we didn't generate the wrapper
2983 if pb == nil {
2984 return ErrNil
2985 }
2986 var info InternalMessageInfo
2987 siz := info.Size(pb)
2988 p.grow(siz) // make sure buf has enough capacity
2989 p.buf, err = info.Marshal(p.buf, pb, p.deterministic)
2990 return err
2991}
2992
2993// grow grows the buffer's capacity, if necessary, to guarantee space for
2994// another n bytes. After grow(n), at least n bytes can be written to the
2995// buffer without another allocation.
2996func (p *Buffer) grow(n int) {
2997 need := len(p.buf) + n
2998 if need <= cap(p.buf) {
2999 return
3000 }
3001 newCap := len(p.buf) * 2
3002 if newCap < need {
3003 newCap = need
3004 }
3005 p.buf = append(make([]byte, 0, newCap), p.buf...)
3006}