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