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
69 hassizer bool // has custom sizer
70 hasprotosizer bool // has custom protosizer
72 bytesExtensions field // offset of XXX_extensions where the field type is []byte
75 // marshalFieldInfo is the information used for marshaling a field of a message.
76 type marshalFieldInfo struct {
78 wiretag uint64 // tag in wire format
79 tagsize int // size of tag in wire format
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
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
94 isptr bool // elem is pointer typed, thus interface of this type is a direct interface (extension only)
98 marshalInfoMap = map[reflect.Type]*marshalInfo{}
99 marshalInfoLock sync.Mutex
101 uint8SliceType = reflect.TypeOf(([]uint8)(nil)).Kind()
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]
111 u = &marshalInfo{typ: t}
112 marshalInfoMap[t] = u
114 marshalInfoLock.Unlock()
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)
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.
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)
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.
147 return u.marshal(b, ptr, deterministic)
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)
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))
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)
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()
175 // If the message can marshal itself, let it do it, for compatibility.
176 // NOTE: This is not efficient.
178 // Uses the message's Size method if available
180 s := ptr.asPointerTo(u.typ).Interface().(Sizer)
183 // Uses the message's ProtoSize method if available
185 s := ptr.asPointerTo(u.typ).Interface().(ProtoSizer)
189 m := ptr.asPointerTo(u.typ).Interface().(Marshaler)
195 for _, f := range u.fields {
196 if f.isPointer && ptr.offset(f.field).getPointer().isNil() {
197 // nil pointer always marshals to nothing
200 n += f.sizer(ptr.offset(f.field), f.tagsize)
202 if u.extensions.IsValid() {
203 e := ptr.offset(u.extensions).toExtensions()
205 n += u.sizeMessageSet(e)
207 n += u.sizeExtensions(e)
210 if u.v1extensions.IsValid() {
211 m := *ptr.offset(u.v1extensions).toOldExtensions()
212 n += u.sizeV1Extensions(m)
214 if u.bytesExtensions.IsValid() {
215 s := *ptr.offset(u.bytesExtensions).toBytes()
218 if u.unrecognized.IsValid() {
219 s := *ptr.offset(u.unrecognized).toBytes()
223 // cache the result for use in marshal
224 if u.sizecache.IsValid() {
225 atomic.StoreInt32(ptr.offset(u.sizecache).toInt32(), int32(n))
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()))
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()
248 // If the message can marshal itself, let it do it, for compatibility.
249 // NOTE: This is not efficient.
251 m := ptr.asPointerTo(u.typ).Interface().(Marshaler)
252 b1, err := m.Marshal()
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()
262 b, err = u.appendMessageSet(b, e, deterministic)
264 b, err = u.appendExtensions(b, e, deterministic)
270 if u.v1extensions.IsValid() {
271 m := *ptr.offset(u.v1extensions).toOldExtensions()
272 b, err = u.appendV1Extensions(b, m, deterministic)
277 if u.bytesExtensions.IsValid() {
278 s := *ptr.offset(u.bytesExtensions).toBytes()
281 for _, f := range u.fields {
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.
287 errLater = &RequiredNotSetError{f.name}
292 if f.isPointer && ptr.offset(f.field).getPointer().isNil() {
293 // nil pointer always marshals to nothing
296 b, err = f.marshaler(b, ptr.offset(f.field), f.wiretag, deterministic)
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.
302 errLater = &RequiredNotSetError{f.name + "." + err1.field}
306 if err == errRepeatedHasNil {
307 err = errors.New("proto: repeated field " + f.name + " has nil element")
309 if err == errInvalidUTF8 {
311 fullName := revProtoTypes[reflect.PtrTo(u.typ)] + "." + f.name
312 errLater = &invalidUTF8Error{fullName}
319 if u.unrecognized.IsValid() {
320 s := *ptr.offset(u.unrecognized).toBytes()
326 // computeMarshalInfo initializes the marshal info.
327 func (u *marshalInfo) computeMarshalInfo() {
330 if u.initialized != 0 { // non-atomic read is ok as it is protected by the lock
335 u.unrecognized = invalidField
336 u.extensions = invalidField
337 u.v1extensions = invalidField
338 u.bytesExtensions = invalidField
339 u.sizecache = invalidField
340 isOneofMessage := false
342 if reflect.PtrTo(t).Implements(sizerType) {
345 if reflect.PtrTo(t).Implements(protosizerType) {
346 u.hasprotosizer = true
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)
358 // deal with XXX fields first
359 for i := 0; i < t.NumField(); i++ {
361 if f.Tag.Get("protobuf_oneof") != "" {
362 isOneofMessage = true
364 if !strings.HasPrefix(f.Name, "XXX_") {
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)
379 u.bytesExtensions = toField(&f)
381 case "XXX_NoUnkeyedLiteral":
384 panic("unknown XXX field: " + f.Name)
389 // get oneof implementers
390 var oneofImplementers []interface{}
391 // gogo: isOneofMessage is needed for embedded oneof messages, without a marshaler and unmarshaler
392 if m, ok := reflect.Zero(reflect.PtrTo(t)).Interface().(oneofMessage); ok && isOneofMessage {
393 _, _, _, oneofImplementers = m.XXX_OneofFuncs()
397 fields := make([]marshalFieldInfo, n) // batch allocation
398 u.fields = make([]*marshalFieldInfo, 0, n)
399 for i, j := 0, 0; i < t.NumField(); i++ {
402 if strings.HasPrefix(f.Name, "XXX_") {
408 u.fields = append(u.fields, field)
409 if f.Tag.Get("protobuf_oneof") != "" {
410 field.computeOneofFieldInfo(&f, oneofImplementers)
413 if f.Tag.Get("protobuf") == "" {
414 // field has no tag (not in generated message), ignore it
415 u.fields = u.fields[:len(u.fields)-1]
419 field.computeMarshalFieldInfo(&f)
422 // fields are marshaled in tag order on the wire.
423 sort.Sort(byTag(u.fields))
425 atomic.StoreInt32(&u.initialized, 1)
428 // helper for sorting fields by tag
429 type byTag []*marshalFieldInfo
431 func (a byTag) Len() int { return len(a) }
432 func (a byTag) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
433 func (a byTag) Less(i, j int) bool { return a[i].wiretag < a[j].wiretag }
435 // getExtElemInfo returns the information to marshal an extension element.
436 // The info it returns is initialized.
437 func (u *marshalInfo) getExtElemInfo(desc *ExtensionDesc) *marshalElemInfo {
438 // get from cache first
440 e, ok := u.extElems[desc.Field]
446 t := reflect.TypeOf(desc.ExtensionType) // pointer or slice to basic type or struct
447 tags := strings.Split(desc.Tag, ",")
448 tag, err := strconv.Atoi(tags[1])
450 panic("tag is not an integer")
452 wt := wiretype(tags[0])
453 sizr, marshalr := typeMarshaler(t, tags, false, false)
454 e = &marshalElemInfo{
455 wiretag: uint64(tag)<<3 | wt,
456 tagsize: SizeVarint(uint64(tag) << 3),
459 isptr: t.Kind() == reflect.Ptr,
464 if u.extElems == nil {
465 u.extElems = make(map[int32]*marshalElemInfo)
467 u.extElems[desc.Field] = e
472 // computeMarshalFieldInfo fills up the information to marshal a field.
473 func (fi *marshalFieldInfo) computeMarshalFieldInfo(f *reflect.StructField) {
474 // parse protobuf tag of the field.
475 // tag has format of "bytes,49,opt,name=foo,def=hello!"
476 tags := strings.Split(f.Tag.Get("protobuf"), ",")
480 tag, err := strconv.Atoi(tags[1])
482 panic("tag is not an integer")
484 wt := wiretype(tags[0])
485 if tags[2] == "req" {
488 fi.setTag(f, tag, wt)
489 fi.setMarshaler(f, tags)
492 func (fi *marshalFieldInfo) computeOneofFieldInfo(f *reflect.StructField, oneofImplementers []interface{}) {
493 fi.field = toField(f)
494 fi.wiretag = math.MaxInt32 // Use a large tag number, make oneofs sorted at the end. This tag will not appear on the wire.
496 fi.sizer, fi.marshaler = makeOneOfMarshaler(fi, f)
497 fi.oneofElems = make(map[reflect.Type]*marshalElemInfo)
499 ityp := f.Type // interface type
500 for _, o := range oneofImplementers {
501 t := reflect.TypeOf(o)
502 if !t.Implements(ityp) {
505 sf := t.Elem().Field(0) // oneof implementer is a struct with a single field
506 tags := strings.Split(sf.Tag.Get("protobuf"), ",")
507 tag, err := strconv.Atoi(tags[1])
509 panic("tag is not an integer")
511 wt := wiretype(tags[0])
512 sizr, marshalr := typeMarshaler(sf.Type, tags, false, true) // oneof should not omit any zero value
513 fi.oneofElems[t.Elem()] = &marshalElemInfo{
514 wiretag: uint64(tag)<<3 | wt,
515 tagsize: SizeVarint(uint64(tag) << 3),
522 type oneofMessage interface {
523 XXX_OneofFuncs() (func(Message, *Buffer) error, func(Message, int, int, *Buffer) (bool, error), func(Message) int, []interface{})
526 // wiretype returns the wire encoding of the type.
527 func wiretype(encoding string) uint64 {
533 case "varint", "zigzag32", "zigzag64":
538 return WireStartGroup
540 panic("unknown wire type " + encoding)
543 // setTag fills up the tag (in wire format) and its size in the info of a field.
544 func (fi *marshalFieldInfo) setTag(f *reflect.StructField, tag int, wt uint64) {
545 fi.field = toField(f)
546 fi.wiretag = uint64(tag)<<3 | wt
547 fi.tagsize = SizeVarint(uint64(tag) << 3)
550 // setMarshaler fills up the sizer and marshaler in the info of a field.
551 func (fi *marshalFieldInfo) setMarshaler(f *reflect.StructField, tags []string) {
552 switch f.Type.Kind() {
556 fi.sizer, fi.marshaler = makeMapMarshaler(f)
558 case reflect.Ptr, reflect.Slice:
561 fi.sizer, fi.marshaler = typeMarshaler(f.Type, tags, true, false)
564 // typeMarshaler returns the sizer and marshaler of a given field.
565 // t is the type of the field.
566 // tags is the generated "protobuf" tag of the field.
567 // If nozero is true, zero value is not marshaled to the wire.
568 // If oneof is true, it is a oneof field.
569 func typeMarshaler(t reflect.Type, tags []string, nozero, oneof bool) (sizer, marshaler) {
574 if t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8 {
578 if t.Kind() == reflect.Ptr {
588 isWktPointer := false
590 for i := 2; i < len(tags); i++ {
591 if tags[i] == "packed" {
594 if tags[i] == "proto3" {
597 if strings.HasPrefix(tags[i], "customtype=") {
600 if tags[i] == "stdtime" {
603 if tags[i] == "stdduration" {
606 if tags[i] == "wktptr" {
610 validateUTF8 = validateUTF8 && proto3
611 if !proto3 && !pointer && !slice {
616 if reflect.PtrTo(t).Implements(customType) {
618 return makeMessageRefSliceMarshaler(getMarshalInfo(t))
621 return makeCustomPtrMarshaler(getMarshalInfo(t))
623 return makeCustomMarshaler(getMarshalInfo(t))
625 panic(fmt.Sprintf("custom type: type: %v, does not implement the proto.custom interface", t))
632 return makeTimePtrSliceMarshaler(getMarshalInfo(t))
634 return makeTimePtrMarshaler(getMarshalInfo(t))
637 return makeTimeSliceMarshaler(getMarshalInfo(t))
639 return makeTimeMarshaler(getMarshalInfo(t))
645 return makeDurationPtrSliceMarshaler(getMarshalInfo(t))
647 return makeDurationPtrMarshaler(getMarshalInfo(t))
650 return makeDurationSliceMarshaler(getMarshalInfo(t))
652 return makeDurationMarshaler(getMarshalInfo(t))
657 case reflect.Float64:
660 return makeStdDoubleValuePtrSliceMarshaler(getMarshalInfo(t))
662 return makeStdDoubleValuePtrMarshaler(getMarshalInfo(t))
665 return makeStdDoubleValueSliceMarshaler(getMarshalInfo(t))
667 return makeStdDoubleValueMarshaler(getMarshalInfo(t))
668 case reflect.Float32:
671 return makeStdFloatValuePtrSliceMarshaler(getMarshalInfo(t))
673 return makeStdFloatValuePtrMarshaler(getMarshalInfo(t))
676 return makeStdFloatValueSliceMarshaler(getMarshalInfo(t))
678 return makeStdFloatValueMarshaler(getMarshalInfo(t))
682 return makeStdInt64ValuePtrSliceMarshaler(getMarshalInfo(t))
684 return makeStdInt64ValuePtrMarshaler(getMarshalInfo(t))
687 return makeStdInt64ValueSliceMarshaler(getMarshalInfo(t))
689 return makeStdInt64ValueMarshaler(getMarshalInfo(t))
693 return makeStdUInt64ValuePtrSliceMarshaler(getMarshalInfo(t))
695 return makeStdUInt64ValuePtrMarshaler(getMarshalInfo(t))
698 return makeStdUInt64ValueSliceMarshaler(getMarshalInfo(t))
700 return makeStdUInt64ValueMarshaler(getMarshalInfo(t))
704 return makeStdInt32ValuePtrSliceMarshaler(getMarshalInfo(t))
706 return makeStdInt32ValuePtrMarshaler(getMarshalInfo(t))
709 return makeStdInt32ValueSliceMarshaler(getMarshalInfo(t))
711 return makeStdInt32ValueMarshaler(getMarshalInfo(t))
715 return makeStdUInt32ValuePtrSliceMarshaler(getMarshalInfo(t))
717 return makeStdUInt32ValuePtrMarshaler(getMarshalInfo(t))
720 return makeStdUInt32ValueSliceMarshaler(getMarshalInfo(t))
722 return makeStdUInt32ValueMarshaler(getMarshalInfo(t))
726 return makeStdBoolValuePtrSliceMarshaler(getMarshalInfo(t))
728 return makeStdBoolValuePtrMarshaler(getMarshalInfo(t))
731 return makeStdBoolValueSliceMarshaler(getMarshalInfo(t))
733 return makeStdBoolValueMarshaler(getMarshalInfo(t))
737 return makeStdStringValuePtrSliceMarshaler(getMarshalInfo(t))
739 return makeStdStringValuePtrMarshaler(getMarshalInfo(t))
742 return makeStdStringValueSliceMarshaler(getMarshalInfo(t))
744 return makeStdStringValueMarshaler(getMarshalInfo(t))
748 return makeStdBytesValuePtrSliceMarshaler(getMarshalInfo(t))
750 return makeStdBytesValuePtrMarshaler(getMarshalInfo(t))
753 return makeStdBytesValueSliceMarshaler(getMarshalInfo(t))
755 return makeStdBytesValueMarshaler(getMarshalInfo(t))
757 panic(fmt.Sprintf("unknown wktpointer type %#v", t))
764 return sizeBoolPtr, appendBoolPtr
768 return sizeBoolPackedSlice, appendBoolPackedSlice
770 return sizeBoolSlice, appendBoolSlice
773 return sizeBoolValueNoZero, appendBoolValueNoZero
775 return sizeBoolValue, appendBoolValue
780 return sizeFixed32Ptr, appendFixed32Ptr
784 return sizeFixed32PackedSlice, appendFixed32PackedSlice
786 return sizeFixed32Slice, appendFixed32Slice
789 return sizeFixed32ValueNoZero, appendFixed32ValueNoZero
791 return sizeFixed32Value, appendFixed32Value
794 return sizeVarint32Ptr, appendVarint32Ptr
798 return sizeVarint32PackedSlice, appendVarint32PackedSlice
800 return sizeVarint32Slice, appendVarint32Slice
803 return sizeVarint32ValueNoZero, appendVarint32ValueNoZero
805 return sizeVarint32Value, appendVarint32Value
811 return sizeFixedS32Ptr, appendFixedS32Ptr
815 return sizeFixedS32PackedSlice, appendFixedS32PackedSlice
817 return sizeFixedS32Slice, appendFixedS32Slice
820 return sizeFixedS32ValueNoZero, appendFixedS32ValueNoZero
822 return sizeFixedS32Value, appendFixedS32Value
825 return sizeVarintS32Ptr, appendVarintS32Ptr
829 return sizeVarintS32PackedSlice, appendVarintS32PackedSlice
831 return sizeVarintS32Slice, appendVarintS32Slice
834 return sizeVarintS32ValueNoZero, appendVarintS32ValueNoZero
836 return sizeVarintS32Value, appendVarintS32Value
839 return sizeZigzag32Ptr, appendZigzag32Ptr
843 return sizeZigzag32PackedSlice, appendZigzag32PackedSlice
845 return sizeZigzag32Slice, appendZigzag32Slice
848 return sizeZigzag32ValueNoZero, appendZigzag32ValueNoZero
850 return sizeZigzag32Value, appendZigzag32Value
856 return sizeFixed64Ptr, appendFixed64Ptr
860 return sizeFixed64PackedSlice, appendFixed64PackedSlice
862 return sizeFixed64Slice, appendFixed64Slice
865 return sizeFixed64ValueNoZero, appendFixed64ValueNoZero
867 return sizeFixed64Value, appendFixed64Value
870 return sizeVarint64Ptr, appendVarint64Ptr
874 return sizeVarint64PackedSlice, appendVarint64PackedSlice
876 return sizeVarint64Slice, appendVarint64Slice
879 return sizeVarint64ValueNoZero, appendVarint64ValueNoZero
881 return sizeVarint64Value, appendVarint64Value
887 return sizeFixedS64Ptr, appendFixedS64Ptr
891 return sizeFixedS64PackedSlice, appendFixedS64PackedSlice
893 return sizeFixedS64Slice, appendFixedS64Slice
896 return sizeFixedS64ValueNoZero, appendFixedS64ValueNoZero
898 return sizeFixedS64Value, appendFixedS64Value
901 return sizeVarintS64Ptr, appendVarintS64Ptr
905 return sizeVarintS64PackedSlice, appendVarintS64PackedSlice
907 return sizeVarintS64Slice, appendVarintS64Slice
910 return sizeVarintS64ValueNoZero, appendVarintS64ValueNoZero
912 return sizeVarintS64Value, appendVarintS64Value
915 return sizeZigzag64Ptr, appendZigzag64Ptr
919 return sizeZigzag64PackedSlice, appendZigzag64PackedSlice
921 return sizeZigzag64Slice, appendZigzag64Slice
924 return sizeZigzag64ValueNoZero, appendZigzag64ValueNoZero
926 return sizeZigzag64Value, appendZigzag64Value
928 case reflect.Float32:
930 return sizeFloat32Ptr, appendFloat32Ptr
934 return sizeFloat32PackedSlice, appendFloat32PackedSlice
936 return sizeFloat32Slice, appendFloat32Slice
939 return sizeFloat32ValueNoZero, appendFloat32ValueNoZero
941 return sizeFloat32Value, appendFloat32Value
942 case reflect.Float64:
944 return sizeFloat64Ptr, appendFloat64Ptr
948 return sizeFloat64PackedSlice, appendFloat64PackedSlice
950 return sizeFloat64Slice, appendFloat64Slice
953 return sizeFloat64ValueNoZero, appendFloat64ValueNoZero
955 return sizeFloat64Value, appendFloat64Value
959 return sizeStringPtr, appendUTF8StringPtr
962 return sizeStringSlice, appendUTF8StringSlice
965 return sizeStringValueNoZero, appendUTF8StringValueNoZero
967 return sizeStringValue, appendUTF8StringValue
970 return sizeStringPtr, appendStringPtr
973 return sizeStringSlice, appendStringSlice
976 return sizeStringValueNoZero, appendStringValueNoZero
978 return sizeStringValue, appendStringValue
981 return sizeBytesSlice, appendBytesSlice
984 // Oneof bytes field may also have "proto3" tag.
985 // We want to marshal it as a oneof field. Do this
986 // check before the proto3 check.
987 return sizeBytesOneof, appendBytesOneof
990 return sizeBytes3, appendBytes3
992 return sizeBytes, appendBytes
997 return makeGroupSliceMarshaler(getMarshalInfo(t))
999 return makeGroupMarshaler(getMarshalInfo(t))
1003 return makeMessageSliceMarshaler(getMarshalInfo(t))
1005 return makeMessageMarshaler(getMarshalInfo(t))
1008 return makeMessageRefSliceMarshaler(getMarshalInfo(t))
1010 return makeMessageRefMarshaler(getMarshalInfo(t))
1014 panic(fmt.Sprintf("unknown or mismatched type: type: %v, wire type: %v", t, encoding))
1017 // Below are functions to size/marshal a specific type of a field.
1018 // They are stored in the field's info, and called by function pointers.
1019 // They have type sizer or marshaler.
1021 func sizeFixed32Value(_ pointer, tagsize int) int {
1024 func sizeFixed32ValueNoZero(ptr pointer, tagsize int) int {
1025 v := *ptr.toUint32()
1031 func sizeFixed32Ptr(ptr pointer, tagsize int) int {
1032 p := *ptr.toUint32Ptr()
1038 func sizeFixed32Slice(ptr pointer, tagsize int) int {
1039 s := *ptr.toUint32Slice()
1040 return (4 + tagsize) * len(s)
1042 func sizeFixed32PackedSlice(ptr pointer, tagsize int) int {
1043 s := *ptr.toUint32Slice()
1047 return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize
1049 func sizeFixedS32Value(_ pointer, tagsize int) int {
1052 func sizeFixedS32ValueNoZero(ptr pointer, tagsize int) int {
1059 func sizeFixedS32Ptr(ptr pointer, tagsize int) int {
1060 p := ptr.getInt32Ptr()
1066 func sizeFixedS32Slice(ptr pointer, tagsize int) int {
1067 s := ptr.getInt32Slice()
1068 return (4 + tagsize) * len(s)
1070 func sizeFixedS32PackedSlice(ptr pointer, tagsize int) int {
1071 s := ptr.getInt32Slice()
1075 return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize
1077 func sizeFloat32Value(_ pointer, tagsize int) int {
1080 func sizeFloat32ValueNoZero(ptr pointer, tagsize int) int {
1081 v := math.Float32bits(*ptr.toFloat32())
1087 func sizeFloat32Ptr(ptr pointer, tagsize int) int {
1088 p := *ptr.toFloat32Ptr()
1094 func sizeFloat32Slice(ptr pointer, tagsize int) int {
1095 s := *ptr.toFloat32Slice()
1096 return (4 + tagsize) * len(s)
1098 func sizeFloat32PackedSlice(ptr pointer, tagsize int) int {
1099 s := *ptr.toFloat32Slice()
1103 return 4*len(s) + SizeVarint(uint64(4*len(s))) + tagsize
1105 func sizeFixed64Value(_ pointer, tagsize int) int {
1108 func sizeFixed64ValueNoZero(ptr pointer, tagsize int) int {
1109 v := *ptr.toUint64()
1115 func sizeFixed64Ptr(ptr pointer, tagsize int) int {
1116 p := *ptr.toUint64Ptr()
1122 func sizeFixed64Slice(ptr pointer, tagsize int) int {
1123 s := *ptr.toUint64Slice()
1124 return (8 + tagsize) * len(s)
1126 func sizeFixed64PackedSlice(ptr pointer, tagsize int) int {
1127 s := *ptr.toUint64Slice()
1131 return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize
1133 func sizeFixedS64Value(_ pointer, tagsize int) int {
1136 func sizeFixedS64ValueNoZero(ptr pointer, tagsize int) int {
1143 func sizeFixedS64Ptr(ptr pointer, tagsize int) int {
1144 p := *ptr.toInt64Ptr()
1150 func sizeFixedS64Slice(ptr pointer, tagsize int) int {
1151 s := *ptr.toInt64Slice()
1152 return (8 + tagsize) * len(s)
1154 func sizeFixedS64PackedSlice(ptr pointer, tagsize int) int {
1155 s := *ptr.toInt64Slice()
1159 return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize
1161 func sizeFloat64Value(_ pointer, tagsize int) int {
1164 func sizeFloat64ValueNoZero(ptr pointer, tagsize int) int {
1165 v := math.Float64bits(*ptr.toFloat64())
1171 func sizeFloat64Ptr(ptr pointer, tagsize int) int {
1172 p := *ptr.toFloat64Ptr()
1178 func sizeFloat64Slice(ptr pointer, tagsize int) int {
1179 s := *ptr.toFloat64Slice()
1180 return (8 + tagsize) * len(s)
1182 func sizeFloat64PackedSlice(ptr pointer, tagsize int) int {
1183 s := *ptr.toFloat64Slice()
1187 return 8*len(s) + SizeVarint(uint64(8*len(s))) + tagsize
1189 func sizeVarint32Value(ptr pointer, tagsize int) int {
1190 v := *ptr.toUint32()
1191 return SizeVarint(uint64(v)) + tagsize
1193 func sizeVarint32ValueNoZero(ptr pointer, tagsize int) int {
1194 v := *ptr.toUint32()
1198 return SizeVarint(uint64(v)) + tagsize
1200 func sizeVarint32Ptr(ptr pointer, tagsize int) int {
1201 p := *ptr.toUint32Ptr()
1205 return SizeVarint(uint64(*p)) + tagsize
1207 func sizeVarint32Slice(ptr pointer, tagsize int) int {
1208 s := *ptr.toUint32Slice()
1210 for _, v := range s {
1211 n += SizeVarint(uint64(v)) + tagsize
1215 func sizeVarint32PackedSlice(ptr pointer, tagsize int) int {
1216 s := *ptr.toUint32Slice()
1221 for _, v := range s {
1222 n += SizeVarint(uint64(v))
1224 return n + SizeVarint(uint64(n)) + tagsize
1226 func sizeVarintS32Value(ptr pointer, tagsize int) int {
1228 return SizeVarint(uint64(v)) + tagsize
1230 func sizeVarintS32ValueNoZero(ptr pointer, tagsize int) int {
1235 return SizeVarint(uint64(v)) + tagsize
1237 func sizeVarintS32Ptr(ptr pointer, tagsize int) int {
1238 p := ptr.getInt32Ptr()
1242 return SizeVarint(uint64(*p)) + tagsize
1244 func sizeVarintS32Slice(ptr pointer, tagsize int) int {
1245 s := ptr.getInt32Slice()
1247 for _, v := range s {
1248 n += SizeVarint(uint64(v)) + tagsize
1252 func sizeVarintS32PackedSlice(ptr pointer, tagsize int) int {
1253 s := ptr.getInt32Slice()
1258 for _, v := range s {
1259 n += SizeVarint(uint64(v))
1261 return n + SizeVarint(uint64(n)) + tagsize
1263 func sizeVarint64Value(ptr pointer, tagsize int) int {
1264 v := *ptr.toUint64()
1265 return SizeVarint(v) + tagsize
1267 func sizeVarint64ValueNoZero(ptr pointer, tagsize int) int {
1268 v := *ptr.toUint64()
1272 return SizeVarint(v) + tagsize
1274 func sizeVarint64Ptr(ptr pointer, tagsize int) int {
1275 p := *ptr.toUint64Ptr()
1279 return SizeVarint(*p) + tagsize
1281 func sizeVarint64Slice(ptr pointer, tagsize int) int {
1282 s := *ptr.toUint64Slice()
1284 for _, v := range s {
1285 n += SizeVarint(v) + tagsize
1289 func sizeVarint64PackedSlice(ptr pointer, tagsize int) int {
1290 s := *ptr.toUint64Slice()
1295 for _, v := range s {
1298 return n + SizeVarint(uint64(n)) + tagsize
1300 func sizeVarintS64Value(ptr pointer, tagsize int) int {
1302 return SizeVarint(uint64(v)) + tagsize
1304 func sizeVarintS64ValueNoZero(ptr pointer, tagsize int) int {
1309 return SizeVarint(uint64(v)) + tagsize
1311 func sizeVarintS64Ptr(ptr pointer, tagsize int) int {
1312 p := *ptr.toInt64Ptr()
1316 return SizeVarint(uint64(*p)) + tagsize
1318 func sizeVarintS64Slice(ptr pointer, tagsize int) int {
1319 s := *ptr.toInt64Slice()
1321 for _, v := range s {
1322 n += SizeVarint(uint64(v)) + tagsize
1326 func sizeVarintS64PackedSlice(ptr pointer, tagsize int) int {
1327 s := *ptr.toInt64Slice()
1332 for _, v := range s {
1333 n += SizeVarint(uint64(v))
1335 return n + SizeVarint(uint64(n)) + tagsize
1337 func sizeZigzag32Value(ptr pointer, tagsize int) int {
1339 return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
1341 func sizeZigzag32ValueNoZero(ptr pointer, tagsize int) int {
1346 return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
1348 func sizeZigzag32Ptr(ptr pointer, tagsize int) int {
1349 p := ptr.getInt32Ptr()
1354 return SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
1356 func sizeZigzag32Slice(ptr pointer, tagsize int) int {
1357 s := ptr.getInt32Slice()
1359 for _, v := range s {
1360 n += SizeVarint(uint64((uint32(v)<<1)^uint32((int32(v)>>31)))) + tagsize
1364 func sizeZigzag32PackedSlice(ptr pointer, tagsize int) int {
1365 s := ptr.getInt32Slice()
1370 for _, v := range s {
1371 n += SizeVarint(uint64((uint32(v) << 1) ^ uint32((int32(v) >> 31))))
1373 return n + SizeVarint(uint64(n)) + tagsize
1375 func sizeZigzag64Value(ptr pointer, tagsize int) int {
1377 return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
1379 func sizeZigzag64ValueNoZero(ptr pointer, tagsize int) int {
1384 return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
1386 func sizeZigzag64Ptr(ptr pointer, tagsize int) int {
1387 p := *ptr.toInt64Ptr()
1392 return SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
1394 func sizeZigzag64Slice(ptr pointer, tagsize int) int {
1395 s := *ptr.toInt64Slice()
1397 for _, v := range s {
1398 n += SizeVarint(uint64(v<<1)^uint64((int64(v)>>63))) + tagsize
1402 func sizeZigzag64PackedSlice(ptr pointer, tagsize int) int {
1403 s := *ptr.toInt64Slice()
1408 for _, v := range s {
1409 n += SizeVarint(uint64(v<<1) ^ uint64((int64(v) >> 63)))
1411 return n + SizeVarint(uint64(n)) + tagsize
1413 func sizeBoolValue(_ pointer, tagsize int) int {
1416 func sizeBoolValueNoZero(ptr pointer, tagsize int) int {
1423 func sizeBoolPtr(ptr pointer, tagsize int) int {
1424 p := *ptr.toBoolPtr()
1430 func sizeBoolSlice(ptr pointer, tagsize int) int {
1431 s := *ptr.toBoolSlice()
1432 return (1 + tagsize) * len(s)
1434 func sizeBoolPackedSlice(ptr pointer, tagsize int) int {
1435 s := *ptr.toBoolSlice()
1439 return len(s) + SizeVarint(uint64(len(s))) + tagsize
1441 func sizeStringValue(ptr pointer, tagsize int) int {
1442 v := *ptr.toString()
1443 return len(v) + SizeVarint(uint64(len(v))) + tagsize
1445 func sizeStringValueNoZero(ptr pointer, tagsize int) int {
1446 v := *ptr.toString()
1450 return len(v) + SizeVarint(uint64(len(v))) + tagsize
1452 func sizeStringPtr(ptr pointer, tagsize int) int {
1453 p := *ptr.toStringPtr()
1458 return len(v) + SizeVarint(uint64(len(v))) + tagsize
1460 func sizeStringSlice(ptr pointer, tagsize int) int {
1461 s := *ptr.toStringSlice()
1463 for _, v := range s {
1464 n += len(v) + SizeVarint(uint64(len(v))) + tagsize
1468 func sizeBytes(ptr pointer, tagsize int) int {
1473 return len(v) + SizeVarint(uint64(len(v))) + tagsize
1475 func sizeBytes3(ptr pointer, tagsize int) int {
1480 return len(v) + SizeVarint(uint64(len(v))) + tagsize
1482 func sizeBytesOneof(ptr pointer, tagsize int) int {
1484 return len(v) + SizeVarint(uint64(len(v))) + tagsize
1486 func sizeBytesSlice(ptr pointer, tagsize int) int {
1487 s := *ptr.toBytesSlice()
1489 for _, v := range s {
1490 n += len(v) + SizeVarint(uint64(len(v))) + tagsize
1495 // appendFixed32 appends an encoded fixed32 to b.
1496 func appendFixed32(b []byte, v uint32) []byte {
1505 // appendFixed64 appends an encoded fixed64 to b.
1506 func appendFixed64(b []byte, v uint64) []byte {
1519 // appendVarint appends an encoded varint to b.
1520 func appendVarint(b []byte, v uint64) []byte {
1521 // TODO: make 1-byte (maybe 2-byte) case inline-able, once we
1522 // have non-leaf inliner.
1525 b = append(b, byte(v))
1533 byte((v>>7)&0x7f|0x80),
1538 byte((v>>7)&0x7f|0x80),
1539 byte((v>>14)&0x7f|0x80),
1544 byte((v>>7)&0x7f|0x80),
1545 byte((v>>14)&0x7f|0x80),
1546 byte((v>>21)&0x7f|0x80),
1551 byte((v>>7)&0x7f|0x80),
1552 byte((v>>14)&0x7f|0x80),
1553 byte((v>>21)&0x7f|0x80),
1554 byte((v>>28)&0x7f|0x80),
1559 byte((v>>7)&0x7f|0x80),
1560 byte((v>>14)&0x7f|0x80),
1561 byte((v>>21)&0x7f|0x80),
1562 byte((v>>28)&0x7f|0x80),
1563 byte((v>>35)&0x7f|0x80),
1568 byte((v>>7)&0x7f|0x80),
1569 byte((v>>14)&0x7f|0x80),
1570 byte((v>>21)&0x7f|0x80),
1571 byte((v>>28)&0x7f|0x80),
1572 byte((v>>35)&0x7f|0x80),
1573 byte((v>>42)&0x7f|0x80),
1578 byte((v>>7)&0x7f|0x80),
1579 byte((v>>14)&0x7f|0x80),
1580 byte((v>>21)&0x7f|0x80),
1581 byte((v>>28)&0x7f|0x80),
1582 byte((v>>35)&0x7f|0x80),
1583 byte((v>>42)&0x7f|0x80),
1584 byte((v>>49)&0x7f|0x80),
1589 byte((v>>7)&0x7f|0x80),
1590 byte((v>>14)&0x7f|0x80),
1591 byte((v>>21)&0x7f|0x80),
1592 byte((v>>28)&0x7f|0x80),
1593 byte((v>>35)&0x7f|0x80),
1594 byte((v>>42)&0x7f|0x80),
1595 byte((v>>49)&0x7f|0x80),
1596 byte((v>>56)&0x7f|0x80),
1602 func appendFixed32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1603 v := *ptr.toUint32()
1604 b = appendVarint(b, wiretag)
1605 b = appendFixed32(b, v)
1608 func appendFixed32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1609 v := *ptr.toUint32()
1613 b = appendVarint(b, wiretag)
1614 b = appendFixed32(b, v)
1617 func appendFixed32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1618 p := *ptr.toUint32Ptr()
1622 b = appendVarint(b, wiretag)
1623 b = appendFixed32(b, *p)
1626 func appendFixed32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1627 s := *ptr.toUint32Slice()
1628 for _, v := range s {
1629 b = appendVarint(b, wiretag)
1630 b = appendFixed32(b, v)
1634 func appendFixed32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1635 s := *ptr.toUint32Slice()
1639 b = appendVarint(b, wiretag&^7|WireBytes)
1640 b = appendVarint(b, uint64(4*len(s)))
1641 for _, v := range s {
1642 b = appendFixed32(b, v)
1646 func appendFixedS32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1648 b = appendVarint(b, wiretag)
1649 b = appendFixed32(b, uint32(v))
1652 func appendFixedS32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1657 b = appendVarint(b, wiretag)
1658 b = appendFixed32(b, uint32(v))
1661 func appendFixedS32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1662 p := ptr.getInt32Ptr()
1666 b = appendVarint(b, wiretag)
1667 b = appendFixed32(b, uint32(*p))
1670 func appendFixedS32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1671 s := ptr.getInt32Slice()
1672 for _, v := range s {
1673 b = appendVarint(b, wiretag)
1674 b = appendFixed32(b, uint32(v))
1678 func appendFixedS32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1679 s := ptr.getInt32Slice()
1683 b = appendVarint(b, wiretag&^7|WireBytes)
1684 b = appendVarint(b, uint64(4*len(s)))
1685 for _, v := range s {
1686 b = appendFixed32(b, uint32(v))
1690 func appendFloat32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1691 v := math.Float32bits(*ptr.toFloat32())
1692 b = appendVarint(b, wiretag)
1693 b = appendFixed32(b, v)
1696 func appendFloat32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1697 v := math.Float32bits(*ptr.toFloat32())
1701 b = appendVarint(b, wiretag)
1702 b = appendFixed32(b, v)
1705 func appendFloat32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1706 p := *ptr.toFloat32Ptr()
1710 b = appendVarint(b, wiretag)
1711 b = appendFixed32(b, math.Float32bits(*p))
1714 func appendFloat32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1715 s := *ptr.toFloat32Slice()
1716 for _, v := range s {
1717 b = appendVarint(b, wiretag)
1718 b = appendFixed32(b, math.Float32bits(v))
1722 func appendFloat32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1723 s := *ptr.toFloat32Slice()
1727 b = appendVarint(b, wiretag&^7|WireBytes)
1728 b = appendVarint(b, uint64(4*len(s)))
1729 for _, v := range s {
1730 b = appendFixed32(b, math.Float32bits(v))
1734 func appendFixed64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1735 v := *ptr.toUint64()
1736 b = appendVarint(b, wiretag)
1737 b = appendFixed64(b, v)
1740 func appendFixed64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1741 v := *ptr.toUint64()
1745 b = appendVarint(b, wiretag)
1746 b = appendFixed64(b, v)
1749 func appendFixed64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1750 p := *ptr.toUint64Ptr()
1754 b = appendVarint(b, wiretag)
1755 b = appendFixed64(b, *p)
1758 func appendFixed64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1759 s := *ptr.toUint64Slice()
1760 for _, v := range s {
1761 b = appendVarint(b, wiretag)
1762 b = appendFixed64(b, v)
1766 func appendFixed64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1767 s := *ptr.toUint64Slice()
1771 b = appendVarint(b, wiretag&^7|WireBytes)
1772 b = appendVarint(b, uint64(8*len(s)))
1773 for _, v := range s {
1774 b = appendFixed64(b, v)
1778 func appendFixedS64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1780 b = appendVarint(b, wiretag)
1781 b = appendFixed64(b, uint64(v))
1784 func appendFixedS64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1789 b = appendVarint(b, wiretag)
1790 b = appendFixed64(b, uint64(v))
1793 func appendFixedS64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1794 p := *ptr.toInt64Ptr()
1798 b = appendVarint(b, wiretag)
1799 b = appendFixed64(b, uint64(*p))
1802 func appendFixedS64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1803 s := *ptr.toInt64Slice()
1804 for _, v := range s {
1805 b = appendVarint(b, wiretag)
1806 b = appendFixed64(b, uint64(v))
1810 func appendFixedS64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1811 s := *ptr.toInt64Slice()
1815 b = appendVarint(b, wiretag&^7|WireBytes)
1816 b = appendVarint(b, uint64(8*len(s)))
1817 for _, v := range s {
1818 b = appendFixed64(b, uint64(v))
1822 func appendFloat64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1823 v := math.Float64bits(*ptr.toFloat64())
1824 b = appendVarint(b, wiretag)
1825 b = appendFixed64(b, v)
1828 func appendFloat64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1829 v := math.Float64bits(*ptr.toFloat64())
1833 b = appendVarint(b, wiretag)
1834 b = appendFixed64(b, v)
1837 func appendFloat64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1838 p := *ptr.toFloat64Ptr()
1842 b = appendVarint(b, wiretag)
1843 b = appendFixed64(b, math.Float64bits(*p))
1846 func appendFloat64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1847 s := *ptr.toFloat64Slice()
1848 for _, v := range s {
1849 b = appendVarint(b, wiretag)
1850 b = appendFixed64(b, math.Float64bits(v))
1854 func appendFloat64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1855 s := *ptr.toFloat64Slice()
1859 b = appendVarint(b, wiretag&^7|WireBytes)
1860 b = appendVarint(b, uint64(8*len(s)))
1861 for _, v := range s {
1862 b = appendFixed64(b, math.Float64bits(v))
1866 func appendVarint32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1867 v := *ptr.toUint32()
1868 b = appendVarint(b, wiretag)
1869 b = appendVarint(b, uint64(v))
1872 func appendVarint32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1873 v := *ptr.toUint32()
1877 b = appendVarint(b, wiretag)
1878 b = appendVarint(b, uint64(v))
1881 func appendVarint32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1882 p := *ptr.toUint32Ptr()
1886 b = appendVarint(b, wiretag)
1887 b = appendVarint(b, uint64(*p))
1890 func appendVarint32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1891 s := *ptr.toUint32Slice()
1892 for _, v := range s {
1893 b = appendVarint(b, wiretag)
1894 b = appendVarint(b, uint64(v))
1898 func appendVarint32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1899 s := *ptr.toUint32Slice()
1903 b = appendVarint(b, wiretag&^7|WireBytes)
1906 for _, v := range s {
1907 n += SizeVarint(uint64(v))
1909 b = appendVarint(b, uint64(n))
1910 for _, v := range s {
1911 b = appendVarint(b, uint64(v))
1915 func appendVarintS32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1917 b = appendVarint(b, wiretag)
1918 b = appendVarint(b, uint64(v))
1921 func appendVarintS32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1926 b = appendVarint(b, wiretag)
1927 b = appendVarint(b, uint64(v))
1930 func appendVarintS32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1931 p := ptr.getInt32Ptr()
1935 b = appendVarint(b, wiretag)
1936 b = appendVarint(b, uint64(*p))
1939 func appendVarintS32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1940 s := ptr.getInt32Slice()
1941 for _, v := range s {
1942 b = appendVarint(b, wiretag)
1943 b = appendVarint(b, uint64(v))
1947 func appendVarintS32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1948 s := ptr.getInt32Slice()
1952 b = appendVarint(b, wiretag&^7|WireBytes)
1955 for _, v := range s {
1956 n += SizeVarint(uint64(v))
1958 b = appendVarint(b, uint64(n))
1959 for _, v := range s {
1960 b = appendVarint(b, uint64(v))
1964 func appendVarint64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1965 v := *ptr.toUint64()
1966 b = appendVarint(b, wiretag)
1967 b = appendVarint(b, v)
1970 func appendVarint64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1971 v := *ptr.toUint64()
1975 b = appendVarint(b, wiretag)
1976 b = appendVarint(b, v)
1979 func appendVarint64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1980 p := *ptr.toUint64Ptr()
1984 b = appendVarint(b, wiretag)
1985 b = appendVarint(b, *p)
1988 func appendVarint64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1989 s := *ptr.toUint64Slice()
1990 for _, v := range s {
1991 b = appendVarint(b, wiretag)
1992 b = appendVarint(b, v)
1996 func appendVarint64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
1997 s := *ptr.toUint64Slice()
2001 b = appendVarint(b, wiretag&^7|WireBytes)
2004 for _, v := range s {
2007 b = appendVarint(b, uint64(n))
2008 for _, v := range s {
2009 b = appendVarint(b, v)
2013 func appendVarintS64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2015 b = appendVarint(b, wiretag)
2016 b = appendVarint(b, uint64(v))
2019 func appendVarintS64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2024 b = appendVarint(b, wiretag)
2025 b = appendVarint(b, uint64(v))
2028 func appendVarintS64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2029 p := *ptr.toInt64Ptr()
2033 b = appendVarint(b, wiretag)
2034 b = appendVarint(b, uint64(*p))
2037 func appendVarintS64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2038 s := *ptr.toInt64Slice()
2039 for _, v := range s {
2040 b = appendVarint(b, wiretag)
2041 b = appendVarint(b, uint64(v))
2045 func appendVarintS64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2046 s := *ptr.toInt64Slice()
2050 b = appendVarint(b, wiretag&^7|WireBytes)
2053 for _, v := range s {
2054 n += SizeVarint(uint64(v))
2056 b = appendVarint(b, uint64(n))
2057 for _, v := range s {
2058 b = appendVarint(b, uint64(v))
2062 func appendZigzag32Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2064 b = appendVarint(b, wiretag)
2065 b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
2068 func appendZigzag32ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2073 b = appendVarint(b, wiretag)
2074 b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
2077 func appendZigzag32Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2078 p := ptr.getInt32Ptr()
2082 b = appendVarint(b, wiretag)
2084 b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
2087 func appendZigzag32Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2088 s := ptr.getInt32Slice()
2089 for _, v := range s {
2090 b = appendVarint(b, wiretag)
2091 b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
2095 func appendZigzag32PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2096 s := ptr.getInt32Slice()
2100 b = appendVarint(b, wiretag&^7|WireBytes)
2103 for _, v := range s {
2104 n += SizeVarint(uint64((uint32(v) << 1) ^ uint32((int32(v) >> 31))))
2106 b = appendVarint(b, uint64(n))
2107 for _, v := range s {
2108 b = appendVarint(b, uint64((uint32(v)<<1)^uint32((int32(v)>>31))))
2112 func appendZigzag64Value(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2114 b = appendVarint(b, wiretag)
2115 b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
2118 func appendZigzag64ValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2123 b = appendVarint(b, wiretag)
2124 b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
2127 func appendZigzag64Ptr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2128 p := *ptr.toInt64Ptr()
2132 b = appendVarint(b, wiretag)
2134 b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
2137 func appendZigzag64Slice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2138 s := *ptr.toInt64Slice()
2139 for _, v := range s {
2140 b = appendVarint(b, wiretag)
2141 b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
2145 func appendZigzag64PackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2146 s := *ptr.toInt64Slice()
2150 b = appendVarint(b, wiretag&^7|WireBytes)
2153 for _, v := range s {
2154 n += SizeVarint(uint64(v<<1) ^ uint64((int64(v) >> 63)))
2156 b = appendVarint(b, uint64(n))
2157 for _, v := range s {
2158 b = appendVarint(b, uint64(v<<1)^uint64((int64(v)>>63)))
2162 func appendBoolValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2164 b = appendVarint(b, wiretag)
2172 func appendBoolValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2177 b = appendVarint(b, wiretag)
2182 func appendBoolPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2183 p := *ptr.toBoolPtr()
2187 b = appendVarint(b, wiretag)
2195 func appendBoolSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2196 s := *ptr.toBoolSlice()
2197 for _, v := range s {
2198 b = appendVarint(b, wiretag)
2207 func appendBoolPackedSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2208 s := *ptr.toBoolSlice()
2212 b = appendVarint(b, wiretag&^7|WireBytes)
2213 b = appendVarint(b, uint64(len(s)))
2214 for _, v := range s {
2223 func appendStringValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2224 v := *ptr.toString()
2225 b = appendVarint(b, wiretag)
2226 b = appendVarint(b, uint64(len(v)))
2230 func appendStringValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2231 v := *ptr.toString()
2235 b = appendVarint(b, wiretag)
2236 b = appendVarint(b, uint64(len(v)))
2240 func appendStringPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2241 p := *ptr.toStringPtr()
2246 b = appendVarint(b, wiretag)
2247 b = appendVarint(b, uint64(len(v)))
2251 func appendStringSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2252 s := *ptr.toStringSlice()
2253 for _, v := range s {
2254 b = appendVarint(b, wiretag)
2255 b = appendVarint(b, uint64(len(v)))
2260 func appendUTF8StringValue(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2261 var invalidUTF8 bool
2262 v := *ptr.toString()
2263 if !utf8.ValidString(v) {
2266 b = appendVarint(b, wiretag)
2267 b = appendVarint(b, uint64(len(v)))
2270 return b, errInvalidUTF8
2274 func appendUTF8StringValueNoZero(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2275 var invalidUTF8 bool
2276 v := *ptr.toString()
2280 if !utf8.ValidString(v) {
2283 b = appendVarint(b, wiretag)
2284 b = appendVarint(b, uint64(len(v)))
2287 return b, errInvalidUTF8
2291 func appendUTF8StringPtr(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2292 var invalidUTF8 bool
2293 p := *ptr.toStringPtr()
2298 if !utf8.ValidString(v) {
2301 b = appendVarint(b, wiretag)
2302 b = appendVarint(b, uint64(len(v)))
2305 return b, errInvalidUTF8
2309 func appendUTF8StringSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2310 var invalidUTF8 bool
2311 s := *ptr.toStringSlice()
2312 for _, v := range s {
2313 if !utf8.ValidString(v) {
2316 b = appendVarint(b, wiretag)
2317 b = appendVarint(b, uint64(len(v)))
2321 return b, errInvalidUTF8
2325 func appendBytes(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2330 b = appendVarint(b, wiretag)
2331 b = appendVarint(b, uint64(len(v)))
2335 func appendBytes3(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2340 b = appendVarint(b, wiretag)
2341 b = appendVarint(b, uint64(len(v)))
2345 func appendBytesOneof(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2347 b = appendVarint(b, wiretag)
2348 b = appendVarint(b, uint64(len(v)))
2352 func appendBytesSlice(b []byte, ptr pointer, wiretag uint64, _ bool) ([]byte, error) {
2353 s := *ptr.toBytesSlice()
2354 for _, v := range s {
2355 b = appendVarint(b, wiretag)
2356 b = appendVarint(b, uint64(len(v)))
2362 // makeGroupMarshaler returns the sizer and marshaler for a group.
2363 // u is the marshal info of the underlying message.
2364 func makeGroupMarshaler(u *marshalInfo) (sizer, marshaler) {
2365 return func(ptr pointer, tagsize int) int {
2366 p := ptr.getPointer()
2370 return u.size(p) + 2*tagsize
2372 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
2373 p := ptr.getPointer()
2378 b = appendVarint(b, wiretag) // start group
2379 b, err = u.marshal(b, p, deterministic)
2380 b = appendVarint(b, wiretag+(WireEndGroup-WireStartGroup)) // end group
2385 // makeGroupSliceMarshaler returns the sizer and marshaler for a group slice.
2386 // u is the marshal info of the underlying message.
2387 func makeGroupSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
2388 return func(ptr pointer, tagsize int) int {
2389 s := ptr.getPointerSlice()
2391 for _, v := range s {
2395 n += u.size(v) + 2*tagsize
2399 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
2400 s := ptr.getPointerSlice()
2403 for _, v := range s {
2405 return b, errRepeatedHasNil
2407 b = appendVarint(b, wiretag) // start group
2408 b, err = u.marshal(b, v, deterministic)
2409 b = appendVarint(b, wiretag+(WireEndGroup-WireStartGroup)) // end group
2410 if !nerr.Merge(err) {
2412 err = errRepeatedHasNil
2421 // makeMessageMarshaler returns the sizer and marshaler for a message field.
2422 // u is the marshal info of the message.
2423 func makeMessageMarshaler(u *marshalInfo) (sizer, marshaler) {
2424 return func(ptr pointer, tagsize int) int {
2425 p := ptr.getPointer()
2430 return siz + SizeVarint(uint64(siz)) + tagsize
2432 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
2433 p := ptr.getPointer()
2437 b = appendVarint(b, wiretag)
2438 siz := u.cachedsize(p)
2439 b = appendVarint(b, uint64(siz))
2440 return u.marshal(b, p, deterministic)
2444 // makeMessageSliceMarshaler returns the sizer and marshaler for a message slice.
2445 // u is the marshal info of the message.
2446 func makeMessageSliceMarshaler(u *marshalInfo) (sizer, marshaler) {
2447 return func(ptr pointer, tagsize int) int {
2448 s := ptr.getPointerSlice()
2450 for _, v := range s {
2455 n += siz + SizeVarint(uint64(siz)) + tagsize
2459 func(b []byte, ptr pointer, wiretag uint64, deterministic bool) ([]byte, error) {
2460 s := ptr.getPointerSlice()
2463 for _, v := range s {
2465 return b, errRepeatedHasNil
2467 b = appendVarint(b, wiretag)
2468 siz := u.cachedsize(v)
2469 b = appendVarint(b, uint64(siz))
2470 b, err = u.marshal(b, v, deterministic)
2472 if !nerr.Merge(err) {
2474 err = errRepeatedHasNil
2483 // makeMapMarshaler returns the sizer and marshaler for a map field.
2484 // f is the pointer to the reflect data structure of the field.
2485 func makeMapMarshaler(f *reflect.StructField) (sizer, marshaler) {
2486 // figure out key and value type
2490 tags := strings.Split(f.Tag.Get("protobuf"), ",")
2491 keyTags := strings.Split(f.Tag.Get("protobuf_key"), ",")
2492 valTags := strings.Split(f.Tag.Get("protobuf_val"), ",")
2494 for _, t := range tags {
2495 if strings.HasPrefix(t, "customtype=") {
2496 valTags = append(valTags, t)
2499 valTags = append(valTags, t)
2502 if t == "stdduration" {
2503 valTags = append(valTags, t)
2507 valTags = append(valTags, t)
2510 keySizer, keyMarshaler := typeMarshaler(keyType, keyTags, false, false) // don't omit zero value in map
2511 valSizer, valMarshaler := typeMarshaler(valType, valTags, false, false) // don't omit zero value in map
2512 keyWireTag := 1<<3 | wiretype(keyTags[0])
2513 valWireTag := 2<<3 | wiretype(valTags[0])
2515 // We create an interface to get the addresses of the map key and value.
2516 // If value is pointer-typed, the interface is a direct interface, the
2517 // idata itself is the value. Otherwise, the idata is the pointer to the
2519 // Key cannot be pointer-typed.
2520 valIsPtr := valType.Kind() == reflect.Ptr
2522 // If value is a message with nested maps, calling
2523 // valSizer in marshal may be quadratic. We should use
2524 // cached version in marshal (but not in size).
2525 // If value is not message type, we don't have size cache,
2526 // but it cannot be nested either. Just use valSizer.
2527 valCachedSizer := valSizer
2528 if valIsPtr && !stdOptions && valType.Elem().Kind() == reflect.Struct {
2529 u := getMarshalInfo(valType.Elem())
2530 valCachedSizer = func(ptr pointer, tagsize int) int {
2531 // Same as message sizer, but use cache.
2532 p := ptr.getPointer()
2536 siz := u.cachedsize(p)
2537 return siz + SizeVarint(uint64(siz)) + tagsize
2540 return func(ptr pointer, tagsize int) int {
2541 m := ptr.asPointerTo(t).Elem() // the map
2543 for _, k := range m.MapKeys() {
2545 vi := m.MapIndex(k).Interface()
2546 kaddr := toAddrPointer(&ki, false) // pointer to key
2547 vaddr := toAddrPointer(&vi, valIsPtr) // pointer to value
2548 siz := keySizer(kaddr, 1) + valSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1)
2549 n += siz + SizeVarint(uint64(siz)) + tagsize
2553 func(b []byte, ptr pointer, tag uint64, deterministic bool) ([]byte, error) {
2554 m := ptr.asPointerTo(t).Elem() // the map
2557 if len(keys) > 1 && deterministic {
2558 sort.Sort(mapKeys(keys))
2562 for _, k := range keys {
2564 vi := m.MapIndex(k).Interface()
2565 kaddr := toAddrPointer(&ki, false) // pointer to key
2566 vaddr := toAddrPointer(&vi, valIsPtr) // pointer to value
2567 b = appendVarint(b, tag)
2568 siz := keySizer(kaddr, 1) + valCachedSizer(vaddr, 1) // tag of key = 1 (size=1), tag of val = 2 (size=1)
2569 b = appendVarint(b, uint64(siz))
2570 b, err = keyMarshaler(b, kaddr, keyWireTag, deterministic)
2571 if !nerr.Merge(err) {
2574 b, err = valMarshaler(b, vaddr, valWireTag, deterministic)
2575 if err != ErrNil && !nerr.Merge(err) { // allow nil value in map
2583 // makeOneOfMarshaler returns the sizer and marshaler for a oneof field.
2584 // fi is the marshal info of the field.
2585 // f is the pointer to the reflect data structure of the field.
2586 func makeOneOfMarshaler(fi *marshalFieldInfo, f *reflect.StructField) (sizer, marshaler) {
2587 // Oneof field is an interface. We need to get the actual data type on the fly.
2589 return func(ptr pointer, _ int) int {
2590 p := ptr.getInterfacePointer()
2594 v := ptr.asPointerTo(t).Elem().Elem().Elem() // *interface -> interface -> *struct -> struct
2596 e := fi.oneofElems[telem]
2597 return e.sizer(p, e.tagsize)
2599 func(b []byte, ptr pointer, _ uint64, deterministic bool) ([]byte, error) {
2600 p := ptr.getInterfacePointer()
2604 v := ptr.asPointerTo(t).Elem().Elem().Elem() // *interface -> interface -> *struct -> struct
2606 if telem.Field(0).Type.Kind() == reflect.Ptr && p.getPointer().isNil() {
2607 return b, errOneofHasNil
2609 e := fi.oneofElems[telem]
2610 return e.marshaler(b, p, e.wiretag, deterministic)
2614 // sizeExtensions computes the size of encoded data for a XXX_InternalExtensions field.
2615 func (u *marshalInfo) sizeExtensions(ext *XXX_InternalExtensions) int {
2616 m, mu := ext.extensionsRead()
2623 for _, e := range m {
2624 if e.value == nil || e.desc == nil {
2625 // Extension is only in its encoded form.
2630 // We don't skip extensions that have an encoded form set,
2631 // because the extension value may have been mutated after
2632 // the last time this function was called.
2633 ei := u.getExtElemInfo(e.desc)
2635 p := toAddrPointer(&v, ei.isptr)
2636 n += ei.sizer(p, ei.tagsize)
2642 // appendExtensions marshals a XXX_InternalExtensions field to the end of byte slice b.
2643 func (u *marshalInfo) appendExtensions(b []byte, ext *XXX_InternalExtensions, deterministic bool) ([]byte, error) {
2644 m, mu := ext.extensionsRead()
2654 // Fast-path for common cases: zero or one extensions.
2655 // Don't bother sorting the keys.
2657 for _, e := range m {
2658 if e.value == nil || e.desc == nil {
2659 // Extension is only in its encoded form.
2660 b = append(b, e.enc...)
2664 // We don't skip extensions that have an encoded form set,
2665 // because the extension value may have been mutated after
2666 // the last time this function was called.
2668 ei := u.getExtElemInfo(e.desc)
2670 p := toAddrPointer(&v, ei.isptr)
2671 b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
2672 if !nerr.Merge(err) {
2679 // Sort the keys to provide a deterministic encoding.
2680 // Not sure this is required, but the old code does it.
2681 keys := make([]int, 0, len(m))
2683 keys = append(keys, int(k))
2687 for _, k := range keys {
2689 if e.value == nil || e.desc == nil {
2690 // Extension is only in its encoded form.
2691 b = append(b, e.enc...)
2695 // We don't skip extensions that have an encoded form set,
2696 // because the extension value may have been mutated after
2697 // the last time this function was called.
2699 ei := u.getExtElemInfo(e.desc)
2701 p := toAddrPointer(&v, ei.isptr)
2702 b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
2703 if !nerr.Merge(err) {
2710 // message set format is:
2711 // message MessageSet {
2712 // repeated group Item = 1 {
2713 // required int32 type_id = 2;
2714 // required string message = 3;
2718 // sizeMessageSet computes the size of encoded data for a XXX_InternalExtensions field
2719 // in message set format (above).
2720 func (u *marshalInfo) sizeMessageSet(ext *XXX_InternalExtensions) int {
2721 m, mu := ext.extensionsRead()
2728 for id, e := range m {
2729 n += 2 // start group, end group. tag = 1 (size=1)
2730 n += SizeVarint(uint64(id)) + 1 // type_id, tag = 2 (size=1)
2732 if e.value == nil || e.desc == nil {
2733 // Extension is only in its encoded form.
2734 msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint
2735 siz := len(msgWithLen)
2736 n += siz + 1 // message, tag = 3 (size=1)
2740 // We don't skip extensions that have an encoded form set,
2741 // because the extension value may have been mutated after
2742 // the last time this function was called.
2744 ei := u.getExtElemInfo(e.desc)
2746 p := toAddrPointer(&v, ei.isptr)
2747 n += ei.sizer(p, 1) // message, tag = 3 (size=1)
2753 // appendMessageSet marshals a XXX_InternalExtensions field in message set format (above)
2754 // to the end of byte slice b.
2755 func (u *marshalInfo) appendMessageSet(b []byte, ext *XXX_InternalExtensions, deterministic bool) ([]byte, error) {
2756 m, mu := ext.extensionsRead()
2766 // Fast-path for common cases: zero or one extensions.
2767 // Don't bother sorting the keys.
2769 for id, e := range m {
2770 b = append(b, 1<<3|WireStartGroup)
2771 b = append(b, 2<<3|WireVarint)
2772 b = appendVarint(b, uint64(id))
2774 if e.value == nil || e.desc == nil {
2775 // Extension is only in its encoded form.
2776 msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint
2777 b = append(b, 3<<3|WireBytes)
2778 b = append(b, msgWithLen...)
2779 b = append(b, 1<<3|WireEndGroup)
2783 // We don't skip extensions that have an encoded form set,
2784 // because the extension value may have been mutated after
2785 // the last time this function was called.
2787 ei := u.getExtElemInfo(e.desc)
2789 p := toAddrPointer(&v, ei.isptr)
2790 b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic)
2791 if !nerr.Merge(err) {
2794 b = append(b, 1<<3|WireEndGroup)
2799 // Sort the keys to provide a deterministic encoding.
2800 keys := make([]int, 0, len(m))
2802 keys = append(keys, int(k))
2806 for _, id := range keys {
2808 b = append(b, 1<<3|WireStartGroup)
2809 b = append(b, 2<<3|WireVarint)
2810 b = appendVarint(b, uint64(id))
2812 if e.value == nil || e.desc == nil {
2813 // Extension is only in its encoded form.
2814 msgWithLen := skipVarint(e.enc) // skip old tag, but leave the length varint
2815 b = append(b, 3<<3|WireBytes)
2816 b = append(b, msgWithLen...)
2817 b = append(b, 1<<3|WireEndGroup)
2821 // We don't skip extensions that have an encoded form set,
2822 // because the extension value may have been mutated after
2823 // the last time this function was called.
2825 ei := u.getExtElemInfo(e.desc)
2827 p := toAddrPointer(&v, ei.isptr)
2828 b, err = ei.marshaler(b, p, 3<<3|WireBytes, deterministic)
2829 b = append(b, 1<<3|WireEndGroup)
2830 if !nerr.Merge(err) {
2837 // sizeV1Extensions computes the size of encoded data for a V1-API extension field.
2838 func (u *marshalInfo) sizeV1Extensions(m map[int32]Extension) int {
2844 for _, e := range m {
2845 if e.value == nil || e.desc == nil {
2846 // Extension is only in its encoded form.
2851 // We don't skip extensions that have an encoded form set,
2852 // because the extension value may have been mutated after
2853 // the last time this function was called.
2855 ei := u.getExtElemInfo(e.desc)
2857 p := toAddrPointer(&v, ei.isptr)
2858 n += ei.sizer(p, ei.tagsize)
2863 // appendV1Extensions marshals a V1-API extension field to the end of byte slice b.
2864 func (u *marshalInfo) appendV1Extensions(b []byte, m map[int32]Extension, deterministic bool) ([]byte, error) {
2869 // Sort the keys to provide a deterministic encoding.
2870 keys := make([]int, 0, len(m))
2872 keys = append(keys, int(k))
2878 for _, k := range keys {
2880 if e.value == nil || e.desc == nil {
2881 // Extension is only in its encoded form.
2882 b = append(b, e.enc...)
2886 // We don't skip extensions that have an encoded form set,
2887 // because the extension value may have been mutated after
2888 // the last time this function was called.
2890 ei := u.getExtElemInfo(e.desc)
2892 p := toAddrPointer(&v, ei.isptr)
2893 b, err = ei.marshaler(b, p, ei.wiretag, deterministic)
2894 if !nerr.Merge(err) {
2901 // newMarshaler is the interface representing objects that can marshal themselves.
2903 // This exists to support protoc-gen-go generated messages.
2904 // The proto package will stop type-asserting to this interface in the future.
2906 // DO NOT DEPEND ON THIS.
2907 type newMarshaler interface {
2909 XXX_Marshal(b []byte, deterministic bool) ([]byte, error)
2912 // Size returns the encoded size of a protocol buffer message.
2913 // This is the main entry point.
2914 func Size(pb Message) int {
2915 if m, ok := pb.(newMarshaler); ok {
2918 if m, ok := pb.(Marshaler); ok {
2919 // If the message can marshal itself, let it do it, for compatibility.
2920 // NOTE: This is not efficient.
2924 // in case somehow we didn't generate the wrapper
2928 var info InternalMessageInfo
2929 return info.Size(pb)
2932 // Marshal takes a protocol buffer message
2933 // and encodes it into the wire format, returning the data.
2934 // This is the main entry point.
2935 func Marshal(pb Message) ([]byte, error) {
2936 if m, ok := pb.(newMarshaler); ok {
2938 b := make([]byte, 0, siz)
2939 return m.XXX_Marshal(b, false)
2941 if m, ok := pb.(Marshaler); ok {
2942 // If the message can marshal itself, let it do it, for compatibility.
2943 // NOTE: This is not efficient.
2946 // in case somehow we didn't generate the wrapper
2950 var info InternalMessageInfo
2951 siz := info.Size(pb)
2952 b := make([]byte, 0, siz)
2953 return info.Marshal(b, pb, false)
2956 // Marshal takes a protocol buffer message
2957 // and encodes it into the wire format, writing the result to the
2959 // This is an alternative entry point. It is not necessary to use
2960 // a Buffer for most applications.
2961 func (p *Buffer) Marshal(pb Message) error {
2963 if p.deterministic {
2964 if _, ok := pb.(Marshaler); ok {
2965 return fmt.Errorf("proto: deterministic not supported by the Marshal method of %T", pb)
2968 if m, ok := pb.(newMarshaler); ok {
2970 p.grow(siz) // make sure buf has enough capacity
2971 p.buf, err = m.XXX_Marshal(p.buf, p.deterministic)
2974 if m, ok := pb.(Marshaler); ok {
2975 // If the message can marshal itself, let it do it, for compatibility.
2976 // NOTE: This is not efficient.
2978 b, err = m.Marshal()
2979 p.buf = append(p.buf, b...)
2982 // in case somehow we didn't generate the wrapper
2986 var info InternalMessageInfo
2987 siz := info.Size(pb)
2988 p.grow(siz) // make sure buf has enough capacity
2989 p.buf, err = info.Marshal(p.buf, pb, p.deterministic)
2993 // grow grows the buffer's capacity, if necessary, to guarantee space for
2994 // another n bytes. After grow(n), at least n bytes can be written to the
2995 // buffer without another allocation.
2996 func (p *Buffer) grow(n int) {
2997 need := len(p.buf) + n
2998 if need <= cap(p.buf) {
3001 newCap := len(p.buf) * 2
3005 p.buf = append(make([]byte, 0, newCap), p.buf...)