1 // Go support for Protocol Buffers - Google's data interchange format
3 // Copyright 2016 The Go Authors. All rights reserved.
4 // https://github.com/golang/protobuf
6 // Redistribution and use in source and binary forms, with or without
7 // modification, are permitted provided that the following conditions are
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
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.
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.
47 // a sizer takes a pointer to a field and the size of its tag, computes the size of
49 type sizer func(pointer, int) int
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)
55 // marshalInfo is the information used for marshaling a message.
56 type marshalInfo struct {
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
70 // marshalFieldInfo is the information used for marshaling a field of a message.
71 type marshalFieldInfo struct {
73 wiretag uint64 // tag in wire format
74 tagsize int // size of tag in wire format
78 required bool // field is required
79 name string // name of the field, for error reporting
80 oneofElems map[reflect.Type]*marshalElemInfo // info of oneof elements
83 // marshalElemInfo is the information used for marshaling an extension or oneof element.
84 type marshalElemInfo struct {
85 wiretag uint64 // tag in wire format
86 tagsize int // size of tag in wire format
89 isptr bool // elem is pointer typed, thus interface of this type is a direct interface (extension only)
90 deref bool // dereference the pointer before operating on it; implies isptr
94 marshalInfoMap = map[reflect.Type]*marshalInfo{}
95 marshalInfoLock sync.Mutex
98 // getMarshalInfo returns the information to marshal a given type of message.
99 // The info it returns may not necessarily initialized.
100 // t is the type of the message (NOT the pointer to it).
101 func getMarshalInfo(t reflect.Type) *marshalInfo {
102 marshalInfoLock.Lock()
103 u, ok := marshalInfoMap[t]
105 u = &marshalInfo{typ: t}
106 marshalInfoMap[t] = u
108 marshalInfoLock.Unlock()
112 // Size is the entry point from generated code,
113 // and should be ONLY called by generated code.
114 // It computes the size of encoded data of msg.
115 // a is a pointer to a place to store cached marshal info.
116 func (a *InternalMessageInfo) Size(msg Message) int {
117 u := getMessageMarshalInfo(msg, a)
118 ptr := toPointer(&msg)
120 // We get here if msg is a typed nil ((*SomeMessage)(nil)),
121 // so it satisfies the interface, and msg == nil wouldn't
122 // catch it. We don't want crash in this case.
128 // Marshal is the entry point from generated code,
129 // and should be ONLY called by generated code.
130 // It marshals msg to the end of b.
131 // a is a pointer to a place to store cached marshal info.
132 func (a *InternalMessageInfo) Marshal(b []byte, msg Message, deterministic bool) ([]byte, error) {
133 u := getMessageMarshalInfo(msg, a)
134 ptr := toPointer(&msg)
136 // We get here if msg is a typed nil ((*SomeMessage)(nil)),
137 // so it satisfies the interface, and msg == nil wouldn't
138 // catch it. We don't want crash in this case.
141 return u.marshal(b, ptr, deterministic)
144 func getMessageMarshalInfo(msg interface{}, a *InternalMessageInfo) *marshalInfo {
145 // u := a.marshal, but atomically.
146 // We use an atomic here to ensure memory consistency.
147 u := atomicLoadMarshalInfo(&a.marshal)
149 // Get marshal information from type of message.
150 t := reflect.ValueOf(msg).Type()
151 if t.Kind() != reflect.Ptr {
152 panic(fmt.Sprintf("cannot handle non-pointer message type %v", t))
154 u = getMarshalInfo(t.Elem())
155 // Store it in the cache for later users.
156 // a.marshal = u, but atomically.
157 atomicStoreMarshalInfo(&a.marshal, u)
162 // size is the main function to compute the size of the encoded data of a message.
163 // ptr is the pointer to the message.
164 func (u *marshalInfo) size(ptr pointer) int {
165 if atomic.LoadInt32(&u.initialized) == 0 {
166 u.computeMarshalInfo()
169 // If the message can marshal itself, let it do it, for compatibility.
170 // NOTE: This is not efficient.
172 m := ptr.asPointerTo(u.typ).Interface().(Marshaler)
178 for _, f := range u.fields {
179 if f.isPointer && ptr.offset(f.field).getPointer().isNil() {
180 // nil pointer always marshals to nothing
183 n += f.sizer(ptr.offset(f.field), f.tagsize)
185 if u.extensions.IsValid() {
186 e := ptr.offset(u.extensions).toExtensions()
188 n += u.sizeMessageSet(e)
190 n += u.sizeExtensions(e)
193 if u.v1extensions.IsValid() {
194 m := *ptr.offset(u.v1extensions).toOldExtensions()
195 n += u.sizeV1Extensions(m)
197 if u.unrecognized.IsValid() {
198 s := *ptr.offset(u.unrecognized).toBytes()
201 // cache the result for use in marshal
202 if u.sizecache.IsValid() {
203 atomic.StoreInt32(ptr.offset(u.sizecache).toInt32(), int32(n))
208 // cachedsize gets the size from cache. If there is no cache (i.e. message is not generated),
209 // fall back to compute the size.
210 func (u *marshalInfo) cachedsize(ptr pointer) int {
211 if u.sizecache.IsValid() {
212 return int(atomic.LoadInt32(ptr.offset(u.sizecache).toInt32()))
217 // marshal is the main function to marshal a message. It takes a byte slice and appends
218 // the encoded data to the end of the slice, returns the slice and error (if any).
219 // ptr is the pointer to the message.
220 // If deterministic is true, map is marshaled in deterministic order.
221 func (u *marshalInfo) marshal(b []byte, ptr pointer, deterministic bool) ([]byte, error) {
222 if atomic.LoadInt32(&u.initialized) == 0 {
223 u.computeMarshalInfo()
226 // If the message can marshal itself, let it do it, for compatibility.
227 // NOTE: This is not efficient.
229 m := ptr.asPointerTo(u.typ).Interface().(Marshaler)
230 b1, err := m.Marshal()
235 var err, errLater error
236 // The old marshaler encodes extensions at beginning.
237 if u.extensions.IsValid() {
238 e := ptr.offset(u.extensions).toExtensions()
240 b, err = u.appendMessageSet(b, e, deterministic)
242 b, err = u.appendExtensions(b, e, deterministic)
248 if u.v1extensions.IsValid() {
249 m := *ptr.offset(u.v1extensions).toOldExtensions()
250 b, err = u.appendV1Extensions(b, m, deterministic)
255 for _, f := range u.fields {
257 if ptr.offset(f.field).getPointer().isNil() {
258 // Required field is not set.
259 // We record the error but keep going, to give a complete marshaling.
261 errLater = &RequiredNotSetError{f.name}
266 if f.isPointer && ptr.offset(f.field).getPointer().isNil() {
267 // nil pointer always marshals to nothing
270 b, err = f.marshaler(b, ptr.offset(f.field), f.wiretag, deterministic)
272 if err1, ok := err.(*RequiredNotSetError); ok {
273 // Required field in submessage is not set.
274 // We record the error but keep going, to give a complete marshaling.
276 errLater = &RequiredNotSetError{f.name + "." + err1.field}
280 if err == errRepeatedHasNil {
281 err = errors.New("proto: repeated field " + f.name + " has nil element")
283 if err == errInvalidUTF8 {
285 fullName := revProtoTypes[reflect.PtrTo(u.typ)] + "." + f.name
286 errLater = &invalidUTF8Error{fullName}
293 if u.unrecognized.IsValid() {
294 s := *ptr.offset(u.unrecognized).toBytes()
300 // computeMarshalInfo initializes the marshal info.
301 func (u *marshalInfo) computeMarshalInfo() {
304 if u.initialized != 0 { // non-atomic read is ok as it is protected by the lock
309 u.unrecognized = invalidField
310 u.extensions = invalidField
311 u.v1extensions = invalidField
312 u.sizecache = invalidField
314 // If the message can marshal itself, let it do it, for compatibility.
315 // NOTE: This is not efficient.
316 if reflect.PtrTo(t).Implements(marshalerType) {
317 u.hasmarshaler = true
318 atomic.StoreInt32(&u.initialized, 1)
322 // get oneof implementers
323 var oneofImplementers []interface{}
324 switch m := reflect.Zero(reflect.PtrTo(t)).Interface().(type) {
325 case oneofFuncsIface:
326 _, _, _, oneofImplementers = m.XXX_OneofFuncs()
327 case oneofWrappersIface:
328 oneofImplementers = m.XXX_OneofWrappers()
333 // deal with XXX fields first
334 for i := 0; i < t.NumField(); i++ {
336 if !strings.HasPrefix(f.Name, "XXX_") {
340 case "XXX_sizecache":
341 u.sizecache = toField(&f)
342 case "XXX_unrecognized":
343 u.unrecognized = toField(&f)
344 case "XXX_InternalExtensions":
345 u.extensions = toField(&f)
346 u.messageset = f.Tag.Get("protobuf_messageset") == "1"
347 case "XXX_extensions":
348 u.v1extensions = toField(&f)
349 case "XXX_NoUnkeyedLiteral":
352 panic("unknown XXX field: " + f.Name)
358 fields := make([]marshalFieldInfo, n) // batch allocation
359 u.fields = make([]*marshalFieldInfo, 0, n)
360 for i, j := 0, 0; i < t.NumField(); i++ {
363 if strings.HasPrefix(f.Name, "XXX_") {
369 u.fields = append(u.fields, field)
370 if f.Tag.Get("protobuf_oneof") != "" {
371 field.computeOneofFieldInfo(&f, oneofImplementers)
374 if f.Tag.Get("protobuf") == "" {
375 // field has no tag (not in generated message), ignore it
376 u.fields = u.fields[:len(u.fields)-1]
380 field.computeMarshalFieldInfo(&f)
383 // fields are marshaled in tag order on the wire.
384 sort.Sort(byTag(u.fields))
386 atomic.StoreInt32(&u.initialized, 1)
389 // helper for sorting fields by tag
390 type byTag []*marshalFieldInfo
392 func (a byTag) Len() int { return len(a) }
393 func (a byTag) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
394 func (a byTag) Less(i, j int) bool { return a[i].wiretag < a[j].wiretag }
396 // getExtElemInfo returns the information to marshal an extension element.
397 // The info it returns is initialized.
398 func (u *marshalInfo) getExtElemInfo(desc *ExtensionDesc) *marshalElemInfo {
399 // get from cache first
401 e, ok := u.extElems[desc.Field]
407 t := reflect.TypeOf(desc.ExtensionType) // pointer or slice to basic type or struct
408 tags := strings.Split(desc.Tag, ",")
409 tag, err := strconv.Atoi(tags[1])
411 panic("tag is not an integer")
413 wt := wiretype(tags[0])
414 if t.Kind() == reflect.Ptr && t.Elem().Kind() != reflect.Struct {
417 sizer, marshaler := typeMarshaler(t, tags, false, false)
419 if t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 {
423 e = &marshalElemInfo{
424 wiretag: uint64(tag)<<3 | wt,
425 tagsize: SizeVarint(uint64(tag) << 3),
427 marshaler: marshaler,
428 isptr: t.Kind() == reflect.Ptr,
434 if u.extElems == nil {
435 u.extElems = make(map[int32]*marshalElemInfo)
437 u.extElems[desc.Field] = e
442 // computeMarshalFieldInfo fills up the information to marshal a field.
443 func (fi *marshalFieldInfo) computeMarshalFieldInfo(f *reflect.StructField) {
444 // parse protobuf tag of the field.
445 // tag has format of "bytes,49,opt,name=foo,def=hello!"
446 tags := strings.Split(f.Tag.Get("protobuf"), ",")
450 tag, err := strconv.Atoi(tags[1])
452 panic("tag is not an integer")
454 wt := wiretype(tags[0])
455 if tags[2] == "req" {
458 fi.setTag(f, tag, wt)
459 fi.setMarshaler(f, tags)
462 func (fi *marshalFieldInfo) computeOneofFieldInfo(f *reflect.StructField, oneofImplementers []interface{}) {
463 fi.field = toField(f)
464 fi.wiretag = math.MaxInt32 // Use a large tag number, make oneofs sorted at the end. This tag will not appear on the wire.
466 fi.sizer, fi.marshaler = makeOneOfMarshaler(fi, f)
467 fi.oneofElems = make(map[reflect.Type]*marshalElemInfo)
469 ityp := f.Type // interface type
470 for _, o := range oneofImplementers {
471 t := reflect.TypeOf(o)
472 if !t.Implements(ityp) {
475 sf := t.Elem().Field(0) // oneof implementer is a struct with a single field
476 tags := strings.Split(sf.Tag.Get("protobuf"), ",")
477 tag, err := strconv.Atoi(tags[1])
479 panic("tag is not an integer")
481 wt := wiretype(tags[0])
482 sizer, marshaler := typeMarshaler(sf.Type, tags, false, true) // oneof should not omit any zero value
483 fi.oneofElems[t.Elem()] = &marshalElemInfo{
484 wiretag: uint64(tag)<<3 | wt,
485 tagsize: SizeVarint(uint64(tag) << 3),
487 marshaler: marshaler,
492 // wiretype returns the wire encoding of the type.
493 func wiretype(encoding string) uint64 {
499 case "varint", "zigzag32", "zigzag64":
504 return WireStartGroup
506 panic("unknown wire type " + encoding)
509 // setTag fills up the tag (in wire format) and its size in the info of a field.
510 func (fi *marshalFieldInfo) setTag(f *reflect.StructField, tag int, wt uint64) {
511 fi.field = toField(f)
512 fi.wiretag = uint64(tag)<<3 | wt
513 fi.tagsize = SizeVarint(uint64(tag) << 3)
516 // setMarshaler fills up the sizer and marshaler in the info of a field.
517 func (fi *marshalFieldInfo) setMarshaler(f *reflect.StructField, tags []string) {
518 switch f.Type.Kind() {
522 fi.sizer, fi.marshaler = makeMapMarshaler(f)
524 case reflect.Ptr, reflect.Slice:
527 fi.sizer, fi.marshaler = typeMarshaler(f.Type, tags, true, false)
530 // typeMarshaler returns the sizer and marshaler of a given field.
531 // t is the type of the field.
532 // tags is the generated "protobuf" tag of the field.
533 // If nozero is true, zero value is not marshaled to the wire.
534 // If oneof is true, it is a oneof field.
535 func typeMarshaler(t reflect.Type, tags []string, nozero, oneof bool) (sizer, marshaler) {
540 if t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 {
544 if t.Kind() == reflect.Ptr {
552 for i := 2; i < len(tags); i++ {
553 if tags[i] == "packed" {
556 if tags[i] == "proto3" {
560 validateUTF8 = validateUTF8 && proto3
565 return sizeBoolPtr, appendBoolPtr
569 return sizeBoolPackedSlice, appendBoolPackedSlice
571 return sizeBoolSlice, appendBoolSlice
574 return sizeBoolValueNoZero, appendBoolValueNoZero
576 return sizeBoolValue, appendBoolValue
581 return sizeFixed32Ptr, appendFixed32Ptr
585 return sizeFixed32PackedSlice, appendFixed32PackedSlice
587 return sizeFixed32Slice, appendFixed32Slice
590 return sizeFixed32ValueNoZero, appendFixed32ValueNoZero
592 return sizeFixed32Value, appendFixed32Value
595 return sizeVarint32Ptr, appendVarint32Ptr
599 return sizeVarint32PackedSlice, appendVarint32PackedSlice
601 return sizeVarint32Slice, appendVarint32Slice
604 return sizeVarint32ValueNoZero, appendVarint32ValueNoZero
606 return sizeVarint32Value, appendVarint32Value
612 return sizeFixedS32Ptr, appendFixedS32Ptr
616 return sizeFixedS32PackedSlice, appendFixedS32PackedSlice
618 return sizeFixedS32Slice, appendFixedS32Slice
621 return sizeFixedS32ValueNoZero, appendFixedS32ValueNoZero
623 return sizeFixedS32Value, appendFixedS32Value
626 return sizeVarintS32Ptr, appendVarintS32Ptr
630 return sizeVarintS32PackedSlice, appendVarintS32PackedSlice
632 return sizeVarintS32Slice, appendVarintS32Slice
635 return sizeVarintS32ValueNoZero, appendVarintS32ValueNoZero
637 return sizeVarintS32Value, appendVarintS32Value
640 return sizeZigzag32Ptr, appendZigzag32Ptr
644 return sizeZigzag32PackedSlice, appendZigzag32PackedSlice
646 return sizeZigzag32Slice, appendZigzag32Slice
649 return sizeZigzag32ValueNoZero, appendZigzag32ValueNoZero
651 return sizeZigzag32Value, appendZigzag32Value
657 return sizeFixed64Ptr, appendFixed64Ptr
661 return sizeFixed64PackedSlice, appendFixed64PackedSlice
663 return sizeFixed64Slice, appendFixed64Slice
666 return sizeFixed64ValueNoZero, appendFixed64ValueNoZero
668 return sizeFixed64Value, appendFixed64Value
671 return sizeVarint64Ptr, appendVarint64Ptr
675 return sizeVarint64PackedSlice, appendVarint64PackedSlice
677 return sizeVarint64Slice, appendVarint64Slice
680 return sizeVarint64ValueNoZero, appendVarint64ValueNoZero
682 return sizeVarint64Value, appendVarint64Value
688 return sizeFixedS64Ptr, appendFixedS64Ptr
692 return sizeFixedS64PackedSlice, appendFixedS64PackedSlice
694 return sizeFixedS64Slice, appendFixedS64Slice
697 return sizeFixedS64ValueNoZero, appendFixedS64ValueNoZero
699 return sizeFixedS64Value, appendFixedS64Value
702 return sizeVarintS64Ptr, appendVarintS64Ptr
706 return sizeVarintS64PackedSlice, appendVarintS64PackedSlice
708 return sizeVarintS64Slice, appendVarintS64Slice
711 return sizeVarintS64ValueNoZero, appendVarintS64ValueNoZero
713 return sizeVarintS64Value, appendVarintS64Value
716 return sizeZigzag64Ptr, appendZigzag64Ptr
720 return sizeZigzag64PackedSlice, appendZigzag64PackedSlice
722 return sizeZigzag64Slice, appendZigzag64Slice
725 return sizeZigzag64ValueNoZero, appendZigzag64ValueNoZero
727 return sizeZigzag64Value, appendZigzag64Value
729 case reflect.Float32:
731 return sizeFloat32Ptr, appendFloat32Ptr
735 return sizeFloat32PackedSlice, appendFloat32PackedSlice
737 return sizeFloat32Slice, appendFloat32Slice
740 return sizeFloat32ValueNoZero, appendFloat32ValueNoZero
742 return sizeFloat32Value, appendFloat32Value
743 case reflect.Float64:
745 return sizeFloat64Ptr, appendFloat64Ptr
749 return sizeFloat64PackedSlice, appendFloat64PackedSlice
751 return sizeFloat64Slice, appendFloat64Slice
754 return sizeFloat64ValueNoZero, appendFloat64ValueNoZero
756 return sizeFloat64Value, appendFloat64Value
760 return sizeStringPtr, appendUTF8StringPtr
763 return sizeStringSlice, appendUTF8StringSlice
766 return sizeStringValueNoZero, appendUTF8StringValueNoZero
768 return sizeStringValue, appendUTF8StringValue
771 return sizeStringPtr, appendStringPtr
774 return sizeStringSlice, appendStringSlice
777 return sizeStringValueNoZero, appendStringValueNoZero
779 return sizeStringValue, appendStringValue
782 return sizeBytesSlice, appendBytesSlice
785 // Oneof bytes field may also have "proto3" tag.
786 // We want to marshal it as a oneof field. Do this
787 // check before the proto3 check.
788 return sizeBytesOneof, appendBytesOneof
791 return sizeBytes3, appendBytes3
793 return sizeBytes, appendBytes
798 return makeGroupSliceMarshaler(getMarshalInfo(t))
800 return makeGroupMarshaler(getMarshalInfo(t))
803 return makeMessageSliceMarshaler(getMarshalInfo(t))
805 return makeMessageMarshaler(getMarshalInfo(t))
808 panic(fmt.Sprintf("unknown or mismatched type: type: %v, wire type: %v", t, encoding))
811 // Below are functions to size/marshal a specific type of a field.
812 // They are stored in the field's info, and called by function pointers.
813 // They have type sizer or marshaler.
815 func sizeFixed32Value(_ pointer, tagsize int) int {
818 func sizeFixed32ValueNoZero(ptr pointer, tagsize int) int {
825 func sizeFixed32Ptr(ptr pointer, tagsize int) int {
826 p := *ptr.toUint32Ptr()
832 func sizeFixed32Slice(ptr pointer, tagsize int) int {
833 s := *ptr.toUint32Slice()
834 return (4 + tagsize) * len(s)
836 func sizeFixed32PackedSlice(ptr pointer, tagsize int) int {
837 s := *ptr.toUint32Slice()
841 return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize
843 func sizeFixedS32Value(_ pointer, tagsize int) int {
846 func sizeFixedS32ValueNoZero(ptr pointer, tagsize int) int {
853 func sizeFixedS32Ptr(ptr pointer, tagsize int) int {
854 p := ptr.getInt32Ptr()
860 func sizeFixedS32Slice(ptr pointer, tagsize int) int {
861 s := ptr.getInt32Slice()
862 return (4 + tagsize) * len(s)
864 func sizeFixedS32PackedSlice(ptr pointer, tagsize int) int {
865 s := ptr.getInt32Slice()
869 return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize
871 func sizeFloat32Value(_ pointer, tagsize int) int {
874 func sizeFloat32ValueNoZero(ptr pointer, tagsize int) int {
875 v := math.Float32bits(*ptr.toFloat32())
881 func sizeFloat32Ptr(ptr pointer, tagsize int) int {
882 p := *ptr.toFloat32Ptr()
888 func sizeFloat32Slice(ptr pointer, tagsize int) int {
889 s := *ptr.toFloat32Slice()
890 return (4 + tagsize) * len(s)
892 func sizeFloat32PackedSlice(ptr pointer, tagsize int) int {
893 s := *ptr.toFloat32Slice()
897 return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize
899 func sizeFixed64Value(_ pointer, tagsize int) int {
902 func sizeFixed64ValueNoZero(ptr pointer, tagsize int) int {
909 func sizeFixed64Ptr(ptr pointer, tagsize int) int {
910 p := *ptr.toUint64Ptr()
916 func sizeFixed64Slice(ptr pointer, tagsize int) int {
917 s := *ptr.toUint64Slice()
918 return (8 + tagsize) * len(s)
920 func sizeFixed64PackedSlice(ptr pointer, tagsize int) int {
921 s := *ptr.toUint64Slice()
925 return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize
927 func sizeFixedS64Value(_ pointer, tagsize int) int {
930 func sizeFixedS64ValueNoZero(ptr pointer, tagsize int) int {
937 func sizeFixedS64Ptr(ptr pointer, tagsize int) int {
938 p := *ptr.toInt64Ptr()
944 func sizeFixedS64Slice(ptr pointer, tagsize int) int {
945 s := *ptr.toInt64Slice()
946 return (8 + tagsize) * len(s)
948 func sizeFixedS64PackedSlice(ptr pointer, tagsize int) int {
949 s := *ptr.toInt64Slice()
953 return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize
955 func sizeFloat64Value(_ pointer, tagsize int) int {
958 func sizeFloat64ValueNoZero(ptr pointer, tagsize int) int {
959 v := math.Float64bits(*ptr.toFloat64())
965 func sizeFloat64Ptr(ptr pointer, tagsize int) int {
966 p := *ptr.toFloat64Ptr()
972 func sizeFloat64Slice(ptr pointer, tagsize int) int {
973 s := *ptr.toFloat64Slice()
974 return (8 + tagsize) * len(s)
976 func sizeFloat64PackedSlice(ptr pointer, tagsize int) int {
977 s := *ptr.toFloat64Slice()
981 return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize
983 func sizeVarint32Value(ptr pointer, tagsize int) int {
985 return SizeVarint(uint64(v)) + tagsize
987 func sizeVarint32ValueNoZero(ptr pointer, tagsize int) int {
992 return SizeVarint(uint64(v)) + tagsize
994 func sizeVarint32Ptr(ptr pointer, tagsize int) int {
995 p := *ptr.toUint32Ptr()
999 return SizeVarint(uint64(*p)) + tagsize
1001 func sizeVarint32Slice(ptr pointer, tagsize int) int {
1002 s := *ptr.toUint32Slice()
1004 for _, v := range s {
1005 n += SizeVarint(uint64(v)) + tagsize
1009 func sizeVarint32PackedSlice(ptr pointer, tagsize int) int {
1010 s := *ptr.toUint32Slice()
1015 for _, v := range s {
1016 n += SizeVarint(uint64(v))
1018 return n + SizeVarint(uint64(n)) + tagsize
1020 func sizeVarintS32Value(ptr pointer, tagsize int) int {
1022 return SizeVarint(uint64(v)) + tagsize
1024 func sizeVarintS32ValueNoZero(ptr pointer, tagsize int) int {
1029 return SizeVarint(uint64(v)) + tagsize
1031 func sizeVarintS32Ptr(ptr pointer, tagsize int) int {
1032 p := ptr.getInt32Ptr()
1036 return SizeVarint(uint64(*p)) + tagsize
1038 func sizeVarintS32Slice(ptr pointer, tagsize int) int {
1039 s := ptr.getInt32Slice()
1041 for _, v := range s {
1042 n += SizeVarint(uint64(v)) + tagsize
1046 func sizeVarintS32PackedSlice(ptr pointer, tagsize int) int {
1047 s := ptr.getInt32Slice()
1052 for _, v := range s {
1053 n += SizeVarint(uint64(v))
1055 return n + SizeVarint(uint64(n)) + tagsize
1057 func sizeVarint64Value(ptr pointer, tagsize int) int {
1058 v := *ptr.toUint64()
1059 return SizeVarint(v) + tagsize
1061 func sizeVarint64ValueNoZero(ptr pointer, tagsize int) int {
1062 v := *ptr.toUint64()
1066 return SizeVarint(v) + tagsize
1068 func sizeVarint64Ptr(ptr pointer, tagsize int) int {
1069 p := *ptr.toUint64Ptr()
1073 return SizeVarint(*p) + tagsize
1075 func sizeVarint64Slice(ptr pointer, tagsize int) int {
1076 s := *ptr.toUint64Slice()
1078 for _, v := range s {
1079 n += SizeVarint(v) + tagsize
1083 func sizeVarint64PackedSlice(ptr pointer, tagsize int) int {
1084 s := *ptr.toUint64Slice()
1089 for _, v := range s {
1092 return n + SizeVarint(uint64(n)) + tagsize
1094 func sizeVarintS64Value(ptr pointer, tagsize int) int {
1096 return SizeVarint(uint64(v)) + tagsize
1098 func sizeVarintS64ValueNoZero(ptr pointer, tagsize int) int {
1103 return SizeVarint(uint64(v)) + tagsize
1105 func sizeVarintS64Ptr(ptr pointer, tagsize int) int {
1106 p := *ptr.toInt64Ptr()
1110 return SizeVarint(uint64(*p)) + tagsize
1112 func sizeVarintS64Slice(ptr pointer, tagsize int) int {
1113 s := *ptr.toInt64Slice()
1115 for _, v := range s {
1116 n += SizeVarint(uint64(v)) + tagsize
1120 func sizeVarintS64PackedSlice(ptr pointer, tagsize int) int {
1121 s := *ptr.toInt64Slice()
1126 for _, v := range s {
1127 n += SizeVarint(uint64(v))
1129 return n + SizeVarint(uint64(n)) + tagsize
1131 func sizeZigzag32Value(ptr pointer, tagsize int) int {
1133 return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
1135 func sizeZigzag32ValueNoZero(ptr pointer, tagsize int) int {
1140 return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
1142 func sizeZigzag32Ptr(ptr pointer, tagsize int) int {
1143 p := ptr.getInt32Ptr()
1148 return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
1150 func sizeZigzag32Slice(ptr pointer, tagsize int) int {
1151 s := ptr.getInt32Slice()
1153 for _, v := range s {
1154 n += SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
1158 func sizeZigzag32PackedSlice(ptr pointer, tagsize int) int {
1159 s := ptr.getInt32Slice()
1164 for _, v := range s {
1165 n += SizeVarint(uint64((uint32(v) << 1) ^ uint32((int32(v) >> 31))))
1167 return n + SizeVarint(uint64(n)) + tagsize
1169 func sizeZigzag64Value(ptr pointer, tagsize int) int {
1171 return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
1173 func sizeZigzag64ValueNoZero(ptr pointer, tagsize int) int {
1178 return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
1180 func sizeZigzag64Ptr(ptr pointer, tagsize int) int {
1181 p := *ptr.toInt64Ptr()
1186 return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
1188 func sizeZigzag64Slice(ptr pointer, tagsize int) int {
1189 s := *ptr.toInt64Slice()
1191 for _, v := range s {
1192 n += SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
1196 func sizeZigzag64PackedSlice(ptr pointer, tagsize int) int {
1197 s := *ptr.toInt64Slice()
1202 for _, v := range s {
1203 n += SizeVarint(uint64(v<<1) ^ uint64((int64(v) >> 63)))
1205 return n + SizeVarint(uint64(n)) + tagsize
1207 func sizeBoolValue(_ pointer, tagsize int) int {
1210 func sizeBoolValueNoZero(ptr pointer, tagsize int) int {
1217 func sizeBoolPtr(ptr pointer, tagsize int) int {
1218 p := *ptr.toBoolPtr()
1224 func sizeBoolSlice(ptr pointer, tagsize int) int {
1225 s := *ptr.toBoolSlice()
1226 return (1 + tagsize) * len(s)
1228 func sizeBoolPackedSlice(ptr pointer, tagsize int) int {
1229 s := *ptr.toBoolSlice()
1233 return len(s) + SizeVarint(uint64(len(s))) + tagsize
1235 func sizeStringValue(ptr pointer, tagsize int) int {
1236 v := *ptr.toString()
1237 return len(v) + SizeVarint(uint64(len(v))) + tagsize
1239 func sizeStringValueNoZero(ptr pointer, tagsize int) int {
1240 v := *ptr.toString()
1244 return len(v) + SizeVarint(uint64(len(v))) + tagsize
1246 func sizeStringPtr(ptr pointer, tagsize int) int {
1247 p := *ptr.toStringPtr()
1252 return len(v) + SizeVarint(uint64(len(v))) + tagsize
1254 func sizeStringSlice(ptr pointer, tagsize int) int {
1255 s := *ptr.toStringSlice()
1257 for _, v := range s {
1258 n += len(v) + SizeVarint(uint64(len(v))) + tagsize
1262 func sizeBytes(ptr pointer, tagsize int) int {
1267 return len(v) + SizeVarint(uint64(len(v))) + tagsize
1269 func sizeBytes3(ptr pointer, tagsize int) int {
1274 return len(v) + SizeVarint(uint64(len(v))) + tagsize
1276 func sizeBytesOneof(ptr pointer, tagsize int) int {
1278 return len(v) + SizeVarint(uint64(len(v))) + tagsize
1280 func sizeBytesSlice(ptr pointer, tagsize int) int {
1281 s := *ptr.toBytesSlice()
1283 for _, v := range s {
1284 n += len(v) + SizeVarint(uint64(len(v))) + tagsize
1289 // appendFixed32 appends an encoded fixed32 to b.
1290 func appendFixed32(b []byte, v uint32) []byte {
1299 // appendFixed64 appends an encoded fixed64 to b.
1300 func appendFixed64(b []byte, v uint64) []byte {
1313 // appendVarint appends an encoded varint to b.
1314 func appendVarint(b []byte, v uint64) []byte {
1315 // TODO: make 1-byte (maybe 2-byte) case inline-able, once we
1316 // have non-leaf inliner.
1319 b = append(b, byte(v))
1327 byte((v>>7)&0x7f|0x80),
1332 byte((v>>7)&0x7f|0x80),
1333 byte((v>>14)&0x7f|0x80),
1338 byte((v>>7)&0x7f|0x80),
1339 byte((v>>14)&0x7f|0x80),
1340 byte((v>>21)&0x7f|0x80),
1345 byte((v>>7)&0x7f|0x80),
1346 byte((v>>14)&0x7f|0x80),
1347 byte((v>>21)&0x7f|0x80),
1348 byte((v>>28)&0x7f|0x80),
1353 byte((v>>7)&0x7f|0x80),
1354 byte((v>>14)&0x7f|0x80),
1355 byte((v>>21)&0x7f|0x80),
1356 byte((v>>28)&0x7f|0x80),
1357 byte((v>>35)&0x7f|0x80),
1362 byte((v>>7)&0x7f|0x80),
1363 byte((v>>14)&0x7f|0x80),
1364 byte((v>>21)&0x7f|0x80),
1365 byte((v>>28)&0x7f|0x80),
1366 byte((v>>35)&0x7f|0x80),
1367 byte((v>>42)&0x7f|0x80),
1372 byte((v>>7)&0x7f|0x80),
1373 byte((v>>14)&0x7f|0x80),
1374 byte((v>>21)&0x7f|0x80),
1375 byte((v>>28)&0x7f|0x80),
1376 byte((v>>35)&0x7f|0x80),
1377 byte((v>>42)&0x7f|0x80),
1378 byte((v>>49)&0x7f|0x80),
1383 byte((v>>7)&0x7f|0x80),
1384 byte((v>>14)&0x7f|0x80),
1385 byte((v>>21)&0x7f|0x80),
1386 byte((v>>28)&0x7f|0x80),
1387 byte((v>>35)&0x7f|0x80),
1388 byte((v>>42)&0x7f|0x80),
1389 byte((v>>49)&0x7f|0x80),
1390 byte((v>>56)&0x7f|0x80),
1396 func appendFixed32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1397 v := *ptr.toUint32()
1398 b = appendVarint(b, wiretag)
1399 b = appendFixed32(b, v)
1402 func appendFixed32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1403 v := *ptr.toUint32()
1407 b = appendVarint(b, wiretag)
1408 b = appendFixed32(b, v)
1411 func appendFixed32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1412 p := *ptr.toUint32Ptr()
1416 b = appendVarint(b, wiretag)
1417 b = appendFixed32(b, *p)
1420 func appendFixed32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1421 s := *ptr.toUint32Slice()
1422 for _, v := range s {
1423 b = appendVarint(b, wiretag)
1424 b = appendFixed32(b, v)
1428 func appendFixed32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1429 s := *ptr.toUint32Slice()
1433 b = appendVarint(b, wiretag&^7|WireBytes)
1434 b = appendVarint(b, uint64(4*len(s)))
1435 for _, v := range s {
1436 b = appendFixed32(b, v)
1440 func appendFixedS32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1442 b = appendVarint(b, wiretag)
1443 b = appendFixed32(b, uint32(v))
1446 func appendFixedS32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1451 b = appendVarint(b, wiretag)
1452 b = appendFixed32(b, uint32(v))
1455 func appendFixedS32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1456 p := ptr.getInt32Ptr()
1460 b = appendVarint(b, wiretag)
1461 b = appendFixed32(b, uint32(*p))
1464 func appendFixedS32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1465 s := ptr.getInt32Slice()
1466 for _, v := range s {
1467 b = appendVarint(b, wiretag)
1468 b = appendFixed32(b, uint32(v))
1472 func appendFixedS32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1473 s := ptr.getInt32Slice()
1477 b = appendVarint(b, wiretag&^7|WireBytes)
1478 b = appendVarint(b, uint64(4*len(s)))
1479 for _, v := range s {
1480 b = appendFixed32(b, uint32(v))
1484 func appendFloat32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1485 v := math.Float32bits(*ptr.toFloat32())
1486 b = appendVarint(b, wiretag)
1487 b = appendFixed32(b, v)
1490 func appendFloat32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1491 v := math.Float32bits(*ptr.toFloat32())
1495 b = appendVarint(b, wiretag)
1496 b = appendFixed32(b, v)
1499 func appendFloat32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1500 p := *ptr.toFloat32Ptr()
1504 b = appendVarint(b, wiretag)
1505 b = appendFixed32(b, math.Float32bits(*p))
1508 func appendFloat32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1509 s := *ptr.toFloat32Slice()
1510 for _, v := range s {
1511 b = appendVarint(b, wiretag)
1512 b = appendFixed32(b, math.Float32bits(v))
1516 func appendFloat32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1517 s := *ptr.toFloat32Slice()
1521 b = appendVarint(b, wiretag&^7|WireBytes)
1522 b = appendVarint(b, uint64(4*len(s)))
1523 for _, v := range s {
1524 b = appendFixed32(b, math.Float32bits(v))
1528 func appendFixed64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1529 v := *ptr.toUint64()
1530 b = appendVarint(b, wiretag)
1531 b = appendFixed64(b, v)
1534 func appendFixed64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1535 v := *ptr.toUint64()
1539 b = appendVarint(b, wiretag)
1540 b = appendFixed64(b, v)
1543 func appendFixed64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1544 p := *ptr.toUint64Ptr()
1548 b = appendVarint(b, wiretag)
1549 b = appendFixed64(b, *p)
1552 func appendFixed64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1553 s := *ptr.toUint64Slice()
1554 for _, v := range s {
1555 b = appendVarint(b, wiretag)
1556 b = appendFixed64(b, v)
1560 func appendFixed64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1561 s := *ptr.toUint64Slice()
1565 b = appendVarint(b, wiretag&^7|WireBytes)
1566 b = appendVarint(b, uint64(8*len(s)))
1567 for _, v := range s {
1568 b = appendFixed64(b, v)
1572 func appendFixedS64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1574 b = appendVarint(b, wiretag)
1575 b = appendFixed64(b, uint64(v))
1578 func appendFixedS64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1583 b = appendVarint(b, wiretag)
1584 b = appendFixed64(b, uint64(v))
1587 func appendFixedS64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1588 p := *ptr.toInt64Ptr()
1592 b = appendVarint(b, wiretag)
1593 b = appendFixed64(b, uint64(*p))
1596 func appendFixedS64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1597 s := *ptr.toInt64Slice()
1598 for _, v := range s {
1599 b = appendVarint(b, wiretag)
1600 b = appendFixed64(b, uint64(v))
1604 func appendFixedS64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1605 s := *ptr.toInt64Slice()
1609 b = appendVarint(b, wiretag&^7|WireBytes)
1610 b = appendVarint(b, uint64(8*len(s)))
1611 for _, v := range s {
1612 b = appendFixed64(b, uint64(v))
1616 func appendFloat64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1617 v := math.Float64bits(*ptr.toFloat64())
1618 b = appendVarint(b, wiretag)
1619 b = appendFixed64(b, v)
1622 func appendFloat64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1623 v := math.Float64bits(*ptr.toFloat64())
1627 b = appendVarint(b, wiretag)
1628 b = appendFixed64(b, v)
1631 func appendFloat64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1632 p := *ptr.toFloat64Ptr()
1636 b = appendVarint(b, wiretag)
1637 b = appendFixed64(b, math.Float64bits(*p))
1640 func appendFloat64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1641 s := *ptr.toFloat64Slice()
1642 for _, v := range s {
1643 b = appendVarint(b, wiretag)
1644 b = appendFixed64(b, math.Float64bits(v))
1648 func appendFloat64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1649 s := *ptr.toFloat64Slice()
1653 b = appendVarint(b, wiretag&^7|WireBytes)
1654 b = appendVarint(b, uint64(8*len(s)))
1655 for _, v := range s {
1656 b = appendFixed64(b, math.Float64bits(v))
1660 func appendVarint32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1661 v := *ptr.toUint32()
1662 b = appendVarint(b, wiretag)
1663 b = appendVarint(b, uint64(v))
1666 func appendVarint32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1667 v := *ptr.toUint32()
1671 b = appendVarint(b, wiretag)
1672 b = appendVarint(b, uint64(v))
1675 func appendVarint32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1676 p := *ptr.toUint32Ptr()
1680 b = appendVarint(b, wiretag)
1681 b = appendVarint(b, uint64(*p))
1684 func appendVarint32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1685 s := *ptr.toUint32Slice()
1686 for _, v := range s {
1687 b = appendVarint(b, wiretag)
1688 b = appendVarint(b, uint64(v))
1692 func appendVarint32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1693 s := *ptr.toUint32Slice()
1697 b = appendVarint(b, wiretag&^7|WireBytes)
1700 for _, v := range s {
1701 n += SizeVarint(uint64(v))
1703 b = appendVarint(b, uint64(n))
1704 for _, v := range s {
1705 b = appendVarint(b, uint64(v))
1709 func appendVarintS32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1711 b = appendVarint(b, wiretag)
1712 b = appendVarint(b, uint64(v))
1715 func appendVarintS32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1720 b = appendVarint(b, wiretag)
1721 b = appendVarint(b, uint64(v))
1724 func appendVarintS32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1725 p := ptr.getInt32Ptr()
1729 b = appendVarint(b, wiretag)
1730 b = appendVarint(b, uint64(*p))
1733 func appendVarintS32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1734 s := ptr.getInt32Slice()
1735 for _, v := range s {
1736 b = appendVarint(b, wiretag)
1737 b = appendVarint(b, uint64(v))
1741 func appendVarintS32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1742 s := ptr.getInt32Slice()
1746 b = appendVarint(b, wiretag&^7|WireBytes)
1749 for _, v := range s {
1750 n += SizeVarint(uint64(v))
1752 b = appendVarint(b, uint64(n))
1753 for _, v := range s {
1754 b = appendVarint(b, uint64(v))
1758 func appendVarint64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1759 v := *ptr.toUint64()
1760 b = appendVarint(b, wiretag)
1761 b = appendVarint(b, v)
1764 func appendVarint64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1765 v := *ptr.toUint64()
1769 b = appendVarint(b, wiretag)
1770 b = appendVarint(b, v)
1773 func appendVarint64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1774 p := *ptr.toUint64Ptr()
1778 b = appendVarint(b, wiretag)
1779 b = appendVarint(b, *p)
1782 func appendVarint64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1783 s := *ptr.toUint64Slice()
1784 for _, v := range s {
1785 b = appendVarint(b, wiretag)
1786 b = appendVarint(b, v)
1790 func appendVarint64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1791 s := *ptr.toUint64Slice()
1795 b = appendVarint(b, wiretag&^7|WireBytes)
1798 for _, v := range s {
1801 b = appendVarint(b, uint64(n))
1802 for _, v := range s {
1803 b = appendVarint(b, v)
1807 func appendVarintS64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1809 b = appendVarint(b, wiretag)
1810 b = appendVarint(b, uint64(v))
1813 func appendVarintS64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1818 b = appendVarint(b, wiretag)
1819 b = appendVarint(b, uint64(v))
1822 func appendVarintS64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1823 p := *ptr.toInt64Ptr()
1827 b = appendVarint(b, wiretag)
1828 b = appendVarint(b, uint64(*p))
1831 func appendVarintS64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1832 s := *ptr.toInt64Slice()
1833 for _, v := range s {
1834 b = appendVarint(b, wiretag)
1835 b = appendVarint(b, uint64(v))
1839 func appendVarintS64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1840 s := *ptr.toInt64Slice()
1844 b = appendVarint(b, wiretag&^7|WireBytes)
1847 for _, v := range s {
1848 n += SizeVarint(uint64(v))
1850 b = appendVarint(b, uint64(n))
1851 for _, v := range s {
1852 b = appendVarint(b, uint64(v))
1856 func appendZigzag32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1858 b = appendVarint(b, wiretag)
1859 b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
1862 func appendZigzag32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1867 b = appendVarint(b, wiretag)
1868 b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
1871 func appendZigzag32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1872 p := ptr.getInt32Ptr()
1876 b = appendVarint(b, wiretag)
1878 b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
1881 func appendZigzag32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1882 s := ptr.getInt32Slice()
1883 for _, v := range s {
1884 b = appendVarint(b, wiretag)
1885 b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
1889 func appendZigzag32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1890 s := ptr.getInt32Slice()
1894 b = appendVarint(b, wiretag&^7|WireBytes)
1897 for _, v := range s {
1898 n += SizeVarint(uint64((uint32(v) << 1) ^ uint32((int32(v) >> 31))))
1900 b = appendVarint(b, uint64(n))
1901 for _, v := range s {
1902 b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
1906 func appendZigzag64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1908 b = appendVarint(b, wiretag)
1909 b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
1912 func appendZigzag64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1917 b = appendVarint(b, wiretag)
1918 b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
1921 func appendZigzag64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1922 p := *ptr.toInt64Ptr()
1926 b = appendVarint(b, wiretag)
1928 b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
1931 func appendZigzag64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1932 s := *ptr.toInt64Slice()
1933 for _, v := range s {
1934 b = appendVarint(b, wiretag)
1935 b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
1939 func appendZigzag64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1940 s := *ptr.toInt64Slice()
1944 b = appendVarint(b, wiretag&^7|WireBytes)
1947 for _, v := range s {
1948 n += SizeVarint(uint64(v<<1) ^ uint64((int64(v) >> 63)))
1950 b = appendVarint(b, uint64(n))
1951 for _, v := range s {
1952 b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
1956 func appendBoolValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1958 b = appendVarint(b, wiretag)
1966 func appendBoolValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1971 b = appendVarint(b, wiretag)
1976 func appendBoolPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1977 p := *ptr.toBoolPtr()
1981 b = appendVarint(b, wiretag)
1989 func appendBoolSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1990 s := *ptr.toBoolSlice()
1991 for _, v := range s {
1992 b = appendVarint(b, wiretag)
2001 func appendBoolPackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2002 s := *ptr.toBoolSlice()
2006 b = appendVarint(b, wiretag&^7|WireBytes)
2007 b = appendVarint(b, uint64(len(s)))
2008 for _, v := range s {
2017 func appendStringValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2018 v := *ptr.toString()
2019 b = appendVarint(b, wiretag)
2020 b = appendVarint(b, uint64(len(v)))
2024 func appendStringValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2025 v := *ptr.toString()
2029 b = appendVarint(b, wiretag)
2030 b = appendVarint(b, uint64(len(v)))
2034 func appendStringPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2035 p := *ptr.toStringPtr()
2040 b = appendVarint(b, wiretag)
2041 b = appendVarint(b, uint64(len(v)))
2045 func appendStringSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2046 s := *ptr.toStringSlice()
2047 for _, v := range s {
2048 b = appendVarint(b, wiretag)
2049 b = appendVarint(b, uint64(len(v)))
2054 func appendUTF8StringValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2055 var invalidUTF8 bool
2056 v := *ptr.toString()
2057 if !utf8.ValidString(v) {
2060 b = appendVarint(b, wiretag)
2061 b = appendVarint(b, uint64(len(v)))
2064 return b, errInvalidUTF8
2068 func appendUTF8StringValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2069 var invalidUTF8 bool
2070 v := *ptr.toString()
2074 if !utf8.ValidString(v) {
2077 b = appendVarint(b, wiretag)
2078 b = appendVarint(b, uint64(len(v)))
2081 return b, errInvalidUTF8
2085 func appendUTF8StringPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2086 var invalidUTF8 bool
2087 p := *ptr.toStringPtr()
2092 if !utf8.ValidString(v) {
2095 b = appendVarint(b, wiretag)
2096 b = appendVarint(b, uint64(len(v)))
2099 return b, errInvalidUTF8
2103 func appendUTF8StringSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2104 var invalidUTF8 bool
2105 s := *ptr.toStringSlice()
2106 for _, v := range s {
2107 if !utf8.ValidString(v) {
2110 b = appendVarint(b, wiretag)
2111 b = appendVarint(b, uint64(len(v)))
2115 return b, errInvalidUTF8
2119 func appendBytes(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2124 b = appendVarint(b, wiretag)
2125 b = appendVarint(b, uint64(len(v)))
2129 func appendBytes3(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2134 b = appendVarint(b, wiretag)
2135 b = appendVarint(b, uint64(len(v)))
2139 func appendBytesOneof(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2141 b = appendVarint(b, wiretag)
2142 b = appendVarint(b, uint64(len(v)))
2146 func appendBytesSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2147 s := *ptr.toBytesSlice()
2148 for _, v := range s {
2149 b = appendVarint(b, wiretag)
2150 b = appendVarint(b, uint64(len(v)))
2156 // makeGroupMarshaler returns the sizer and marshaler for a group.
2157 // u is the marshal info of the underlying message.
2158 func makeGroupMarshaler(u *marshalInfo) (sizer, marshaler) {
2159 return func(ptr pointer, tagsize int) int {
2160 p := ptr.getPointer()
2164 return u.size(p) + 2*tagsize
2166 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
2167 p := ptr.getPointer()
2172 b = appendVarint(b, wiretag) // start group
2173 b, err = u.marshal(b, p, deterministic)
2174 b = appendVarint(b, wiretag+(WireEndGroup-WireStartGroup)) // end group
2179 // makeGroupSliceMarshaler returns the sizer and marshaler for a group slice.
2180 // u is the marshal info of the underlying message.
2181 func makeGroupSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
2182 return func(ptr pointer, tagsize int) int {
2183 s := ptr.getPointerSlice()
2185 for _, v := range s {
2189 n += u.size(v) + 2*tagsize
2193 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
2194 s := ptr.getPointerSlice()
2197 for _, v := range s {
2199 return b, errRepeatedHasNil
2201 b = appendVarint(b, wiretag) // start group
2202 b, err = u.marshal(b, v, deterministic)
2203 b = appendVarint(b, wiretag+(WireEndGroup-WireStartGroup)) // end group
2204 if !nerr.Merge(err) {
2206 err = errRepeatedHasNil
2215 // makeMessageMarshaler returns the sizer and marshaler for a message field.
2216 // u is the marshal info of the message.
2217 func makeMessageMarshaler(u *marshalInfo) (sizer, marshaler) {
2218 return func(ptr pointer, tagsize int) int {
2219 p := ptr.getPointer()
2224 return siz + SizeVarint(uint64(siz)) + tagsize
2226 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
2227 p := ptr.getPointer()
2231 b = appendVarint(b, wiretag)
2232 siz := u.cachedsize(p)
2233 b = appendVarint(b, uint64(siz))
2234 return u.marshal(b, p, deterministic)
2238 // makeMessageSliceMarshaler returns the sizer and marshaler for a message slice.
2239 // u is the marshal info of the message.
2240 func makeMessageSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
2241 return func(ptr pointer, tagsize int) int {
2242 s := ptr.getPointerSlice()
2244 for _, v := range s {
2249 n += siz + SizeVarint(uint64(siz)) + tagsize
2253 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
2254 s := ptr.getPointerSlice()
2257 for _, v := range s {
2259 return b, errRepeatedHasNil
2261 b = appendVarint(b, wiretag)
2262 siz := u.cachedsize(v)
2263 b = appendVarint(b, uint64(siz))
2264 b, err = u.marshal(b, v, deterministic)
2266 if !nerr.Merge(err) {
2268 err = errRepeatedHasNil
2277 // makeMapMarshaler returns the sizer and marshaler for a map field.
2278 // f is the pointer to the reflect data structure of the field.
2279 func makeMapMarshaler(f *reflect.StructField) (sizer, marshaler) {
2280 // figure out key and value type
2284 keyTags := strings.Split(f.Tag.Get("protobuf_key"), ",")
2285 valTags := strings.Split(f.Tag.Get("protobuf_val"), ",")
2286 keySizer, keyMarshaler := typeMarshaler(keyType, keyTags, false, false) // don't omit zero value in map
2287 valSizer, valMarshaler := typeMarshaler(valType, valTags, false, false) // don't omit zero value in map
2288 keyWireTag := 1<<3 | wiretype(keyTags[0])
2289 valWireTag := 2<<3 | wiretype(valTags[0])
2291 // We create an interface to get the addresses of the map key and value.
2292 // If value is pointer-typed, the interface is a direct interface, the
2293 // idata itself is the value. Otherwise, the idata is the pointer to the
2295 // Key cannot be pointer-typed.
2296 valIsPtr := valType.Kind() == reflect.Ptr
2298 // If value is a message with nested maps, calling
2299 // valSizer in marshal may be quadratic. We should use
2300 // cached version in marshal (but not in size).
2301 // If value is not message type, we don't have size cache,
2302 // but it cannot be nested either. Just use valSizer.
2303 valCachedSizer := valSizer
2304 if valIsPtr && valType.Elem().Kind() == reflect.Struct {
2305 u := getMarshalInfo(valType.Elem())
2306 valCachedSizer = func(ptr pointer, tagsize int) int {
2307 // Same as message sizer, but use cache.
2308 p := ptr.getPointer()
2312 siz := u.cachedsize(p)
2313 return siz + SizeVarint(uint64(siz)) + tagsize
2316 return func(ptr pointer, tagsize int) int {
2317 m := ptr.asPointerTo(t).Elem() // the map
2319 for _, k := range m.MapKeys() {
2321 vi := m.MapIndex(k).Interface()
2322 kaddr := toAddrPointer(&ki, false, false) // pointer to key
2323 vaddr := toAddrPointer(&vi, valIsPtr, false) // pointer to value
2324 siz := keySizer(kaddr, 1) + valSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1)
2325 n += siz + SizeVarint(uint64(siz)) + tagsize
2329 func(b []byte, ptr pointer, tag uint64, deterministic bool) ([]byte, error) {
2330 m := ptr.asPointerTo(t).Elem() // the map
2333 if len(keys) > 1 && deterministic {
2334 sort.Sort(mapKeys(keys))
2338 for _, k := range keys {
2340 vi := m.MapIndex(k).Interface()
2341 kaddr := toAddrPointer(&ki, false, false) // pointer to key
2342 vaddr := toAddrPointer(&vi, valIsPtr, false) // pointer to value
2343 b = appendVarint(b, tag)
2344 siz := keySizer(kaddr, 1) + valCachedSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1)
2345 b = appendVarint(b, uint64(siz))
2346 b, err = keyMarshaler(b, kaddr, keyWireTag, deterministic)
2347 if !nerr.Merge(err) {
2350 b, err = valMarshaler(b, vaddr, valWireTag, deterministic)
2351 if err != ErrNil && !nerr.Merge(err) { // allow nil value in map
2359 // makeOneOfMarshaler returns the sizer and marshaler for a oneof field.
2360 // fi is the marshal info of the field.
2361 // f is the pointer to the reflect data structure of the field.
2362 func makeOneOfMarshaler(fi *marshalFieldInfo, f *reflect.StructField) (sizer, marshaler) {
2363 // Oneof field is an interface. We need to get the actual data type on the fly.
2365 return func(ptr pointer, _ int) int {
2366 p := ptr.getInterfacePointer()
2370 v := ptr.asPointerTo(t).Elem().Elem().Elem() // *interface -> interface -> *struct -> struct
2372 e := fi.oneofElems[telem]
2373 return e.sizer(p, e.tagsize)
2375 func(b []byte, ptr pointer, _ uint64, deterministic bool) ([]byte, error) {
2376 p := ptr.getInterfacePointer()
2380 v := ptr.asPointerTo(t).Elem().Elem().Elem() // *interface -> interface -> *struct -> struct
2382 if telem.Field(0).Type.Kind() == reflect.Ptr && p.getPointer().isNil() {
2383 return b, errOneofHasNil
2385 e := fi.oneofElems[telem]
2386 return e.marshaler(b, p, e.wiretag, deterministic)
2390 // sizeExtensions computes the size of encoded data for a XXX_InternalExtensions field.
2391 func (u *marshalInfo) sizeExtensions(ext *XXX_InternalExtensions) int {
2392 m, mu := ext.extensionsRead()
2399 for _, e := range m {
2400 if e.value == nil || e.desc == nil {
2401 // Extension is only in its encoded form.
2406 // We don't skip extensions that have an encoded form set,
2407 // because the extension value may have been mutated after
2408 // the last time this function was called.
2409 ei := u.getExtElemInfo(e.desc)
2411 p := toAddrPointer(&v, ei.isptr, ei.deref)
2412 n += ei.sizer(p, ei.tagsize)
2418 // appendExtensions marshals a XXX_InternalExtensions field to the end of byte slice b.
2419 func (u *marshalInfo) appendExtensions(b []byte, ext *XXX_InternalExtensions, deterministic bool) ([]byte, error) {
2420 m, mu := ext.extensionsRead()
2430 // Fast-path for common cases: zero or one extensions.
2431 // Don't bother sorting the keys.
2433 for _, e := range m {
2434 if e.value == nil || e.desc == nil {
2435 // Extension is only in its encoded form.
2436 b = append(b, e.enc...)
2440 // We don't skip extensions that have an encoded form set,
2441 // because the extension value may have been mutated after
2442 // the last time this function was called.
2444 ei := u.getExtElemInfo(e.desc)
2446 p := toAddrPointer(&v, ei.isptr, ei.deref)
2447 b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
2448 if !nerr.Merge(err) {
2455 // Sort the keys to provide a deterministic encoding.
2456 // Not sure this is required, but the old code does it.
2457 keys := make([]int, 0, len(m))
2459 keys = append(keys, int(k))
2463 for _, k := range keys {
2465 if e.value == nil || e.desc == nil {
2466 // Extension is only in its encoded form.
2467 b = append(b, e.enc...)
2471 // We don't skip extensions that have an encoded form set,
2472 // because the extension value may have been mutated after
2473 // the last time this function was called.
2475 ei := u.getExtElemInfo(e.desc)
2477 p := toAddrPointer(&v, ei.isptr, ei.deref)
2478 b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
2479 if !nerr.Merge(err) {
2486 // message set format is:
2487 // message MessageSet {
2488 // repeated group Item = 1 {
2489 // required int32 type_id = 2;
2490 // required string message = 3;
2494 // sizeMessageSet computes the size of encoded data for a XXX_InternalExtensions field
2495 // in message set format (above).
2496 func (u *marshalInfo) sizeMessageSet(ext *XXX_InternalExtensions) int {
2497 m, mu := ext.extensionsRead()
2504 for id, e := range m {
2505 n += 2 // start group, end group. tag = 1 (size=1)
2506 n += SizeVarint(uint64(id)) + 1 // type_id, tag = 2 (size=1)
2508 if e.value == nil || e.desc == nil {
2509 // Extension is only in its encoded form.
2510 msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint
2511 siz := len(msgWithLen)
2512 n += siz + 1 // message, tag = 3 (size=1)
2516 // We don't skip extensions that have an encoded form set,
2517 // because the extension value may have been mutated after
2518 // the last time this function was called.
2520 ei := u.getExtElemInfo(e.desc)
2522 p := toAddrPointer(&v, ei.isptr, ei.deref)
2523 n += ei.sizer(p, 1) // message, tag = 3 (size=1)
2529 // appendMessageSet marshals a XXX_InternalExtensions field in message set format (above)
2530 // to the end of byte slice b.
2531 func (u *marshalInfo) appendMessageSet(b []byte, ext *XXX_InternalExtensions, deterministic bool) ([]byte, error) {
2532 m, mu := ext.extensionsRead()
2542 // Fast-path for common cases: zero or one extensions.
2543 // Don't bother sorting the keys.
2545 for id, e := range m {
2546 b = append(b, 1<<3|WireStartGroup)
2547 b = append(b, 2<<3|WireVarint)
2548 b = appendVarint(b, uint64(id))
2550 if e.value == nil || e.desc == nil {
2551 // Extension is only in its encoded form.
2552 msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint
2553 b = append(b, 3<<3|WireBytes)
2554 b = append(b, msgWithLen...)
2555 b = append(b, 1<<3|WireEndGroup)
2559 // We don't skip extensions that have an encoded form set,
2560 // because the extension value may have been mutated after
2561 // the last time this function was called.
2563 ei := u.getExtElemInfo(e.desc)
2565 p := toAddrPointer(&v, ei.isptr, ei.deref)
2566 b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic)
2567 if !nerr.Merge(err) {
2570 b = append(b, 1<<3|WireEndGroup)
2575 // Sort the keys to provide a deterministic encoding.
2576 keys := make([]int, 0, len(m))
2578 keys = append(keys, int(k))
2582 for _, id := range keys {
2584 b = append(b, 1<<3|WireStartGroup)
2585 b = append(b, 2<<3|WireVarint)
2586 b = appendVarint(b, uint64(id))
2588 if e.value == nil || e.desc == nil {
2589 // Extension is only in its encoded form.
2590 msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint
2591 b = append(b, 3<<3|WireBytes)
2592 b = append(b, msgWithLen...)
2593 b = append(b, 1<<3|WireEndGroup)
2597 // We don't skip extensions that have an encoded form set,
2598 // because the extension value may have been mutated after
2599 // the last time this function was called.
2601 ei := u.getExtElemInfo(e.desc)
2603 p := toAddrPointer(&v, ei.isptr, ei.deref)
2604 b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic)
2605 b = append(b, 1<<3|WireEndGroup)
2606 if !nerr.Merge(err) {
2613 // sizeV1Extensions computes the size of encoded data for a V1-API extension field.
2614 func (u *marshalInfo) sizeV1Extensions(m map[int32]Extension) int {
2620 for _, e := range m {
2621 if e.value == nil || e.desc == nil {
2622 // Extension is only in its encoded form.
2627 // We don't skip extensions that have an encoded form set,
2628 // because the extension value may have been mutated after
2629 // the last time this function was called.
2631 ei := u.getExtElemInfo(e.desc)
2633 p := toAddrPointer(&v, ei.isptr, ei.deref)
2634 n += ei.sizer(p, ei.tagsize)
2639 // appendV1Extensions marshals a V1-API extension field to the end of byte slice b.
2640 func (u *marshalInfo) appendV1Extensions(b []byte, m map[int32]Extension, deterministic bool) ([]byte, error) {
2645 // Sort the keys to provide a deterministic encoding.
2646 keys := make([]int, 0, len(m))
2648 keys = append(keys, int(k))
2654 for _, k := range keys {
2656 if e.value == nil || e.desc == nil {
2657 // Extension is only in its encoded form.
2658 b = append(b, e.enc...)
2662 // We don't skip extensions that have an encoded form set,
2663 // because the extension value may have been mutated after
2664 // the last time this function was called.
2666 ei := u.getExtElemInfo(e.desc)
2668 p := toAddrPointer(&v, ei.isptr, ei.deref)
2669 b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
2670 if !nerr.Merge(err) {
2677 // newMarshaler is the interface representing objects that can marshal themselves.
2679 // This exists to support protoc-gen-go generated messages.
2680 // The proto package will stop type-asserting to this interface in the future.
2682 // DO NOT DEPEND ON THIS.
2683 type newMarshaler interface {
2685 XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
2688 // Size returns the encoded size of a protocol buffer message.
2689 // This is the main entry point.
2690 func Size(pb Message) int {
2691 if m, ok := pb.(newMarshaler); ok {
2694 if m, ok := pb.(Marshaler); ok {
2695 // If the message can marshal itself, let it do it, for compatibility.
2696 // NOTE: This is not efficient.
2700 // in case somehow we didn't generate the wrapper
2704 var info InternalMessageInfo
2705 return info.Size(pb)
2708 // Marshal takes a protocol buffer message
2709 // and encodes it into the wire format, returning the data.
2710 // This is the main entry point.
2711 func Marshal(pb Message) ([]byte, error) {
2712 if m, ok := pb.(newMarshaler); ok {
2714 b := make([]byte, 0, siz)
2715 return m.XXX_Marshal(b, false)
2717 if m, ok := pb.(Marshaler); ok {
2718 // If the message can marshal itself, let it do it, for compatibility.
2719 // NOTE: This is not efficient.
2722 // in case somehow we didn't generate the wrapper
2726 var info InternalMessageInfo
2727 siz := info.Size(pb)
2728 b := make([]byte, 0, siz)
2729 return info.Marshal(b, pb, false)
2732 // Marshal takes a protocol buffer message
2733 // and encodes it into the wire format, writing the result to the
2735 // This is an alternative entry point. It is not necessary to use
2736 // a Buffer for most applications.
2737 func (p *Buffer) Marshal(pb Message) error {
2739 if m, ok := pb.(newMarshaler); ok {
2741 p.grow(siz) // make sure buf has enough capacity
2742 p.buf, err = m.XXX_Marshal(p.buf, p.deterministic)
2745 if m, ok := pb.(Marshaler); ok {
2746 // If the message can marshal itself, let it do it, for compatibility.
2747 // NOTE: This is not efficient.
2748 b, err := m.Marshal()
2749 p.buf = append(p.buf, b...)
2752 // in case somehow we didn't generate the wrapper
2756 var info InternalMessageInfo
2757 siz := info.Size(pb)
2758 p.grow(siz) // make sure buf has enough capacity
2759 p.buf, err = info.Marshal(p.buf, pb, p.deterministic)
2763 // grow grows the buffer's capacity, if necessary, to guarantee space for
2764 // another n bytes. After grow(n), at least n bytes can be written to the
2765 // buffer without another allocation.
2766 func (p *Buffer) grow(n int) {
2767 need := len(p.buf) + n
2768 if need <= cap(p.buf) {
2771 newCap := len(p.buf) * 2
2775 p.buf = append(make([]byte, 0, newCap), p.buf...)