github.com/matm/etcd@v0.3.1-0.20140328024009-5b4a473f1453/third_party/code.google.com/p/gogoprotobuf/proto/encode.go (about) 1 // Go support for Protocol Buffers - Google's data interchange format 2 // 3 // Copyright 2010 The Go Authors. All rights reserved. 4 // http://code.google.com/p/goprotobuf/ 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 // ErrNil is the error returned if Marshal is called with nil. 68 ErrNil = errors.New("proto: Marshal called with nil") 69 ) 70 71 // The fundamental encoders that put bytes on the wire. 72 // Those that take integer types all accept uint64 and are 73 // therefore of type valueEncoder. 74 75 const maxVarintBytes = 10 // maximum length of a varint 76 77 // EncodeVarint returns the varint encoding of x. 78 // This is the format for the 79 // int32, int64, uint32, uint64, bool, and enum 80 // protocol buffer types. 81 // Not used by the package itself, but helpful to clients 82 // wishing to use the same encoding. 83 func EncodeVarint(x uint64) []byte { 84 var buf [maxVarintBytes]byte 85 var n int 86 for n = 0; x > 127; n++ { 87 buf[n] = 0x80 | uint8(x&0x7F) 88 x >>= 7 89 } 90 buf[n] = uint8(x) 91 n++ 92 return buf[0:n] 93 } 94 95 // EncodeVarint writes a varint-encoded integer to the Buffer. 96 // This is the format for the 97 // int32, int64, uint32, uint64, bool, and enum 98 // protocol buffer types. 99 func (p *Buffer) EncodeVarint(x uint64) error { 100 for x >= 1<<7 { 101 p.buf = append(p.buf, uint8(x&0x7f|0x80)) 102 x >>= 7 103 } 104 p.buf = append(p.buf, uint8(x)) 105 return nil 106 } 107 108 func sizeVarint(x uint64) (n int) { 109 for { 110 n++ 111 x >>= 7 112 if x == 0 { 113 break 114 } 115 } 116 return n 117 } 118 119 // EncodeFixed64 writes a 64-bit integer to the Buffer. 120 // This is the format for the 121 // fixed64, sfixed64, and double protocol buffer types. 122 func (p *Buffer) EncodeFixed64(x uint64) error { 123 p.buf = append(p.buf, 124 uint8(x), 125 uint8(x>>8), 126 uint8(x>>16), 127 uint8(x>>24), 128 uint8(x>>32), 129 uint8(x>>40), 130 uint8(x>>48), 131 uint8(x>>56)) 132 return nil 133 } 134 135 func sizeFixed64(x uint64) int { 136 return 8 137 } 138 139 // EncodeFixed32 writes a 32-bit integer to the Buffer. 140 // This is the format for the 141 // fixed32, sfixed32, and float protocol buffer types. 142 func (p *Buffer) EncodeFixed32(x uint64) error { 143 p.buf = append(p.buf, 144 uint8(x), 145 uint8(x>>8), 146 uint8(x>>16), 147 uint8(x>>24)) 148 return nil 149 } 150 151 func sizeFixed32(x uint64) int { 152 return 4 153 } 154 155 // EncodeZigzag64 writes a zigzag-encoded 64-bit integer 156 // to the Buffer. 157 // This is the format used for the sint64 protocol buffer type. 158 func (p *Buffer) EncodeZigzag64(x uint64) error { 159 // use signed number to get arithmetic right shift. 160 return p.EncodeVarint(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 161 } 162 163 func sizeZigzag64(x uint64) int { 164 return sizeVarint(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 165 } 166 167 // EncodeZigzag32 writes a zigzag-encoded 32-bit integer 168 // to the Buffer. 169 // This is the format used for the sint32 protocol buffer type. 170 func (p *Buffer) EncodeZigzag32(x uint64) error { 171 // use signed number to get arithmetic right shift. 172 return p.EncodeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31)))) 173 } 174 175 func sizeZigzag32(x uint64) int { 176 return sizeVarint(uint64((uint32(x) << 1) ^ uint32((int32(x) >> 31)))) 177 } 178 179 // EncodeRawBytes writes a count-delimited byte buffer to the Buffer. 180 // This is the format used for the bytes protocol buffer 181 // type and for embedded messages. 182 func (p *Buffer) EncodeRawBytes(b []byte) error { 183 p.EncodeVarint(uint64(len(b))) 184 p.buf = append(p.buf, b...) 185 return nil 186 } 187 188 func sizeRawBytes(b []byte) int { 189 return sizeVarint(uint64(len(b))) + 190 len(b) 191 } 192 193 // EncodeStringBytes writes an encoded string to the Buffer. 194 // This is the format used for the proto2 string type. 195 func (p *Buffer) EncodeStringBytes(s string) error { 196 p.EncodeVarint(uint64(len(s))) 197 p.buf = append(p.buf, s...) 198 return nil 199 } 200 201 func sizeStringBytes(s string) int { 202 return sizeVarint(uint64(len(s))) + 203 len(s) 204 } 205 206 // Marshaler is the interface representing objects that can marshal themselves. 207 type Marshaler interface { 208 Marshal() ([]byte, error) 209 } 210 211 // Marshal takes the protocol buffer 212 // and encodes it into the wire format, returning the data. 213 func Marshal(pb Message) ([]byte, error) { 214 // Can the object marshal itself? 215 if m, ok := pb.(Marshaler); ok { 216 return m.Marshal() 217 } 218 p := NewBuffer(nil) 219 err := p.Marshal(pb) 220 var state errorState 221 if err != nil && !state.shouldContinue(err, nil) { 222 return nil, err 223 } 224 return p.buf, err 225 } 226 227 // Marshal takes the protocol buffer 228 // and encodes it into the wire format, writing the result to the 229 // Buffer. 230 func (p *Buffer) Marshal(pb Message) error { 231 // Can the object marshal itself? 232 if m, ok := pb.(Marshaler); ok { 233 data, err := m.Marshal() 234 if err != nil { 235 return err 236 } 237 p.buf = append(p.buf, data...) 238 return nil 239 } 240 241 t, base, err := getbase(pb) 242 if structPointer_IsNil(base) { 243 return ErrNil 244 } 245 if err == nil { 246 err = p.enc_struct(t.Elem(), GetProperties(t.Elem()), base) 247 } 248 249 if collectStats { 250 stats.Encode++ 251 } 252 253 return err 254 } 255 256 // Size returns the encoded size of a protocol buffer. 257 func Size(pb Message) (n int) { 258 // Can the object marshal itself? If so, Size is slow. 259 // TODO: add Size to Marshaler, or add a Sizer interface. 260 if m, ok := pb.(Marshaler); ok { 261 b, _ := m.Marshal() 262 return len(b) 263 } 264 265 t, base, err := getbase(pb) 266 if structPointer_IsNil(base) { 267 return 0 268 } 269 if err == nil { 270 n = size_struct(t.Elem(), GetProperties(t.Elem()), base) 271 } 272 273 if collectStats { 274 stats.Size++ 275 } 276 277 return 278 } 279 280 // Individual type encoders. 281 282 // Encode a bool. 283 func (o *Buffer) enc_bool(p *Properties, base structPointer) error { 284 v := *structPointer_Bool(base, p.field) 285 if v == nil { 286 return ErrNil 287 } 288 x := 0 289 if *v { 290 x = 1 291 } 292 o.buf = append(o.buf, p.tagcode...) 293 p.valEnc(o, uint64(x)) 294 return nil 295 } 296 297 func size_bool(p *Properties, base structPointer) int { 298 v := *structPointer_Bool(base, p.field) 299 if v == nil { 300 return 0 301 } 302 return len(p.tagcode) + 1 // each bool takes exactly one byte 303 } 304 305 // Encode an int32. 306 func (o *Buffer) enc_int32(p *Properties, base structPointer) error { 307 v := structPointer_Word32(base, p.field) 308 if word32_IsNil(v) { 309 return ErrNil 310 } 311 x := word32_Get(v) 312 o.buf = append(o.buf, p.tagcode...) 313 p.valEnc(o, uint64(x)) 314 return nil 315 } 316 317 func size_int32(p *Properties, base structPointer) (n int) { 318 v := structPointer_Word32(base, p.field) 319 if word32_IsNil(v) { 320 return 0 321 } 322 x := word32_Get(v) 323 n += len(p.tagcode) 324 n += p.valSize(uint64(x)) 325 return 326 } 327 328 // Encode an int64. 329 func (o *Buffer) enc_int64(p *Properties, base structPointer) error { 330 v := structPointer_Word64(base, p.field) 331 if word64_IsNil(v) { 332 return ErrNil 333 } 334 x := word64_Get(v) 335 o.buf = append(o.buf, p.tagcode...) 336 p.valEnc(o, x) 337 return nil 338 } 339 340 func size_int64(p *Properties, base structPointer) (n int) { 341 v := structPointer_Word64(base, p.field) 342 if word64_IsNil(v) { 343 return 0 344 } 345 x := word64_Get(v) 346 n += len(p.tagcode) 347 n += p.valSize(x) 348 return 349 } 350 351 // Encode a string. 352 func (o *Buffer) enc_string(p *Properties, base structPointer) error { 353 v := *structPointer_String(base, p.field) 354 if v == nil { 355 return ErrNil 356 } 357 x := *v 358 o.buf = append(o.buf, p.tagcode...) 359 o.EncodeStringBytes(x) 360 return nil 361 } 362 363 func size_string(p *Properties, base structPointer) (n int) { 364 v := *structPointer_String(base, p.field) 365 if v == nil { 366 return 0 367 } 368 x := *v 369 n += len(p.tagcode) 370 n += sizeStringBytes(x) 371 return 372 } 373 374 // All protocol buffer fields are nillable, but be careful. 375 func isNil(v reflect.Value) bool { 376 switch v.Kind() { 377 case reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice: 378 return v.IsNil() 379 } 380 return false 381 } 382 383 // Encode a message struct. 384 func (o *Buffer) enc_struct_message(p *Properties, base structPointer) error { 385 var state errorState 386 structp := structPointer_GetStructPointer(base, p.field) 387 if structPointer_IsNil(structp) { 388 return ErrNil 389 } 390 391 // Can the object marshal itself? 392 if p.isMarshaler { 393 m := structPointer_Interface(structp, p.stype).(Marshaler) 394 data, err := m.Marshal() 395 if err != nil && !state.shouldContinue(err, nil) { 396 return err 397 } 398 o.buf = append(o.buf, p.tagcode...) 399 o.EncodeRawBytes(data) 400 return nil 401 } 402 403 // need the length before we can write out the message itself, 404 // so marshal into a separate byte buffer first. 405 obuf := o.buf 406 o.buf = o.bufalloc() 407 408 err := o.enc_struct(p.stype, p.sprop, structp) 409 410 nbuf := o.buf 411 o.buf = obuf 412 if err != nil && !state.shouldContinue(err, nil) { 413 o.buffree(nbuf) 414 return err 415 } 416 o.buf = append(o.buf, p.tagcode...) 417 o.EncodeRawBytes(nbuf) 418 o.buffree(nbuf) 419 return state.err 420 } 421 422 func size_struct_message(p *Properties, base structPointer) int { 423 structp := structPointer_GetStructPointer(base, p.field) 424 if structPointer_IsNil(structp) { 425 return 0 426 } 427 428 // Can the object marshal itself? 429 if p.isMarshaler { 430 m := structPointer_Interface(structp, p.stype).(Marshaler) 431 data, _ := m.Marshal() 432 n0 := len(p.tagcode) 433 n1 := sizeRawBytes(data) 434 return n0 + n1 435 } 436 437 n0 := len(p.tagcode) 438 n1 := size_struct(p.stype, p.sprop, structp) 439 n2 := sizeVarint(uint64(n1)) // size of encoded length 440 return n0 + n1 + n2 441 } 442 443 // Encode a group struct. 444 func (o *Buffer) enc_struct_group(p *Properties, base structPointer) error { 445 var state errorState 446 b := structPointer_GetStructPointer(base, p.field) 447 if structPointer_IsNil(b) { 448 return ErrNil 449 } 450 451 o.EncodeVarint(uint64((p.Tag << 3) | WireStartGroup)) 452 err := o.enc_struct(p.stype, p.sprop, b) 453 if err != nil && !state.shouldContinue(err, nil) { 454 return err 455 } 456 o.EncodeVarint(uint64((p.Tag << 3) | WireEndGroup)) 457 return state.err 458 } 459 460 func size_struct_group(p *Properties, base structPointer) (n int) { 461 b := structPointer_GetStructPointer(base, p.field) 462 if structPointer_IsNil(b) { 463 return 0 464 } 465 466 n += sizeVarint(uint64((p.Tag << 3) | WireStartGroup)) 467 n += size_struct(p.stype, p.sprop, b) 468 n += sizeVarint(uint64((p.Tag << 3) | WireEndGroup)) 469 return 470 } 471 472 // Encode a slice of bools ([]bool). 473 func (o *Buffer) enc_slice_bool(p *Properties, base structPointer) error { 474 s := *structPointer_BoolSlice(base, p.field) 475 l := len(s) 476 if l == 0 { 477 return ErrNil 478 } 479 for _, x := range s { 480 o.buf = append(o.buf, p.tagcode...) 481 v := uint64(0) 482 if x { 483 v = 1 484 } 485 p.valEnc(o, v) 486 } 487 return nil 488 } 489 490 func size_slice_bool(p *Properties, base structPointer) int { 491 s := *structPointer_BoolSlice(base, p.field) 492 l := len(s) 493 if l == 0 { 494 return 0 495 } 496 return l * (len(p.tagcode) + 1) // each bool takes exactly one byte 497 } 498 499 // Encode a slice of bools ([]bool) in packed format. 500 func (o *Buffer) enc_slice_packed_bool(p *Properties, base structPointer) error { 501 s := *structPointer_BoolSlice(base, p.field) 502 l := len(s) 503 if l == 0 { 504 return ErrNil 505 } 506 o.buf = append(o.buf, p.tagcode...) 507 o.EncodeVarint(uint64(l)) // each bool takes exactly one byte 508 for _, x := range s { 509 v := uint64(0) 510 if x { 511 v = 1 512 } 513 p.valEnc(o, v) 514 } 515 return nil 516 } 517 518 func size_slice_packed_bool(p *Properties, base structPointer) (n int) { 519 s := *structPointer_BoolSlice(base, p.field) 520 l := len(s) 521 if l == 0 { 522 return 0 523 } 524 n += len(p.tagcode) 525 n += sizeVarint(uint64(l)) 526 n += l // each bool takes exactly one byte 527 return 528 } 529 530 // Encode a slice of bytes ([]byte). 531 func (o *Buffer) enc_slice_byte(p *Properties, base structPointer) error { 532 s := *structPointer_Bytes(base, p.field) 533 if s == nil { 534 return ErrNil 535 } 536 o.buf = append(o.buf, p.tagcode...) 537 o.EncodeRawBytes(s) 538 return nil 539 } 540 541 func size_slice_byte(p *Properties, base structPointer) (n int) { 542 s := *structPointer_Bytes(base, p.field) 543 if s == nil { 544 return 0 545 } 546 n += len(p.tagcode) 547 n += sizeRawBytes(s) 548 return 549 } 550 551 // Encode a slice of int32s ([]int32). 552 func (o *Buffer) enc_slice_int32(p *Properties, base structPointer) error { 553 s := structPointer_Word32Slice(base, p.field) 554 l := s.Len() 555 if l == 0 { 556 return ErrNil 557 } 558 for i := 0; i < l; i++ { 559 o.buf = append(o.buf, p.tagcode...) 560 x := s.Index(i) 561 p.valEnc(o, uint64(x)) 562 } 563 return nil 564 } 565 566 func size_slice_int32(p *Properties, base structPointer) (n int) { 567 s := structPointer_Word32Slice(base, p.field) 568 l := s.Len() 569 if l == 0 { 570 return 0 571 } 572 for i := 0; i < l; i++ { 573 n += len(p.tagcode) 574 x := s.Index(i) 575 n += p.valSize(uint64(x)) 576 } 577 return 578 } 579 580 // Encode a slice of int32s ([]int32) in packed format. 581 func (o *Buffer) enc_slice_packed_int32(p *Properties, base structPointer) error { 582 s := structPointer_Word32Slice(base, p.field) 583 l := s.Len() 584 if l == 0 { 585 return ErrNil 586 } 587 // TODO: Reuse a Buffer. 588 buf := NewBuffer(nil) 589 for i := 0; i < l; i++ { 590 p.valEnc(buf, uint64(s.Index(i))) 591 } 592 593 o.buf = append(o.buf, p.tagcode...) 594 o.EncodeVarint(uint64(len(buf.buf))) 595 o.buf = append(o.buf, buf.buf...) 596 return nil 597 } 598 599 func size_slice_packed_int32(p *Properties, base structPointer) (n int) { 600 s := structPointer_Word32Slice(base, p.field) 601 l := s.Len() 602 if l == 0 { 603 return 0 604 } 605 var bufSize int 606 for i := 0; i < l; i++ { 607 bufSize += p.valSize(uint64(s.Index(i))) 608 } 609 610 n += len(p.tagcode) 611 n += sizeVarint(uint64(bufSize)) 612 n += bufSize 613 return 614 } 615 616 // Encode a slice of int64s ([]int64). 617 func (o *Buffer) enc_slice_int64(p *Properties, base structPointer) error { 618 s := structPointer_Word64Slice(base, p.field) 619 l := s.Len() 620 if l == 0 { 621 return ErrNil 622 } 623 for i := 0; i < l; i++ { 624 o.buf = append(o.buf, p.tagcode...) 625 p.valEnc(o, s.Index(i)) 626 } 627 return nil 628 } 629 630 func size_slice_int64(p *Properties, base structPointer) (n int) { 631 s := structPointer_Word64Slice(base, p.field) 632 l := s.Len() 633 if l == 0 { 634 return 0 635 } 636 for i := 0; i < l; i++ { 637 n += len(p.tagcode) 638 n += p.valSize(s.Index(i)) 639 } 640 return 641 } 642 643 // Encode a slice of int64s ([]int64) in packed format. 644 func (o *Buffer) enc_slice_packed_int64(p *Properties, base structPointer) error { 645 s := structPointer_Word64Slice(base, p.field) 646 l := s.Len() 647 if l == 0 { 648 return ErrNil 649 } 650 // TODO: Reuse a Buffer. 651 buf := NewBuffer(nil) 652 for i := 0; i < l; i++ { 653 p.valEnc(buf, s.Index(i)) 654 } 655 656 o.buf = append(o.buf, p.tagcode...) 657 o.EncodeVarint(uint64(len(buf.buf))) 658 o.buf = append(o.buf, buf.buf...) 659 return nil 660 } 661 662 func size_slice_packed_int64(p *Properties, base structPointer) (n int) { 663 s := structPointer_Word64Slice(base, p.field) 664 l := s.Len() 665 if l == 0 { 666 return 0 667 } 668 var bufSize int 669 for i := 0; i < l; i++ { 670 bufSize += p.valSize(s.Index(i)) 671 } 672 673 n += len(p.tagcode) 674 n += sizeVarint(uint64(bufSize)) 675 n += bufSize 676 return 677 } 678 679 // Encode a slice of slice of bytes ([][]byte). 680 func (o *Buffer) enc_slice_slice_byte(p *Properties, base structPointer) error { 681 ss := *structPointer_BytesSlice(base, p.field) 682 l := len(ss) 683 if l == 0 { 684 return ErrNil 685 } 686 for i := 0; i < l; i++ { 687 o.buf = append(o.buf, p.tagcode...) 688 o.EncodeRawBytes(ss[i]) 689 } 690 return nil 691 } 692 693 func size_slice_slice_byte(p *Properties, base structPointer) (n int) { 694 ss := *structPointer_BytesSlice(base, p.field) 695 l := len(ss) 696 if l == 0 { 697 return 0 698 } 699 n += l * len(p.tagcode) 700 for i := 0; i < l; i++ { 701 n += sizeRawBytes(ss[i]) 702 } 703 return 704 } 705 706 // Encode a slice of strings ([]string). 707 func (o *Buffer) enc_slice_string(p *Properties, base structPointer) error { 708 ss := *structPointer_StringSlice(base, p.field) 709 l := len(ss) 710 for i := 0; i < l; i++ { 711 o.buf = append(o.buf, p.tagcode...) 712 o.EncodeStringBytes(ss[i]) 713 } 714 return nil 715 } 716 717 func size_slice_string(p *Properties, base structPointer) (n int) { 718 ss := *structPointer_StringSlice(base, p.field) 719 l := len(ss) 720 n += l * len(p.tagcode) 721 for i := 0; i < l; i++ { 722 n += sizeStringBytes(ss[i]) 723 } 724 return 725 } 726 727 // Encode a slice of message structs ([]*struct). 728 func (o *Buffer) enc_slice_struct_message(p *Properties, base structPointer) error { 729 var state errorState 730 s := structPointer_StructPointerSlice(base, p.field) 731 l := s.Len() 732 733 for i := 0; i < l; i++ { 734 structp := s.Index(i) 735 if structPointer_IsNil(structp) { 736 return ErrRepeatedHasNil 737 } 738 739 // Can the object marshal itself? 740 if p.isMarshaler { 741 m := structPointer_Interface(structp, p.stype).(Marshaler) 742 data, err := m.Marshal() 743 if err != nil && !state.shouldContinue(err, nil) { 744 return err 745 } 746 o.buf = append(o.buf, p.tagcode...) 747 o.EncodeRawBytes(data) 748 continue 749 } 750 751 obuf := o.buf 752 o.buf = o.bufalloc() 753 754 err := o.enc_struct(p.stype, p.sprop, structp) 755 756 nbuf := o.buf 757 o.buf = obuf 758 if err != nil && !state.shouldContinue(err, nil) { 759 o.buffree(nbuf) 760 if err == ErrNil { 761 return ErrRepeatedHasNil 762 } 763 return err 764 } 765 o.buf = append(o.buf, p.tagcode...) 766 o.EncodeRawBytes(nbuf) 767 768 o.buffree(nbuf) 769 } 770 return state.err 771 } 772 773 func size_slice_struct_message(p *Properties, base structPointer) (n int) { 774 s := structPointer_StructPointerSlice(base, p.field) 775 l := s.Len() 776 n += l * len(p.tagcode) 777 for i := 0; i < l; i++ { 778 structp := s.Index(i) 779 if structPointer_IsNil(structp) { 780 return // return the size up to this point 781 } 782 783 // Can the object marshal itself? 784 if p.isMarshaler { 785 m := structPointer_Interface(structp, p.stype).(Marshaler) 786 data, _ := m.Marshal() 787 n += len(p.tagcode) 788 n += sizeRawBytes(data) 789 continue 790 } 791 792 n0 := size_struct(p.stype, p.sprop, structp) 793 n1 := sizeVarint(uint64(n0)) // size of encoded length 794 n += n0 + n1 795 } 796 return 797 } 798 799 // Encode a slice of group structs ([]*struct). 800 func (o *Buffer) enc_slice_struct_group(p *Properties, base structPointer) error { 801 var state errorState 802 s := structPointer_StructPointerSlice(base, p.field) 803 l := s.Len() 804 805 for i := 0; i < l; i++ { 806 b := s.Index(i) 807 if structPointer_IsNil(b) { 808 return ErrRepeatedHasNil 809 } 810 811 o.EncodeVarint(uint64((p.Tag << 3) | WireStartGroup)) 812 813 err := o.enc_struct(p.stype, p.sprop, b) 814 815 if err != nil && !state.shouldContinue(err, nil) { 816 if err == ErrNil { 817 return ErrRepeatedHasNil 818 } 819 return err 820 } 821 822 o.EncodeVarint(uint64((p.Tag << 3) | WireEndGroup)) 823 } 824 return state.err 825 } 826 827 func size_slice_struct_group(p *Properties, base structPointer) (n int) { 828 s := structPointer_StructPointerSlice(base, p.field) 829 l := s.Len() 830 831 n += l * sizeVarint(uint64((p.Tag<<3)|WireStartGroup)) 832 n += l * sizeVarint(uint64((p.Tag<<3)|WireEndGroup)) 833 for i := 0; i < l; i++ { 834 b := s.Index(i) 835 if structPointer_IsNil(b) { 836 return // return size up to this point 837 } 838 839 n += size_struct(p.stype, p.sprop, b) 840 } 841 return 842 } 843 844 // Encode an extension map. 845 func (o *Buffer) enc_map(p *Properties, base structPointer) error { 846 v := *structPointer_ExtMap(base, p.field) 847 if err := encodeExtensionMap(v); err != nil { 848 return err 849 } 850 // Fast-path for common cases: zero or one extensions. 851 if len(v) <= 1 { 852 for _, e := range v { 853 o.buf = append(o.buf, e.enc...) 854 } 855 return nil 856 } 857 858 // Sort keys to provide a deterministic encoding. 859 keys := make([]int, 0, len(v)) 860 for k := range v { 861 keys = append(keys, int(k)) 862 } 863 sort.Ints(keys) 864 865 for _, k := range keys { 866 o.buf = append(o.buf, v[int32(k)].enc...) 867 } 868 return nil 869 } 870 871 func size_map(p *Properties, base structPointer) int { 872 v := *structPointer_ExtMap(base, p.field) 873 return sizeExtensionMap(v) 874 } 875 876 // Encode a struct. 877 func (o *Buffer) enc_struct(t reflect.Type, prop *StructProperties, base structPointer) error { 878 var state errorState 879 // Encode fields in tag order so that decoders may use optimizations 880 // that depend on the ordering. 881 // http://code.google.com/apis/protocolbuffers/docs/encoding.html#order 882 for _, i := range prop.order { 883 p := prop.Prop[i] 884 if p.enc != nil { 885 err := p.enc(o, p, base) 886 if err != nil { 887 if err == ErrNil { 888 if p.Required && state.err == nil { 889 state.err = &RequiredNotSetError{p.Name} 890 } 891 } else if !state.shouldContinue(err, p) { 892 return err 893 } 894 } 895 } 896 } 897 898 // Add unrecognized fields at the end. 899 if prop.unrecField.IsValid() { 900 v := *structPointer_Bytes(base, prop.unrecField) 901 if len(v) > 0 { 902 o.buf = append(o.buf, v...) 903 } 904 } 905 906 return state.err 907 } 908 909 func size_struct(t reflect.Type, prop *StructProperties, base structPointer) (n int) { 910 for _, i := range prop.order { 911 p := prop.Prop[i] 912 if p.size != nil { 913 n += p.size(p, base) 914 } 915 } 916 917 // Add unrecognized fields at the end. 918 if prop.unrecField.IsValid() { 919 v := *structPointer_Bytes(base, prop.unrecField) 920 n += len(v) 921 } 922 923 return 924 } 925 926 // errorState maintains the first error that occurs and updates that error 927 // with additional context. 928 type errorState struct { 929 err error 930 } 931 932 // shouldContinue reports whether encoding should continue upon encountering the 933 // given error. If the error is RequiredNotSetError, shouldContinue returns true 934 // and, if this is the first appearance of that error, remembers it for future 935 // reporting. 936 // 937 // If prop is not nil, it may update any error with additional context about the 938 // field with the error. 939 func (s *errorState) shouldContinue(err error, prop *Properties) bool { 940 // Ignore unset required fields. 941 reqNotSet, ok := err.(*RequiredNotSetError) 942 if !ok { 943 return false 944 } 945 if s.err == nil { 946 if prop != nil { 947 err = &RequiredNotSetError{prop.Name + "." + reqNotSet.field} 948 } 949 s.err = err 950 } 951 return true 952 }