podman

1
// 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

32
package proto
33

34
import (
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.
49
type 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).
53
type marshaler func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error)
54

55
// marshalInfo is the information used for marshaling a message.
56
type 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.
76
type 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.
89
type 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

97
var (
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).
107
func 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.
122
func (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.
138
func (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

150
func 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.
170
func (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.
232
func (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.
243
func (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.
327
func (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 isOneofMessage {
393
		switch m := reflect.Zero(reflect.PtrTo(t)).Interface().(type) {
394
		case oneofFuncsIface:
395
			_, _, _, oneofImplementers = m.XXX_OneofFuncs()
396
		case oneofWrappersIface:
397
			oneofImplementers = m.XXX_OneofWrappers()
398
		}
399
	}
400

401
	// normal fields
402
	fields := make([]marshalFieldInfo, n) // batch allocation
403
	u.fields = make([]*marshalFieldInfo, 0, n)
404
	for i, j := 0, 0; i < t.NumField(); i++ {
405
		f := t.Field(i)
406

407
		if strings.HasPrefix(f.Name, "XXX_") {
408
			continue
409
		}
410
		field := &fields[j]
411
		j++
412
		field.name = f.Name
413
		u.fields = append(u.fields, field)
414
		if f.Tag.Get("protobuf_oneof") != "" {
415
			field.computeOneofFieldInfo(&f, oneofImplementers)
416
			continue
417
		}
418
		if f.Tag.Get("protobuf") == "" {
419
			// field has no tag (not in generated message), ignore it
420
			u.fields = u.fields[:len(u.fields)-1]
421
			j--
422
			continue
423
		}
424
		field.computeMarshalFieldInfo(&f)
425
	}
426

427
	// fields are marshaled in tag order on the wire.
428
	sort.Sort(byTag(u.fields))
429

430
	atomic.StoreInt32(&u.initialized, 1)
431
}
432

433
// helper for sorting fields by tag
434
type byTag []*marshalFieldInfo
435

436
func (a byTag) Len() int           { return len(a) }
437
func (a byTag) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
438
func (a byTag) Less(i, j int) bool { return a[i].wiretag < a[j].wiretag }
439

440
// getExtElemInfo returns the information to marshal an extension element.
441
// The info it returns is initialized.
442
func (u *marshalInfo) getExtElemInfo(desc *ExtensionDesc) *marshalElemInfo {
443
	// get from cache first
444
	u.RLock()
445
	e, ok := u.extElems[desc.Field]
446
	u.RUnlock()
447
	if ok {
448
		return e
449
	}
450

451
	t := reflect.TypeOf(desc.ExtensionType) // pointer or slice to basic type or struct
452
	tags := strings.Split(desc.Tag, ",")
453
	tag, err := strconv.Atoi(tags[1])
454
	if err != nil {
455
		panic("tag is not an integer")
456
	}
457
	wt := wiretype(tags[0])
458
	sizr, marshalr := typeMarshaler(t, tags, false, false)
459
	e = &marshalElemInfo{
460
		wiretag:   uint64(tag)<<3 | wt,
461
		tagsize:   SizeVarint(uint64(tag) << 3),
462
		sizer:     sizr,
463
		marshaler: marshalr,
464
		isptr:     t.Kind() == reflect.Ptr,
465
	}
466

467
	// update cache
468
	u.Lock()
469
	if u.extElems == nil {
470
		u.extElems = make(map[int32]*marshalElemInfo)
471
	}
472
	u.extElems[desc.Field] = e
473
	u.Unlock()
474
	return e
475
}
476

477
// computeMarshalFieldInfo fills up the information to marshal a field.
478
func (fi *marshalFieldInfo) computeMarshalFieldInfo(f *reflect.StructField) {
479
	// parse protobuf tag of the field.
480
	// tag has format of "bytes,49,opt,name=foo,def=hello!"
481
	tags := strings.Split(f.Tag.Get("protobuf"), ",")
482
	if tags[0] == "" {
483
		return
484
	}
485
	tag, err := strconv.Atoi(tags[1])
486
	if err != nil {
487
		panic("tag is not an integer")
488
	}
489
	wt := wiretype(tags[0])
490
	if tags[2] == "req" {
491
		fi.required = true
492
	}
493
	fi.setTag(f, tag, wt)
494
	fi.setMarshaler(f, tags)
495
}
496

497
func (fi *marshalFieldInfo) computeOneofFieldInfo(f *reflect.StructField, oneofImplementers []interface{}) {
498
	fi.field = toField(f)
499
	fi.wiretag = math.MaxInt32 // Use a large tag number, make oneofs sorted at the end. This tag will not appear on the wire.
500
	fi.isPointer = true
501
	fi.sizer, fi.marshaler = makeOneOfMarshaler(fi, f)
502
	fi.oneofElems = make(map[reflect.Type]*marshalElemInfo)
503

504
	ityp := f.Type // interface type
505
	for _, o := range oneofImplementers {
506
		t := reflect.TypeOf(o)
507
		if !t.Implements(ityp) {
508
			continue
509
		}
510
		sf := t.Elem().Field(0) // oneof implementer is a struct with a single field
511
		tags := strings.Split(sf.Tag.Get("protobuf"), ",")
512
		tag, err := strconv.Atoi(tags[1])
513
		if err != nil {
514
			panic("tag is not an integer")
515
		}
516
		wt := wiretype(tags[0])
517
		sizr, marshalr := typeMarshaler(sf.Type, tags, false, true) // oneof should not omit any zero value
518
		fi.oneofElems[t.Elem()] = &marshalElemInfo{
519
			wiretag:   uint64(tag)<<3 | wt,
520
			tagsize:   SizeVarint(uint64(tag) << 3),
521
			sizer:     sizr,
522
			marshaler: marshalr,
523
		}
524
	}
525
}
526

527
// wiretype returns the wire encoding of the type.
528
func wiretype(encoding string) uint64 {
529
	switch encoding {
530
	case "fixed32":
531
		return WireFixed32
532
	case "fixed64":
533
		return WireFixed64
534
	case "varint", "zigzag32", "zigzag64":
535
		return WireVarint
536
	case "bytes":
537
		return WireBytes
538
	case "group":
539
		return WireStartGroup
540
	}
541
	panic("unknown wire type " + encoding)
542
}
543

544
// setTag fills up the tag (in wire format) and its size in the info of a field.
545
func (fi *marshalFieldInfo) setTag(f *reflect.StructField, tag int, wt uint64) {
546
	fi.field = toField(f)
547
	fi.wiretag = uint64(tag)<<3 | wt
548
	fi.tagsize = SizeVarint(uint64(tag) << 3)
549
}
550

551
// setMarshaler fills up the sizer and marshaler in the info of a field.
552
func (fi *marshalFieldInfo) setMarshaler(f *reflect.StructField, tags []string) {
553
	switch f.Type.Kind() {
554
	case reflect.Map:
555
		// map field
556
		fi.isPointer = true
557
		fi.sizer, fi.marshaler = makeMapMarshaler(f)
558
		return
559
	case reflect.Ptr, reflect.Slice:
560
		fi.isPointer = true
561
	}
562
	fi.sizer, fi.marshaler = typeMarshaler(f.Type, tags, true, false)
563
}
564

565
// typeMarshaler returns the sizer and marshaler of a given field.
566
// t is the type of the field.
567
// tags is the generated "protobuf" tag of the field.
568
// If nozero is true, zero value is not marshaled to the wire.
569
// If oneof is true, it is a oneof field.
570
func typeMarshaler(t reflect.Type, tags []string, nozero, oneof bool) (sizer, marshaler) {
571
	encoding := tags[0]
572

573
	pointer := false
574
	slice := false
575
	if t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 {
576
		slice = true
577
		t = t.Elem()
578
	}
579
	if t.Kind() == reflect.Ptr {
580
		pointer = true
581
		t = t.Elem()
582
	}
583

584
	packed := false
585
	proto3 := false
586
	ctype := false
587
	isTime := false
588
	isDuration := false
589
	isWktPointer := false
590
	validateUTF8 := true
591
	for i := 2; i < len(tags); i++ {
592
		if tags[i] == "packed" {
593
			packed = true
594
		}
595
		if tags[i] == "proto3" {
596
			proto3 = true
597
		}
598
		if strings.HasPrefix(tags[i], "customtype=") {
599
			ctype = true
600
		}
601
		if tags[i] == "stdtime" {
602
			isTime = true
603
		}
604
		if tags[i] == "stdduration" {
605
			isDuration = true
606
		}
607
		if tags[i] == "wktptr" {
608
			isWktPointer = true
609
		}
610
	}
611
	validateUTF8 = validateUTF8 && proto3
612
	if !proto3 && !pointer && !slice {
613
		nozero = false
614
	}
615

616
	if ctype {
617
		if reflect.PtrTo(t).Implements(customType) {
618
			if slice {
619
				return makeMessageRefSliceMarshaler(getMarshalInfo(t))
620
			}
621
			if pointer {
622
				return makeCustomPtrMarshaler(getMarshalInfo(t))
623
			}
624
			return makeCustomMarshaler(getMarshalInfo(t))
625
		} else {
626
			panic(fmt.Sprintf("custom type: type: %v, does not implement the proto.custom interface", t))
627
		}
628
	}
629

630
	if isTime {
631
		if pointer {
632
			if slice {
633
				return makeTimePtrSliceMarshaler(getMarshalInfo(t))
634
			}
635
			return makeTimePtrMarshaler(getMarshalInfo(t))
636
		}
637
		if slice {
638
			return makeTimeSliceMarshaler(getMarshalInfo(t))
639
		}
640
		return makeTimeMarshaler(getMarshalInfo(t))
641
	}
642

643
	if isDuration {
644
		if pointer {
645
			if slice {
646
				return makeDurationPtrSliceMarshaler(getMarshalInfo(t))
647
			}
648
			return makeDurationPtrMarshaler(getMarshalInfo(t))
649
		}
650
		if slice {
651
			return makeDurationSliceMarshaler(getMarshalInfo(t))
652
		}
653
		return makeDurationMarshaler(getMarshalInfo(t))
654
	}
655

656
	if isWktPointer {
657
		switch t.Kind() {
658
		case reflect.Float64:
659
			if pointer {
660
				if slice {
661
					return makeStdDoubleValuePtrSliceMarshaler(getMarshalInfo(t))
662
				}
663
				return makeStdDoubleValuePtrMarshaler(getMarshalInfo(t))
664
			}
665
			if slice {
666
				return makeStdDoubleValueSliceMarshaler(getMarshalInfo(t))
667
			}
668
			return makeStdDoubleValueMarshaler(getMarshalInfo(t))
669
		case reflect.Float32:
670
			if pointer {
671
				if slice {
672
					return makeStdFloatValuePtrSliceMarshaler(getMarshalInfo(t))
673
				}
674
				return makeStdFloatValuePtrMarshaler(getMarshalInfo(t))
675
			}
676
			if slice {
677
				return makeStdFloatValueSliceMarshaler(getMarshalInfo(t))
678
			}
679
			return makeStdFloatValueMarshaler(getMarshalInfo(t))
680
		case reflect.Int64:
681
			if pointer {
682
				if slice {
683
					return makeStdInt64ValuePtrSliceMarshaler(getMarshalInfo(t))
684
				}
685
				return makeStdInt64ValuePtrMarshaler(getMarshalInfo(t))
686
			}
687
			if slice {
688
				return makeStdInt64ValueSliceMarshaler(getMarshalInfo(t))
689
			}
690
			return makeStdInt64ValueMarshaler(getMarshalInfo(t))
691
		case reflect.Uint64:
692
			if pointer {
693
				if slice {
694
					return makeStdUInt64ValuePtrSliceMarshaler(getMarshalInfo(t))
695
				}
696
				return makeStdUInt64ValuePtrMarshaler(getMarshalInfo(t))
697
			}
698
			if slice {
699
				return makeStdUInt64ValueSliceMarshaler(getMarshalInfo(t))
700
			}
701
			return makeStdUInt64ValueMarshaler(getMarshalInfo(t))
702
		case reflect.Int32:
703
			if pointer {
704
				if slice {
705
					return makeStdInt32ValuePtrSliceMarshaler(getMarshalInfo(t))
706
				}
707
				return makeStdInt32ValuePtrMarshaler(getMarshalInfo(t))
708
			}
709
			if slice {
710
				return makeStdInt32ValueSliceMarshaler(getMarshalInfo(t))
711
			}
712
			return makeStdInt32ValueMarshaler(getMarshalInfo(t))
713
		case reflect.Uint32:
714
			if pointer {
715
				if slice {
716
					return makeStdUInt32ValuePtrSliceMarshaler(getMarshalInfo(t))
717
				}
718
				return makeStdUInt32ValuePtrMarshaler(getMarshalInfo(t))
719
			}
720
			if slice {
721
				return makeStdUInt32ValueSliceMarshaler(getMarshalInfo(t))
722
			}
723
			return makeStdUInt32ValueMarshaler(getMarshalInfo(t))
724
		case reflect.Bool:
725
			if pointer {
726
				if slice {
727
					return makeStdBoolValuePtrSliceMarshaler(getMarshalInfo(t))
728
				}
729
				return makeStdBoolValuePtrMarshaler(getMarshalInfo(t))
730
			}
731
			if slice {
732
				return makeStdBoolValueSliceMarshaler(getMarshalInfo(t))
733
			}
734
			return makeStdBoolValueMarshaler(getMarshalInfo(t))
735
		case reflect.String:
736
			if pointer {
737
				if slice {
738
					return makeStdStringValuePtrSliceMarshaler(getMarshalInfo(t))
739
				}
740
				return makeStdStringValuePtrMarshaler(getMarshalInfo(t))
741
			}
742
			if slice {
743
				return makeStdStringValueSliceMarshaler(getMarshalInfo(t))
744
			}
745
			return makeStdStringValueMarshaler(getMarshalInfo(t))
746
		case uint8SliceType:
747
			if pointer {
748
				if slice {
749
					return makeStdBytesValuePtrSliceMarshaler(getMarshalInfo(t))
750
				}
751
				return makeStdBytesValuePtrMarshaler(getMarshalInfo(t))
752
			}
753
			if slice {
754
				return makeStdBytesValueSliceMarshaler(getMarshalInfo(t))
755
			}
756
			return makeStdBytesValueMarshaler(getMarshalInfo(t))
757
		default:
758
			panic(fmt.Sprintf("unknown wktpointer type %#v", t))
759
		}
760
	}
761

762
	switch t.Kind() {
763
	case reflect.Bool:
764
		if pointer {
765
			return sizeBoolPtr, appendBoolPtr
766
		}
767
		if slice {
768
			if packed {
769
				return sizeBoolPackedSlice, appendBoolPackedSlice
770
			}
771
			return sizeBoolSlice, appendBoolSlice
772
		}
773
		if nozero {
774
			return sizeBoolValueNoZero, appendBoolValueNoZero
775
		}
776
		return sizeBoolValue, appendBoolValue
777
	case reflect.Uint32:
778
		switch encoding {
779
		case "fixed32":
780
			if pointer {
781
				return sizeFixed32Ptr, appendFixed32Ptr
782
			}
783
			if slice {
784
				if packed {
785
					return sizeFixed32PackedSlice, appendFixed32PackedSlice
786
				}
787
				return sizeFixed32Slice, appendFixed32Slice
788
			}
789
			if nozero {
790
				return sizeFixed32ValueNoZero, appendFixed32ValueNoZero
791
			}
792
			return sizeFixed32Value, appendFixed32Value
793
		case "varint":
794
			if pointer {
795
				return sizeVarint32Ptr, appendVarint32Ptr
796
			}
797
			if slice {
798
				if packed {
799
					return sizeVarint32PackedSlice, appendVarint32PackedSlice
800
				}
801
				return sizeVarint32Slice, appendVarint32Slice
802
			}
803
			if nozero {
804
				return sizeVarint32ValueNoZero, appendVarint32ValueNoZero
805
			}
806
			return sizeVarint32Value, appendVarint32Value
807
		}
808
	case reflect.Int32:
809
		switch encoding {
810
		case "fixed32":
811
			if pointer {
812
				return sizeFixedS32Ptr, appendFixedS32Ptr
813
			}
814
			if slice {
815
				if packed {
816
					return sizeFixedS32PackedSlice, appendFixedS32PackedSlice
817
				}
818
				return sizeFixedS32Slice, appendFixedS32Slice
819
			}
820
			if nozero {
821
				return sizeFixedS32ValueNoZero, appendFixedS32ValueNoZero
822
			}
823
			return sizeFixedS32Value, appendFixedS32Value
824
		case "varint":
825
			if pointer {
826
				return sizeVarintS32Ptr, appendVarintS32Ptr
827
			}
828
			if slice {
829
				if packed {
830
					return sizeVarintS32PackedSlice, appendVarintS32PackedSlice
831
				}
832
				return sizeVarintS32Slice, appendVarintS32Slice
833
			}
834
			if nozero {
835
				return sizeVarintS32ValueNoZero, appendVarintS32ValueNoZero
836
			}
837
			return sizeVarintS32Value, appendVarintS32Value
838
		case "zigzag32":
839
			if pointer {
840
				return sizeZigzag32Ptr, appendZigzag32Ptr
841
			}
842
			if slice {
843
				if packed {
844
					return sizeZigzag32PackedSlice, appendZigzag32PackedSlice
845
				}
846
				return sizeZigzag32Slice, appendZigzag32Slice
847
			}
848
			if nozero {
849
				return sizeZigzag32ValueNoZero, appendZigzag32ValueNoZero
850
			}
851
			return sizeZigzag32Value, appendZigzag32Value
852
		}
853
	case reflect.Uint64:
854
		switch encoding {
855
		case "fixed64":
856
			if pointer {
857
				return sizeFixed64Ptr, appendFixed64Ptr
858
			}
859
			if slice {
860
				if packed {
861
					return sizeFixed64PackedSlice, appendFixed64PackedSlice
862
				}
863
				return sizeFixed64Slice, appendFixed64Slice
864
			}
865
			if nozero {
866
				return sizeFixed64ValueNoZero, appendFixed64ValueNoZero
867
			}
868
			return sizeFixed64Value, appendFixed64Value
869
		case "varint":
870
			if pointer {
871
				return sizeVarint64Ptr, appendVarint64Ptr
872
			}
873
			if slice {
874
				if packed {
875
					return sizeVarint64PackedSlice, appendVarint64PackedSlice
876
				}
877
				return sizeVarint64Slice, appendVarint64Slice
878
			}
879
			if nozero {
880
				return sizeVarint64ValueNoZero, appendVarint64ValueNoZero
881
			}
882
			return sizeVarint64Value, appendVarint64Value
883
		}
884
	case reflect.Int64:
885
		switch encoding {
886
		case "fixed64":
887
			if pointer {
888
				return sizeFixedS64Ptr, appendFixedS64Ptr
889
			}
890
			if slice {
891
				if packed {
892
					return sizeFixedS64PackedSlice, appendFixedS64PackedSlice
893
				}
894
				return sizeFixedS64Slice, appendFixedS64Slice
895
			}
896
			if nozero {
897
				return sizeFixedS64ValueNoZero, appendFixedS64ValueNoZero
898
			}
899
			return sizeFixedS64Value, appendFixedS64Value
900
		case "varint":
901
			if pointer {
902
				return sizeVarintS64Ptr, appendVarintS64Ptr
903
			}
904
			if slice {
905
				if packed {
906
					return sizeVarintS64PackedSlice, appendVarintS64PackedSlice
907
				}
908
				return sizeVarintS64Slice, appendVarintS64Slice
909
			}
910
			if nozero {
911
				return sizeVarintS64ValueNoZero, appendVarintS64ValueNoZero
912
			}
913
			return sizeVarintS64Value, appendVarintS64Value
914
		case "zigzag64":
915
			if pointer {
916
				return sizeZigzag64Ptr, appendZigzag64Ptr
917
			}
918
			if slice {
919
				if packed {
920
					return sizeZigzag64PackedSlice, appendZigzag64PackedSlice
921
				}
922
				return sizeZigzag64Slice, appendZigzag64Slice
923
			}
924
			if nozero {
925
				return sizeZigzag64ValueNoZero, appendZigzag64ValueNoZero
926
			}
927
			return sizeZigzag64Value, appendZigzag64Value
928
		}
929
	case reflect.Float32:
930
		if pointer {
931
			return sizeFloat32Ptr, appendFloat32Ptr
932
		}
933
		if slice {
934
			if packed {
935
				return sizeFloat32PackedSlice, appendFloat32PackedSlice
936
			}
937
			return sizeFloat32Slice, appendFloat32Slice
938
		}
939
		if nozero {
940
			return sizeFloat32ValueNoZero, appendFloat32ValueNoZero
941
		}
942
		return sizeFloat32Value, appendFloat32Value
943
	case reflect.Float64:
944
		if pointer {
945
			return sizeFloat64Ptr, appendFloat64Ptr
946
		}
947
		if slice {
948
			if packed {
949
				return sizeFloat64PackedSlice, appendFloat64PackedSlice
950
			}
951
			return sizeFloat64Slice, appendFloat64Slice
952
		}
953
		if nozero {
954
			return sizeFloat64ValueNoZero, appendFloat64ValueNoZero
955
		}
956
		return sizeFloat64Value, appendFloat64Value
957
	case reflect.String:
958
		if validateUTF8 {
959
			if pointer {
960
				return sizeStringPtr, appendUTF8StringPtr
961
			}
962
			if slice {
963
				return sizeStringSlice, appendUTF8StringSlice
964
			}
965
			if nozero {
966
				return sizeStringValueNoZero, appendUTF8StringValueNoZero
967
			}
968
			return sizeStringValue, appendUTF8StringValue
969
		}
970
		if pointer {
971
			return sizeStringPtr, appendStringPtr
972
		}
973
		if slice {
974
			return sizeStringSlice, appendStringSlice
975
		}
976
		if nozero {
977
			return sizeStringValueNoZero, appendStringValueNoZero
978
		}
979
		return sizeStringValue, appendStringValue
980
	case reflect.Slice:
981
		if slice {
982
			return sizeBytesSlice, appendBytesSlice
983
		}
984
		if oneof {
985
			// Oneof bytes field may also have "proto3" tag.
986
			// We want to marshal it as a oneof field. Do this
987
			// check before the proto3 check.
988
			return sizeBytesOneof, appendBytesOneof
989
		}
990
		if proto3 {
991
			return sizeBytes3, appendBytes3
992
		}
993
		return sizeBytes, appendBytes
994
	case reflect.Struct:
995
		switch encoding {
996
		case "group":
997
			if slice {
998
				return makeGroupSliceMarshaler(getMarshalInfo(t))
999
			}
1000
			return makeGroupMarshaler(getMarshalInfo(t))
1001
		case "bytes":
1002
			if pointer {
1003
				if slice {
1004
					return makeMessageSliceMarshaler(getMarshalInfo(t))
1005
				}
1006
				return makeMessageMarshaler(getMarshalInfo(t))
1007
			} else {
1008
				if slice {
1009
					return makeMessageRefSliceMarshaler(getMarshalInfo(t))
1010
				}
1011
				return makeMessageRefMarshaler(getMarshalInfo(t))
1012
			}
1013
		}
1014
	}
1015
	panic(fmt.Sprintf("unknown or mismatched type: type: %v, wire type: %v", t, encoding))
1016
}
1017

1018
// Below are functions to size/marshal a specific type of a field.
1019
// They are stored in the field's info, and called by function pointers.
1020
// They have type sizer or marshaler.
1021

1022
func sizeFixed32Value(_ pointer, tagsize int) int {
1023
	return 4 + tagsize
1024
}
1025
func sizeFixed32ValueNoZero(ptr pointer, tagsize int) int {
1026
	v := *ptr.toUint32()
1027
	if v == 0 {
1028
		return 0
1029
	}
1030
	return 4 + tagsize
1031
}
1032
func sizeFixed32Ptr(ptr pointer, tagsize int) int {
1033
	p := *ptr.toUint32Ptr()
1034
	if p == nil {
1035
		return 0
1036
	}
1037
	return 4 + tagsize
1038
}
1039
func sizeFixed32Slice(ptr pointer, tagsize int) int {
1040
	s := *ptr.toUint32Slice()
1041
	return (4 + tagsize) * len(s)
1042
}
1043
func sizeFixed32PackedSlice(ptr pointer, tagsize int) int {
1044
	s := *ptr.toUint32Slice()
1045
	if len(s) == 0 {
1046
		return 0
1047
	}
1048
	return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize
1049
}
1050
func sizeFixedS32Value(_ pointer, tagsize int) int {
1051
	return 4 + tagsize
1052
}
1053
func sizeFixedS32ValueNoZero(ptr pointer, tagsize int) int {
1054
	v := *ptr.toInt32()
1055
	if v == 0 {
1056
		return 0
1057
	}
1058
	return 4 + tagsize
1059
}
1060
func sizeFixedS32Ptr(ptr pointer, tagsize int) int {
1061
	p := ptr.getInt32Ptr()
1062
	if p == nil {
1063
		return 0
1064
	}
1065
	return 4 + tagsize
1066
}
1067
func sizeFixedS32Slice(ptr pointer, tagsize int) int {
1068
	s := ptr.getInt32Slice()
1069
	return (4 + tagsize) * len(s)
1070
}
1071
func sizeFixedS32PackedSlice(ptr pointer, tagsize int) int {
1072
	s := ptr.getInt32Slice()
1073
	if len(s) == 0 {
1074
		return 0
1075
	}
1076
	return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize
1077
}
1078
func sizeFloat32Value(_ pointer, tagsize int) int {
1079
	return 4 + tagsize
1080
}
1081
func sizeFloat32ValueNoZero(ptr pointer, tagsize int) int {
1082
	v := math.Float32bits(*ptr.toFloat32())
1083
	if v == 0 {
1084
		return 0
1085
	}
1086
	return 4 + tagsize
1087
}
1088
func sizeFloat32Ptr(ptr pointer, tagsize int) int {
1089
	p := *ptr.toFloat32Ptr()
1090
	if p == nil {
1091
		return 0
1092
	}
1093
	return 4 + tagsize
1094
}
1095
func sizeFloat32Slice(ptr pointer, tagsize int) int {
1096
	s := *ptr.toFloat32Slice()
1097
	return (4 + tagsize) * len(s)
1098
}
1099
func sizeFloat32PackedSlice(ptr pointer, tagsize int) int {
1100
	s := *ptr.toFloat32Slice()
1101
	if len(s) == 0 {
1102
		return 0
1103
	}
1104
	return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize
1105
}
1106
func sizeFixed64Value(_ pointer, tagsize int) int {
1107
	return 8 + tagsize
1108
}
1109
func sizeFixed64ValueNoZero(ptr pointer, tagsize int) int {
1110
	v := *ptr.toUint64()
1111
	if v == 0 {
1112
		return 0
1113
	}
1114
	return 8 + tagsize
1115
}
1116
func sizeFixed64Ptr(ptr pointer, tagsize int) int {
1117
	p := *ptr.toUint64Ptr()
1118
	if p == nil {
1119
		return 0
1120
	}
1121
	return 8 + tagsize
1122
}
1123
func sizeFixed64Slice(ptr pointer, tagsize int) int {
1124
	s := *ptr.toUint64Slice()
1125
	return (8 + tagsize) * len(s)
1126
}
1127
func sizeFixed64PackedSlice(ptr pointer, tagsize int) int {
1128
	s := *ptr.toUint64Slice()
1129
	if len(s) == 0 {
1130
		return 0
1131
	}
1132
	return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize
1133
}
1134
func sizeFixedS64Value(_ pointer, tagsize int) int {
1135
	return 8 + tagsize
1136
}
1137
func sizeFixedS64ValueNoZero(ptr pointer, tagsize int) int {
1138
	v := *ptr.toInt64()
1139
	if v == 0 {
1140
		return 0
1141
	}
1142
	return 8 + tagsize
1143
}
1144
func sizeFixedS64Ptr(ptr pointer, tagsize int) int {
1145
	p := *ptr.toInt64Ptr()
1146
	if p == nil {
1147
		return 0
1148
	}
1149
	return 8 + tagsize
1150
}
1151
func sizeFixedS64Slice(ptr pointer, tagsize int) int {
1152
	s := *ptr.toInt64Slice()
1153
	return (8 + tagsize) * len(s)
1154
}
1155
func sizeFixedS64PackedSlice(ptr pointer, tagsize int) int {
1156
	s := *ptr.toInt64Slice()
1157
	if len(s) == 0 {
1158
		return 0
1159
	}
1160
	return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize
1161
}
1162
func sizeFloat64Value(_ pointer, tagsize int) int {
1163
	return 8 + tagsize
1164
}
1165
func sizeFloat64ValueNoZero(ptr pointer, tagsize int) int {
1166
	v := math.Float64bits(*ptr.toFloat64())
1167
	if v == 0 {
1168
		return 0
1169
	}
1170
	return 8 + tagsize
1171
}
1172
func sizeFloat64Ptr(ptr pointer, tagsize int) int {
1173
	p := *ptr.toFloat64Ptr()
1174
	if p == nil {
1175
		return 0
1176
	}
1177
	return 8 + tagsize
1178
}
1179
func sizeFloat64Slice(ptr pointer, tagsize int) int {
1180
	s := *ptr.toFloat64Slice()
1181
	return (8 + tagsize) * len(s)
1182
}
1183
func sizeFloat64PackedSlice(ptr pointer, tagsize int) int {
1184
	s := *ptr.toFloat64Slice()
1185
	if len(s) == 0 {
1186
		return 0
1187
	}
1188
	return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize
1189
}
1190
func sizeVarint32Value(ptr pointer, tagsize int) int {
1191
	v := *ptr.toUint32()
1192
	return SizeVarint(uint64(v)) + tagsize
1193
}
1194
func sizeVarint32ValueNoZero(ptr pointer, tagsize int) int {
1195
	v := *ptr.toUint32()
1196
	if v == 0 {
1197
		return 0
1198
	}
1199
	return SizeVarint(uint64(v)) + tagsize
1200
}
1201
func sizeVarint32Ptr(ptr pointer, tagsize int) int {
1202
	p := *ptr.toUint32Ptr()
1203
	if p == nil {
1204
		return 0
1205
	}
1206
	return SizeVarint(uint64(*p)) + tagsize
1207
}
1208
func sizeVarint32Slice(ptr pointer, tagsize int) int {
1209
	s := *ptr.toUint32Slice()
1210
	n := 0
1211
	for _, v := range s {
1212
		n += SizeVarint(uint64(v)) + tagsize
1213
	}
1214
	return n
1215
}
1216
func sizeVarint32PackedSlice(ptr pointer, tagsize int) int {
1217
	s := *ptr.toUint32Slice()
1218
	if len(s) == 0 {
1219
		return 0
1220
	}
1221
	n := 0
1222
	for _, v := range s {
1223
		n += SizeVarint(uint64(v))
1224
	}
1225
	return n + SizeVarint(uint64(n)) + tagsize
1226
}
1227
func sizeVarintS32Value(ptr pointer, tagsize int) int {
1228
	v := *ptr.toInt32()
1229
	return SizeVarint(uint64(v)) + tagsize
1230
}
1231
func sizeVarintS32ValueNoZero(ptr pointer, tagsize int) int {
1232
	v := *ptr.toInt32()
1233
	if v == 0 {
1234
		return 0
1235
	}
1236
	return SizeVarint(uint64(v)) + tagsize
1237
}
1238
func sizeVarintS32Ptr(ptr pointer, tagsize int) int {
1239
	p := ptr.getInt32Ptr()
1240
	if p == nil {
1241
		return 0
1242
	}
1243
	return SizeVarint(uint64(*p)) + tagsize
1244
}
1245
func sizeVarintS32Slice(ptr pointer, tagsize int) int {
1246
	s := ptr.getInt32Slice()
1247
	n := 0
1248
	for _, v := range s {
1249
		n += SizeVarint(uint64(v)) + tagsize
1250
	}
1251
	return n
1252
}
1253
func sizeVarintS32PackedSlice(ptr pointer, tagsize int) int {
1254
	s := ptr.getInt32Slice()
1255
	if len(s) == 0 {
1256
		return 0
1257
	}
1258
	n := 0
1259
	for _, v := range s {
1260
		n += SizeVarint(uint64(v))
1261
	}
1262
	return n + SizeVarint(uint64(n)) + tagsize
1263
}
1264
func sizeVarint64Value(ptr pointer, tagsize int) int {
1265
	v := *ptr.toUint64()
1266
	return SizeVarint(v) + tagsize
1267
}
1268
func sizeVarint64ValueNoZero(ptr pointer, tagsize int) int {
1269
	v := *ptr.toUint64()
1270
	if v == 0 {
1271
		return 0
1272
	}
1273
	return SizeVarint(v) + tagsize
1274
}
1275
func sizeVarint64Ptr(ptr pointer, tagsize int) int {
1276
	p := *ptr.toUint64Ptr()
1277
	if p == nil {
1278
		return 0
1279
	}
1280
	return SizeVarint(*p) + tagsize
1281
}
1282
func sizeVarint64Slice(ptr pointer, tagsize int) int {
1283
	s := *ptr.toUint64Slice()
1284
	n := 0
1285
	for _, v := range s {
1286
		n += SizeVarint(v) + tagsize
1287
	}
1288
	return n
1289
}
1290
func sizeVarint64PackedSlice(ptr pointer, tagsize int) int {
1291
	s := *ptr.toUint64Slice()
1292
	if len(s) == 0 {
1293
		return 0
1294
	}
1295
	n := 0
1296
	for _, v := range s {
1297
		n += SizeVarint(v)
1298
	}
1299
	return n + SizeVarint(uint64(n)) + tagsize
1300
}
1301
func sizeVarintS64Value(ptr pointer, tagsize int) int {
1302
	v := *ptr.toInt64()
1303
	return SizeVarint(uint64(v)) + tagsize
1304
}
1305
func sizeVarintS64ValueNoZero(ptr pointer, tagsize int) int {
1306
	v := *ptr.toInt64()
1307
	if v == 0 {
1308
		return 0
1309
	}
1310
	return SizeVarint(uint64(v)) + tagsize
1311
}
1312
func sizeVarintS64Ptr(ptr pointer, tagsize int) int {
1313
	p := *ptr.toInt64Ptr()
1314
	if p == nil {
1315
		return 0
1316
	}
1317
	return SizeVarint(uint64(*p)) + tagsize
1318
}
1319
func sizeVarintS64Slice(ptr pointer, tagsize int) int {
1320
	s := *ptr.toInt64Slice()
1321
	n := 0
1322
	for _, v := range s {
1323
		n += SizeVarint(uint64(v)) + tagsize
1324
	}
1325
	return n
1326
}
1327
func sizeVarintS64PackedSlice(ptr pointer, tagsize int) int {
1328
	s := *ptr.toInt64Slice()
1329
	if len(s) == 0 {
1330
		return 0
1331
	}
1332
	n := 0
1333
	for _, v := range s {
1334
		n += SizeVarint(uint64(v))
1335
	}
1336
	return n + SizeVarint(uint64(n)) + tagsize
1337
}
1338
func sizeZigzag32Value(ptr pointer, tagsize int) int {
1339
	v := *ptr.toInt32()
1340
	return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
1341
}
1342
func sizeZigzag32ValueNoZero(ptr pointer, tagsize int) int {
1343
	v := *ptr.toInt32()
1344
	if v == 0 {
1345
		return 0
1346
	}
1347
	return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
1348
}
1349
func sizeZigzag32Ptr(ptr pointer, tagsize int) int {
1350
	p := ptr.getInt32Ptr()
1351
	if p == nil {
1352
		return 0
1353
	}
1354
	v := *p
1355
	return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
1356
}
1357
func sizeZigzag32Slice(ptr pointer, tagsize int) int {
1358
	s := ptr.getInt32Slice()
1359
	n := 0
1360
	for _, v := range s {
1361
		n += SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
1362
	}
1363
	return n
1364
}
1365
func sizeZigzag32PackedSlice(ptr pointer, tagsize int) int {
1366
	s := ptr.getInt32Slice()
1367
	if len(s) == 0 {
1368
		return 0
1369
	}
1370
	n := 0
1371
	for _, v := range s {
1372
		n += SizeVarint(uint64((uint32(v) << 1) ^ uint32((int32(v) >> 31))))
1373
	}
1374
	return n + SizeVarint(uint64(n)) + tagsize
1375
}
1376
func sizeZigzag64Value(ptr pointer, tagsize int) int {
1377
	v := *ptr.toInt64()
1378
	return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
1379
}
1380
func sizeZigzag64ValueNoZero(ptr pointer, tagsize int) int {
1381
	v := *ptr.toInt64()
1382
	if v == 0 {
1383
		return 0
1384
	}
1385
	return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
1386
}
1387
func sizeZigzag64Ptr(ptr pointer, tagsize int) int {
1388
	p := *ptr.toInt64Ptr()
1389
	if p == nil {
1390
		return 0
1391
	}
1392
	v := *p
1393
	return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
1394
}
1395
func sizeZigzag64Slice(ptr pointer, tagsize int) int {
1396
	s := *ptr.toInt64Slice()
1397
	n := 0
1398
	for _, v := range s {
1399
		n += SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
1400
	}
1401
	return n
1402
}
1403
func sizeZigzag64PackedSlice(ptr pointer, tagsize int) int {
1404
	s := *ptr.toInt64Slice()
1405
	if len(s) == 0 {
1406
		return 0
1407
	}
1408
	n := 0
1409
	for _, v := range s {
1410
		n += SizeVarint(uint64(v<<1) ^ uint64((int64(v) >> 63)))
1411
	}
1412
	return n + SizeVarint(uint64(n)) + tagsize
1413
}
1414
func sizeBoolValue(_ pointer, tagsize int) int {
1415
	return 1 + tagsize
1416
}
1417
func sizeBoolValueNoZero(ptr pointer, tagsize int) int {
1418
	v := *ptr.toBool()
1419
	if !v {
1420
		return 0
1421
	}
1422
	return 1 + tagsize
1423
}
1424
func sizeBoolPtr(ptr pointer, tagsize int) int {
1425
	p := *ptr.toBoolPtr()
1426
	if p == nil {
1427
		return 0
1428
	}
1429
	return 1 + tagsize
1430
}
1431
func sizeBoolSlice(ptr pointer, tagsize int) int {
1432
	s := *ptr.toBoolSlice()
1433
	return (1 + tagsize) * len(s)
1434
}
1435
func sizeBoolPackedSlice(ptr pointer, tagsize int) int {
1436
	s := *ptr.toBoolSlice()
1437
	if len(s) == 0 {
1438
		return 0
1439
	}
1440
	return len(s) + SizeVarint(uint64(len(s))) + tagsize
1441
}
1442
func sizeStringValue(ptr pointer, tagsize int) int {
1443
	v := *ptr.toString()
1444
	return len(v) + SizeVarint(uint64(len(v))) + tagsize
1445
}
1446
func sizeStringValueNoZero(ptr pointer, tagsize int) int {
1447
	v := *ptr.toString()
1448
	if v == "" {
1449
		return 0
1450
	}
1451
	return len(v) + SizeVarint(uint64(len(v))) + tagsize
1452
}
1453
func sizeStringPtr(ptr pointer, tagsize int) int {
1454
	p := *ptr.toStringPtr()
1455
	if p == nil {
1456
		return 0
1457
	}
1458
	v := *p
1459
	return len(v) + SizeVarint(uint64(len(v))) + tagsize
1460
}
1461
func sizeStringSlice(ptr pointer, tagsize int) int {
1462
	s := *ptr.toStringSlice()
1463
	n := 0
1464
	for _, v := range s {
1465
		n += len(v) + SizeVarint(uint64(len(v))) + tagsize
1466
	}
1467
	return n
1468
}
1469
func sizeBytes(ptr pointer, tagsize int) int {
1470
	v := *ptr.toBytes()
1471
	if v == nil {
1472
		return 0
1473
	}
1474
	return len(v) + SizeVarint(uint64(len(v))) + tagsize
1475
}
1476
func sizeBytes3(ptr pointer, tagsize int) int {
1477
	v := *ptr.toBytes()
1478
	if len(v) == 0 {
1479
		return 0
1480
	}
1481
	return len(v) + SizeVarint(uint64(len(v))) + tagsize
1482
}
1483
func sizeBytesOneof(ptr pointer, tagsize int) int {
1484
	v := *ptr.toBytes()
1485
	return len(v) + SizeVarint(uint64(len(v))) + tagsize
1486
}
1487
func sizeBytesSlice(ptr pointer, tagsize int) int {
1488
	s := *ptr.toBytesSlice()
1489
	n := 0
1490
	for _, v := range s {
1491
		n += len(v) + SizeVarint(uint64(len(v))) + tagsize
1492
	}
1493
	return n
1494
}
1495

1496
// appendFixed32 appends an encoded fixed32 to b.
1497
func appendFixed32(b []byte, v uint32) []byte {
1498
	b = append(b,
1499
		byte(v),
1500
		byte(v>>8),
1501
		byte(v>>16),
1502
		byte(v>>24))
1503
	return b
1504
}
1505

1506
// appendFixed64 appends an encoded fixed64 to b.
1507
func appendFixed64(b []byte, v uint64) []byte {
1508
	b = append(b,
1509
		byte(v),
1510
		byte(v>>8),
1511
		byte(v>>16),
1512
		byte(v>>24),
1513
		byte(v>>32),
1514
		byte(v>>40),
1515
		byte(v>>48),
1516
		byte(v>>56))
1517
	return b
1518
}
1519

1520
// appendVarint appends an encoded varint to b.
1521
func appendVarint(b []byte, v uint64) []byte {
1522
	// TODO: make 1-byte (maybe 2-byte) case inline-able, once we
1523
	// have non-leaf inliner.
1524
	switch {
1525
	case v < 1<<7:
1526
		b = append(b, byte(v))
1527
	case v < 1<<14:
1528
		b = append(b,
1529
			byte(v&0x7f|0x80),
1530
			byte(v>>7))
1531
	case v < 1<<21:
1532
		b = append(b,
1533
			byte(v&0x7f|0x80),
1534
			byte((v>>7)&0x7f|0x80),
1535
			byte(v>>14))
1536
	case v < 1<<28:
1537
		b = append(b,
1538
			byte(v&0x7f|0x80),
1539
			byte((v>>7)&0x7f|0x80),
1540
			byte((v>>14)&0x7f|0x80),
1541
			byte(v>>21))
1542
	case v < 1<<35:
1543
		b = append(b,
1544
			byte(v&0x7f|0x80),
1545
			byte((v>>7)&0x7f|0x80),
1546
			byte((v>>14)&0x7f|0x80),
1547
			byte((v>>21)&0x7f|0x80),
1548
			byte(v>>28))
1549
	case v < 1<<42:
1550
		b = append(b,
1551
			byte(v&0x7f|0x80),
1552
			byte((v>>7)&0x7f|0x80),
1553
			byte((v>>14)&0x7f|0x80),
1554
			byte((v>>21)&0x7f|0x80),
1555
			byte((v>>28)&0x7f|0x80),
1556
			byte(v>>35))
1557
	case v < 1<<49:
1558
		b = append(b,
1559
			byte(v&0x7f|0x80),
1560
			byte((v>>7)&0x7f|0x80),
1561
			byte((v>>14)&0x7f|0x80),
1562
			byte((v>>21)&0x7f|0x80),
1563
			byte((v>>28)&0x7f|0x80),
1564
			byte((v>>35)&0x7f|0x80),
1565
			byte(v>>42))
1566
	case v < 1<<56:
1567
		b = append(b,
1568
			byte(v&0x7f|0x80),
1569
			byte((v>>7)&0x7f|0x80),
1570
			byte((v>>14)&0x7f|0x80),
1571
			byte((v>>21)&0x7f|0x80),
1572
			byte((v>>28)&0x7f|0x80),
1573
			byte((v>>35)&0x7f|0x80),
1574
			byte((v>>42)&0x7f|0x80),
1575
			byte(v>>49))
1576
	case v < 1<<63:
1577
		b = append(b,
1578
			byte(v&0x7f|0x80),
1579
			byte((v>>7)&0x7f|0x80),
1580
			byte((v>>14)&0x7f|0x80),
1581
			byte((v>>21)&0x7f|0x80),
1582
			byte((v>>28)&0x7f|0x80),
1583
			byte((v>>35)&0x7f|0x80),
1584
			byte((v>>42)&0x7f|0x80),
1585
			byte((v>>49)&0x7f|0x80),
1586
			byte(v>>56))
1587
	default:
1588
		b = append(b,
1589
			byte(v&0x7f|0x80),
1590
			byte((v>>7)&0x7f|0x80),
1591
			byte((v>>14)&0x7f|0x80),
1592
			byte((v>>21)&0x7f|0x80),
1593
			byte((v>>28)&0x7f|0x80),
1594
			byte((v>>35)&0x7f|0x80),
1595
			byte((v>>42)&0x7f|0x80),
1596
			byte((v>>49)&0x7f|0x80),
1597
			byte((v>>56)&0x7f|0x80),
1598
			1)
1599
	}
1600
	return b
1601
}
1602

1603
func appendFixed32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1604
	v := *ptr.toUint32()
1605
	b = appendVarint(b, wiretag)
1606
	b = appendFixed32(b, v)
1607
	return b, nil
1608
}
1609
func appendFixed32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1610
	v := *ptr.toUint32()
1611
	if v == 0 {
1612
		return b, nil
1613
	}
1614
	b = appendVarint(b, wiretag)
1615
	b = appendFixed32(b, v)
1616
	return b, nil
1617
}
1618
func appendFixed32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1619
	p := *ptr.toUint32Ptr()
1620
	if p == nil {
1621
		return b, nil
1622
	}
1623
	b = appendVarint(b, wiretag)
1624
	b = appendFixed32(b, *p)
1625
	return b, nil
1626
}
1627
func appendFixed32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1628
	s := *ptr.toUint32Slice()
1629
	for _, v := range s {
1630
		b = appendVarint(b, wiretag)
1631
		b = appendFixed32(b, v)
1632
	}
1633
	return b, nil
1634
}
1635
func appendFixed32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1636
	s := *ptr.toUint32Slice()
1637
	if len(s) == 0 {
1638
		return b, nil
1639
	}
1640
	b = appendVarint(b, wiretag&^7|WireBytes)
1641
	b = appendVarint(b, uint64(4*len(s)))
1642
	for _, v := range s {
1643
		b = appendFixed32(b, v)
1644
	}
1645
	return b, nil
1646
}
1647
func appendFixedS32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1648
	v := *ptr.toInt32()
1649
	b = appendVarint(b, wiretag)
1650
	b = appendFixed32(b, uint32(v))
1651
	return b, nil
1652
}
1653
func appendFixedS32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1654
	v := *ptr.toInt32()
1655
	if v == 0 {
1656
		return b, nil
1657
	}
1658
	b = appendVarint(b, wiretag)
1659
	b = appendFixed32(b, uint32(v))
1660
	return b, nil
1661
}
1662
func appendFixedS32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1663
	p := ptr.getInt32Ptr()
1664
	if p == nil {
1665
		return b, nil
1666
	}
1667
	b = appendVarint(b, wiretag)
1668
	b = appendFixed32(b, uint32(*p))
1669
	return b, nil
1670
}
1671
func appendFixedS32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1672
	s := ptr.getInt32Slice()
1673
	for _, v := range s {
1674
		b = appendVarint(b, wiretag)
1675
		b = appendFixed32(b, uint32(v))
1676
	}
1677
	return b, nil
1678
}
1679
func appendFixedS32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1680
	s := ptr.getInt32Slice()
1681
	if len(s) == 0 {
1682
		return b, nil
1683
	}
1684
	b = appendVarint(b, wiretag&^7|WireBytes)
1685
	b = appendVarint(b, uint64(4*len(s)))
1686
	for _, v := range s {
1687
		b = appendFixed32(b, uint32(v))
1688
	}
1689
	return b, nil
1690
}
1691
func appendFloat32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1692
	v := math.Float32bits(*ptr.toFloat32())
1693
	b = appendVarint(b, wiretag)
1694
	b = appendFixed32(b, v)
1695
	return b, nil
1696
}
1697
func appendFloat32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1698
	v := math.Float32bits(*ptr.toFloat32())
1699
	if v == 0 {
1700
		return b, nil
1701
	}
1702
	b = appendVarint(b, wiretag)
1703
	b = appendFixed32(b, v)
1704
	return b, nil
1705
}
1706
func appendFloat32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1707
	p := *ptr.toFloat32Ptr()
1708
	if p == nil {
1709
		return b, nil
1710
	}
1711
	b = appendVarint(b, wiretag)
1712
	b = appendFixed32(b, math.Float32bits(*p))
1713
	return b, nil
1714
}
1715
func appendFloat32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1716
	s := *ptr.toFloat32Slice()
1717
	for _, v := range s {
1718
		b = appendVarint(b, wiretag)
1719
		b = appendFixed32(b, math.Float32bits(v))
1720
	}
1721
	return b, nil
1722
}
1723
func appendFloat32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1724
	s := *ptr.toFloat32Slice()
1725
	if len(s) == 0 {
1726
		return b, nil
1727
	}
1728
	b = appendVarint(b, wiretag&^7|WireBytes)
1729
	b = appendVarint(b, uint64(4*len(s)))
1730
	for _, v := range s {
1731
		b = appendFixed32(b, math.Float32bits(v))
1732
	}
1733
	return b, nil
1734
}
1735
func appendFixed64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1736
	v := *ptr.toUint64()
1737
	b = appendVarint(b, wiretag)
1738
	b = appendFixed64(b, v)
1739
	return b, nil
1740
}
1741
func appendFixed64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1742
	v := *ptr.toUint64()
1743
	if v == 0 {
1744
		return b, nil
1745
	}
1746
	b = appendVarint(b, wiretag)
1747
	b = appendFixed64(b, v)
1748
	return b, nil
1749
}
1750
func appendFixed64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1751
	p := *ptr.toUint64Ptr()
1752
	if p == nil {
1753
		return b, nil
1754
	}
1755
	b = appendVarint(b, wiretag)
1756
	b = appendFixed64(b, *p)
1757
	return b, nil
1758
}
1759
func appendFixed64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1760
	s := *ptr.toUint64Slice()
1761
	for _, v := range s {
1762
		b = appendVarint(b, wiretag)
1763
		b = appendFixed64(b, v)
1764
	}
1765
	return b, nil
1766
}
1767
func appendFixed64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1768
	s := *ptr.toUint64Slice()
1769
	if len(s) == 0 {
1770
		return b, nil
1771
	}
1772
	b = appendVarint(b, wiretag&^7|WireBytes)
1773
	b = appendVarint(b, uint64(8*len(s)))
1774
	for _, v := range s {
1775
		b = appendFixed64(b, v)
1776
	}
1777
	return b, nil
1778
}
1779
func appendFixedS64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1780
	v := *ptr.toInt64()
1781
	b = appendVarint(b, wiretag)
1782
	b = appendFixed64(b, uint64(v))
1783
	return b, nil
1784
}
1785
func appendFixedS64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1786
	v := *ptr.toInt64()
1787
	if v == 0 {
1788
		return b, nil
1789
	}
1790
	b = appendVarint(b, wiretag)
1791
	b = appendFixed64(b, uint64(v))
1792
	return b, nil
1793
}
1794
func appendFixedS64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1795
	p := *ptr.toInt64Ptr()
1796
	if p == nil {
1797
		return b, nil
1798
	}
1799
	b = appendVarint(b, wiretag)
1800
	b = appendFixed64(b, uint64(*p))
1801
	return b, nil
1802
}
1803
func appendFixedS64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1804
	s := *ptr.toInt64Slice()
1805
	for _, v := range s {
1806
		b = appendVarint(b, wiretag)
1807
		b = appendFixed64(b, uint64(v))
1808
	}
1809
	return b, nil
1810
}
1811
func appendFixedS64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1812
	s := *ptr.toInt64Slice()
1813
	if len(s) == 0 {
1814
		return b, nil
1815
	}
1816
	b = appendVarint(b, wiretag&^7|WireBytes)
1817
	b = appendVarint(b, uint64(8*len(s)))
1818
	for _, v := range s {
1819
		b = appendFixed64(b, uint64(v))
1820
	}
1821
	return b, nil
1822
}
1823
func appendFloat64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1824
	v := math.Float64bits(*ptr.toFloat64())
1825
	b = appendVarint(b, wiretag)
1826
	b = appendFixed64(b, v)
1827
	return b, nil
1828
}
1829
func appendFloat64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1830
	v := math.Float64bits(*ptr.toFloat64())
1831
	if v == 0 {
1832
		return b, nil
1833
	}
1834
	b = appendVarint(b, wiretag)
1835
	b = appendFixed64(b, v)
1836
	return b, nil
1837
}
1838
func appendFloat64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1839
	p := *ptr.toFloat64Ptr()
1840
	if p == nil {
1841
		return b, nil
1842
	}
1843
	b = appendVarint(b, wiretag)
1844
	b = appendFixed64(b, math.Float64bits(*p))
1845
	return b, nil
1846
}
1847
func appendFloat64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1848
	s := *ptr.toFloat64Slice()
1849
	for _, v := range s {
1850
		b = appendVarint(b, wiretag)
1851
		b = appendFixed64(b, math.Float64bits(v))
1852
	}
1853
	return b, nil
1854
}
1855
func appendFloat64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1856
	s := *ptr.toFloat64Slice()
1857
	if len(s) == 0 {
1858
		return b, nil
1859
	}
1860
	b = appendVarint(b, wiretag&^7|WireBytes)
1861
	b = appendVarint(b, uint64(8*len(s)))
1862
	for _, v := range s {
1863
		b = appendFixed64(b, math.Float64bits(v))
1864
	}
1865
	return b, nil
1866
}
1867
func appendVarint32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1868
	v := *ptr.toUint32()
1869
	b = appendVarint(b, wiretag)
1870
	b = appendVarint(b, uint64(v))
1871
	return b, nil
1872
}
1873
func appendVarint32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1874
	v := *ptr.toUint32()
1875
	if v == 0 {
1876
		return b, nil
1877
	}
1878
	b = appendVarint(b, wiretag)
1879
	b = appendVarint(b, uint64(v))
1880
	return b, nil
1881
}
1882
func appendVarint32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1883
	p := *ptr.toUint32Ptr()
1884
	if p == nil {
1885
		return b, nil
1886
	}
1887
	b = appendVarint(b, wiretag)
1888
	b = appendVarint(b, uint64(*p))
1889
	return b, nil
1890
}
1891
func appendVarint32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1892
	s := *ptr.toUint32Slice()
1893
	for _, v := range s {
1894
		b = appendVarint(b, wiretag)
1895
		b = appendVarint(b, uint64(v))
1896
	}
1897
	return b, nil
1898
}
1899
func appendVarint32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1900
	s := *ptr.toUint32Slice()
1901
	if len(s) == 0 {
1902
		return b, nil
1903
	}
1904
	b = appendVarint(b, wiretag&^7|WireBytes)
1905
	// compute size
1906
	n := 0
1907
	for _, v := range s {
1908
		n += SizeVarint(uint64(v))
1909
	}
1910
	b = appendVarint(b, uint64(n))
1911
	for _, v := range s {
1912
		b = appendVarint(b, uint64(v))
1913
	}
1914
	return b, nil
1915
}
1916
func appendVarintS32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1917
	v := *ptr.toInt32()
1918
	b = appendVarint(b, wiretag)
1919
	b = appendVarint(b, uint64(v))
1920
	return b, nil
1921
}
1922
func appendVarintS32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1923
	v := *ptr.toInt32()
1924
	if v == 0 {
1925
		return b, nil
1926
	}
1927
	b = appendVarint(b, wiretag)
1928
	b = appendVarint(b, uint64(v))
1929
	return b, nil
1930
}
1931
func appendVarintS32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1932
	p := ptr.getInt32Ptr()
1933
	if p == nil {
1934
		return b, nil
1935
	}
1936
	b = appendVarint(b, wiretag)
1937
	b = appendVarint(b, uint64(*p))
1938
	return b, nil
1939
}
1940
func appendVarintS32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1941
	s := ptr.getInt32Slice()
1942
	for _, v := range s {
1943
		b = appendVarint(b, wiretag)
1944
		b = appendVarint(b, uint64(v))
1945
	}
1946
	return b, nil
1947
}
1948
func appendVarintS32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1949
	s := ptr.getInt32Slice()
1950
	if len(s) == 0 {
1951
		return b, nil
1952
	}
1953
	b = appendVarint(b, wiretag&^7|WireBytes)
1954
	// compute size
1955
	n := 0
1956
	for _, v := range s {
1957
		n += SizeVarint(uint64(v))
1958
	}
1959
	b = appendVarint(b, uint64(n))
1960
	for _, v := range s {
1961
		b = appendVarint(b, uint64(v))
1962
	}
1963
	return b, nil
1964
}
1965
func appendVarint64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1966
	v := *ptr.toUint64()
1967
	b = appendVarint(b, wiretag)
1968
	b = appendVarint(b, v)
1969
	return b, nil
1970
}
1971
func appendVarint64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1972
	v := *ptr.toUint64()
1973
	if v == 0 {
1974
		return b, nil
1975
	}
1976
	b = appendVarint(b, wiretag)
1977
	b = appendVarint(b, v)
1978
	return b, nil
1979
}
1980
func appendVarint64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1981
	p := *ptr.toUint64Ptr()
1982
	if p == nil {
1983
		return b, nil
1984
	}
1985
	b = appendVarint(b, wiretag)
1986
	b = appendVarint(b, *p)
1987
	return b, nil
1988
}
1989
func appendVarint64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1990
	s := *ptr.toUint64Slice()
1991
	for _, v := range s {
1992
		b = appendVarint(b, wiretag)
1993
		b = appendVarint(b, v)
1994
	}
1995
	return b, nil
1996
}
1997
func appendVarint64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1998
	s := *ptr.toUint64Slice()
1999
	if len(s) == 0 {
2000
		return b, nil
2001
	}
2002
	b = appendVarint(b, wiretag&^7|WireBytes)
2003
	// compute size
2004
	n := 0
2005
	for _, v := range s {
2006
		n += SizeVarint(v)
2007
	}
2008
	b = appendVarint(b, uint64(n))
2009
	for _, v := range s {
2010
		b = appendVarint(b, v)
2011
	}
2012
	return b, nil
2013
}
2014
func appendVarintS64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2015
	v := *ptr.toInt64()
2016
	b = appendVarint(b, wiretag)
2017
	b = appendVarint(b, uint64(v))
2018
	return b, nil
2019
}
2020
func appendVarintS64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2021
	v := *ptr.toInt64()
2022
	if v == 0 {
2023
		return b, nil
2024
	}
2025
	b = appendVarint(b, wiretag)
2026
	b = appendVarint(b, uint64(v))
2027
	return b, nil
2028
}
2029
func appendVarintS64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2030
	p := *ptr.toInt64Ptr()
2031
	if p == nil {
2032
		return b, nil
2033
	}
2034
	b = appendVarint(b, wiretag)
2035
	b = appendVarint(b, uint64(*p))
2036
	return b, nil
2037
}
2038
func appendVarintS64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2039
	s := *ptr.toInt64Slice()
2040
	for _, v := range s {
2041
		b = appendVarint(b, wiretag)
2042
		b = appendVarint(b, uint64(v))
2043
	}
2044
	return b, nil
2045
}
2046
func appendVarintS64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2047
	s := *ptr.toInt64Slice()
2048
	if len(s) == 0 {
2049
		return b, nil
2050
	}
2051
	b = appendVarint(b, wiretag&^7|WireBytes)
2052
	// compute size
2053
	n := 0
2054
	for _, v := range s {
2055
		n += SizeVarint(uint64(v))
2056
	}
2057
	b = appendVarint(b, uint64(n))
2058
	for _, v := range s {
2059
		b = appendVarint(b, uint64(v))
2060
	}
2061
	return b, nil
2062
}
2063
func appendZigzag32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2064
	v := *ptr.toInt32()
2065
	b = appendVarint(b, wiretag)
2066
	b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
2067
	return b, nil
2068
}
2069
func appendZigzag32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2070
	v := *ptr.toInt32()
2071
	if v == 0 {
2072
		return b, nil
2073
	}
2074
	b = appendVarint(b, wiretag)
2075
	b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
2076
	return b, nil
2077
}
2078
func appendZigzag32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2079
	p := ptr.getInt32Ptr()
2080
	if p == nil {
2081
		return b, nil
2082
	}
2083
	b = appendVarint(b, wiretag)
2084
	v := *p
2085
	b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
2086
	return b, nil
2087
}
2088
func appendZigzag32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2089
	s := ptr.getInt32Slice()
2090
	for _, v := range s {
2091
		b = appendVarint(b, wiretag)
2092
		b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
2093
	}
2094
	return b, nil
2095
}
2096
func appendZigzag32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2097
	s := ptr.getInt32Slice()
2098
	if len(s) == 0 {
2099
		return b, nil
2100
	}
2101
	b = appendVarint(b, wiretag&^7|WireBytes)
2102
	// compute size
2103
	n := 0
2104
	for _, v := range s {
2105
		n += SizeVarint(uint64((uint32(v) << 1) ^ uint32((int32(v) >> 31))))
2106
	}
2107
	b = appendVarint(b, uint64(n))
2108
	for _, v := range s {
2109
		b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
2110
	}
2111
	return b, nil
2112
}
2113
func appendZigzag64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2114
	v := *ptr.toInt64()
2115
	b = appendVarint(b, wiretag)
2116
	b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
2117
	return b, nil
2118
}
2119
func appendZigzag64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2120
	v := *ptr.toInt64()
2121
	if v == 0 {
2122
		return b, nil
2123
	}
2124
	b = appendVarint(b, wiretag)
2125
	b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
2126
	return b, nil
2127
}
2128
func appendZigzag64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2129
	p := *ptr.toInt64Ptr()
2130
	if p == nil {
2131
		return b, nil
2132
	}
2133
	b = appendVarint(b, wiretag)
2134
	v := *p
2135
	b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
2136
	return b, nil
2137
}
2138
func appendZigzag64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2139
	s := *ptr.toInt64Slice()
2140
	for _, v := range s {
2141
		b = appendVarint(b, wiretag)
2142
		b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
2143
	}
2144
	return b, nil
2145
}
2146
func appendZigzag64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2147
	s := *ptr.toInt64Slice()
2148
	if len(s) == 0 {
2149
		return b, nil
2150
	}
2151
	b = appendVarint(b, wiretag&^7|WireBytes)
2152
	// compute size
2153
	n := 0
2154
	for _, v := range s {
2155
		n += SizeVarint(uint64(v<<1) ^ uint64((int64(v) >> 63)))
2156
	}
2157
	b = appendVarint(b, uint64(n))
2158
	for _, v := range s {
2159
		b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
2160
	}
2161
	return b, nil
2162
}
2163
func appendBoolValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2164
	v := *ptr.toBool()
2165
	b = appendVarint(b, wiretag)
2166
	if v {
2167
		b = append(b, 1)
2168
	} else {
2169
		b = append(b, 0)
2170
	}
2171
	return b, nil
2172
}
2173
func appendBoolValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2174
	v := *ptr.toBool()
2175
	if !v {
2176
		return b, nil
2177
	}
2178
	b = appendVarint(b, wiretag)
2179
	b = append(b, 1)
2180
	return b, nil
2181
}
2182

2183
func appendBoolPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2184
	p := *ptr.toBoolPtr()
2185
	if p == nil {
2186
		return b, nil
2187
	}
2188
	b = appendVarint(b, wiretag)
2189
	if *p {
2190
		b = append(b, 1)
2191
	} else {
2192
		b = append(b, 0)
2193
	}
2194
	return b, nil
2195
}
2196
func appendBoolSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2197
	s := *ptr.toBoolSlice()
2198
	for _, v := range s {
2199
		b = appendVarint(b, wiretag)
2200
		if v {
2201
			b = append(b, 1)
2202
		} else {
2203
			b = append(b, 0)
2204
		}
2205
	}
2206
	return b, nil
2207
}
2208
func appendBoolPackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2209
	s := *ptr.toBoolSlice()
2210
	if len(s) == 0 {
2211
		return b, nil
2212
	}
2213
	b = appendVarint(b, wiretag&^7|WireBytes)
2214
	b = appendVarint(b, uint64(len(s)))
2215
	for _, v := range s {
2216
		if v {
2217
			b = append(b, 1)
2218
		} else {
2219
			b = append(b, 0)
2220
		}
2221
	}
2222
	return b, nil
2223
}
2224
func appendStringValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2225
	v := *ptr.toString()
2226
	b = appendVarint(b, wiretag)
2227
	b = appendVarint(b, uint64(len(v)))
2228
	b = append(b, v...)
2229
	return b, nil
2230
}
2231
func appendStringValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2232
	v := *ptr.toString()
2233
	if v == "" {
2234
		return b, nil
2235
	}
2236
	b = appendVarint(b, wiretag)
2237
	b = appendVarint(b, uint64(len(v)))
2238
	b = append(b, v...)
2239
	return b, nil
2240
}
2241
func appendStringPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2242
	p := *ptr.toStringPtr()
2243
	if p == nil {
2244
		return b, nil
2245
	}
2246
	v := *p
2247
	b = appendVarint(b, wiretag)
2248
	b = appendVarint(b, uint64(len(v)))
2249
	b = append(b, v...)
2250
	return b, nil
2251
}
2252
func appendStringSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2253
	s := *ptr.toStringSlice()
2254
	for _, v := range s {
2255
		b = appendVarint(b, wiretag)
2256
		b = appendVarint(b, uint64(len(v)))
2257
		b = append(b, v...)
2258
	}
2259
	return b, nil
2260
}
2261
func appendUTF8StringValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2262
	var invalidUTF8 bool
2263
	v := *ptr.toString()
2264
	if !utf8.ValidString(v) {
2265
		invalidUTF8 = true
2266
	}
2267
	b = appendVarint(b, wiretag)
2268
	b = appendVarint(b, uint64(len(v)))
2269
	b = append(b, v...)
2270
	if invalidUTF8 {
2271
		return b, errInvalidUTF8
2272
	}
2273
	return b, nil
2274
}
2275
func appendUTF8StringValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2276
	var invalidUTF8 bool
2277
	v := *ptr.toString()
2278
	if v == "" {
2279
		return b, nil
2280
	}
2281
	if !utf8.ValidString(v) {
2282
		invalidUTF8 = true
2283
	}
2284
	b = appendVarint(b, wiretag)
2285
	b = appendVarint(b, uint64(len(v)))
2286
	b = append(b, v...)
2287
	if invalidUTF8 {
2288
		return b, errInvalidUTF8
2289
	}
2290
	return b, nil
2291
}
2292
func appendUTF8StringPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2293
	var invalidUTF8 bool
2294
	p := *ptr.toStringPtr()
2295
	if p == nil {
2296
		return b, nil
2297
	}
2298
	v := *p
2299
	if !utf8.ValidString(v) {
2300
		invalidUTF8 = true
2301
	}
2302
	b = appendVarint(b, wiretag)
2303
	b = appendVarint(b, uint64(len(v)))
2304
	b = append(b, v...)
2305
	if invalidUTF8 {
2306
		return b, errInvalidUTF8
2307
	}
2308
	return b, nil
2309
}
2310
func appendUTF8StringSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2311
	var invalidUTF8 bool
2312
	s := *ptr.toStringSlice()
2313
	for _, v := range s {
2314
		if !utf8.ValidString(v) {
2315
			invalidUTF8 = true
2316
		}
2317
		b = appendVarint(b, wiretag)
2318
		b = appendVarint(b, uint64(len(v)))
2319
		b = append(b, v...)
2320
	}
2321
	if invalidUTF8 {
2322
		return b, errInvalidUTF8
2323
	}
2324
	return b, nil
2325
}
2326
func appendBytes(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2327
	v := *ptr.toBytes()
2328
	if v == nil {
2329
		return b, nil
2330
	}
2331
	b = appendVarint(b, wiretag)
2332
	b = appendVarint(b, uint64(len(v)))
2333
	b = append(b, v...)
2334
	return b, nil
2335
}
2336
func appendBytes3(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2337
	v := *ptr.toBytes()
2338
	if len(v) == 0 {
2339
		return b, nil
2340
	}
2341
	b = appendVarint(b, wiretag)
2342
	b = appendVarint(b, uint64(len(v)))
2343
	b = append(b, v...)
2344
	return b, nil
2345
}
2346
func appendBytesOneof(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2347
	v := *ptr.toBytes()
2348
	b = appendVarint(b, wiretag)
2349
	b = appendVarint(b, uint64(len(v)))
2350
	b = append(b, v...)
2351
	return b, nil
2352
}
2353
func appendBytesSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2354
	s := *ptr.toBytesSlice()
2355
	for _, v := range s {
2356
		b = appendVarint(b, wiretag)
2357
		b = appendVarint(b, uint64(len(v)))
2358
		b = append(b, v...)
2359
	}
2360
	return b, nil
2361
}
2362

2363
// makeGroupMarshaler returns the sizer and marshaler for a group.
2364
// u is the marshal info of the underlying message.
2365
func makeGroupMarshaler(u *marshalInfo) (sizer, marshaler) {
2366
	return func(ptr pointer, tagsize int) int {
2367
			p := ptr.getPointer()
2368
			if p.isNil() {
2369
				return 0
2370
			}
2371
			return u.size(p) + 2*tagsize
2372
		},
2373
		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
2374
			p := ptr.getPointer()
2375
			if p.isNil() {
2376
				return b, nil
2377
			}
2378
			var err error
2379
			b = appendVarint(b, wiretag) // start group
2380
			b, err = u.marshal(b, p, deterministic)
2381
			b = appendVarint(b, wiretag+(WireEndGroup-WireStartGroup)) // end group
2382
			return b, err
2383
		}
2384
}
2385

2386
// makeGroupSliceMarshaler returns the sizer and marshaler for a group slice.
2387
// u is the marshal info of the underlying message.
2388
func makeGroupSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
2389
	return func(ptr pointer, tagsize int) int {
2390
			s := ptr.getPointerSlice()
2391
			n := 0
2392
			for _, v := range s {
2393
				if v.isNil() {
2394
					continue
2395
				}
2396
				n += u.size(v) + 2*tagsize
2397
			}
2398
			return n
2399
		},
2400
		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
2401
			s := ptr.getPointerSlice()
2402
			var err error
2403
			var nerr nonFatal
2404
			for _, v := range s {
2405
				if v.isNil() {
2406
					return b, errRepeatedHasNil
2407
				}
2408
				b = appendVarint(b, wiretag) // start group
2409
				b, err = u.marshal(b, v, deterministic)
2410
				b = appendVarint(b, wiretag+(WireEndGroup-WireStartGroup)) // end group
2411
				if !nerr.Merge(err) {
2412
					if err == ErrNil {
2413
						err = errRepeatedHasNil
2414
					}
2415
					return b, err
2416
				}
2417
			}
2418
			return b, nerr.E
2419
		}
2420
}
2421

2422
// makeMessageMarshaler returns the sizer and marshaler for a message field.
2423
// u is the marshal info of the message.
2424
func makeMessageMarshaler(u *marshalInfo) (sizer, marshaler) {
2425
	return func(ptr pointer, tagsize int) int {
2426
			p := ptr.getPointer()
2427
			if p.isNil() {
2428
				return 0
2429
			}
2430
			siz := u.size(p)
2431
			return siz + SizeVarint(uint64(siz)) + tagsize
2432
		},
2433
		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
2434
			p := ptr.getPointer()
2435
			if p.isNil() {
2436
				return b, nil
2437
			}
2438
			b = appendVarint(b, wiretag)
2439
			siz := u.cachedsize(p)
2440
			b = appendVarint(b, uint64(siz))
2441
			return u.marshal(b, p, deterministic)
2442
		}
2443
}
2444

2445
// makeMessageSliceMarshaler returns the sizer and marshaler for a message slice.
2446
// u is the marshal info of the message.
2447
func makeMessageSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
2448
	return func(ptr pointer, tagsize int) int {
2449
			s := ptr.getPointerSlice()
2450
			n := 0
2451
			for _, v := range s {
2452
				if v.isNil() {
2453
					continue
2454
				}
2455
				siz := u.size(v)
2456
				n += siz + SizeVarint(uint64(siz)) + tagsize
2457
			}
2458
			return n
2459
		},
2460
		func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
2461
			s := ptr.getPointerSlice()
2462
			var err error
2463
			var nerr nonFatal
2464
			for _, v := range s {
2465
				if v.isNil() {
2466
					return b, errRepeatedHasNil
2467
				}
2468
				b = appendVarint(b, wiretag)
2469
				siz := u.cachedsize(v)
2470
				b = appendVarint(b, uint64(siz))
2471
				b, err = u.marshal(b, v, deterministic)
2472

2473
				if !nerr.Merge(err) {
2474
					if err == ErrNil {
2475
						err = errRepeatedHasNil
2476
					}
2477
					return b, err
2478
				}
2479
			}
2480
			return b, nerr.E
2481
		}
2482
}
2483

2484
// makeMapMarshaler returns the sizer and marshaler for a map field.
2485
// f is the pointer to the reflect data structure of the field.
2486
func makeMapMarshaler(f *reflect.StructField) (sizer, marshaler) {
2487
	// figure out key and value type
2488
	t := f.Type
2489
	keyType := t.Key()
2490
	valType := t.Elem()
2491
	tags := strings.Split(f.Tag.Get("protobuf"), ",")
2492
	keyTags := strings.Split(f.Tag.Get("protobuf_key"), ",")
2493
	valTags := strings.Split(f.Tag.Get("protobuf_val"), ",")
2494
	stdOptions := false
2495
	for _, t := range tags {
2496
		if strings.HasPrefix(t, "customtype=") {
2497
			valTags = append(valTags, t)
2498
		}
2499
		if t == "stdtime" {
2500
			valTags = append(valTags, t)
2501
			stdOptions = true
2502
		}
2503
		if t == "stdduration" {
2504
			valTags = append(valTags, t)
2505
			stdOptions = true
2506
		}
2507
		if t == "wktptr" {
2508
			valTags = append(valTags, t)
2509
		}
2510
	}
2511
	keySizer, keyMarshaler := typeMarshaler(keyType, keyTags, false, false) // don't omit zero value in map
2512
	valSizer, valMarshaler := typeMarshaler(valType, valTags, false, false) // don't omit zero value in map
2513
	keyWireTag := 1<<3 | wiretype(keyTags[0])
2514
	valWireTag := 2<<3 | wiretype(valTags[0])
2515

2516
	// We create an interface to get the addresses of the map key and value.
2517
	// If value is pointer-typed, the interface is a direct interface, the
2518
	// idata itself is the value. Otherwise, the idata is the pointer to the
2519
	// value.
2520
	// Key cannot be pointer-typed.
2521
	valIsPtr := valType.Kind() == reflect.Ptr
2522

2523
	// If value is a message with nested maps, calling
2524
	// valSizer in marshal may be quadratic. We should use
2525
	// cached version in marshal (but not in size).
2526
	// If value is not message type, we don't have size cache,
2527
	// but it cannot be nested either. Just use valSizer.
2528
	valCachedSizer := valSizer
2529
	if valIsPtr && !stdOptions && valType.Elem().Kind() == reflect.Struct {
2530
		u := getMarshalInfo(valType.Elem())
2531
		valCachedSizer = func(ptr pointer, tagsize int) int {
2532
			// Same as message sizer, but use cache.
2533
			p := ptr.getPointer()
2534
			if p.isNil() {
2535
				return 0
2536
			}
2537
			siz := u.cachedsize(p)
2538
			return siz + SizeVarint(uint64(siz)) + tagsize
2539
		}
2540
	}
2541
	return func(ptr pointer, tagsize int) int {
2542
			m := ptr.asPointerTo(t).Elem() // the map
2543
			n := 0
2544
			for _, k := range m.MapKeys() {
2545
				ki := k.Interface()
2546
				vi := m.MapIndex(k).Interface()
2547
				kaddr := toAddrPointer(&ki, false)             // pointer to key
2548
				vaddr := toAddrPointer(&vi, valIsPtr)          // pointer to value
2549
				siz := keySizer(kaddr, 1) + valSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1)
2550
				n += siz + SizeVarint(uint64(siz)) + tagsize
2551
			}
2552
			return n
2553
		},
2554
		func(b []byte, ptr pointer, tag uint64, deterministic bool) ([]byte, error) {
2555
			m := ptr.asPointerTo(t).Elem() // the map
2556
			var err error
2557
			keys := m.MapKeys()
2558
			if len(keys) > 1 && deterministic {
2559
				sort.Sort(mapKeys(keys))
2560
			}
2561

2562
			var nerr nonFatal
2563
			for _, k := range keys {
2564
				ki := k.Interface()
2565
				vi := m.MapIndex(k).Interface()
2566
				kaddr := toAddrPointer(&ki, false)    // pointer to key
2567
				vaddr := toAddrPointer(&vi, valIsPtr) // pointer to value
2568
				b = appendVarint(b, tag)
2569
				siz := keySizer(kaddr, 1) + valCachedSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1)
2570
				b = appendVarint(b, uint64(siz))
2571
				b, err = keyMarshaler(b, kaddr, keyWireTag, deterministic)
2572
				if !nerr.Merge(err) {
2573
					return b, err
2574
				}
2575
				b, err = valMarshaler(b, vaddr, valWireTag, deterministic)
2576
				if err != ErrNil && !nerr.Merge(err) { // allow nil value in map
2577
					return b, err
2578
				}
2579
			}
2580
			return b, nerr.E
2581
		}
2582
}
2583

2584
// makeOneOfMarshaler returns the sizer and marshaler for a oneof field.
2585
// fi is the marshal info of the field.
2586
// f is the pointer to the reflect data structure of the field.
2587
func makeOneOfMarshaler(fi *marshalFieldInfo, f *reflect.StructField) (sizer, marshaler) {
2588
	// Oneof field is an interface. We need to get the actual data type on the fly.
2589
	t := f.Type
2590
	return func(ptr pointer, _ int) int {
2591
			p := ptr.getInterfacePointer()
2592
			if p.isNil() {
2593
				return 0
2594
			}
2595
			v := ptr.asPointerTo(t).Elem().Elem().Elem() // *interface -> interface -> *struct -> struct
2596
			telem := v.Type()
2597
			e := fi.oneofElems[telem]
2598
			return e.sizer(p, e.tagsize)
2599
		},
2600
		func(b []byte, ptr pointer, _ uint64, deterministic bool) ([]byte, error) {
2601
			p := ptr.getInterfacePointer()
2602
			if p.isNil() {
2603
				return b, nil
2604
			}
2605
			v := ptr.asPointerTo(t).Elem().Elem().Elem() // *interface -> interface -> *struct -> struct
2606
			telem := v.Type()
2607
			if telem.Field(0).Type.Kind() == reflect.Ptr && p.getPointer().isNil() {
2608
				return b, errOneofHasNil
2609
			}
2610
			e := fi.oneofElems[telem]
2611
			return e.marshaler(b, p, e.wiretag, deterministic)
2612
		}
2613
}
2614

2615
// sizeExtensions computes the size of encoded data for a XXX_InternalExtensions field.
2616
func (u *marshalInfo) sizeExtensions(ext *XXX_InternalExtensions) int {
2617
	m, mu := ext.extensionsRead()
2618
	if m == nil {
2619
		return 0
2620
	}
2621
	mu.Lock()
2622

2623
	n := 0
2624
	for _, e := range m {
2625
		if e.value == nil || e.desc == nil {
2626
			// Extension is only in its encoded form.
2627
			n += len(e.enc)
2628
			continue
2629
		}
2630

2631
		// We don't skip extensions that have an encoded form set,
2632
		// because the extension value may have been mutated after
2633
		// the last time this function was called.
2634
		ei := u.getExtElemInfo(e.desc)
2635
		v := e.value
2636
		p := toAddrPointer(&v, ei.isptr)
2637
		n += ei.sizer(p, ei.tagsize)
2638
	}
2639
	mu.Unlock()
2640
	return n
2641
}
2642

2643
// appendExtensions marshals a XXX_InternalExtensions field to the end of byte slice b.
2644
func (u *marshalInfo) appendExtensions(b []byte, ext *XXX_InternalExtensions, deterministic bool) ([]byte, error) {
2645
	m, mu := ext.extensionsRead()
2646
	if m == nil {
2647
		return b, nil
2648
	}
2649
	mu.Lock()
2650
	defer mu.Unlock()
2651

2652
	var err error
2653
	var nerr nonFatal
2654

2655
	// Fast-path for common cases: zero or one extensions.
2656
	// Don't bother sorting the keys.
2657
	if len(m) <= 1 {
2658
		for _, e := range m {
2659
			if e.value == nil || e.desc == nil {
2660
				// Extension is only in its encoded form.
2661
				b = append(b, e.enc...)
2662
				continue
2663
			}
2664

2665
			// We don't skip extensions that have an encoded form set,
2666
			// because the extension value may have been mutated after
2667
			// the last time this function was called.
2668

2669
			ei := u.getExtElemInfo(e.desc)
2670
			v := e.value
2671
			p := toAddrPointer(&v, ei.isptr)
2672
			b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
2673
			if !nerr.Merge(err) {
2674
				return b, err
2675
			}
2676
		}
2677
		return b, nerr.E
2678
	}
2679

2680
	// Sort the keys to provide a deterministic encoding.
2681
	// Not sure this is required, but the old code does it.
2682
	keys := make([]int, 0, len(m))
2683
	for k := range m {
2684
		keys = append(keys, int(k))
2685
	}
2686
	sort.Ints(keys)
2687

2688
	for _, k := range keys {
2689
		e := m[int32(k)]
2690
		if e.value == nil || e.desc == nil {
2691
			// Extension is only in its encoded form.
2692
			b = append(b, e.enc...)
2693
			continue
2694
		}
2695

2696
		// We don't skip extensions that have an encoded form set,
2697
		// because the extension value may have been mutated after
2698
		// the last time this function was called.
2699

2700
		ei := u.getExtElemInfo(e.desc)
2701
		v := e.value
2702
		p := toAddrPointer(&v, ei.isptr)
2703
		b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
2704
		if !nerr.Merge(err) {
2705
			return b, err
2706
		}
2707
	}
2708
	return b, nerr.E
2709
}
2710

2711
// message set format is:
2712
//   message MessageSet {
2713
//     repeated group Item = 1 {
2714
//       required int32 type_id = 2;
2715
//       required string message = 3;
2716
//     };
2717
//   }
2718

2719
// sizeMessageSet computes the size of encoded data for a XXX_InternalExtensions field
2720
// in message set format (above).
2721
func (u *marshalInfo) sizeMessageSet(ext *XXX_InternalExtensions) int {
2722
	m, mu := ext.extensionsRead()
2723
	if m == nil {
2724
		return 0
2725
	}
2726
	mu.Lock()
2727

2728
	n := 0
2729
	for id, e := range m {
2730
		n += 2                          // start group, end group. tag = 1 (size=1)
2731
		n += SizeVarint(uint64(id)) + 1 // type_id, tag = 2 (size=1)
2732

2733
		if e.value == nil || e.desc == nil {
2734
			// Extension is only in its encoded form.
2735
			msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint
2736
			siz := len(msgWithLen)
2737
			n += siz + 1 // message, tag = 3 (size=1)
2738
			continue
2739
		}
2740

2741
		// We don't skip extensions that have an encoded form set,
2742
		// because the extension value may have been mutated after
2743
		// the last time this function was called.
2744

2745
		ei := u.getExtElemInfo(e.desc)
2746
		v := e.value
2747
		p := toAddrPointer(&v, ei.isptr)
2748
		n += ei.sizer(p, 1) // message, tag = 3 (size=1)
2749
	}
2750
	mu.Unlock()
2751
	return n
2752
}
2753

2754
// appendMessageSet marshals a XXX_InternalExtensions field in message set format (above)
2755
// to the end of byte slice b.
2756
func (u *marshalInfo) appendMessageSet(b []byte, ext *XXX_InternalExtensions, deterministic bool) ([]byte, error) {
2757
	m, mu := ext.extensionsRead()
2758
	if m == nil {
2759
		return b, nil
2760
	}
2761
	mu.Lock()
2762
	defer mu.Unlock()
2763

2764
	var err error
2765
	var nerr nonFatal
2766

2767
	// Fast-path for common cases: zero or one extensions.
2768
	// Don't bother sorting the keys.
2769
	if len(m) <= 1 {
2770
		for id, e := range m {
2771
			b = append(b, 1<<3|WireStartGroup)
2772
			b = append(b, 2<<3|WireVarint)
2773
			b = appendVarint(b, uint64(id))
2774

2775
			if e.value == nil || e.desc == nil {
2776
				// Extension is only in its encoded form.
2777
				msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint
2778
				b = append(b, 3<<3|WireBytes)
2779
				b = append(b, msgWithLen...)
2780
				b = append(b, 1<<3|WireEndGroup)
2781
				continue
2782
			}
2783

2784
			// We don't skip extensions that have an encoded form set,
2785
			// because the extension value may have been mutated after
2786
			// the last time this function was called.
2787

2788
			ei := u.getExtElemInfo(e.desc)
2789
			v := e.value
2790
			p := toAddrPointer(&v, ei.isptr)
2791
			b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic)
2792
			if !nerr.Merge(err) {
2793
				return b, err
2794
			}
2795
			b = append(b, 1<<3|WireEndGroup)
2796
		}
2797
		return b, nerr.E
2798
	}
2799

2800
	// Sort the keys to provide a deterministic encoding.
2801
	keys := make([]int, 0, len(m))
2802
	for k := range m {
2803
		keys = append(keys, int(k))
2804
	}
2805
	sort.Ints(keys)
2806

2807
	for _, id := range keys {
2808
		e := m[int32(id)]
2809
		b = append(b, 1<<3|WireStartGroup)
2810
		b = append(b, 2<<3|WireVarint)
2811
		b = appendVarint(b, uint64(id))
2812

2813
		if e.value == nil || e.desc == nil {
2814
			// Extension is only in its encoded form.
2815
			msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint
2816
			b = append(b, 3<<3|WireBytes)
2817
			b = append(b, msgWithLen...)
2818
			b = append(b, 1<<3|WireEndGroup)
2819
			continue
2820
		}
2821

2822
		// We don't skip extensions that have an encoded form set,
2823
		// because the extension value may have been mutated after
2824
		// the last time this function was called.
2825

2826
		ei := u.getExtElemInfo(e.desc)
2827
		v := e.value
2828
		p := toAddrPointer(&v, ei.isptr)
2829
		b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic)
2830
		b = append(b, 1<<3|WireEndGroup)
2831
		if !nerr.Merge(err) {
2832
			return b, err
2833
		}
2834
	}
2835
	return b, nerr.E
2836
}
2837

2838
// sizeV1Extensions computes the size of encoded data for a V1-API extension field.
2839
func (u *marshalInfo) sizeV1Extensions(m map[int32]Extension) int {
2840
	if m == nil {
2841
		return 0
2842
	}
2843

2844
	n := 0
2845
	for _, e := range m {
2846
		if e.value == nil || e.desc == nil {
2847
			// Extension is only in its encoded form.
2848
			n += len(e.enc)
2849
			continue
2850
		}
2851

2852
		// We don't skip extensions that have an encoded form set,
2853
		// because the extension value may have been mutated after
2854
		// the last time this function was called.
2855

2856
		ei := u.getExtElemInfo(e.desc)
2857
		v := e.value
2858
		p := toAddrPointer(&v, ei.isptr)
2859
		n += ei.sizer(p, ei.tagsize)
2860
	}
2861
	return n
2862
}
2863

2864
// appendV1Extensions marshals a V1-API extension field to the end of byte slice b.
2865
func (u *marshalInfo) appendV1Extensions(b []byte, m map[int32]Extension, deterministic bool) ([]byte, error) {
2866
	if m == nil {
2867
		return b, nil
2868
	}
2869

2870
	// Sort the keys to provide a deterministic encoding.
2871
	keys := make([]int, 0, len(m))
2872
	for k := range m {
2873
		keys = append(keys, int(k))
2874
	}
2875
	sort.Ints(keys)
2876

2877
	var err error
2878
	var nerr nonFatal
2879
	for _, k := range keys {
2880
		e := m[int32(k)]
2881
		if e.value == nil || e.desc == nil {
2882
			// Extension is only in its encoded form.
2883
			b = append(b, e.enc...)
2884
			continue
2885
		}
2886

2887
		// We don't skip extensions that have an encoded form set,
2888
		// because the extension value may have been mutated after
2889
		// the last time this function was called.
2890

2891
		ei := u.getExtElemInfo(e.desc)
2892
		v := e.value
2893
		p := toAddrPointer(&v, ei.isptr)
2894
		b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
2895
		if !nerr.Merge(err) {
2896
			return b, err
2897
		}
2898
	}
2899
	return b, nerr.E
2900
}
2901

2902
// newMarshaler is the interface representing objects that can marshal themselves.
2903
//
2904
// This exists to support protoc-gen-go generated messages.
2905
// The proto package will stop type-asserting to this interface in the future.
2906
//
2907
// DO NOT DEPEND ON THIS.
2908
type newMarshaler interface {
2909
	XXX_Size() int
2910
	XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
2911
}
2912

2913
// Size returns the encoded size of a protocol buffer message.
2914
// This is the main entry point.
2915
func Size(pb Message) int {
2916
	if m, ok := pb.(newMarshaler); ok {
2917
		return m.XXX_Size()
2918
	}
2919
	if m, ok := pb.(Marshaler); ok {
2920
		// If the message can marshal itself, let it do it, for compatibility.
2921
		// NOTE: This is not efficient.
2922
		b, _ := m.Marshal()
2923
		return len(b)
2924
	}
2925
	// in case somehow we didn't generate the wrapper
2926
	if pb == nil {
2927
		return 0
2928
	}
2929
	var info InternalMessageInfo
2930
	return info.Size(pb)
2931
}
2932

2933
// Marshal takes a protocol buffer message
2934
// and encodes it into the wire format, returning the data.
2935
// This is the main entry point.
2936
func Marshal(pb Message) ([]byte, error) {
2937
	if m, ok := pb.(newMarshaler); ok {
2938
		siz := m.XXX_Size()
2939
		b := make([]byte, 0, siz)
2940
		return m.XXX_Marshal(b, false)
2941
	}
2942
	if m, ok := pb.(Marshaler); ok {
2943
		// If the message can marshal itself, let it do it, for compatibility.
2944
		// NOTE: This is not efficient.
2945
		return m.Marshal()
2946
	}
2947
	// in case somehow we didn't generate the wrapper
2948
	if pb == nil {
2949
		return nil, ErrNil
2950
	}
2951
	var info InternalMessageInfo
2952
	siz := info.Size(pb)
2953
	b := make([]byte, 0, siz)
2954
	return info.Marshal(b, pb, false)
2955
}
2956

2957
// Marshal takes a protocol buffer message
2958
// and encodes it into the wire format, writing the result to the
2959
// Buffer.
2960
// This is an alternative entry point. It is not necessary to use
2961
// a Buffer for most applications.
2962
func (p *Buffer) Marshal(pb Message) error {
2963
	var err error
2964
	if p.deterministic {
2965
		if _, ok := pb.(Marshaler); ok {
2966
			return fmt.Errorf("proto: deterministic not supported by the Marshal method of %T", pb)
2967
		}
2968
	}
2969
	if m, ok := pb.(newMarshaler); ok {
2970
		siz := m.XXX_Size()
2971
		p.grow(siz) // make sure buf has enough capacity
2972
		pp := p.buf[len(p.buf) : len(p.buf) : len(p.buf)+siz]
2973
		pp, err = m.XXX_Marshal(pp, p.deterministic)
2974
		p.buf = append(p.buf, pp...)
2975
		return err
2976
	}
2977
	if m, ok := pb.(Marshaler); ok {
2978
		// If the message can marshal itself, let it do it, for compatibility.
2979
		// NOTE: This is not efficient.
2980
		var b []byte
2981
		b, err = m.Marshal()
2982
		p.buf = append(p.buf, b...)
2983
		return err
2984
	}
2985
	// in case somehow we didn't generate the wrapper
2986
	if pb == nil {
2987
		return ErrNil
2988
	}
2989
	var info InternalMessageInfo
2990
	siz := info.Size(pb)
2991
	p.grow(siz) // make sure buf has enough capacity
2992
	p.buf, err = info.Marshal(p.buf, pb, p.deterministic)
2993
	return err
2994
}
2995

2996
// grow grows the buffer's capacity, if necessary, to guarantee space for
2997
// another n bytes. After grow(n), at least n bytes can be written to the
2998
// buffer without another allocation.
2999
func (p *Buffer) grow(n int) {
3000
	need := len(p.buf) + n
3001
	if need <= cap(p.buf) {
3002
		return
3003
	}
3004
	newCap := len(p.buf) * 2
3005
	if newCap < need {
3006
		newCap = need
3007
	}
3008
	p.buf = append(make([]byte, 0, newCap), p.buf...)
3009
}
3010