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