vendor/github.com/golang/protobuf/proto/encode.go

   1 // Go support for Protocol Buffers - Google's data interchange format
   2 //
   3 // Copyright 2010 The Go Authors.  All rights reserved.
   4 // https://github.com/golang/protobuf
   5 //
   6 // Redistribution and use in source and binary forms, with or without
   7 // modification, are permitted provided that the following conditions are
   8 // met:
   9 //
  10 //     * Redistributions of source code must retain the above copyright
  11 // notice, this list of conditions and the following disclaimer.
  12 //     * Redistributions in binary form must reproduce the above
  13 // copyright notice, this list of conditions and the following disclaimer
  14 // in the documentation and/or other materials provided with the
  15 // distribution.
  16 //     * Neither the name of Google Inc. nor the names of its
  17 // contributors may be used to endorse or promote products derived from
  18 // this software without specific prior written permission.
  19 //
  20 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  23 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31
  32 package proto
  33
  34 /*
  35  * Routines for encoding data into the wire format for protocol buffers.
  36  */
  37
  38 import (
  39         "errors"
  40         "fmt"
  41         "reflect"
  42         "sort"
  43 )
  44
  45 // RequiredNotSetError is the error returned if Marshal is called with
  46 // a protocol buffer struct whose required fields have not
  47 // all been initialized. It is also the error returned if Unmarshal is
  48 // called with an encoded protocol buffer that does not include all the
  49 // required fields.
  50 //
  51 // When printed, RequiredNotSetError reports the first unset required field in a
  52 // message. If the field cannot be precisely determined, it is reported as
  53 // "{Unknown}".
  54 type RequiredNotSetError struct {
  55         field string
  56 }
  57
  58 func (e *RequiredNotSetError) Error() string {
  59         return fmt.Sprintf("proto: required field %q not set", e.field)
  60 }
  61
  62 var (
  63         // errRepeatedHasNil is the error returned if Marshal is called with
  64         // a struct with a repeated field containing a nil element.
  65         errRepeatedHasNil = errors.New("proto: repeated field has nil element")
  66
  67         // errOneofHasNil is the error returned if Marshal is called with
  68         // a struct with a oneof field containing a nil element.
  69         errOneofHasNil = errors.New("proto: oneof field has nil value")
  70
  71         // ErrNil is the error returned if Marshal is called with nil.
  72         ErrNil = errors.New("proto: Marshal called with nil")
  73
  74         // ErrTooLarge is the error returned if Marshal is called with a
  75         // message that encodes to >2GB.
  76         ErrTooLarge = errors.New("proto: message encodes to over 2 GB")
  77 )
  78
  79 // The fundamental encoders that put bytes on the wire.
  80 // Those that take integer types all accept uint64 and are
  81 // therefore of type valueEncoder.
  82
  83 const maxVarintBytes = 10 // maximum length of a varint
  84
  85 // maxMarshalSize is the largest allowed size of an encoded protobuf,
  86 // since C++ and Java use signed int32s for the size.
  87 const maxMarshalSize = 1<<31 - 1
  88
  89 // EncodeVarint returns the varint encoding of x.
  90 // This is the format for the
  91 // int32, int64, uint32, uint64, bool, and enum
  92 // protocol buffer types.
  93 // Not used by the package itself, but helpful to clients
  94 // wishing to use the same encoding.
  95 func EncodeVarint(x uint64) []byte {
  96         var buf [maxVarintBytes]byte
  97         var n int
  98         for n = 0; x > 127; n++ {
  99                 buf[n] = 0x80 | uint8(x&0x7F)
 100                 x >>= 7
 101         }
 102         buf[n] = uint8(x)
 103         n++
 104         return buf[0:n]
 105 }
 106
 107 // EncodeVarint writes a varint-encoded integer to the Buffer.
 108 // This is the format for the
 109 // int32, int64, uint32, uint64, bool, and enum
 110 // protocol buffer types.
 111 func (p *Buffer) EncodeVarint(x uint64) error {
 112         for x >= 1<<7 {
 113                 p.buf = append(p.buf, uint8(x&0x7f|0x80))
 114                 x >>= 7
 115         }
 116         p.buf = append(p.buf, uint8(x))
 117         return nil
 118 }
 119
 120 // SizeVarint returns the varint encoding size of an integer.
 121 func SizeVarint(x uint64) int {
 122         return sizeVarint(x)
 123 }
 124
 125 func sizeVarint(x uint64) (n int) {
 126         for {
 127                 n++
 128                 x >>= 7
 129                 if x == 0 {
 130                         break
 131                 }
 132         }
 133         return n
 134 }
 135
 136 // EncodeFixed64 writes a 64-bit integer to the Buffer.
 137 // This is the format for the
 138 // fixed64, sfixed64, and double protocol buffer types.
 139 func (p *Buffer) EncodeFixed64(x uint64) error {
 140         p.buf = append(p.buf,
 141                 uint8(x),
 142                 uint8(x>>8),
 143                 uint8(x>>16),
 144                 uint8(x>>24),
 145                 uint8(x>>32),
 146                 uint8(x>>40),
 147                 uint8(x>>48),
 148                 uint8(x>>56))
 149         return nil
 150 }
 151
 152 func sizeFixed64(x uint64) int {
 153         return 8
 154 }
 155
 156 // EncodeFixed32 writes a 32-bit integer to the Buffer.
 157 // This is the format for the
 158 // fixed32, sfixed32, and float protocol buffer types.
 159 func (p *Buffer) EncodeFixed32(x uint64) error {
 160         p.buf = append(p.buf,
 161                 uint8(x),
 162                 uint8(x>>8),
 163                 uint8(x>>16),
 164                 uint8(x>>24))
 165         return nil
 166 }
 167
 168 func sizeFixed32(x uint64) int {
 169         return 4
 170 }
 171
 172 // EncodeZigzag64 writes a zigzag-encoded 64-bit integer
 173 // to the Buffer.
 174 // This is the format used for the sint64 protocol buffer type.
 175 func (p *Buffer) EncodeZigzag64(x uint64) error {
 176         // use signed number to get arithmetic right shift.
 177         return p.EncodeVarint((x << 1) ^ uint64((int64(x) >> 63)))
 178 }
 179
 180 func sizeZigzag64(x uint64) int {
 181         return sizeVarint((x << 1) ^ uint64((int64(x) >> 63)))
 182 }
 183
 184 // EncodeZigzag32 writes a zigzag-encoded 32-bit integer
 185 // to the Buffer.
 186 // This is the format used for the sint32 protocol buffer type.
 187 func (p *Buffer) EncodeZigzag32(x uint64) error {
 188         // use signed number to get arithmetic right shift.
 189         return p.EncodeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31))))
 190 }
 191
 192 func sizeZigzag32(x uint64) int {
 193         return sizeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31))))
 194 }
 195
 196 // EncodeRawBytes writes a count-delimited byte buffer to the Buffer.
 197 // This is the format used for the bytes protocol buffer
 198 // type and for embedded messages.
 199 func (p *Buffer) EncodeRawBytes(b []byte) error {
 200         p.EncodeVarint(uint64(len(b)))
 201         p.buf = append(p.buf, b...)
 202         return nil
 203 }
 204
 205 func sizeRawBytes(b []byte) int {
 206         return sizeVarint(uint64(len(b))) +
 207                 len(b)
 208 }
 209
 210 // EncodeStringBytes writes an encoded string to the Buffer.
 211 // This is the format used for the proto2 string type.
 212 func (p *Buffer) EncodeStringBytes(s string) error {
 213         p.EncodeVarint(uint64(len(s)))
 214         p.buf = append(p.buf, s...)
 215         return nil
 216 }
 217
 218 func sizeStringBytes(s string) int {
 219         return sizeVarint(uint64(len(s))) +
 220                 len(s)
 221 }
 222
 223 // Marshaler is the interface representing objects that can marshal themselves.
 224 type Marshaler interface {
 225         Marshal() ([]byte, error)
 226 }
 227
 228 // Marshal takes the protocol buffer
 229 // and encodes it into the wire format, returning the data.
 230 func Marshal(pb Message) ([]byte, error) {
 231         // Can the object marshal itself?
 232         if m, ok := pb.(Marshaler); ok {
 233                 return m.Marshal()
 234         }
 235         p := NewBuffer(nil)
 236         err := p.Marshal(pb)
 237         if p.buf == nil && err == nil {
 238                 // Return a non-nil slice on success.
 239                 return []byte{}, nil
 240         }
 241         return p.buf, err
 242 }
 243
 244 // EncodeMessage writes the protocol buffer to the Buffer,
 245 // prefixed by a varint-encoded length.
 246 func (p *Buffer) EncodeMessage(pb Message) error {
 247         t, base, err := getbase(pb)
 248         if structPointer_IsNil(base) {
 249                 return ErrNil
 250         }
 251         if err == nil {
 252                 var state errorState
 253                 err = p.enc_len_struct(GetProperties(t.Elem()), base, &state)
 254         }
 255         return err
 256 }
 257
 258 // Marshal takes the protocol buffer
 259 // and encodes it into the wire format, writing the result to the
 260 // Buffer.
 261 func (p *Buffer) Marshal(pb Message) error {
 262         // Can the object marshal itself?
 263         if m, ok := pb.(Marshaler); ok {
 264                 data, err := m.Marshal()
 265                 p.buf = append(p.buf, data...)
 266                 return err
 267         }
 268
 269         t, base, err := getbase(pb)
 270         if structPointer_IsNil(base) {
 271                 return ErrNil
 272         }
 273         if err == nil {
 274                 err = p.enc_struct(GetProperties(t.Elem()), base)
 275         }
 276
 277         if collectStats {
 278                 (stats).Encode++ // Parens are to work around a goimports bug.
 279         }
 280
 281         if len(p.buf) > maxMarshalSize {
 282                 return ErrTooLarge
 283         }
 284         return err
 285 }
 286
 287 // Size returns the encoded size of a protocol buffer.
 288 func Size(pb Message) (n int) {
 289         // Can the object marshal itself?  If so, Size is slow.
 290         // TODO: add Size to Marshaler, or add a Sizer interface.
 291         if m, ok := pb.(Marshaler); ok {
 292                 b, _ := m.Marshal()
 293                 return len(b)
 294         }
 295
 296         t, base, err := getbase(pb)
 297         if structPointer_IsNil(base) {
 298                 return 0
 299         }
 300         if err == nil {
 301                 n = size_struct(GetProperties(t.Elem()), base)
 302         }
 303
 304         if collectStats {
 305                 (stats).Size++ // Parens are to work around a goimports bug.
 306         }
 307
 308         return
 309 }
 310
 311 // Individual type encoders.
 312
 313 // Encode a bool.
 314 func (o *Buffer) enc_bool(p *Properties, base structPointer) error {
 315         v := *structPointer_Bool(base, p.field)
 316         if v == nil {
 317                 return ErrNil
 318         }
 319         x := 0
 320         if *v {
 321                 x = 1
 322         }
 323         o.buf = append(o.buf, p.tagcode...)
 324         p.valEnc(o, uint64(x))
 325         return nil
 326 }
 327
 328 func (o *Buffer) enc_proto3_bool(p *Properties, base structPointer) error {
 329         v := *structPointer_BoolVal(base, p.field)
 330         if !v {
 331                 return ErrNil
 332         }
 333         o.buf = append(o.buf, p.tagcode...)
 334         p.valEnc(o, 1)
 335         return nil
 336 }
 337
 338 func size_bool(p *Properties, base structPointer) int {
 339         v := *structPointer_Bool(base, p.field)
 340         if v == nil {
 341                 return 0
 342         }
 343         return len(p.tagcode) + 1 // each bool takes exactly one byte
 344 }
 345
 346 func size_proto3_bool(p *Properties, base structPointer) int {
 347         v := *structPointer_BoolVal(base, p.field)
 348         if !v && !p.oneof {
 349                 return 0
 350         }
 351         return len(p.tagcode) + 1 // each bool takes exactly one byte
 352 }
 353
 354 // Encode an int32.
 355 func (o *Buffer) enc_int32(p *Properties, base structPointer) error {
 356         v := structPointer_Word32(base, p.field)
 357         if word32_IsNil(v) {
 358                 return ErrNil
 359         }
 360         x := int32(word32_Get(v)) // permit sign extension to use full 64-bit range
 361         o.buf = append(o.buf, p.tagcode...)
 362         p.valEnc(o, uint64(x))
 363         return nil
 364 }
 365
 366 func (o *Buffer) enc_proto3_int32(p *Properties, base structPointer) error {
 367         v := structPointer_Word32Val(base, p.field)
 368         x := int32(word32Val_Get(v)) // permit sign extension to use full 64-bit range
 369         if x == 0 {
 370                 return ErrNil
 371         }
 372         o.buf = append(o.buf, p.tagcode...)
 373         p.valEnc(o, uint64(x))
 374         return nil
 375 }
 376
 377 func size_int32(p *Properties, base structPointer) (n int) {
 378         v := structPointer_Word32(base, p.field)
 379         if word32_IsNil(v) {
 380                 return 0
 381         }
 382         x := int32(word32_Get(v)) // permit sign extension to use full 64-bit range
 383         n += len(p.tagcode)
 384         n += p.valSize(uint64(x))
 385         return
 386 }
 387
 388 func size_proto3_int32(p *Properties, base structPointer) (n int) {
 389         v := structPointer_Word32Val(base, p.field)
 390         x := int32(word32Val_Get(v)) // permit sign extension to use full 64-bit range
 391         if x == 0 && !p.oneof {
 392                 return 0
 393         }
 394         n += len(p.tagcode)
 395         n += p.valSize(uint64(x))
 396         return
 397 }
 398
 399 // Encode a uint32.
 400 // Exactly the same as int32, except for no sign extension.
 401 func (o *Buffer) enc_uint32(p *Properties, base structPointer) error {
 402         v := structPointer_Word32(base, p.field)
 403         if word32_IsNil(v) {
 404                 return ErrNil
 405         }
 406         x := word32_Get(v)
 407         o.buf = append(o.buf, p.tagcode...)
 408         p.valEnc(o, uint64(x))
 409         return nil
 410 }
 411
 412 func (o *Buffer) enc_proto3_uint32(p *Properties, base structPointer) error {
 413         v := structPointer_Word32Val(base, p.field)
 414         x := word32Val_Get(v)
 415         if x == 0 {
 416                 return ErrNil
 417         }
 418         o.buf = append(o.buf, p.tagcode...)
 419         p.valEnc(o, uint64(x))
 420         return nil
 421 }
 422
 423 func size_uint32(p *Properties, base structPointer) (n int) {
 424         v := structPointer_Word32(base, p.field)
 425         if word32_IsNil(v) {
 426                 return 0
 427         }
 428         x := word32_Get(v)
 429         n += len(p.tagcode)
 430         n += p.valSize(uint64(x))
 431         return
 432 }
 433
 434 func size_proto3_uint32(p *Properties, base structPointer) (n int) {
 435         v := structPointer_Word32Val(base, p.field)
 436         x := word32Val_Get(v)
 437         if x == 0 && !p.oneof {
 438                 return 0
 439         }
 440         n += len(p.tagcode)
 441         n += p.valSize(uint64(x))
 442         return
 443 }
 444
 445 // Encode an int64.
 446 func (o *Buffer) enc_int64(p *Properties, base structPointer) error {
 447         v := structPointer_Word64(base, p.field)
 448         if word64_IsNil(v) {
 449                 return ErrNil
 450         }
 451         x := word64_Get(v)
 452         o.buf = append(o.buf, p.tagcode...)
 453         p.valEnc(o, x)
 454         return nil
 455 }
 456
 457 func (o *Buffer) enc_proto3_int64(p *Properties, base structPointer) error {
 458         v := structPointer_Word64Val(base, p.field)
 459         x := word64Val_Get(v)
 460         if x == 0 {
 461                 return ErrNil
 462         }
 463         o.buf = append(o.buf, p.tagcode...)
 464         p.valEnc(o, x)
 465         return nil
 466 }
 467
 468 func size_int64(p *Properties, base structPointer) (n int) {
 469         v := structPointer_Word64(base, p.field)
 470         if word64_IsNil(v) {
 471                 return 0
 472         }
 473         x := word64_Get(v)
 474         n += len(p.tagcode)
 475         n += p.valSize(x)
 476         return
 477 }
 478
 479 func size_proto3_int64(p *Properties, base structPointer) (n int) {
 480         v := structPointer_Word64Val(base, p.field)
 481         x := word64Val_Get(v)
 482         if x == 0 && !p.oneof {
 483                 return 0
 484         }
 485         n += len(p.tagcode)
 486         n += p.valSize(x)
 487         return
 488 }
 489
 490 // Encode a string.
 491 func (o *Buffer) enc_string(p *Properties, base structPointer) error {
 492         v := *structPointer_String(base, p.field)
 493         if v == nil {
 494                 return ErrNil
 495         }
 496         x := *v
 497         o.buf = append(o.buf, p.tagcode...)
 498         o.EncodeStringBytes(x)
 499         return nil
 500 }
 501
 502 func (o *Buffer) enc_proto3_string(p *Properties, base structPointer) error {
 503         v := *structPointer_StringVal(base, p.field)
 504         if v == "" {
 505                 return ErrNil
 506         }
 507         o.buf = append(o.buf, p.tagcode...)
 508         o.EncodeStringBytes(v)
 509         return nil
 510 }
 511
 512 func size_string(p *Properties, base structPointer) (n int) {
 513         v := *structPointer_String(base, p.field)
 514         if v == nil {
 515                 return 0
 516         }
 517         x := *v
 518         n += len(p.tagcode)
 519         n += sizeStringBytes(x)
 520         return
 521 }
 522
 523 func size_proto3_string(p *Properties, base structPointer) (n int) {
 524         v := *structPointer_StringVal(base, p.field)
 525         if v == "" && !p.oneof {
 526                 return 0
 527         }
 528         n += len(p.tagcode)
 529         n += sizeStringBytes(v)
 530         return
 531 }
 532
 533 // All protocol buffer fields are nillable, but be careful.
 534 func isNil(v reflect.Value) bool {
 535         switch v.Kind() {
 536         case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
 537                 return v.IsNil()
 538         }
 539         return false
 540 }
 541
 542 // Encode a message struct.
 543 func (o *Buffer) enc_struct_message(p *Properties, base structPointer) error {
 544         var state errorState
 545         structp := structPointer_GetStructPointer(base, p.field)
 546         if structPointer_IsNil(structp) {
 547                 return ErrNil
 548         }
 549
 550         // Can the object marshal itself?
 551         if p.isMarshaler {
 552                 m := structPointer_Interface(structp, p.stype).(Marshaler)
 553                 data, err := m.Marshal()
 554                 if err != nil && !state.shouldContinue(err, nil) {
 555                         return err
 556                 }
 557                 o.buf = append(o.buf, p.tagcode...)
 558                 o.EncodeRawBytes(data)
 559                 return state.err
 560         }
 561
 562         o.buf = append(o.buf, p.tagcode...)
 563         return o.enc_len_struct(p.sprop, structp, &state)
 564 }
 565
 566 func size_struct_message(p *Properties, base structPointer) int {
 567         structp := structPointer_GetStructPointer(base, p.field)
 568         if structPointer_IsNil(structp) {
 569                 return 0
 570         }
 571
 572         // Can the object marshal itself?
 573         if p.isMarshaler {
 574                 m := structPointer_Interface(structp, p.stype).(Marshaler)
 575                 data, _ := m.Marshal()
 576                 n0 := len(p.tagcode)
 577                 n1 := sizeRawBytes(data)
 578                 return n0 + n1
 579         }
 580
 581         n0 := len(p.tagcode)
 582         n1 := size_struct(p.sprop, structp)
 583         n2 := sizeVarint(uint64(n1)) // size of encoded length
 584         return n0 + n1 + n2
 585 }
 586
 587 // Encode a group struct.
 588 func (o *Buffer) enc_struct_group(p *Properties, base structPointer) error {
 589         var state errorState
 590         b := structPointer_GetStructPointer(base, p.field)
 591         if structPointer_IsNil(b) {
 592                 return ErrNil
 593         }
 594
 595         o.EncodeVarint(uint64((p.Tag << 3) | WireStartGroup))
 596         err := o.enc_struct(p.sprop, b)
 597         if err != nil && !state.shouldContinue(err, nil) {
 598                 return err
 599         }
 600         o.EncodeVarint(uint64((p.Tag << 3) | WireEndGroup))
 601         return state.err
 602 }
 603
 604 func size_struct_group(p *Properties, base structPointer) (n int) {
 605         b := structPointer_GetStructPointer(base, p.field)
 606         if structPointer_IsNil(b) {
 607                 return 0
 608         }
 609
 610         n += sizeVarint(uint64((p.Tag << 3) | WireStartGroup))
 611         n += size_struct(p.sprop, b)
 612         n += sizeVarint(uint64((p.Tag << 3) | WireEndGroup))
 613         return
 614 }
 615
 616 // Encode a slice of bools ([]bool).
 617 func (o *Buffer) enc_slice_bool(p *Properties, base structPointer) error {
 618         s := *structPointer_BoolSlice(base, p.field)
 619         l := len(s)
 620         if l == 0 {
 621                 return ErrNil
 622         }
 623         for _, x := range s {
 624                 o.buf = append(o.buf, p.tagcode...)
 625                 v := uint64(0)
 626                 if x {
 627                         v = 1
 628                 }
 629                 p.valEnc(o, v)
 630         }
 631         return nil
 632 }
 633
 634 func size_slice_bool(p *Properties, base structPointer) int {
 635         s := *structPointer_BoolSlice(base, p.field)
 636         l := len(s)
 637         if l == 0 {
 638                 return 0
 639         }
 640         return l * (len(p.tagcode) + 1) // each bool takes exactly one byte
 641 }
 642
 643 // Encode a slice of bools ([]bool) in packed format.
 644 func (o *Buffer) enc_slice_packed_bool(p *Properties, base structPointer) error {
 645         s := *structPointer_BoolSlice(base, p.field)
 646         l := len(s)
 647         if l == 0 {
 648                 return ErrNil
 649         }
 650         o.buf = append(o.buf, p.tagcode...)
 651         o.EncodeVarint(uint64(l)) // each bool takes exactly one byte
 652         for _, x := range s {
 653                 v := uint64(0)
 654                 if x {
 655                         v = 1
 656                 }
 657                 p.valEnc(o, v)
 658         }
 659         return nil
 660 }
 661
 662 func size_slice_packed_bool(p *Properties, base structPointer) (n int) {
 663         s := *structPointer_BoolSlice(base, p.field)
 664         l := len(s)
 665         if l == 0 {
 666                 return 0
 667         }
 668         n += len(p.tagcode)
 669         n += sizeVarint(uint64(l))
 670         n += l // each bool takes exactly one byte
 671         return
 672 }
 673
 674 // Encode a slice of bytes ([]byte).
 675 func (o *Buffer) enc_slice_byte(p *Properties, base structPointer) error {
 676         s := *structPointer_Bytes(base, p.field)
 677         if s == nil {
 678                 return ErrNil
 679         }
 680         o.buf = append(o.buf, p.tagcode...)
 681         o.EncodeRawBytes(s)
 682         return nil
 683 }
 684
 685 func (o *Buffer) enc_proto3_slice_byte(p *Properties, base structPointer) error {
 686         s := *structPointer_Bytes(base, p.field)
 687         if len(s) == 0 {
 688                 return ErrNil
 689         }
 690         o.buf = append(o.buf, p.tagcode...)
 691         o.EncodeRawBytes(s)
 692         return nil
 693 }
 694
 695 func size_slice_byte(p *Properties, base structPointer) (n int) {
 696         s := *structPointer_Bytes(base, p.field)
 697         if s == nil && !p.oneof {
 698                 return 0
 699         }
 700         n += len(p.tagcode)
 701         n += sizeRawBytes(s)
 702         return
 703 }
 704
 705 func size_proto3_slice_byte(p *Properties, base structPointer) (n int) {
 706         s := *structPointer_Bytes(base, p.field)
 707         if len(s) == 0 && !p.oneof {
 708                 return 0
 709         }
 710         n += len(p.tagcode)
 711         n += sizeRawBytes(s)
 712         return
 713 }
 714
 715 // Encode a slice of int32s ([]int32).
 716 func (o *Buffer) enc_slice_int32(p *Properties, base structPointer) error {
 717         s := structPointer_Word32Slice(base, p.field)
 718         l := s.Len()
 719         if l == 0 {
 720                 return ErrNil
 721         }
 722         for i := 0; i < l; i++ {
 723                 o.buf = append(o.buf, p.tagcode...)
 724                 x := int32(s.Index(i)) // permit sign extension to use full 64-bit range
 725                 p.valEnc(o, uint64(x))
 726         }
 727         return nil
 728 }
 729
 730 func size_slice_int32(p *Properties, base structPointer) (n int) {
 731         s := structPointer_Word32Slice(base, p.field)
 732         l := s.Len()
 733         if l == 0 {
 734                 return 0
 735         }
 736         for i := 0; i < l; i++ {
 737                 n += len(p.tagcode)
 738                 x := int32(s.Index(i)) // permit sign extension to use full 64-bit range
 739                 n += p.valSize(uint64(x))
 740         }
 741         return
 742 }
 743
 744 // Encode a slice of int32s ([]int32) in packed format.
 745 func (o *Buffer) enc_slice_packed_int32(p *Properties, base structPointer) error {
 746         s := structPointer_Word32Slice(base, p.field)
 747         l := s.Len()
 748         if l == 0 {
 749                 return ErrNil
 750         }
 751         // TODO: Reuse a Buffer.
 752         buf := NewBuffer(nil)
 753         for i := 0; i < l; i++ {
 754                 x := int32(s.Index(i)) // permit sign extension to use full 64-bit range
 755                 p.valEnc(buf, uint64(x))
 756         }
 757
 758         o.buf = append(o.buf, p.tagcode...)
 759         o.EncodeVarint(uint64(len(buf.buf)))
 760         o.buf = append(o.buf, buf.buf...)
 761         return nil
 762 }
 763
 764 func size_slice_packed_int32(p *Properties, base structPointer) (n int) {
 765         s := structPointer_Word32Slice(base, p.field)
 766         l := s.Len()
 767         if l == 0 {
 768                 return 0
 769         }
 770         var bufSize int
 771         for i := 0; i < l; i++ {
 772                 x := int32(s.Index(i)) // permit sign extension to use full 64-bit range
 773                 bufSize += p.valSize(uint64(x))
 774         }
 775
 776         n += len(p.tagcode)
 777         n += sizeVarint(uint64(bufSize))
 778         n += bufSize
 779         return
 780 }
 781
 782 // Encode a slice of uint32s ([]uint32).
 783 // Exactly the same as int32, except for no sign extension.
 784 func (o *Buffer) enc_slice_uint32(p *Properties, base structPointer) error {
 785         s := structPointer_Word32Slice(base, p.field)
 786         l := s.Len()
 787         if l == 0 {
 788                 return ErrNil
 789         }
 790         for i := 0; i < l; i++ {
 791                 o.buf = append(o.buf, p.tagcode...)
 792                 x := s.Index(i)
 793                 p.valEnc(o, uint64(x))
 794         }
 795         return nil
 796 }
 797
 798 func size_slice_uint32(p *Properties, base structPointer) (n int) {
 799         s := structPointer_Word32Slice(base, p.field)
 800         l := s.Len()
 801         if l == 0 {
 802                 return 0
 803         }
 804         for i := 0; i < l; i++ {
 805                 n += len(p.tagcode)
 806                 x := s.Index(i)
 807                 n += p.valSize(uint64(x))
 808         }
 809         return
 810 }
 811
 812 // Encode a slice of uint32s ([]uint32) in packed format.
 813 // Exactly the same as int32, except for no sign extension.
 814 func (o *Buffer) enc_slice_packed_uint32(p *Properties, base structPointer) error {
 815         s := structPointer_Word32Slice(base, p.field)
 816         l := s.Len()
 817         if l == 0 {
 818                 return ErrNil
 819         }
 820         // TODO: Reuse a Buffer.
 821         buf := NewBuffer(nil)
 822         for i := 0; i < l; i++ {
 823                 p.valEnc(buf, uint64(s.Index(i)))
 824         }
 825
 826         o.buf = append(o.buf, p.tagcode...)
 827         o.EncodeVarint(uint64(len(buf.buf)))
 828         o.buf = append(o.buf, buf.buf...)
 829         return nil
 830 }
 831
 832 func size_slice_packed_uint32(p *Properties, base structPointer) (n int) {
 833         s := structPointer_Word32Slice(base, p.field)
 834         l := s.Len()
 835         if l == 0 {
 836                 return 0
 837         }
 838         var bufSize int
 839         for i := 0; i < l; i++ {
 840                 bufSize += p.valSize(uint64(s.Index(i)))
 841         }
 842
 843         n += len(p.tagcode)
 844         n += sizeVarint(uint64(bufSize))
 845         n += bufSize
 846         return
 847 }
 848
 849 // Encode a slice of int64s ([]int64).
 850 func (o *Buffer) enc_slice_int64(p *Properties, base structPointer) error {
 851         s := structPointer_Word64Slice(base, p.field)
 852         l := s.Len()
 853         if l == 0 {
 854                 return ErrNil
 855         }
 856         for i := 0; i < l; i++ {
 857                 o.buf = append(o.buf, p.tagcode...)
 858                 p.valEnc(o, s.Index(i))
 859         }
 860         return nil
 861 }
 862
 863 func size_slice_int64(p *Properties, base structPointer) (n int) {
 864         s := structPointer_Word64Slice(base, p.field)
 865         l := s.Len()
 866         if l == 0 {
 867                 return 0
 868         }
 869         for i := 0; i < l; i++ {
 870                 n += len(p.tagcode)
 871                 n += p.valSize(s.Index(i))
 872         }
 873         return
 874 }
 875
 876 // Encode a slice of int64s ([]int64) in packed format.
 877 func (o *Buffer) enc_slice_packed_int64(p *Properties, base structPointer) error {
 878         s := structPointer_Word64Slice(base, p.field)
 879         l := s.Len()
 880         if l == 0 {
 881                 return ErrNil
 882         }
 883         // TODO: Reuse a Buffer.
 884         buf := NewBuffer(nil)
 885         for i := 0; i < l; i++ {
 886                 p.valEnc(buf, s.Index(i))
 887         }
 888
 889         o.buf = append(o.buf, p.tagcode...)
 890         o.EncodeVarint(uint64(len(buf.buf)))
 891         o.buf = append(o.buf, buf.buf...)
 892         return nil
 893 }
 894
 895 func size_slice_packed_int64(p *Properties, base structPointer) (n int) {
 896         s := structPointer_Word64Slice(base, p.field)
 897         l := s.Len()
 898         if l == 0 {
 899                 return 0
 900         }
 901         var bufSize int
 902         for i := 0; i < l; i++ {
 903                 bufSize += p.valSize(s.Index(i))
 904         }
 905
 906         n += len(p.tagcode)
 907         n += sizeVarint(uint64(bufSize))
 908         n += bufSize
 909         return
 910 }
 911
 912 // Encode a slice of slice of bytes ([][]byte).
 913 func (o *Buffer) enc_slice_slice_byte(p *Properties, base structPointer) error {
 914         ss := *structPointer_BytesSlice(base, p.field)
 915         l := len(ss)
 916         if l == 0 {
 917                 return ErrNil
 918         }
 919         for i := 0; i < l; i++ {
 920                 o.buf = append(o.buf, p.tagcode...)
 921                 o.EncodeRawBytes(ss[i])
 922         }
 923         return nil
 924 }
 925
 926 func size_slice_slice_byte(p *Properties, base structPointer) (n int) {
 927         ss := *structPointer_BytesSlice(base, p.field)
 928         l := len(ss)
 929         if l == 0 {
 930                 return 0
 931         }
 932         n += l * len(p.tagcode)
 933         for i := 0; i < l; i++ {
 934                 n += sizeRawBytes(ss[i])
 935         }
 936         return
 937 }
 938
 939 // Encode a slice of strings ([]string).
 940 func (o *Buffer) enc_slice_string(p *Properties, base structPointer) error {
 941         ss := *structPointer_StringSlice(base, p.field)
 942         l := len(ss)
 943         for i := 0; i < l; i++ {
 944                 o.buf = append(o.buf, p.tagcode...)
 945                 o.EncodeStringBytes(ss[i])
 946         }
 947         return nil
 948 }
 949
 950 func size_slice_string(p *Properties, base structPointer) (n int) {
 951         ss := *structPointer_StringSlice(base, p.field)
 952         l := len(ss)
 953         n += l * len(p.tagcode)
 954         for i := 0; i < l; i++ {
 955                 n += sizeStringBytes(ss[i])
 956         }
 957         return
 958 }
 959
 960 // Encode a slice of message structs ([]*struct).
 961 func (o *Buffer) enc_slice_struct_message(p *Properties, base structPointer) error {
 962         var state errorState
 963         s := structPointer_StructPointerSlice(base, p.field)
 964         l := s.Len()
 965
 966         for i := 0; i < l; i++ {
 967                 structp := s.Index(i)
 968                 if structPointer_IsNil(structp) {
 969                         return errRepeatedHasNil
 970                 }
 971
 972                 // Can the object marshal itself?
 973                 if p.isMarshaler {
 974                         m := structPointer_Interface(structp, p.stype).(Marshaler)
 975                         data, err := m.Marshal()
 976                         if err != nil && !state.shouldContinue(err, nil) {
 977                                 return err
 978                         }
 979                         o.buf = append(o.buf, p.tagcode...)
 980                         o.EncodeRawBytes(data)
 981                         continue
 982                 }
 983
 984                 o.buf = append(o.buf, p.tagcode...)
 985                 err := o.enc_len_struct(p.sprop, structp, &state)
 986                 if err != nil && !state.shouldContinue(err, nil) {
 987                         if err == ErrNil {
 988                                 return errRepeatedHasNil
 989                         }
 990                         return err
 991                 }
 992         }
 993         return state.err
 994 }
 995
 996 func size_slice_struct_message(p *Properties, base structPointer) (n int) {
 997         s := structPointer_StructPointerSlice(base, p.field)
 998         l := s.Len()
 999         n += l * len(p.tagcode)
1000         for i := 0; i < l; i++ {
1001                 structp := s.Index(i)
1002                 if structPointer_IsNil(structp) {
1003                         return // return the size up to this point
1004                 }
1005
1006                 // Can the object marshal itself?
1007                 if p.isMarshaler {
1008                         m := structPointer_Interface(structp, p.stype).(Marshaler)
1009                         data, _ := m.Marshal()
1010                         n += sizeRawBytes(data)
1011                         continue
1012                 }
1013
1014                 n0 := size_struct(p.sprop, structp)
1015                 n1 := sizeVarint(uint64(n0)) // size of encoded length
1016                 n += n0 + n1
1017         }
1018         return
1019 }
1020
1021 // Encode a slice of group structs ([]*struct).
1022 func (o *Buffer) enc_slice_struct_group(p *Properties, base structPointer) error {
1023         var state errorState
1024         s := structPointer_StructPointerSlice(base, p.field)
1025         l := s.Len()
1026
1027         for i := 0; i < l; i++ {
1028                 b := s.Index(i)
1029                 if structPointer_IsNil(b) {
1030                         return errRepeatedHasNil
1031                 }
1032
1033                 o.EncodeVarint(uint64((p.Tag << 3) | WireStartGroup))
1034
1035                 err := o.enc_struct(p.sprop, b)
1036
1037                 if err != nil && !state.shouldContinue(err, nil) {
1038                         if err == ErrNil {
1039                                 return errRepeatedHasNil
1040                         }
1041                         return err
1042                 }
1043
1044                 o.EncodeVarint(uint64((p.Tag << 3) | WireEndGroup))
1045         }
1046         return state.err
1047 }
1048
1049 func size_slice_struct_group(p *Properties, base structPointer) (n int) {
1050         s := structPointer_StructPointerSlice(base, p.field)
1051         l := s.Len()
1052
1053         n += l * sizeVarint(uint64((p.Tag<<3)|WireStartGroup))
1054         n += l * sizeVarint(uint64((p.Tag<<3)|WireEndGroup))
1055         for i := 0; i < l; i++ {
1056                 b := s.Index(i)
1057                 if structPointer_IsNil(b) {
1058                         return // return size up to this point
1059                 }
1060
1061                 n += size_struct(p.sprop, b)
1062         }
1063         return
1064 }
1065
1066 // Encode an extension map.
1067 func (o *Buffer) enc_map(p *Properties, base structPointer) error {
1068         exts := structPointer_ExtMap(base, p.field)
1069         if err := encodeExtensionsMap(*exts); err != nil {
1070                 return err
1071         }
1072
1073         return o.enc_map_body(*exts)
1074 }
1075
1076 func (o *Buffer) enc_exts(p *Properties, base structPointer) error {
1077         exts := structPointer_Extensions(base, p.field)
1078
1079         v, mu := exts.extensionsRead()
1080         if v == nil {
1081                 return nil
1082         }
1083
1084         mu.Lock()
1085         defer mu.Unlock()
1086         if err := encodeExtensionsMap(v); err != nil {
1087                 return err
1088         }
1089
1090         return o.enc_map_body(v)
1091 }
1092
1093 func (o *Buffer) enc_map_body(v map[int32]Extension) error {
1094         // Fast-path for common cases: zero or one extensions.
1095         if len(v) <= 1 {
1096                 for _, e := range v {
1097                         o.buf = append(o.buf, e.enc...)
1098                 }
1099                 return nil
1100         }
1101
1102         // Sort keys to provide a deterministic encoding.
1103         keys := make([]int, 0, len(v))
1104         for k := range v {
1105                 keys = append(keys, int(k))
1106         }
1107         sort.Ints(keys)
1108
1109         for _, k := range keys {
1110                 o.buf = append(o.buf, v[int32(k)].enc...)
1111         }
1112         return nil
1113 }
1114
1115 func size_map(p *Properties, base structPointer) int {
1116         v := structPointer_ExtMap(base, p.field)
1117         return extensionsMapSize(*v)
1118 }
1119
1120 func size_exts(p *Properties, base structPointer) int {
1121         v := structPointer_Extensions(base, p.field)
1122         return extensionsSize(v)
1123 }
1124
1125 // Encode a map field.
1126 func (o *Buffer) enc_new_map(p *Properties, base structPointer) error {
1127         var state errorState // XXX: or do we need to plumb this through?
1128
1129         /*
1130                 A map defined as
1131                         map<key_type, value_type> map_field = N;
1132                 is encoded in the same way as
1133                         message MapFieldEntry {
1134                                 key_type key = 1;
1135                                 value_type value = 2;
1136                         }
1137                         repeated MapFieldEntry map_field = N;
1138         */
1139
1140         v := structPointer_NewAt(base, p.field, p.mtype).Elem() // map[K]V
1141         if v.Len() == 0 {
1142                 return nil
1143         }
1144
1145         keycopy, valcopy, keybase, valbase := mapEncodeScratch(p.mtype)
1146
1147         enc := func() error {
1148                 if err := p.mkeyprop.enc(o, p.mkeyprop, keybase); err != nil {
1149                         return err
1150                 }
1151                 if err := p.mvalprop.enc(o, p.mvalprop, valbase); err != nil && err != ErrNil {
1152                         return err
1153                 }
1154                 return nil
1155         }
1156
1157         // Don't sort map keys. It is not required by the spec, and C++ doesn't do it.
1158         for _, key := range v.MapKeys() {
1159                 val := v.MapIndex(key)
1160
1161                 keycopy.Set(key)
1162                 valcopy.Set(val)
1163
1164                 o.buf = append(o.buf, p.tagcode...)
1165                 if err := o.enc_len_thing(enc, &state); err != nil {
1166                         return err
1167                 }
1168         }
1169         return nil
1170 }
1171
1172 func size_new_map(p *Properties, base structPointer) int {
1173         v := structPointer_NewAt(base, p.field, p.mtype).Elem() // map[K]V
1174
1175         keycopy, valcopy, keybase, valbase := mapEncodeScratch(p.mtype)
1176
1177         n := 0
1178         for _, key := range v.MapKeys() {
1179                 val := v.MapIndex(key)
1180                 keycopy.Set(key)
1181                 valcopy.Set(val)
1182
1183                 // Tag codes for key and val are the responsibility of the sub-sizer.
1184                 keysize := p.mkeyprop.size(p.mkeyprop, keybase)
1185                 valsize := p.mvalprop.size(p.mvalprop, valbase)
1186                 entry := keysize + valsize
1187                 // Add on tag code and length of map entry itself.
1188                 n += len(p.tagcode) + sizeVarint(uint64(entry)) + entry
1189         }
1190         return n
1191 }
1192
1193 // mapEncodeScratch returns a new reflect.Value matching the map's value type,
1194 // and a structPointer suitable for passing to an encoder or sizer.
1195 func mapEncodeScratch(mapType reflect.Type) (keycopy, valcopy reflect.Value, keybase, valbase structPointer) {
1196         // Prepare addressable doubly-indirect placeholders for the key and value types.
1197         // This is needed because the element-type encoders expect **T, but the map iteration produces T.
1198
1199         keycopy = reflect.New(mapType.Key()).Elem()                 // addressable K
1200         keyptr := reflect.New(reflect.PtrTo(keycopy.Type())).Elem() // addressable *K
1201         keyptr.Set(keycopy.Addr())                                  //
1202         keybase = toStructPointer(keyptr.Addr())                    // **K
1203
1204         // Value types are more varied and require special handling.
1205         switch mapType.Elem().Kind() {
1206         case reflect.Slice:
1207                 // []byte
1208                 var dummy []byte
1209                 valcopy = reflect.ValueOf(&dummy).Elem() // addressable []byte
1210                 valbase = toStructPointer(valcopy.Addr())
1211         case reflect.Ptr:
1212                 // message; the generated field type is map[K]*Msg (so V is *Msg),
1213                 // so we only need one level of indirection.
1214                 valcopy = reflect.New(mapType.Elem()).Elem() // addressable V
1215                 valbase = toStructPointer(valcopy.Addr())
1216         default:
1217                 // everything else
1218                 valcopy = reflect.New(mapType.Elem()).Elem()                // addressable V
1219                 valptr := reflect.New(reflect.PtrTo(valcopy.Type())).Elem() // addressable *V
1220                 valptr.Set(valcopy.Addr())                                  //
1221                 valbase = toStructPointer(valptr.Addr())                    // **V
1222         }
1223         return
1224 }
1225
1226 // Encode a struct.
1227 func (o *Buffer) enc_struct(prop *StructProperties, base structPointer) error {
1228         var state errorState
1229         // Encode fields in tag order so that decoders may use optimizations
1230         // that depend on the ordering.
1231         // https://developers.google.com/protocol-buffers/docs/encoding#order
1232         for _, i := range prop.order {
1233                 p := prop.Prop[i]
1234                 if p.enc != nil {
1235                         err := p.enc(o, p, base)
1236                         if err != nil {
1237                                 if err == ErrNil {
1238                                         if p.Required && state.err == nil {
1239                                                 state.err = &RequiredNotSetError{p.Name}
1240                                         }
1241                                 } else if err == errRepeatedHasNil {
1242                                         // Give more context to nil values in repeated fields.
1243                                         return errors.New("repeated field " + p.OrigName + " has nil element")
1244                                 } else if !state.shouldContinue(err, p) {
1245                                         return err
1246                                 }
1247                         }
1248                         if len(o.buf) > maxMarshalSize {
1249                                 return ErrTooLarge
1250                         }
1251                 }
1252         }
1253
1254         // Do oneof fields.
1255         if prop.oneofMarshaler != nil {
1256                 m := structPointer_Interface(base, prop.stype).(Message)
1257                 if err := prop.oneofMarshaler(m, o); err == ErrNil {
1258                         return errOneofHasNil
1259                 } else if err != nil {
1260                         return err
1261                 }
1262         }
1263
1264         // Add unrecognized fields at the end.
1265         if prop.unrecField.IsValid() {
1266                 v := *structPointer_Bytes(base, prop.unrecField)
1267                 if len(o.buf)+len(v) > maxMarshalSize {
1268                         return ErrTooLarge
1269                 }
1270                 if len(v) > 0 {
1271                         o.buf = append(o.buf, v...)
1272                 }
1273         }
1274
1275         return state.err
1276 }
1277
1278 func size_struct(prop *StructProperties, base structPointer) (n int) {
1279         for _, i := range prop.order {
1280                 p := prop.Prop[i]
1281                 if p.size != nil {
1282                         n += p.size(p, base)
1283                 }
1284         }
1285
1286         // Add unrecognized fields at the end.
1287         if prop.unrecField.IsValid() {
1288                 v := *structPointer_Bytes(base, prop.unrecField)
1289                 n += len(v)
1290         }
1291
1292         // Factor in any oneof fields.
1293         if prop.oneofSizer != nil {
1294                 m := structPointer_Interface(base, prop.stype).(Message)
1295                 n += prop.oneofSizer(m)
1296         }
1297
1298         return
1299 }
1300
1301 var zeroes [20]byte // longer than any conceivable sizeVarint
1302
1303 // Encode a struct, preceded by its encoded length (as a varint).
1304 func (o *Buffer) enc_len_struct(prop *StructProperties, base structPointer, state *errorState) error {
1305         return o.enc_len_thing(func() error { return o.enc_struct(prop, base) }, state)
1306 }
1307
1308 // Encode something, preceded by its encoded length (as a varint).
1309 func (o *Buffer) enc_len_thing(enc func() error, state *errorState) error {
1310         iLen := len(o.buf)
1311         o.buf = append(o.buf, 0, 0, 0, 0) // reserve four bytes for length
1312         iMsg := len(o.buf)
1313         err := enc()
1314         if err != nil && !state.shouldContinue(err, nil) {
1315                 return err
1316         }
1317         lMsg := len(o.buf) - iMsg
1318         lLen := sizeVarint(uint64(lMsg))
1319         switch x := lLen - (iMsg - iLen); {
1320         case x > 0: // actual length is x bytes larger than the space we reserved
1321                 // Move msg x bytes right.
1322                 o.buf = append(o.buf, zeroes[:x]...)
1323                 copy(o.buf[iMsg+x:], o.buf[iMsg:iMsg+lMsg])
1324         case x < 0: // actual length is x bytes smaller than the space we reserved
1325                 // Move msg x bytes left.
1326                 copy(o.buf[iMsg+x:], o.buf[iMsg:iMsg+lMsg])
1327                 o.buf = o.buf[:len(o.buf)+x] // x is negative
1328         }
1329         // Encode the length in the reserved space.
1330         o.buf = o.buf[:iLen]
1331         o.EncodeVarint(uint64(lMsg))
1332         o.buf = o.buf[:len(o.buf)+lMsg]
1333         return state.err
1334 }
1335
1336 // errorState maintains the first error that occurs and updates that error
1337 // with additional context.
1338 type errorState struct {
1339         err error
1340 }
1341
1342 // shouldContinue reports whether encoding should continue upon encountering the
1343 // given error. If the error is RequiredNotSetError, shouldContinue returns true
1344 // and, if this is the first appearance of that error, remembers it for future
1345 // reporting.
1346 //
1347 // If prop is not nil, it may update any error with additional context about the
1348 // field with the error.
1349 func (s *errorState) shouldContinue(err error, prop *Properties) bool {
1350         // Ignore unset required fields.
1351         reqNotSet, ok := err.(*RequiredNotSetError)
1352         if !ok {
1353                 return false
1354         }
1355         if s.err == nil {
1356                 if prop != nil {
1357                         err = &RequiredNotSetError{prop.Name + "." + reqNotSet.field}
1358                 }
1359                 s.err = err
1360         }
1361         return true
1362 }